repo stringlengths 7 90 | file_url stringlengths 81 315 | file_path stringlengths 4 228 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 14:38:15 2026-01-05 02:33:18 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtp.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtp.py | import fractions
import math
import sys
from unittest import TestCase
from av import AudioFrame
from aiortc import rtp
from aiortc.rtcrtpparameters import RTCRtpHeaderExtensionParameters, RTCRtpParameters
from aiortc.rtp import (
RtcpByePacket,
RtcpPacket,
RtcpPsfbPacket,
RtcpRrPacket,
RtcpRtpfbPacket,
RtcpSdesPacket,
RtcpSrPacket,
RtpPacket,
clamp_packets_lost,
pack_header_extensions,
pack_packets_lost,
pack_remb_fci,
unpack_header_extensions,
unpack_packets_lost,
unpack_remb_fci,
unwrap_rtx,
wrap_rtx,
)
from .utils import load
def create_audio_frame(sample_func, samples, pts, layout="mono", sample_rate=48000):
frame = AudioFrame(format="s16", layout=layout, samples=samples)
for p in frame.planes:
buf = bytearray()
for i in range(samples):
sample = int(sample_func(i) * 32767)
buf.extend(int.to_bytes(sample, 2, sys.byteorder, signed=True))
p.update(buf)
frame.pts = pts
frame.sample_rate = sample_rate
frame.time_base = fractions.Fraction(1, sample_rate)
return frame
class RtcpPacketTest(TestCase):
def test_bye(self):
data = load("rtcp_bye.bin")
packets = RtcpPacket.parse(data)
self.assertEqual(len(packets), 1)
packet = packets[0]
self.assertIsInstance(packet, RtcpByePacket)
self.assertEqual(packet.sources, [2924645187])
self.assertEqual(bytes(packet), data)
self.assertEqual(repr(packet), "RtcpByePacket(sources=[2924645187])")
def test_bye_invalid(self):
data = load("rtcp_bye_invalid.bin")
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTCP bye length is invalid")
def test_bye_no_sources(self):
data = load("rtcp_bye_no_sources.bin")
packets = RtcpPacket.parse(data)
self.assertEqual(len(packets), 1)
packet = packets[0]
self.assertIsInstance(packet, RtcpByePacket)
self.assertEqual(packet.sources, [])
self.assertEqual(bytes(packet), data)
self.assertEqual(repr(packet), "RtcpByePacket(sources=[])")
def test_bye_only_padding(self):
data = load("rtcp_bye_padding.bin")
packets = RtcpPacket.parse(data)
self.assertEqual(len(packets), 1)
packet = packets[0]
self.assertIsInstance(packet, RtcpByePacket)
self.assertEqual(packet.sources, [])
self.assertEqual(bytes(packet), b"\x80\xcb\x00\x00")
self.assertEqual(repr(packet), "RtcpByePacket(sources=[])")
def test_bye_only_padding_zero(self):
data = load("rtcp_bye_padding.bin")[0:4] + b"\x00\x00\x00\x00"
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTCP packet padding length is invalid")
def test_psfb_invalid(self):
data = load("rtcp_psfb_invalid.bin")
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data)
self.assertEqual(
str(cm.exception), "RTCP payload-specific feedback length is invalid"
)
def test_psfb_pli(self):
data = load("rtcp_psfb_pli.bin")
packets = RtcpPacket.parse(data)
self.assertEqual(len(packets), 1)
packet = packets[0]
self.assertIsInstance(packet, RtcpPsfbPacket)
self.assertEqual(packet.fmt, 1)
self.assertEqual(packet.ssrc, 1414554213)
self.assertEqual(packet.media_ssrc, 587284409)
self.assertEqual(packet.fci, b"")
self.assertEqual(bytes(packet), data)
def test_rr(self):
data = load("rtcp_rr.bin")
packets = RtcpPacket.parse(data)
self.assertEqual(len(packets), 1)
packet = packets[0]
self.assertIsInstance(packet, RtcpRrPacket)
self.assertEqual(packet.ssrc, 817267719)
self.assertEqual(packet.reports[0].ssrc, 1200895919)
self.assertEqual(packet.reports[0].fraction_lost, 0)
self.assertEqual(packet.reports[0].packets_lost, 0)
self.assertEqual(packet.reports[0].highest_sequence, 630)
self.assertEqual(packet.reports[0].jitter, 1906)
self.assertEqual(packet.reports[0].lsr, 0)
self.assertEqual(packet.reports[0].dlsr, 0)
self.assertEqual(bytes(packet), data)
def test_rr_invalid(self):
data = load("rtcp_rr_invalid.bin")
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTCP receiver report length is invalid")
def test_rr_truncated(self):
data = load("rtcp_rr.bin")
for length in range(1, 4):
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data[0:length])
self.assertEqual(
str(cm.exception), "RTCP packet length is less than 4 bytes"
)
for length in range(4, 32):
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data[0:length])
self.assertEqual(str(cm.exception), "RTCP packet is truncated")
def test_sdes(self):
data = load("rtcp_sdes.bin")
packets = RtcpPacket.parse(data)
self.assertEqual(len(packets), 1)
packet = packets[0]
self.assertIsInstance(packet, RtcpSdesPacket)
self.assertEqual(packet.chunks[0].ssrc, 1831097322)
self.assertEqual(
packet.chunks[0].items, [(1, b"{63f459ea-41fe-4474-9d33-9707c9ee79d1}")]
)
self.assertEqual(bytes(packet), data)
def test_sdes_item_truncated(self):
data = load("rtcp_sdes_item_truncated.bin")
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTCP SDES item is truncated")
def test_sdes_source_truncated(self):
data = load("rtcp_sdes_source_truncated.bin")
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTCP SDES source is truncated")
def test_sr(self):
data = load("rtcp_sr.bin")
packets = RtcpPacket.parse(data)
self.assertEqual(len(packets), 1)
packet = packets[0]
self.assertIsInstance(packet, RtcpSrPacket)
self.assertEqual(packet.ssrc, 1831097322)
self.assertEqual(packet.sender_info.ntp_timestamp, 16016567581311369308)
self.assertEqual(packet.sender_info.rtp_timestamp, 1722342718)
self.assertEqual(packet.sender_info.packet_count, 269)
self.assertEqual(packet.sender_info.octet_count, 13557)
self.assertEqual(len(packet.reports), 1)
self.assertEqual(packet.reports[0].ssrc, 2398654957)
self.assertEqual(packet.reports[0].fraction_lost, 0)
self.assertEqual(packet.reports[0].packets_lost, 0)
self.assertEqual(packet.reports[0].highest_sequence, 246)
self.assertEqual(packet.reports[0].jitter, 127)
self.assertEqual(packet.reports[0].lsr, 0)
self.assertEqual(packet.reports[0].dlsr, 0)
self.assertEqual(bytes(packet), data)
def test_sr_invalid(self):
data = load("rtcp_sr_invalid.bin")
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTCP sender report length is invalid")
def test_rtpfb(self):
data = load("rtcp_rtpfb.bin")
packets = RtcpPacket.parse(data)
self.assertEqual(len(packets), 1)
packet = packets[0]
self.assertIsInstance(packet, RtcpRtpfbPacket)
self.assertEqual(packet.fmt, 1)
self.assertEqual(packet.ssrc, 2336520123)
self.assertEqual(packet.media_ssrc, 4145934052)
self.assertEqual(
packet.lost,
[12, 32, 39, 54, 76, 110, 123, 142, 183, 187, 223, 236, 271, 292],
)
self.assertEqual(bytes(packet), data)
def test_rtpfb_invalid(self):
data = load("rtcp_rtpfb_invalid.bin")
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTCP RTP feedback length is invalid")
def test_compound(self):
data = load("rtcp_sr.bin") + load("rtcp_sdes.bin")
packets = RtcpPacket.parse(data)
self.assertEqual(len(packets), 2)
self.assertIsInstance(packets[0], RtcpSrPacket)
self.assertIsInstance(packets[1], RtcpSdesPacket)
def test_bad_version(self):
data = b"\xc0" + load("rtcp_rr.bin")[1:]
with self.assertRaises(ValueError) as cm:
RtcpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTCP packet has invalid version")
class RtpPacketTest(TestCase):
def test_dtmf(self):
data = load("rtp_dtmf.bin")
packet = RtpPacket.parse(data)
self.assertEqual(packet.version, 2)
self.assertEqual(packet.marker, 1)
self.assertEqual(packet.payload_type, 101)
self.assertEqual(packet.sequence_number, 24152)
self.assertEqual(packet.timestamp, 4021352124)
self.assertEqual(packet.csrc, [])
self.assertEqual(packet.extensions, rtp.HeaderExtensions())
self.assertEqual(len(packet.payload), 4)
self.assertEqual(packet.serialize(), data)
def test_no_ssrc(self):
data = load("rtp.bin")
packet = RtpPacket.parse(data)
self.assertEqual(packet.version, 2)
self.assertEqual(packet.marker, 0)
self.assertEqual(packet.payload_type, 0)
self.assertEqual(packet.sequence_number, 15743)
self.assertEqual(packet.timestamp, 3937035252)
self.assertEqual(packet.csrc, [])
self.assertEqual(packet.extensions, rtp.HeaderExtensions())
self.assertEqual(len(packet.payload), 160)
self.assertEqual(packet.serialize(), data)
self.assertEqual(
repr(packet),
"RtpPacket(seq=15743, ts=3937035252, marker=0, payload=0, 160 bytes)",
)
def test_padding_only(self):
data = load("rtp_only_padding.bin")
packet = RtpPacket.parse(data)
self.assertEqual(packet.version, 2)
self.assertEqual(packet.marker, 0)
self.assertEqual(packet.payload_type, 120)
self.assertEqual(packet.sequence_number, 27759)
self.assertEqual(packet.timestamp, 4044047131)
self.assertEqual(packet.csrc, [])
self.assertEqual(packet.extensions, rtp.HeaderExtensions())
self.assertEqual(len(packet.payload), 0)
self.assertEqual(packet.padding_size, 224)
serialized = packet.serialize()
self.assertEqual(len(serialized), len(data))
self.assertEqual(serialized[0:12], data[0:12])
self.assertEqual(serialized[-1], data[-1])
def test_padding_only_with_header_extensions(self):
extensions_map = rtp.HeaderExtensionsMap()
extensions_map.configure(
RTCRtpParameters(
headerExtensions=[
RTCRtpHeaderExtensionParameters(
id=2,
uri="http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time",
)
]
)
)
data = load("rtp_only_padding_with_header_extensions.bin")
packet = RtpPacket.parse(data, extensions_map)
self.assertEqual(packet.version, 2)
self.assertEqual(packet.marker, 0)
self.assertEqual(packet.payload_type, 98)
self.assertEqual(packet.sequence_number, 22138)
self.assertEqual(packet.timestamp, 3171065731)
self.assertEqual(packet.csrc, [])
self.assertEqual(
packet.extensions, rtp.HeaderExtensions(abs_send_time=15846540)
)
self.assertEqual(len(packet.payload), 0)
self.assertEqual(packet.padding_size, 224)
serialized = packet.serialize(extensions_map)
self.assertEqual(len(serialized), len(data))
self.assertEqual(serialized[0:20], data[0:20])
self.assertEqual(serialized[-1], data[-1])
def test_padding_too_long(self):
data = load("rtp_only_padding.bin")[0:12] + b"\x02"
with self.assertRaises(ValueError) as cm:
RtpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTP packet padding length is invalid")
def test_padding_zero(self):
data = load("rtp_only_padding.bin")[0:12] + b"\x00"
with self.assertRaises(ValueError) as cm:
RtpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTP packet padding length is invalid")
def test_with_csrc(self):
data = load("rtp_with_csrc.bin")
packet = RtpPacket.parse(data)
self.assertEqual(packet.version, 2)
self.assertEqual(packet.marker, 0)
self.assertEqual(packet.payload_type, 0)
self.assertEqual(packet.sequence_number, 16082)
self.assertEqual(packet.timestamp, 144)
self.assertEqual(packet.csrc, [2882400001, 3735928559])
self.assertEqual(packet.extensions, rtp.HeaderExtensions())
self.assertEqual(len(packet.payload), 160)
self.assertEqual(packet.serialize(), data)
def test_with_csrc_truncated(self):
data = load("rtp_with_csrc.bin")
for length in range(12, 20):
with self.assertRaises(ValueError) as cm:
RtpPacket.parse(data[0:length])
self.assertEqual(str(cm.exception), "RTP packet has truncated CSRC")
def test_with_sdes_mid(self):
extensions_map = rtp.HeaderExtensionsMap()
extensions_map.configure(
RTCRtpParameters(
headerExtensions=[
RTCRtpHeaderExtensionParameters(
id=9, uri="urn:ietf:params:rtp-hdrext:sdes:mid"
)
]
)
)
data = load("rtp_with_sdes_mid.bin")
packet = RtpPacket.parse(data, extensions_map)
self.assertEqual(packet.version, 2)
self.assertEqual(packet.marker, 1)
self.assertEqual(packet.payload_type, 111)
self.assertEqual(packet.sequence_number, 14156)
self.assertEqual(packet.timestamp, 1327210925)
self.assertEqual(packet.csrc, [])
self.assertEqual(packet.extensions, rtp.HeaderExtensions(mid="0"))
self.assertEqual(len(packet.payload), 54)
self.assertEqual(packet.serialize(extensions_map), data)
def test_with_sdes_mid_truncated(self):
data = load("rtp_with_sdes_mid.bin")
for length in range(12, 16):
with self.assertRaises(ValueError) as cm:
RtpPacket.parse(data[0:length])
self.assertEqual(
str(cm.exception), "RTP packet has truncated extension profile / length"
)
for length in range(16, 20):
with self.assertRaises(ValueError) as cm:
RtpPacket.parse(data[0:length])
self.assertEqual(
str(cm.exception), "RTP packet has truncated extension value"
)
def test_truncated(self):
data = load("rtp.bin")[0:11]
with self.assertRaises(ValueError) as cm:
RtpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTP packet length is less than 12 bytes")
def test_bad_version(self):
data = b"\xc0" + load("rtp.bin")[1:]
with self.assertRaises(ValueError) as cm:
RtpPacket.parse(data)
self.assertEqual(str(cm.exception), "RTP packet has invalid version")
class RtpUtilTest(TestCase):
def test_clamp_packets_lost(self):
self.assertEqual(clamp_packets_lost(-8388609), -8388608)
self.assertEqual(clamp_packets_lost(-8388608), -8388608)
self.assertEqual(clamp_packets_lost(0), 0)
self.assertEqual(clamp_packets_lost(8388607), 8388607)
self.assertEqual(clamp_packets_lost(8388608), 8388607)
def test_pack_packets_lost(self):
self.assertEqual(pack_packets_lost(-8388608), b"\x80\x00\x00")
self.assertEqual(pack_packets_lost(-1), b"\xff\xff\xff")
self.assertEqual(pack_packets_lost(0), b"\x00\x00\x00")
self.assertEqual(pack_packets_lost(1), b"\x00\x00\x01")
self.assertEqual(pack_packets_lost(8388607), b"\x7f\xff\xff")
def test_pack_remb_fci(self):
# exponent = 0, mantissa = 0
data = pack_remb_fci(0, [2529072847])
self.assertEqual(data, b"REMB\x01\x00\x00\x00\x96\xbe\x96\xcf")
# exponent = 0, mantissa = 0x3ffff
data = pack_remb_fci(0x3FFFF, [2529072847])
self.assertEqual(data, b"REMB\x01\x03\xff\xff\x96\xbe\x96\xcf")
# exponent = 1, mantissa = 0
data = pack_remb_fci(0x40000, [2529072847])
self.assertEqual(data, b"REMB\x01\x06\x00\x00\x96\xbe\x96\xcf")
data = pack_remb_fci(4160000, [2529072847])
self.assertEqual(data, b"REMB\x01\x13\xf7\xa0\x96\xbe\x96\xcf")
# exponent = 63, mantissa = 0x3ffff
data = pack_remb_fci(0x3FFFF << 63, [2529072847])
self.assertEqual(data, b"REMB\x01\xff\xff\xff\x96\xbe\x96\xcf")
def test_unpack_packets_lost(self):
self.assertEqual(unpack_packets_lost(b"\x80\x00\x00"), -8388608)
self.assertEqual(unpack_packets_lost(b"\xff\xff\xff"), -1)
self.assertEqual(unpack_packets_lost(b"\x00\x00\x00"), 0)
self.assertEqual(unpack_packets_lost(b"\x00\x00\x01"), 1)
self.assertEqual(unpack_packets_lost(b"\x7f\xff\xff"), 8388607)
def test_unpack_remb_fci(self):
# junk
with self.assertRaises(ValueError):
unpack_remb_fci(b"JUNK")
# exponent = 0, mantissa = 0
bitrate, ssrcs = unpack_remb_fci(b"REMB\x01\x00\x00\x00\x96\xbe\x96\xcf")
self.assertEqual(bitrate, 0)
self.assertEqual(ssrcs, [2529072847])
# exponent = 0, mantissa = 0x3ffff
bitrate, ssrcs = unpack_remb_fci(b"REMB\x01\x03\xff\xff\x96\xbe\x96\xcf")
self.assertEqual(bitrate, 0x3FFFF)
self.assertEqual(ssrcs, [2529072847])
# exponent = 1, mantissa = 0
bitrate, ssrcs = unpack_remb_fci(b"REMB\x01\x06\x00\x00\x96\xbe\x96\xcf")
self.assertEqual(bitrate, 0x40000)
self.assertEqual(ssrcs, [2529072847])
# 4160000 bps
bitrate, ssrcs = unpack_remb_fci(b"REMB\x01\x13\xf7\xa0\x96\xbe\x96\xcf")
self.assertEqual(bitrate, 4160000)
self.assertEqual(ssrcs, [2529072847])
# exponent = 63, mantissa = 0x3ffff
bitrate, ssrcs = unpack_remb_fci(b"REMB\x01\xff\xff\xff\x96\xbe\x96\xcf")
self.assertEqual(bitrate, 0x3FFFF << 63)
self.assertEqual(ssrcs, [2529072847])
def test_unpack_header_extensions(self):
# none
self.assertEqual(unpack_header_extensions(0, None), [])
# one-byte, value
self.assertEqual(unpack_header_extensions(0xBEDE, b"\x900"), [(9, b"0")])
# one-byte, value, padding, value
self.assertEqual(
unpack_header_extensions(0xBEDE, b"\x900\x00\x00\x301"),
[(9, b"0"), (3, b"1")],
)
# one-byte, value, value
self.assertEqual(
unpack_header_extensions(0xBEDE, b"\x10\xc18sdparta_0"),
[(1, b"\xc1"), (3, b"sdparta_0")],
)
# two-byte, value
self.assertEqual(unpack_header_extensions(0x1000, b"\xff\x010"), [(255, b"0")])
# two-byte, value (1 byte), padding, value (2 bytes)
self.assertEqual(
unpack_header_extensions(0x1000, b"\xff\x010\x00\xf0\x0212"),
[(255, b"0"), (240, b"12")],
)
def test_unpack_header_extensions_bad(self):
# one-byte, value (truncated)
with self.assertRaises(ValueError) as cm:
unpack_header_extensions(0xBEDE, b"\x90")
self.assertEqual(
str(cm.exception), "RTP one-byte header extension value is truncated"
)
# two-byte (truncated)
with self.assertRaises(ValueError) as cm:
unpack_header_extensions(0x1000, b"\xff")
self.assertEqual(
str(cm.exception), "RTP two-byte header extension is truncated"
)
# two-byte, value (truncated)
with self.assertRaises(ValueError) as cm:
unpack_header_extensions(0x1000, b"\xff\x020")
self.assertEqual(
str(cm.exception), "RTP two-byte header extension value is truncated"
)
def test_pack_header_extensions(self):
# none
self.assertEqual(pack_header_extensions([]), (0, b""))
# one-byte, single value
self.assertEqual(
pack_header_extensions([(9, b"0")]), (0xBEDE, b"\x900\x00\x00")
)
# one-byte, two values
self.assertEqual(
pack_header_extensions([(1, b"\xc1"), (3, b"sdparta_0")]),
(0xBEDE, b"\x10\xc18sdparta_0"),
)
# two-byte, single value
self.assertEqual(
pack_header_extensions([(255, b"0")]), (0x1000, b"\xff\x010\x00")
)
def test_map_header_extensions(self):
data = bytearray(
[
0x90,
0x64,
0x00,
0x58,
0x65,
0x43,
0x12,
0x78,
0x12,
0x34,
0x56,
0x78, # SSRC
0xBE,
0xDE,
0x00,
0x08, # Extension of size 8x32bit words.
0x40,
0xDA, # AudioLevel.
0x22,
0x01,
0x56,
0xCE, # TransmissionOffset.
0x62,
0x12,
0x34,
0x56, # AbsoluteSendTime.
0x81,
0xCE,
0xAB, # TransportSequenceNumber.
0xA0,
0x03, # VideoRotation.
0xB2,
0x12,
0x48,
0x76, # PlayoutDelayLimits.
0xC2,
0x72,
0x74,
0x78, # RtpStreamId
0xD5,
0x73,
0x74,
0x72,
0x65,
0x61,
0x6D, # RepairedRtpStreamId
0x00,
0x00, # Padding to 32bit boundary.
]
)
extensions_map = rtp.HeaderExtensionsMap()
extensions_map.configure(
RTCRtpParameters(
headerExtensions=[
RTCRtpHeaderExtensionParameters(
id=2, uri="urn:ietf:params:rtp-hdrext:toffset"
),
RTCRtpHeaderExtensionParameters(
id=4, uri="urn:ietf:params:rtp-hdrext:ssrc-audio-level"
),
RTCRtpHeaderExtensionParameters(
id=6,
uri="http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time",
),
RTCRtpHeaderExtensionParameters(
id=8,
uri="http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01",
),
RTCRtpHeaderExtensionParameters(
id=12, uri="urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id"
),
RTCRtpHeaderExtensionParameters(
id=13,
uri="urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id",
),
]
)
)
packet = RtpPacket.parse(data, extensions_map)
# check mapped values
self.assertEqual(packet.extensions.abs_send_time, 0x123456)
self.assertEqual(packet.extensions.audio_level, (True, 90))
self.assertEqual(packet.extensions.mid, None)
self.assertEqual(packet.extensions.repaired_rtp_stream_id, "stream")
self.assertEqual(packet.extensions.rtp_stream_id, "rtx")
self.assertEqual(packet.extensions.transmission_offset, 0x156CE)
self.assertEqual(packet.extensions.transport_sequence_number, 0xCEAB)
# TODO: check
packet.serialize(extensions_map)
def test_rtx(self):
extensions_map = rtp.HeaderExtensionsMap()
extensions_map.configure(
RTCRtpParameters(
headerExtensions=[
RTCRtpHeaderExtensionParameters(
id=9, uri="urn:ietf:params:rtp-hdrext:sdes:mid"
)
]
)
)
data = load("rtp_with_sdes_mid.bin")
packet = RtpPacket.parse(data, extensions_map)
# wrap / unwrap RTX
rtx = wrap_rtx(packet, payload_type=112, sequence_number=12345, ssrc=1234)
recovered = unwrap_rtx(rtx, payload_type=111, ssrc=4084547440)
# check roundtrip
self.assertEqual(recovered.version, packet.version)
self.assertEqual(recovered.marker, packet.marker)
self.assertEqual(recovered.payload_type, packet.payload_type)
self.assertEqual(recovered.sequence_number, packet.sequence_number)
self.assertEqual(recovered.timestamp, packet.timestamp)
self.assertEqual(recovered.ssrc, packet.ssrc)
self.assertEqual(recovered.csrc, packet.csrc)
self.assertEqual(recovered.extensions, packet.extensions)
self.assertEqual(recovered.payload, packet.payload)
def test_compute_audio_level_dbov(self):
num_samples = 960 # 20ms @ 48kHz
# test a frame of all zeroes (-127 dBov, the minimum value)
silent_frame = create_audio_frame(lambda n: 0.0, num_samples, 0)
self.assertEqual(rtp.compute_audio_level_dbov(silent_frame), -127)
# test a 50Hz square wave (0 dBov, the maximum value)
square_frame = create_audio_frame(
lambda n: 1.0 if n < num_samples / 2 else -1.0, num_samples, 0
)
self.assertEqual(rtp.compute_audio_level_dbov(square_frame), 0)
# test a 50Hz sine wave (-3 dBov, the maximum value for a sine wave)
sine_frame = create_audio_frame(
lambda n: math.sin(2 * math.pi * n / num_samples), num_samples, 0
)
self.assertEqual(rtp.compute_audio_level_dbov(sine_frame), -3)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtcrtptransceiver.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtcrtptransceiver.py | from unittest import TestCase
from aiortc.rtcrtpparameters import RTCRtpCodecCapability
from aiortc.rtcrtptransceiver import RTCRtpTransceiver
class RTCRtpTransceiverTest(TestCase):
def test_codec_preferences(self):
transceiver = RTCRtpTransceiver("audio", None, None)
self.assertEqual(transceiver._preferred_codecs, [])
# set empty preferences
transceiver.setCodecPreferences([])
self.assertEqual(transceiver._preferred_codecs, [])
# set single codec
transceiver.setCodecPreferences(
[RTCRtpCodecCapability(mimeType="audio/PCMU", clockRate=8000, channels=1)]
)
self.assertEqual(
transceiver._preferred_codecs,
[RTCRtpCodecCapability(mimeType="audio/PCMU", clockRate=8000, channels=1)],
)
# set single codec (duplicated)
transceiver.setCodecPreferences(
[
RTCRtpCodecCapability(
mimeType="audio/PCMU", clockRate=8000, channels=1
),
RTCRtpCodecCapability(
mimeType="audio/PCMU", clockRate=8000, channels=1
),
]
)
self.assertEqual(
transceiver._preferred_codecs,
[RTCRtpCodecCapability(mimeType="audio/PCMU", clockRate=8000, channels=1)],
)
# set single codec (invalid)
with self.assertRaises(ValueError) as cm:
transceiver.setCodecPreferences(
[
RTCRtpCodecCapability(
mimeType="audio/bogus", clockRate=8000, channels=1
)
]
)
self.assertEqual(str(cm.exception), "Codec is not in capabilities")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtcdtlstransport.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtcdtlstransport.py | import asyncio
import datetime
from unittest import TestCase
from unittest.mock import patch
from OpenSSL import SSL
from aiortc.rtcdtlstransport import (
RTCCertificate,
RTCDtlsFingerprint,
RTCDtlsParameters,
RTCDtlsTransport,
RtpRouter,
)
from aiortc.rtcrtpparameters import (
RTCRtpCodecParameters,
RTCRtpDecodingParameters,
RTCRtpReceiveParameters,
)
from aiortc.rtp import (
RTCP_PSFB_APP,
RTCP_PSFB_PLI,
RTCP_RTPFB_NACK,
RtcpByePacket,
RtcpPsfbPacket,
RtcpReceiverInfo,
RtcpRrPacket,
RtcpRtpfbPacket,
RtcpSenderInfo,
RtcpSrPacket,
RtpPacket,
pack_remb_fci,
)
from .utils import asynctest, dummy_ice_transport_pair, load
RTP = load("rtp.bin")
RTCP = load("rtcp_sr.bin")
class BrokenDataReceiver:
def __init__(self):
self.data = []
async def _handle_data(self, data):
raise Exception("some error")
class DummyDataReceiver:
def __init__(self):
self.data = []
async def _handle_data(self, data):
self.data.append(data)
class DummyRtpReceiver:
def __init__(self):
self.rtp_packets = []
self.rtcp_packets = []
def _handle_disconnect(self):
pass
async def _handle_rtp_packet(self, packet, arrival_time_ms):
self.rtp_packets.append(packet)
async def _handle_rtcp_packet(self, packet):
self.rtcp_packets.append(packet)
class RTCCertificateTest(TestCase):
def test_generate(self):
certificate = RTCCertificate.generateCertificate()
self.assertIsNotNone(certificate)
expires = certificate.expires
self.assertIsNotNone(expires)
self.assertIsInstance(expires, datetime.datetime)
fingerprints = certificate.getFingerprints()
self.assertEqual(len(fingerprints), 1)
self.assertEqual(fingerprints[0].algorithm, "sha-256")
self.assertEqual(len(fingerprints[0].value), 95)
class RTCDtlsTransportTest(TestCase):
def assertCounters(self, transport_a, transport_b, packets_sent_a, packets_sent_b):
stats_a = transport_a._get_stats()[transport_a._stats_id]
stats_b = transport_b._get_stats()[transport_b._stats_id]
self.assertEqual(stats_a.packetsSent, packets_sent_a)
self.assertEqual(stats_a.packetsReceived, packets_sent_b)
self.assertGreater(stats_a.bytesSent, 0)
self.assertGreater(stats_a.bytesReceived, 0)
self.assertEqual(stats_b.packetsSent, packets_sent_b)
self.assertEqual(stats_b.packetsReceived, packets_sent_a)
self.assertGreater(stats_b.bytesSent, 0)
self.assertGreater(stats_b.bytesReceived, 0)
self.assertEqual(stats_a.bytesSent, stats_b.bytesReceived)
self.assertEqual(stats_b.bytesSent, stats_a.bytesReceived)
@asynctest
async def test_data(self):
transport1, transport2 = dummy_ice_transport_pair()
certificate1 = RTCCertificate.generateCertificate()
session1 = RTCDtlsTransport(transport1, [certificate1])
receiver1 = DummyDataReceiver()
session1._register_data_receiver(receiver1)
certificate2 = RTCCertificate.generateCertificate()
session2 = RTCDtlsTransport(transport2, [certificate2])
receiver2 = DummyDataReceiver()
session2._register_data_receiver(receiver2)
await asyncio.gather(
session1.start(session2.getLocalParameters()),
session2.start(session1.getLocalParameters()),
)
# send encypted data
await session1._send_data(b"ping")
await asyncio.sleep(0.1)
self.assertEqual(receiver2.data, [b"ping"])
await session2._send_data(b"pong")
await asyncio.sleep(0.1)
self.assertEqual(receiver1.data, [b"pong"])
# shutdown
await session1.stop()
await asyncio.sleep(0.1)
self.assertEqual(session1.state, "closed")
self.assertEqual(session2.state, "closed")
# try closing again
await session1.stop()
await session2.stop()
# try sending after close
with self.assertRaises(ConnectionError):
await session1._send_data(b"foo")
@asynctest
async def test_data_handler_error(self):
transport1, transport2 = dummy_ice_transport_pair()
certificate1 = RTCCertificate.generateCertificate()
session1 = RTCDtlsTransport(transport1, [certificate1])
receiver1 = DummyDataReceiver()
session1._register_data_receiver(receiver1)
certificate2 = RTCCertificate.generateCertificate()
session2 = RTCDtlsTransport(transport2, [certificate2])
session2._register_data_receiver(BrokenDataReceiver())
await asyncio.gather(
session1.start(session2.getLocalParameters()),
session2.start(session1.getLocalParameters()),
)
# send encypted data
await session1._send_data(b"ping")
await asyncio.sleep(0.1)
# shutdown
await session1.stop()
await session2.stop()
@asynctest
async def test_rtp(self):
transport1, transport2 = dummy_ice_transport_pair()
certificate1 = RTCCertificate.generateCertificate()
session1 = RTCDtlsTransport(transport1, [certificate1])
receiver1 = DummyRtpReceiver()
session1._register_rtp_receiver(
receiver1,
RTCRtpReceiveParameters(
codecs=[
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, payloadType=0
)
],
encodings=[RTCRtpDecodingParameters(ssrc=1831097322, payloadType=0)],
),
)
certificate2 = RTCCertificate.generateCertificate()
session2 = RTCDtlsTransport(transport2, [certificate2])
receiver2 = DummyRtpReceiver()
session2._register_rtp_receiver(
receiver2,
RTCRtpReceiveParameters(
codecs=[
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, payloadType=0
)
],
encodings=[RTCRtpDecodingParameters(ssrc=4028317929, payloadType=0)],
),
)
await asyncio.gather(
session1.start(session2.getLocalParameters()),
session2.start(session1.getLocalParameters()),
)
self.assertCounters(session1, session2, 2, 2)
# send RTP
await session1._send_rtp(RTP)
await asyncio.sleep(0.1)
self.assertCounters(session1, session2, 3, 2)
self.assertEqual(len(receiver2.rtcp_packets), 0)
self.assertEqual(len(receiver2.rtp_packets), 1)
# send RTCP
await session2._send_rtp(RTCP)
await asyncio.sleep(0.1)
self.assertCounters(session1, session2, 3, 3)
self.assertEqual(len(receiver1.rtcp_packets), 1)
self.assertEqual(len(receiver1.rtp_packets), 0)
# shutdown
await session1.stop()
await asyncio.sleep(0.1)
self.assertCounters(session1, session2, 4, 3)
self.assertEqual(session1.state, "closed")
self.assertEqual(session2.state, "closed")
# try closing again
await session1.stop()
await session2.stop()
# try sending after close
with self.assertRaises(ConnectionError):
await session1._send_rtp(RTP)
@asynctest
async def test_rtp_malformed(self):
transport1, transport2 = dummy_ice_transport_pair()
certificate1 = RTCCertificate.generateCertificate()
session1 = RTCDtlsTransport(transport1, [certificate1])
# receive truncated RTP
await session1._handle_rtp_data(RTP[0:8], 0)
# receive truncated RTCP
await session1._handle_rtcp_data(RTCP[0:8])
@asynctest
async def test_srtp_unprotect_error(self):
transport1, transport2 = dummy_ice_transport_pair()
certificate1 = RTCCertificate.generateCertificate()
session1 = RTCDtlsTransport(transport1, [certificate1])
receiver1 = DummyRtpReceiver()
session1._register_rtp_receiver(
receiver1,
RTCRtpReceiveParameters(
codecs=[
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, payloadType=0
)
],
encodings=[RTCRtpDecodingParameters(ssrc=1831097322, payloadType=0)],
),
)
certificate2 = RTCCertificate.generateCertificate()
session2 = RTCDtlsTransport(transport2, [certificate2])
receiver2 = DummyRtpReceiver()
session2._register_rtp_receiver(
receiver2,
RTCRtpReceiveParameters(
codecs=[
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, payloadType=0
)
],
encodings=[RTCRtpDecodingParameters(ssrc=4028317929, payloadType=0)],
),
)
await asyncio.gather(
session1.start(session2.getLocalParameters()),
session2.start(session1.getLocalParameters()),
)
# send same RTP twice, to trigger error on the receiver side:
# "replay check failed (bad index)"
await session1._send_rtp(RTP)
await session1._send_rtp(RTP)
await asyncio.sleep(0.1)
self.assertEqual(len(receiver2.rtcp_packets), 0)
self.assertEqual(len(receiver2.rtp_packets), 1)
# shutdown
await session1.stop()
await session2.stop()
@asynctest
async def test_abrupt_disconnect(self):
transport1, transport2 = dummy_ice_transport_pair()
certificate1 = RTCCertificate.generateCertificate()
session1 = RTCDtlsTransport(transport1, [certificate1])
certificate2 = RTCCertificate.generateCertificate()
session2 = RTCDtlsTransport(transport2, [certificate2])
await asyncio.gather(
session1.start(session2.getLocalParameters()),
session2.start(session1.getLocalParameters()),
)
# break connections -> tasks exits
await transport1.stop()
await transport2.stop()
await asyncio.sleep(0.1)
# close DTLS
await session1.stop()
await session2.stop()
# check outcome
self.assertEqual(session1.state, "closed")
self.assertEqual(session2.state, "closed")
@asynctest
async def test_abrupt_disconnect_2(self):
transport1, transport2 = dummy_ice_transport_pair()
certificate1 = RTCCertificate.generateCertificate()
session1 = RTCDtlsTransport(transport1, [certificate1])
certificate2 = RTCCertificate.generateCertificate()
session2 = RTCDtlsTransport(transport2, [certificate2])
await asyncio.gather(
session1.start(session2.getLocalParameters()),
session2.start(session1.getLocalParameters()),
)
def fake_write_ssl():
raise ConnectionError
session1._write_ssl = fake_write_ssl
# close DTLS -> ConnectionError
await session1.stop()
await session2.stop()
await asyncio.sleep(0.1)
# check outcome
self.assertEqual(session1.state, "closed")
self.assertEqual(session2.state, "closed")
@asynctest
async def test_bad_client_fingerprint(self):
transport1, transport2 = dummy_ice_transport_pair()
certificate1 = RTCCertificate.generateCertificate()
session1 = RTCDtlsTransport(transport1, [certificate1])
certificate2 = RTCCertificate.generateCertificate()
session2 = RTCDtlsTransport(transport2, [certificate2])
bogus_parameters = RTCDtlsParameters(
fingerprints=[
RTCDtlsFingerprint(algorithm="sha-256", value="bogus_fingerprint")
]
)
await asyncio.gather(
session1.start(bogus_parameters),
session2.start(session1.getLocalParameters()),
)
self.assertEqual(session1.state, "failed")
self.assertEqual(session2.state, "connected")
await session1.stop()
await session2.stop()
@patch("aiortc.rtcdtlstransport.SSL.Connection.do_handshake")
@asynctest
async def test_handshake_error(self, mock_do_handshake):
mock_do_handshake.side_effect = SSL.Error(
[("SSL routines", "", "decryption failed or bad record mac")]
)
transport1, transport2 = dummy_ice_transport_pair()
certificate1 = RTCCertificate.generateCertificate()
session1 = RTCDtlsTransport(transport1, [certificate1])
certificate2 = RTCCertificate.generateCertificate()
session2 = RTCDtlsTransport(transport2, [certificate2])
await asyncio.gather(
session1.start(session2.getLocalParameters()),
session2.start(session1.getLocalParameters()),
)
self.assertEqual(session1.state, "failed")
self.assertEqual(session2.state, "failed")
await session1.stop()
await session2.stop()
@asynctest
async def test_lossy_channel(self):
"""
Transport with 25% loss eventually connects.
"""
transport1, transport2 = dummy_ice_transport_pair()
loss_pattern = [True, False, False, False]
transport1._connection.loss_pattern = loss_pattern
transport2._connection.loss_pattern = loss_pattern
certificate1 = RTCCertificate.generateCertificate()
session1 = RTCDtlsTransport(transport1, [certificate1])
certificate2 = RTCCertificate.generateCertificate()
session2 = RTCDtlsTransport(transport2, [certificate2])
await asyncio.gather(
session1.start(session2.getLocalParameters()),
session2.start(session1.getLocalParameters()),
)
await session1.stop()
await session2.stop()
class RtpRouterTest(TestCase):
def test_route_rtcp(self):
receiver = object()
sender = object()
router = RtpRouter()
router.register_receiver(receiver, ssrcs=[1234, 2345], payload_types=[96, 97])
router.register_sender(sender, ssrc=3456)
# BYE
packet = RtcpByePacket(sources=[1234, 2345])
self.assertEqual(router.route_rtcp(packet), set([receiver]))
# RR
packet = RtcpRrPacket(
ssrc=1234,
reports=[
RtcpReceiverInfo(
ssrc=3456,
fraction_lost=0,
packets_lost=0,
highest_sequence=630,
jitter=1906,
lsr=0,
dlsr=0,
)
],
)
self.assertEqual(router.route_rtcp(packet), set([sender]))
# SR
packet = RtcpSrPacket(
ssrc=1234,
sender_info=RtcpSenderInfo(
ntp_timestamp=0, rtp_timestamp=0, packet_count=0, octet_count=0
),
reports=[
RtcpReceiverInfo(
ssrc=3456,
fraction_lost=0,
packets_lost=0,
highest_sequence=630,
jitter=1906,
lsr=0,
dlsr=0,
)
],
)
self.assertEqual(router.route_rtcp(packet), set([receiver, sender]))
# PSFB - PLI
packet = RtcpPsfbPacket(fmt=RTCP_PSFB_PLI, ssrc=1234, media_ssrc=3456)
self.assertEqual(router.route_rtcp(packet), set([sender]))
# PSFB - REMB
packet = RtcpPsfbPacket(
fmt=RTCP_PSFB_APP,
ssrc=1234,
media_ssrc=0,
fci=pack_remb_fci(4160000, [3456]),
)
self.assertEqual(router.route_rtcp(packet), set([sender]))
# PSFB - JUNK
packet = RtcpPsfbPacket(fmt=RTCP_PSFB_APP, ssrc=1234, media_ssrc=0, fci=b"JUNK")
self.assertEqual(router.route_rtcp(packet), set())
# RTPFB
packet = RtcpRtpfbPacket(fmt=RTCP_RTPFB_NACK, ssrc=1234, media_ssrc=3456)
self.assertEqual(router.route_rtcp(packet), set([sender]))
def test_route_rtp(self):
receiver1 = object()
receiver2 = object()
router = RtpRouter()
router.register_receiver(receiver1, ssrcs=[1234, 2345], payload_types=[96, 97])
router.register_receiver(receiver2, ssrcs=[3456, 4567], payload_types=[98, 99])
# known SSRC and payload type
self.assertEqual(
router.route_rtp(RtpPacket(ssrc=1234, payload_type=96)), receiver1
)
self.assertEqual(
router.route_rtp(RtpPacket(ssrc=2345, payload_type=97)), receiver1
)
self.assertEqual(
router.route_rtp(RtpPacket(ssrc=3456, payload_type=98)), receiver2
)
self.assertEqual(
router.route_rtp(RtpPacket(ssrc=4567, payload_type=99)), receiver2
)
# unknown SSRC, known payload type
self.assertEqual(
router.route_rtp(RtpPacket(ssrc=5678, payload_type=96)), receiver1
)
self.assertEqual(router.ssrc_table[5678], receiver1)
# unknown SSRC and payload type
self.assertEqual(router.route_rtp(RtpPacket(ssrc=6789, payload_type=100)), None)
def test_route_rtp_ambiguous_payload_type(self):
receiver1 = object()
receiver2 = object()
router = RtpRouter()
router.register_receiver(receiver1, ssrcs=[1234, 2345], payload_types=[96, 97])
router.register_receiver(receiver2, ssrcs=[3456, 4567], payload_types=[96, 97])
# known SSRC and payload type
self.assertEqual(
router.route_rtp(RtpPacket(ssrc=1234, payload_type=96)), receiver1
)
self.assertEqual(
router.route_rtp(RtpPacket(ssrc=2345, payload_type=97)), receiver1
)
self.assertEqual(
router.route_rtp(RtpPacket(ssrc=3456, payload_type=96)), receiver2
)
self.assertEqual(
router.route_rtp(RtpPacket(ssrc=4567, payload_type=97)), receiver2
)
# unknown SSRC, ambiguous payload type
self.assertEqual(router.route_rtp(RtpPacket(ssrc=5678, payload_type=96)), None)
self.assertEqual(router.route_rtp(RtpPacket(ssrc=5678, payload_type=97)), None)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/docs/conf.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/docs/conf.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# aiortc documentation build configuration file, created by
# sphinx-quickstart on Thu Feb 8 17:22:14 2018.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import os
import sys
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('..'))
class MockOpus:
OpusDecoder = None
OpusEncoder = None
class MockVpx:
Vp8Decoder = None
Vp8Encoder = None
vp8_depayload = None
sys.modules.update({'aiortc.codecs.opus': MockOpus()})
sys.modules.update({'aiortc.codecs.vpx': MockVpx()})
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.intersphinx',
'sphinx_autodoc_typehints',
'sphinxcontrib.asyncio',
]
autodoc_member_order = 'bysource'
intersphinx_mapping = {
'av': ('https://pyav.org/docs/stable', None)
}
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'aiortc'
copyright = u'2018-2019, Jeremy Lainé'
author = u'Jeremy Lainé'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = ''
# The full version, including alpha/beta/rc tags.
release = ''
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = "en"
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'alabaster'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
html_theme_options = {
'description': 'A library for building WebRTC and ORTC applications in Python.',
'github_button': True,
'github_user': 'aiortc',
'github_repo': 'aiortc',
'logo': 'aiortc.svg',
}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
#
# This is required for the alabaster theme
# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
html_sidebars = {
'**': [
'about.html',
'navigation.html',
'relations.html',
'searchbox.html',
]
}
# -- Options for HTMLHelp output ------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = 'aiortcdoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'aiortc.tex', 'aiortc Documentation',
u'Jeremy Lainé', 'manual'),
]
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'aiortc', 'aiortc Documentation',
[author], 1)
]
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'aiortc', 'aiortc Documentation',
author, 'aiortc', 'One line description of project.',
'Miscellaneous'),
]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/videostream-cli/cli.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/videostream-cli/cli.py | import argparse
import asyncio
import logging
import math
import cv2
import numpy
from av import VideoFrame
from aiortc import (
RTCIceCandidate,
RTCPeerConnection,
RTCSessionDescription,
VideoStreamTrack,
)
from aiortc.contrib.media import MediaBlackhole, MediaPlayer, MediaRecorder
from aiortc.contrib.signaling import BYE, add_signaling_arguments, create_signaling
class FlagVideoStreamTrack(VideoStreamTrack):
"""
A video track that returns an animated flag.
"""
def __init__(self):
super().__init__() # don't forget this!
self.counter = 0
height, width = 480, 640
# generate flag
data_bgr = numpy.hstack(
[
self._create_rectangle(
width=213, height=480, color=(255, 0, 0)
), # blue
self._create_rectangle(
width=214, height=480, color=(255, 255, 255)
), # white
self._create_rectangle(width=213, height=480, color=(0, 0, 255)), # red
]
)
# shrink and center it
M = numpy.float32([[0.5, 0, width / 4], [0, 0.5, height / 4]])
data_bgr = cv2.warpAffine(data_bgr, M, (width, height))
# compute animation
omega = 2 * math.pi / height
id_x = numpy.tile(numpy.array(range(width), dtype=numpy.float32), (height, 1))
id_y = numpy.tile(
numpy.array(range(height), dtype=numpy.float32), (width, 1)
).transpose()
self.frames = []
for k in range(30):
phase = 2 * k * math.pi / 30
map_x = id_x + 10 * numpy.cos(omega * id_x + phase)
map_y = id_y + 10 * numpy.sin(omega * id_x + phase)
self.frames.append(
VideoFrame.from_ndarray(
cv2.remap(data_bgr, map_x, map_y, cv2.INTER_LINEAR), format="bgr24"
)
)
async def recv(self):
pts, time_base = await self.next_timestamp()
frame = self.frames[self.counter % 30]
frame.pts = pts
frame.time_base = time_base
self.counter += 1
return frame
def _create_rectangle(self, width, height, color):
data_bgr = numpy.zeros((height, width, 3), numpy.uint8)
data_bgr[:, :] = color
return data_bgr
async def run(pc, player, recorder, signaling, role):
def add_tracks():
if player and player.audio:
pc.addTrack(player.audio)
if player and player.video:
pc.addTrack(player.video)
else:
pc.addTrack(FlagVideoStreamTrack())
@pc.on("track")
def on_track(track):
print("Receiving %s" % track.kind)
recorder.addTrack(track)
# connect signaling
await signaling.connect()
if role == "offer":
# send offer
add_tracks()
await pc.setLocalDescription(await pc.createOffer())
await signaling.send(pc.localDescription)
# consume signaling
while True:
obj = await signaling.receive()
if isinstance(obj, RTCSessionDescription):
await pc.setRemoteDescription(obj)
await recorder.start()
if obj.type == "offer":
# send answer
add_tracks()
await pc.setLocalDescription(await pc.createAnswer())
await signaling.send(pc.localDescription)
elif isinstance(obj, RTCIceCandidate):
await pc.addIceCandidate(obj)
elif obj is BYE:
print("Exiting")
break
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Video stream from the command line")
parser.add_argument("role", choices=["offer", "answer"])
parser.add_argument("--play-from", help="Read the media from a file and sent it."),
parser.add_argument("--record-to", help="Write received media to a file."),
parser.add_argument("--verbose", "-v", action="count")
add_signaling_arguments(parser)
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
# create signaling and peer connection
signaling = create_signaling(args)
pc = RTCPeerConnection()
# create media source
if args.play_from:
player = MediaPlayer(args.play_from)
else:
player = None
# create media sink
if args.record_to:
recorder = MediaRecorder(args.record_to)
else:
recorder = MediaBlackhole()
# run event loop
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(
run(
pc=pc,
player=player,
recorder=recorder,
signaling=signaling,
role=args.role,
)
)
except KeyboardInterrupt:
pass
finally:
# cleanup
loop.run_until_complete(recorder.stop())
loop.run_until_complete(signaling.close())
loop.run_until_complete(pc.close())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/janus/janus.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/janus/janus.py | import argparse
import asyncio
import logging
import random
import string
import time
import aiohttp
from aiortc import RTCPeerConnection, RTCSessionDescription, VideoStreamTrack
from aiortc.contrib.media import MediaPlayer, MediaRecorder
pcs = set()
def transaction_id():
return "".join(random.choice(string.ascii_letters) for x in range(12))
class JanusPlugin:
def __init__(self, session, url):
self._queue = asyncio.Queue()
self._session = session
self._url = url
async def send(self, payload):
message = {"janus": "message", "transaction": transaction_id()}
message.update(payload)
async with self._session._http.post(self._url, json=message) as response:
data = await response.json()
assert data["janus"] == "ack"
response = await self._queue.get()
assert response["transaction"] == message["transaction"]
return response
class JanusSession:
def __init__(self, url):
self._http = None
self._poll_task = None
self._plugins = {}
self._root_url = url
self._session_url = None
async def attach(self, plugin_name: str) -> JanusPlugin:
message = {
"janus": "attach",
"plugin": plugin_name,
"transaction": transaction_id(),
}
async with self._http.post(self._session_url, json=message) as response:
data = await response.json()
assert data["janus"] == "success"
plugin_id = data["data"]["id"]
plugin = JanusPlugin(self, self._session_url + "/" + str(plugin_id))
self._plugins[plugin_id] = plugin
return plugin
async def create(self):
self._http = aiohttp.ClientSession()
message = {"janus": "create", "transaction": transaction_id()}
async with self._http.post(self._root_url, json=message) as response:
data = await response.json()
assert data["janus"] == "success"
session_id = data["data"]["id"]
self._session_url = self._root_url + "/" + str(session_id)
self._poll_task = asyncio.ensure_future(self._poll())
async def destroy(self):
if self._poll_task:
self._poll_task.cancel()
self._poll_task = None
if self._session_url:
message = {"janus": "destroy", "transaction": transaction_id()}
async with self._http.post(self._session_url, json=message) as response:
data = await response.json()
assert data["janus"] == "success"
self._session_url = None
if self._http:
await self._http.close()
self._http = None
async def _poll(self):
while True:
params = {"maxev": 1, "rid": int(time.time() * 1000)}
async with self._http.get(self._session_url, params=params) as response:
data = await response.json()
if data["janus"] == "event":
plugin = self._plugins.get(data["sender"], None)
if plugin:
await plugin._queue.put(data)
else:
print(data)
async def publish(plugin, player):
"""
Send video to the room.
"""
pc = RTCPeerConnection()
pcs.add(pc)
# configure media
media = {"audio": False, "video": True}
if player and player.audio:
pc.addTrack(player.audio)
media["audio"] = True
if player and player.video:
pc.addTrack(player.video)
else:
pc.addTrack(VideoStreamTrack())
# send offer
await pc.setLocalDescription(await pc.createOffer())
request = {"request": "configure"}
request.update(media)
response = await plugin.send(
{
"body": request,
"jsep": {
"sdp": pc.localDescription.sdp,
"trickle": False,
"type": pc.localDescription.type,
},
}
)
# apply answer
await pc.setRemoteDescription(
RTCSessionDescription(
sdp=response["jsep"]["sdp"], type=response["jsep"]["type"]
)
)
async def subscribe(session, room, feed, recorder):
pc = RTCPeerConnection()
pcs.add(pc)
@pc.on("track")
async def on_track(track):
print("Track %s received" % track.kind)
if track.kind == "video":
recorder.addTrack(track)
if track.kind == "audio":
recorder.addTrack(track)
# subscribe
plugin = await session.attach("janus.plugin.videoroom")
response = await plugin.send(
{"body": {"request": "join", "ptype": "subscriber", "room": room, "feed": feed}}
)
# apply offer
await pc.setRemoteDescription(
RTCSessionDescription(
sdp=response["jsep"]["sdp"], type=response["jsep"]["type"]
)
)
# send answer
await pc.setLocalDescription(await pc.createAnswer())
response = await plugin.send(
{
"body": {"request": "start"},
"jsep": {
"sdp": pc.localDescription.sdp,
"trickle": False,
"type": pc.localDescription.type,
},
}
)
await recorder.start()
async def run(player, recorder, room, session):
await session.create()
# join video room
plugin = await session.attach("janus.plugin.videoroom")
response = await plugin.send(
{
"body": {
"display": "aiortc",
"ptype": "publisher",
"request": "join",
"room": room,
}
}
)
publishers = response["plugindata"]["data"]["publishers"]
for publisher in publishers:
print("id: %(id)s, display: %(display)s" % publisher)
# send video
await publish(plugin=plugin, player=player)
# receive video
if recorder is not None and publishers:
await subscribe(
session=session, room=room, feed=publishers[0]["id"], recorder=recorder
)
# exchange media for 10 minutes
print("Exchanging media")
await asyncio.sleep(600)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Janus")
parser.add_argument("url", help="Janus root URL, e.g. http://localhost:8088/janus")
parser.add_argument(
"--room",
type=int,
default=1234,
help="The video room ID to join (default: 1234).",
),
parser.add_argument("--play-from", help="Read the media from a file and sent it."),
parser.add_argument("--record-to", help="Write received media to a file."),
parser.add_argument(
"--play-without-decoding",
help=(
"Read the media without decoding it (experimental). "
"For now it only works with an MPEGTS container with only H.264 video."
),
action="store_true",
)
parser.add_argument("--verbose", "-v", action="count")
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
# create signaling and peer connection
session = JanusSession(args.url)
# create media source
if args.play_from:
player = MediaPlayer(args.play_from, decode=not args.play_without_decoding)
else:
player = None
# create media sink
if args.record_to:
recorder = MediaRecorder(args.record_to)
else:
recorder = None
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(
run(player=player, recorder=recorder, room=args.room, session=session)
)
except KeyboardInterrupt:
pass
finally:
if recorder is not None:
loop.run_until_complete(recorder.stop())
loop.run_until_complete(session.destroy())
# close peer connections
coros = [pc.close() for pc in pcs]
loop.run_until_complete(asyncio.gather(*coros))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/webcam/webcam.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/webcam/webcam.py | import argparse
import asyncio
import json
import logging
import os
import platform
import ssl
from aiohttp import web
from aiortc import RTCPeerConnection, RTCSessionDescription
from aiortc.contrib.media import MediaPlayer, MediaRelay
from aiortc.rtcrtpsender import RTCRtpSender
ROOT = os.path.dirname(__file__)
relay = None
webcam = None
def create_local_tracks(play_from, decode):
global relay, webcam
if play_from:
player = MediaPlayer(play_from, decode=decode)
return player.audio, player.video
else:
options = {"framerate": "30", "video_size": "640x480"}
if relay is None:
if platform.system() == "Darwin":
webcam = MediaPlayer(
"default:none", format="avfoundation", options=options
)
elif platform.system() == "Windows":
webcam = MediaPlayer(
"video=Integrated Camera", format="dshow", options=options
)
else:
webcam = MediaPlayer("/dev/video0", format="v4l2", options=options)
relay = MediaRelay()
return None, relay.subscribe(webcam.video)
def force_codec(pc, sender, forced_codec):
kind = forced_codec.split("/")[0]
codecs = RTCRtpSender.getCapabilities(kind).codecs
transceiver = next(t for t in pc.getTransceivers() if t.sender == sender)
transceiver.setCodecPreferences(
[codec for codec in codecs if codec.mimeType == forced_codec]
)
async def index(request):
content = open(os.path.join(ROOT, "index.html"), "r").read()
return web.Response(content_type="text/html", text=content)
async def javascript(request):
content = open(os.path.join(ROOT, "client.js"), "r").read()
return web.Response(content_type="application/javascript", text=content)
async def offer(request):
params = await request.json()
offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"])
pc = RTCPeerConnection()
pcs.add(pc)
@pc.on("connectionstatechange")
async def on_connectionstatechange():
print("Connection state is %s" % pc.connectionState)
if pc.connectionState == "failed":
await pc.close()
pcs.discard(pc)
# open media source
audio, video = create_local_tracks(
args.play_from, decode=not args.play_without_decoding
)
if audio:
audio_sender = pc.addTrack(audio)
if args.audio_codec:
force_codec(pc, audio_sender, args.audio_codec)
elif args.play_without_decoding:
raise Exception("You must specify the audio codec using --audio-codec")
if video:
video_sender = pc.addTrack(video)
if args.video_codec:
force_codec(pc, video_sender, args.video_codec)
elif args.play_without_decoding:
raise Exception("You must specify the video codec using --video-codec")
await pc.setRemoteDescription(offer)
answer = await pc.createAnswer()
await pc.setLocalDescription(answer)
return web.Response(
content_type="application/json",
text=json.dumps(
{"sdp": pc.localDescription.sdp, "type": pc.localDescription.type}
),
)
pcs = set()
async def on_shutdown(app):
# close peer connections
coros = [pc.close() for pc in pcs]
await asyncio.gather(*coros)
pcs.clear()
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="WebRTC webcam demo")
parser.add_argument("--cert-file", help="SSL certificate file (for HTTPS)")
parser.add_argument("--key-file", help="SSL key file (for HTTPS)")
parser.add_argument("--play-from", help="Read the media from a file and sent it."),
parser.add_argument(
"--play-without-decoding",
help=(
"Read the media without decoding it (experimental). "
"For now it only works with an MPEGTS container with only H.264 video."
),
action="store_true",
)
parser.add_argument(
"--host", default="0.0.0.0", help="Host for HTTP server (default: 0.0.0.0)"
)
parser.add_argument(
"--port", type=int, default=8080, help="Port for HTTP server (default: 8080)"
)
parser.add_argument("--verbose", "-v", action="count")
parser.add_argument(
"--audio-codec", help="Force a specific audio codec (e.g. audio/opus)"
)
parser.add_argument(
"--video-codec", help="Force a specific video codec (e.g. video/H264)"
)
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
if args.cert_file:
ssl_context = ssl.SSLContext()
ssl_context.load_cert_chain(args.cert_file, args.key_file)
else:
ssl_context = None
app = web.Application()
app.on_shutdown.append(on_shutdown)
app.router.add_get("/", index)
app.router.add_get("/client.js", javascript)
app.router.add_post("/offer", offer)
web.run_app(app, host=args.host, port=args.port, ssl_context=ssl_context)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/datachannel-vpn/vpn.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/datachannel-vpn/vpn.py | import argparse
import asyncio
import logging
import tuntap
from aiortc import RTCIceCandidate, RTCPeerConnection, RTCSessionDescription
from aiortc.contrib.signaling import BYE, add_signaling_arguments, create_signaling
logger = logging.Logger("vpn")
def channel_log(channel, t, message):
logger.info("channel(%s) %s %s" % (channel.label, t, repr(message)))
async def consume_signaling(pc, signaling):
while True:
obj = await signaling.receive()
if isinstance(obj, RTCSessionDescription):
await pc.setRemoteDescription(obj)
if obj.type == "offer":
# send answer
await pc.setLocalDescription(await pc.createAnswer())
await signaling.send(pc.localDescription)
elif isinstance(obj, RTCIceCandidate):
await pc.addIceCandidate(obj)
elif obj is BYE:
print("Exiting")
break
def tun_start(tap, channel):
tap.open()
# relay channel -> tap
channel.on("message")(tap.fd.write)
# relay tap -> channel
def tun_reader():
data = tap.fd.read(tap.mtu)
if data:
channel.send(data)
loop = asyncio.get_event_loop()
loop.add_reader(tap.fd, tun_reader)
tap.up()
async def run_answer(pc, signaling, tap):
await signaling.connect()
@pc.on("datachannel")
def on_datachannel(channel):
channel_log(channel, "-", "created by remote party")
if channel.label == "vpntap":
tun_start(tap, channel)
await consume_signaling(pc, signaling)
async def run_offer(pc, signaling, tap):
await signaling.connect()
channel = pc.createDataChannel("vpntap")
channel_log(channel, "-", "created by local party")
@channel.on("open")
def on_open():
tun_start(tap, channel)
# send offer
await pc.setLocalDescription(await pc.createOffer())
await signaling.send(pc.localDescription)
await consume_signaling(pc, signaling)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="VPN over data channel")
parser.add_argument("role", choices=["offer", "answer"])
parser.add_argument("--verbose", "-v", action="count")
add_signaling_arguments(parser)
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
tap = tuntap.Tun(name="revpn-%s" % args.role)
signaling = create_signaling(args)
pc = RTCPeerConnection()
if args.role == "offer":
coro = run_offer(pc, signaling, tap)
else:
coro = run_answer(pc, signaling, tap)
# run event loop
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(coro)
except KeyboardInterrupt:
pass
finally:
loop.run_until_complete(pc.close())
loop.run_until_complete(signaling.close())
tap.close()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/datachannel-vpn/tuntap.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/datachannel-vpn/tuntap.py | import fcntl
import os
import socket
import struct
TUNSETIFF = 0x400454CA
TUNSETOWNER = TUNSETIFF + 2
IFF_TUN = 0x0001
IFF_TAP = 0x0002
IFF_NAPI = 0x0010
IFF_NAPI_FRAGS = 0x0020
IFF_NO_PI = 0x1000
IFF_PERSIST = 0x0800
IFF_NOFILTER = 0x1000
# net/if.h
IFF_UP = 0x1
IFF_RUNNING = 0x40
IFNAMSIZ = 16
# From linux/sockios.h
SIOCGIFCONF = 0x8912
SIOCGIFINDEX = 0x8933
SIOCGIFFLAGS = 0x8913
SIOCSIFFLAGS = 0x8914
SIOCGIFHWADDR = 0x8927
SIOCSIFHWADDR = 0x8924
SIOCGIFADDR = 0x8915
SIOCSIFADDR = 0x8916
SIOCGIFNETMASK = 0x891B
SIOCSIFNETMASK = 0x891C
SIOCETHTOOL = 0x8946
SIOCGIFMTU = 0x8921 # get MTU size
SIOCSIFMTU = 0x8922 # set MTU size
class Tun:
mtu = 1500
def __init__(self, name, mode="tap", persist=True):
self.name = name.encode()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sockfd = sock
@property
def ifflags(self):
# Get existing device flags
ifreq = struct.pack("16sh", self.name, 0)
flags = struct.unpack("16sh", fcntl.ioctl(self.sockfd, SIOCGIFFLAGS, ifreq))[1]
return flags
@ifflags.setter
def ifflags(self, flags):
ifreq = struct.pack("16sh", self.name, flags)
fcntl.ioctl(self.sockfd, SIOCSIFFLAGS, ifreq)
def get_mtu(self):
ifreq = struct.pack("16sh", self.name, 0)
self.mtu = struct.unpack("16sh", fcntl.ioctl(self.sockfd, SIOCGIFMTU, ifreq))[1]
def up(self):
"""Bring up interface. Equivalent to ifconfig [iface] up."""
# Set new flags
flags = self.ifflags | IFF_UP
self.ifflags = flags
self.get_mtu()
def down(self):
"""Bring down interface. Equivalent to ifconfig [iface] down."""
# Set new flags
flags = self.ifflags & ~IFF_UP
self.ifflags = flags
def is_up(self):
"""Return True if the interface is up, False otherwise."""
if self.ifflags & IFF_UP:
return True
else:
return False
def open(self):
"""Open file corresponding to the TUN device."""
self.fd = open("/dev/net/tun", "rb+", buffering=0)
tun_flags = IFF_TAP | IFF_NO_PI | IFF_PERSIST
ifr = struct.pack("16sH", self.name, tun_flags)
fcntl.ioctl(self.fd, TUNSETIFF, ifr)
fcntl.ioctl(self.fd, TUNSETOWNER, os.getuid())
self.ifflags = self.ifflags | IFF_RUNNING
def close(self):
if self.fd:
self.ifflags = self.ifflags & ~IFF_RUNNING
self.fd.close()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/datachannel-filexfer/filexfer.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/datachannel-filexfer/filexfer.py | import argparse
import asyncio
import logging
import time
from aiortc import RTCIceCandidate, RTCPeerConnection, RTCSessionDescription
from aiortc.contrib.signaling import BYE, add_signaling_arguments, create_signaling
# optional, for better performance
try:
import uvloop
except ImportError:
uvloop = None
async def consume_signaling(pc, signaling):
while True:
obj = await signaling.receive()
if isinstance(obj, RTCSessionDescription):
await pc.setRemoteDescription(obj)
if obj.type == "offer":
# send answer
await pc.setLocalDescription(await pc.createAnswer())
await signaling.send(pc.localDescription)
elif isinstance(obj, RTCIceCandidate):
await pc.addIceCandidate(obj)
elif obj is BYE:
print("Exiting")
break
async def run_answer(pc, signaling, filename):
await signaling.connect()
@pc.on("datachannel")
def on_datachannel(channel):
start = time.time()
octets = 0
@channel.on("message")
async def on_message(message):
nonlocal octets
if message:
octets += len(message)
fp.write(message)
else:
elapsed = time.time() - start
print(
"received %d bytes in %.1f s (%.3f Mbps)"
% (octets, elapsed, octets * 8 / elapsed / 1000000)
)
# say goodbye
await signaling.send(BYE)
await consume_signaling(pc, signaling)
async def run_offer(pc, signaling, fp):
await signaling.connect()
done_reading = False
channel = pc.createDataChannel("filexfer")
def send_data():
nonlocal done_reading
while (
channel.bufferedAmount <= channel.bufferedAmountLowThreshold
) and not done_reading:
data = fp.read(16384)
channel.send(data)
if not data:
done_reading = True
channel.on("bufferedamountlow", send_data)
channel.on("open", send_data)
# send offer
await pc.setLocalDescription(await pc.createOffer())
await signaling.send(pc.localDescription)
await consume_signaling(pc, signaling)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Data channel file transfer")
parser.add_argument("role", choices=["send", "receive"])
parser.add_argument("filename")
parser.add_argument("--verbose", "-v", action="count")
add_signaling_arguments(parser)
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
if uvloop is not None:
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
signaling = create_signaling(args)
pc = RTCPeerConnection()
if args.role == "send":
fp = open(args.filename, "rb")
coro = run_offer(pc, signaling, fp)
else:
fp = open(args.filename, "wb")
coro = run_answer(pc, signaling, fp)
# run event loop
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(coro)
except KeyboardInterrupt:
pass
finally:
fp.close()
loop.run_until_complete(pc.close())
loop.run_until_complete(signaling.close())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/datachannel-cli/cli.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/datachannel-cli/cli.py | import argparse
import asyncio
import logging
import time
from aiortc import RTCIceCandidate, RTCPeerConnection, RTCSessionDescription
from aiortc.contrib.signaling import BYE, add_signaling_arguments, create_signaling
def channel_log(channel, t, message):
print("channel(%s) %s %s" % (channel.label, t, message))
def channel_send(channel, message):
channel_log(channel, ">", message)
channel.send(message)
async def consume_signaling(pc, signaling):
while True:
obj = await signaling.receive()
if isinstance(obj, RTCSessionDescription):
await pc.setRemoteDescription(obj)
if obj.type == "offer":
# send answer
await pc.setLocalDescription(await pc.createAnswer())
await signaling.send(pc.localDescription)
elif isinstance(obj, RTCIceCandidate):
await pc.addIceCandidate(obj)
elif obj is BYE:
print("Exiting")
break
time_start = None
def current_stamp():
global time_start
if time_start is None:
time_start = time.time()
return 0
else:
return int((time.time() - time_start) * 1000000)
async def run_answer(pc, signaling):
await signaling.connect()
@pc.on("datachannel")
def on_datachannel(channel):
channel_log(channel, "-", "created by remote party")
@channel.on("message")
def on_message(message):
channel_log(channel, "<", message)
if isinstance(message, str) and message.startswith("ping"):
# reply
channel_send(channel, "pong" + message[4:])
await consume_signaling(pc, signaling)
async def run_offer(pc, signaling):
await signaling.connect()
channel = pc.createDataChannel("chat")
channel_log(channel, "-", "created by local party")
async def send_pings():
while True:
channel_send(channel, "ping %d" % current_stamp())
await asyncio.sleep(1)
@channel.on("open")
def on_open():
asyncio.ensure_future(send_pings())
@channel.on("message")
def on_message(message):
channel_log(channel, "<", message)
if isinstance(message, str) and message.startswith("pong"):
elapsed_ms = (current_stamp() - int(message[5:])) / 1000
print(" RTT %.2f ms" % elapsed_ms)
# send offer
await pc.setLocalDescription(await pc.createOffer())
await signaling.send(pc.localDescription)
await consume_signaling(pc, signaling)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Data channels ping/pong")
parser.add_argument("role", choices=["offer", "answer"])
parser.add_argument("--verbose", "-v", action="count")
add_signaling_arguments(parser)
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
signaling = create_signaling(args)
pc = RTCPeerConnection()
if args.role == "offer":
coro = run_offer(pc, signaling)
else:
coro = run_answer(pc, signaling)
# run event loop
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(coro)
except KeyboardInterrupt:
pass
finally:
loop.run_until_complete(pc.close())
loop.run_until_complete(signaling.close())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/server/server.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/examples/server/server.py | import argparse
import asyncio
import json
import logging
import os
import ssl
import uuid
import cv2
from aiohttp import web
from av import VideoFrame
from aiortc import MediaStreamTrack, RTCPeerConnection, RTCSessionDescription
from aiortc.contrib.media import MediaBlackhole, MediaPlayer, MediaRecorder, MediaRelay
ROOT = os.path.dirname(__file__)
logger = logging.getLogger("pc")
pcs = set()
relay = MediaRelay()
class VideoTransformTrack(MediaStreamTrack):
"""
A video stream track that transforms frames from an another track.
"""
kind = "video"
def __init__(self, track, transform):
super().__init__() # don't forget this!
self.track = track
self.transform = transform
async def recv(self):
frame = await self.track.recv()
if self.transform == "cartoon":
img = frame.to_ndarray(format="bgr24")
# prepare color
img_color = cv2.pyrDown(cv2.pyrDown(img))
for _ in range(6):
img_color = cv2.bilateralFilter(img_color, 9, 9, 7)
img_color = cv2.pyrUp(cv2.pyrUp(img_color))
# prepare edges
img_edges = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
img_edges = cv2.adaptiveThreshold(
cv2.medianBlur(img_edges, 7),
255,
cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY,
9,
2,
)
img_edges = cv2.cvtColor(img_edges, cv2.COLOR_GRAY2RGB)
# combine color and edges
img = cv2.bitwise_and(img_color, img_edges)
# rebuild a VideoFrame, preserving timing information
new_frame = VideoFrame.from_ndarray(img, format="bgr24")
new_frame.pts = frame.pts
new_frame.time_base = frame.time_base
return new_frame
elif self.transform == "edges":
# perform edge detection
img = frame.to_ndarray(format="bgr24")
img = cv2.cvtColor(cv2.Canny(img, 100, 200), cv2.COLOR_GRAY2BGR)
# rebuild a VideoFrame, preserving timing information
new_frame = VideoFrame.from_ndarray(img, format="bgr24")
new_frame.pts = frame.pts
new_frame.time_base = frame.time_base
return new_frame
elif self.transform == "rotate":
# rotate image
img = frame.to_ndarray(format="bgr24")
rows, cols, _ = img.shape
M = cv2.getRotationMatrix2D((cols / 2, rows / 2), frame.time * 45, 1)
img = cv2.warpAffine(img, M, (cols, rows))
# rebuild a VideoFrame, preserving timing information
new_frame = VideoFrame.from_ndarray(img, format="bgr24")
new_frame.pts = frame.pts
new_frame.time_base = frame.time_base
return new_frame
else:
return frame
async def index(request):
content = open(os.path.join(ROOT, "index.html"), "r").read()
return web.Response(content_type="text/html", text=content)
async def javascript(request):
content = open(os.path.join(ROOT, "client.js"), "r").read()
return web.Response(content_type="application/javascript", text=content)
async def offer(request):
params = await request.json()
offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"])
pc = RTCPeerConnection()
pc_id = "PeerConnection(%s)" % uuid.uuid4()
pcs.add(pc)
def log_info(msg, *args):
logger.info(pc_id + " " + msg, *args)
log_info("Created for %s", request.remote)
# prepare local media
player = MediaPlayer(os.path.join(ROOT, "demo-instruct.wav"))
if args.record_to:
recorder = MediaRecorder(args.record_to)
else:
recorder = MediaBlackhole()
@pc.on("datachannel")
def on_datachannel(channel):
@channel.on("message")
def on_message(message):
if isinstance(message, str) and message.startswith("ping"):
channel.send("pong" + message[4:])
@pc.on("connectionstatechange")
async def on_connectionstatechange():
log_info("Connection state is %s", pc.connectionState)
if pc.connectionState == "failed":
await pc.close()
pcs.discard(pc)
@pc.on("track")
def on_track(track):
log_info("Track %s received", track.kind)
if track.kind == "audio":
pc.addTrack(player.audio)
recorder.addTrack(track)
elif track.kind == "video":
pc.addTrack(
VideoTransformTrack(
relay.subscribe(track), transform=params["video_transform"]
)
)
if args.record_to:
recorder.addTrack(relay.subscribe(track))
@track.on("ended")
async def on_ended():
log_info("Track %s ended", track.kind)
await recorder.stop()
# handle offer
await pc.setRemoteDescription(offer)
await recorder.start()
# send answer
answer = await pc.createAnswer()
await pc.setLocalDescription(answer)
return web.Response(
content_type="application/json",
text=json.dumps(
{"sdp": pc.localDescription.sdp, "type": pc.localDescription.type}
),
)
async def on_shutdown(app):
# close peer connections
coros = [pc.close() for pc in pcs]
await asyncio.gather(*coros)
pcs.clear()
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="WebRTC audio / video / data-channels demo"
)
parser.add_argument("--cert-file", help="SSL certificate file (for HTTPS)")
parser.add_argument("--key-file", help="SSL key file (for HTTPS)")
parser.add_argument(
"--host", default="0.0.0.0", help="Host for HTTP server (default: 0.0.0.0)"
)
parser.add_argument(
"--port", type=int, default=8080, help="Port for HTTP server (default: 8080)"
)
parser.add_argument("--record-to", help="Write received media to a file."),
parser.add_argument("--verbose", "-v", action="count")
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
if args.cert_file:
ssl_context = ssl.SSLContext()
ssl_context.load_cert_chain(args.cert_file, args.key_file)
else:
ssl_context = None
app = web.Application()
app.on_shutdown.append(on_shutdown)
app.router.add_get("/", index)
app.router.add_get("/client.js", javascript)
app.router.add_post("/offer", offer)
web.run_app(
app, access_log=None, host=args.host, port=args.port, ssl_context=ssl_context
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/setup.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/setup.py | import os.path
import sys
import setuptools
root_dir = os.path.abspath(os.path.dirname(__file__))
about = {}
about_file = os.path.join(root_dir, "src", "aioice", "about.py")
with open(about_file, encoding="utf-8") as fp:
exec(fp.read(), about)
readme_file = os.path.join(root_dir, "README.rst")
with open(readme_file, encoding="utf-8") as f:
long_description = f.read()
setuptools.setup(
name=about["__title__"],
version=about["__version__"],
description=about["__summary__"],
long_description=long_description,
url=about["__uri__"],
author=about["__author__"],
author_email=about["__email__"],
license=about["__license__"],
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
],
package_dir={"": "src"},
package_data={"aioice": ["py.typed"]},
packages=["aioice"],
install_requires=["dnspython>=2.0.0", "netifaces"],
python_requires=">=3.7",
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/stun.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/stun.py | import asyncio
import binascii
import enum
import hmac
import ipaddress
from collections import OrderedDict
from struct import pack, unpack
from typing import Callable, Dict, List, Optional, Tuple
from .utils import random_transaction_id
COOKIE = 0x2112A442
FINGERPRINT_LENGTH = 8
FINGERPRINT_XOR = 0x5354554E
HEADER_LENGTH = 20
INTEGRITY_LENGTH = 24
IPV4_PROTOCOL = 1
IPV6_PROTOCOL = 2
RETRY_MAX = 6
RETRY_RTO = 0.5
def set_body_length(data: bytes, length: int) -> bytes:
return data[0:2] + pack("!H", length) + data[4:]
def message_fingerprint(data: bytes) -> int:
check_data = set_body_length(data, len(data) - HEADER_LENGTH + FINGERPRINT_LENGTH)
return binascii.crc32(check_data) ^ FINGERPRINT_XOR
def message_integrity(data: bytes, key: bytes) -> bytes:
check_data = set_body_length(data, len(data) - HEADER_LENGTH + INTEGRITY_LENGTH)
return hmac.new(key, check_data, "sha1").digest()
def xor_address(data: bytes, transaction_id: bytes) -> bytes:
xpad = pack("!HI", COOKIE >> 16, COOKIE) + transaction_id
xdata = data[0:2]
for i in range(2, len(data)):
xdata += int.to_bytes(data[i] ^ xpad[i - 2], 1, "big", signed=False)
return xdata
def pack_address(value: Tuple[str, int]) -> bytes:
ip_address = ipaddress.ip_address(value[0])
if isinstance(ip_address, ipaddress.IPv4Address):
protocol = IPV4_PROTOCOL
else:
protocol = IPV6_PROTOCOL
return pack("!BBH", 0, protocol, value[1]) + ip_address.packed
def pack_bytes(value: bytes) -> bytes:
return value
def pack_error_code(value: Tuple[int, str]) -> bytes:
return pack("!HBB", 0, value[0] // 100, value[0] % 100) + value[1].encode("utf8")
def pack_none(value: None) -> bytes:
return b""
def pack_string(value: str) -> bytes:
return value.encode("utf8")
def pack_unsigned(value: int) -> bytes:
return pack("!I", value)
def pack_unsigned_short(value: int) -> bytes:
return pack("!H", value) + b"\x00\x00"
def pack_unsigned_64(value: int) -> bytes:
return pack("!Q", value)
def pack_xor_address(value: Tuple[str, int], transaction_id: bytes) -> bytes:
return xor_address(pack_address(value), transaction_id)
def unpack_address(data: bytes) -> Tuple[str, int]:
if len(data) < 4:
raise ValueError("STUN address length is less than 4 bytes")
reserved, protocol, port = unpack("!BBH", data[0:4])
address = data[4:]
if protocol == IPV4_PROTOCOL:
if len(address) != 4:
raise ValueError("STUN address has invalid length for IPv4")
return (str(ipaddress.IPv4Address(address)), port)
elif protocol == IPV6_PROTOCOL:
if len(address) != 16:
raise ValueError("STUN address has invalid length for IPv6")
return (str(ipaddress.IPv6Address(address)), port)
else:
raise ValueError("STUN address has unknown protocol")
def unpack_xor_address(data: bytes, transaction_id: bytes) -> Tuple[str, int]:
return unpack_address(xor_address(data, transaction_id))
def unpack_bytes(data: bytes) -> bytes:
return data
def unpack_error_code(data: bytes) -> Tuple[int, str]:
if len(data) < 4:
raise ValueError("STUN error code is less than 4 bytes")
reserved, code_high, code_low = unpack("!HBB", data[0:4])
reason = data[4:].decode("utf8")
return (code_high * 100 + code_low, reason)
def unpack_none(data: bytes) -> None:
return None
def unpack_string(data: bytes) -> str:
return data.decode("utf8")
def unpack_unsigned(data: bytes) -> int:
return unpack("!I", data)[0]
def unpack_unsigned_short(data: bytes) -> int:
return unpack("!H", data[0:2])[0]
def unpack_unsigned_64(data: bytes) -> int:
return unpack("!Q", data)[0]
AttributeEntry = Tuple[int, str, Callable, Callable]
ATTRIBUTES: List[AttributeEntry] = [
(0x0001, "MAPPED-ADDRESS", pack_address, unpack_address),
(0x0003, "CHANGE-REQUEST", pack_unsigned, unpack_unsigned),
(0x0004, "SOURCE-ADDRESS", pack_address, unpack_address),
(0x0005, "CHANGED-ADDRESS", pack_address, unpack_address),
(0x0006, "USERNAME", pack_string, unpack_string),
(0x0008, "MESSAGE-INTEGRITY", pack_bytes, unpack_bytes),
(0x0009, "ERROR-CODE", pack_error_code, unpack_error_code),
(0x000C, "CHANNEL-NUMBER", pack_unsigned_short, unpack_unsigned_short),
(0x000D, "LIFETIME", pack_unsigned, unpack_unsigned),
(0x0012, "XOR-PEER-ADDRESS", pack_xor_address, unpack_xor_address),
(0x0014, "REALM", pack_string, unpack_string),
(0x0015, "NONCE", pack_bytes, unpack_bytes),
(0x0016, "XOR-RELAYED-ADDRESS", pack_xor_address, unpack_xor_address),
(0x0019, "REQUESTED-TRANSPORT", pack_unsigned, unpack_unsigned),
(0x0020, "XOR-MAPPED-ADDRESS", pack_xor_address, unpack_xor_address),
(0x0024, "PRIORITY", pack_unsigned, unpack_unsigned),
(0x0025, "USE-CANDIDATE", pack_none, unpack_none),
(0x8022, "SOFTWARE", pack_string, unpack_string),
(0x8028, "FINGERPRINT", pack_unsigned, unpack_unsigned),
(0x8029, "ICE-CONTROLLED", pack_unsigned_64, unpack_unsigned_64),
(0x802A, "ICE-CONTROLLING", pack_unsigned_64, unpack_unsigned_64),
(0x802B, "RESPONSE-ORIGIN", pack_address, unpack_address),
(0x802C, "OTHER-ADDRESS", pack_address, unpack_address),
]
ATTRIBUTES_BY_TYPE: Dict[int, AttributeEntry] = {}
ATTRIBUTES_BY_NAME: Dict[str, AttributeEntry] = {}
for attr in ATTRIBUTES:
ATTRIBUTES_BY_TYPE[attr[0]] = attr
ATTRIBUTES_BY_NAME[attr[1]] = attr
class Class(enum.IntEnum):
REQUEST = 0x000
INDICATION = 0x010
RESPONSE = 0x100
ERROR = 0x110
class Method(enum.IntEnum):
BINDING = 0x1
SHARED_SECRET = 0x2
ALLOCATE = 0x3
REFRESH = 0x4
SEND = 0x6
DATA = 0x7
CREATE_PERMISSION = 0x8
CHANNEL_BIND = 0x9
class Message:
def __init__(
self,
message_method: Method,
message_class: Class,
transaction_id: Optional[bytes] = None,
attributes: Optional[OrderedDict] = None,
) -> None:
self.message_method = message_method
self.message_class = message_class
self.transaction_id = transaction_id or random_transaction_id()
self.attributes = attributes or OrderedDict()
def add_message_integrity(self, key: bytes) -> None:
"""
Add MESSAGE-INTEGRITY and FINGERPRINT attributes to the message.
This must be the last step before sending out the message.
"""
self.attributes.pop("MESSAGE-INTEGRITY", None)
self.attributes.pop("FINGERPRINT", None)
self.attributes["MESSAGE-INTEGRITY"] = message_integrity(bytes(self), key)
self.attributes["FINGERPRINT"] = message_fingerprint(bytes(self))
def __bytes__(self) -> bytes:
data = b""
for attr_name, attr_value in self.attributes.items():
attr_type, _, attr_pack, attr_unpack = ATTRIBUTES_BY_NAME[attr_name]
if attr_pack == pack_xor_address:
v = attr_pack(attr_value, self.transaction_id)
else:
v = attr_pack(attr_value)
attr_len = len(v)
pad_len = padding_length(attr_len)
data += pack("!HH", attr_type, attr_len) + v + bytes(pad_len)
return (
pack(
"!HHI12s",
self.message_method | self.message_class,
len(data),
COOKIE,
self.transaction_id,
)
+ data
)
def __repr__(self) -> str:
return (
"Message(message_method=Method.%s, message_class=Class.%s, transaction_id=%s)"
% (
self.message_method.name,
self.message_class.name,
repr(self.transaction_id),
)
)
class TransactionError(Exception):
response: Optional[Message] = None
class TransactionFailed(TransactionError):
def __init__(self, response: Message) -> None:
self.response = response
def __str__(self) -> str:
out = "STUN transaction failed"
if "ERROR-CODE" in self.response.attributes:
out += " (%s - %s)" % self.response.attributes["ERROR-CODE"]
return out
class TransactionTimeout(TransactionError):
def __str__(self) -> str:
return "STUN transaction timed out"
class Transaction:
def __init__(
self,
request: Message,
addr: Tuple[str, int],
protocol,
retransmissions: Optional[int] = None,
) -> None:
self.__addr = addr
self.__future: asyncio.Future[
Tuple[Message, Tuple[str, int]]
] = asyncio.Future()
self.__request = request
self.__timeout_delay = RETRY_RTO
self.__timeout_handle: Optional[asyncio.TimerHandle] = None
self.__protocol = protocol
self.__tries = 0
self.__tries_max = 1 + (
retransmissions if retransmissions is not None else RETRY_MAX
)
def response_received(self, message: Message, addr: Tuple[str, int]) -> None:
if not self.__future.done():
if message.message_class == Class.RESPONSE:
self.__future.set_result((message, addr))
else:
self.__future.set_exception(TransactionFailed(message))
async def run(self) -> Tuple[Message, Tuple[str, int]]:
try:
self.__retry()
return await self.__future
finally:
if self.__timeout_handle:
self.__timeout_handle.cancel()
def __retry(self) -> None:
if self.__tries >= self.__tries_max:
self.__future.set_exception(TransactionTimeout())
return
self.__protocol.send_stun(self.__request, self.__addr)
loop = asyncio.get_event_loop()
self.__timeout_handle = loop.call_later(self.__timeout_delay, self.__retry)
self.__timeout_delay *= 2
self.__tries += 1
def padding_length(length: int) -> int:
"""
STUN message attributes are padded to a 4-byte boundary.
"""
rest = length % 4
if rest == 0:
return 0
else:
return 4 - rest
def parse_message(data: bytes, integrity_key: Optional[bytes] = None) -> Message:
"""
Parses a STUN message.
If the ``integrity_key`` parameter is given, the message's HMAC will be verified.
"""
if len(data) < HEADER_LENGTH:
raise ValueError("STUN message length is less than 20 bytes")
message_type, length, cookie, transaction_id = unpack(
"!HHI12s", data[0:HEADER_LENGTH]
)
if len(data) != HEADER_LENGTH + length:
raise ValueError("STUN message length does not match")
attributes: OrderedDict = OrderedDict()
pos = HEADER_LENGTH
while pos <= len(data) - 4:
attr_type, attr_len = unpack("!HH", data[pos : pos + 4])
v = data[pos + 4 : pos + 4 + attr_len]
pad_len = padding_length(attr_len)
if attr_type in ATTRIBUTES_BY_TYPE:
_, attr_name, attr_pack, attr_unpack = ATTRIBUTES_BY_TYPE[attr_type]
if attr_unpack == unpack_xor_address:
attributes[attr_name] = attr_unpack(v, transaction_id=transaction_id)
else:
attributes[attr_name] = attr_unpack(v)
if attr_name == "FINGERPRINT":
if attributes[attr_name] != message_fingerprint(data[0:pos]):
raise ValueError("STUN message fingerprint does not match")
elif attr_name == "MESSAGE-INTEGRITY":
if integrity_key is not None and attributes[
attr_name
] != message_integrity(data[0:pos], integrity_key):
raise ValueError("STUN message integrity does not match")
pos += 4 + attr_len + pad_len
return Message(
# An unknown method raises a `ValueError`.
message_method=Method(message_type & 0x3EEF),
# This cast cannot fail, as all 4 possible classes are defined.
message_class=Class(message_type & 0x0110),
transaction_id=transaction_id,
attributes=attributes,
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/ice.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/ice.py | import asyncio
import copy
import enum
import ipaddress
import logging
import random
import secrets
import socket
import threading
from itertools import count
from typing import Dict, Iterable, List, Optional, Set, Text, Tuple, Union, cast
import netifaces
from . import mdns, stun, turn
from .candidate import Candidate, candidate_foundation, candidate_priority
from .utils import create_datagram_endpoint, random_string
logger = logging.getLogger(__name__)
ICE_COMPLETED = 1
ICE_FAILED = 2
CONSENT_FAILURES = 6
CONSENT_INTERVAL = 5
connection_id = count()
protocol_id = count()
_mdns = threading.local()
class TransportPolicy(enum.Enum):
ALL = 0
"""
All ICE candidates will be considered.
"""
RELAY = 1
"""
Only ICE candidates whose IP addresses are being relayed,
such as those being passed through a STUN or TURN server,
will be considered.
"""
async def get_or_create_mdns_protocol(subscriber: object) -> mdns.MDnsProtocol:
if not hasattr(_mdns, "lock"):
_mdns.lock = asyncio.Lock()
_mdns.protocol = None
_mdns.subscribers = set()
async with _mdns.lock:
if _mdns.protocol is None:
_mdns.protocol = await mdns.create_mdns_protocol()
_mdns.subscribers.add(subscriber)
return _mdns.protocol
async def unref_mdns_protocol(subscriber: object) -> None:
if hasattr(_mdns, "lock"):
async with _mdns.lock:
_mdns.subscribers.discard(subscriber)
if _mdns.protocol and not _mdns.subscribers:
await _mdns.protocol.close()
_mdns.protocol = None
def candidate_pair_priority(
local: Candidate, remote: Candidate, ice_controlling: bool
) -> int:
"""
See RFC 5245 - 5.7.2. Computing Pair Priority and Ordering Pairs
"""
G = ice_controlling and local.priority or remote.priority
D = ice_controlling and remote.priority or local.priority
return (1 << 32) * min(G, D) + 2 * max(G, D) + (G > D and 1 or 0)
def get_host_addresses(use_ipv4: bool, use_ipv6: bool) -> List[str]:
"""
Get local IP addresses.
"""
addresses = []
for interface in netifaces.interfaces():
ifaddresses = netifaces.ifaddresses(interface)
for address in ifaddresses.get(socket.AF_INET, []):
if use_ipv4 and address["addr"] != "127.0.0.1":
addresses.append(address["addr"])
for address in ifaddresses.get(socket.AF_INET6, []):
if use_ipv6 and address["addr"] != "::1" and "%" not in address["addr"]:
addresses.append(address["addr"])
return addresses
async def server_reflexive_candidate(
protocol, stun_server: Tuple[str, int]
) -> Candidate:
"""
Query STUN server to obtain a server-reflexive candidate.
"""
# lookup address
loop = asyncio.get_event_loop()
stun_server = (
await loop.run_in_executor(None, socket.gethostbyname, stun_server[0]),
stun_server[1],
)
# perform STUN query
request = stun.Message(
message_method=stun.Method.BINDING, message_class=stun.Class.REQUEST
)
response, _ = await protocol.request(request, stun_server)
local_candidate = protocol.local_candidate
return Candidate(
foundation=candidate_foundation("srflx", "udp", local_candidate.host),
component=local_candidate.component,
transport=local_candidate.transport,
priority=candidate_priority(local_candidate.component, "srflx"),
host=response.attributes["XOR-MAPPED-ADDRESS"][0],
port=response.attributes["XOR-MAPPED-ADDRESS"][1],
type="srflx",
related_address=local_candidate.host,
related_port=local_candidate.port,
)
def sort_candidate_pairs(pairs, ice_controlling: bool) -> None:
"""
Sort a list of candidate pairs.
"""
def pair_priority(pair: CandidatePair) -> int:
return -candidate_pair_priority(
pair.local_candidate, pair.remote_candidate, ice_controlling
)
pairs.sort(key=pair_priority)
def validate_remote_candidate(candidate: Candidate) -> Candidate:
"""
Check the remote candidate is supported.
"""
if candidate.type not in ["host", "relay", "srflx"]:
raise ValueError('Unexpected candidate type "%s"' % candidate.type)
ipaddress.ip_address(candidate.host)
return candidate
class CandidatePair:
def __init__(self, protocol, remote_candidate: Candidate) -> None:
self.handle: Optional[asyncio.Future[None]] = None
self.nominated = False
self.protocol = protocol
self.remote_candidate = remote_candidate
self.remote_nominated = False
self.state = CandidatePair.State.FROZEN
def __repr__(self) -> str:
return "CandidatePair(%s -> %s)" % (self.local_addr, self.remote_addr)
@property
def component(self) -> int:
return self.local_candidate.component
@property
def local_addr(self) -> Tuple[str, int]:
return (self.local_candidate.host, self.local_candidate.port)
@property
def local_candidate(self) -> Candidate:
return self.protocol.local_candidate
@property
def remote_addr(self) -> Tuple[str, int]:
return (self.remote_candidate.host, self.remote_candidate.port)
class State(enum.Enum):
FROZEN = 0
WAITING = 1
IN_PROGRESS = 2
SUCCEEDED = 3
FAILED = 4
class StunProtocol(asyncio.DatagramProtocol):
def __init__(self, receiver) -> None:
self.__closed: asyncio.Future[bool] = asyncio.Future()
self.id = next(protocol_id)
self.local_candidate: Optional[Candidate] = None
self.receiver = receiver
self.transport: Optional[asyncio.DatagramTransport] = None
self.transactions: Dict[bytes, stun.Transaction] = {}
def connection_lost(self, exc: Exception) -> None:
self.__log_debug("connection_lost(%s)", exc)
if not self.__closed.done():
self.receiver.data_received(None, None)
self.__closed.set_result(True)
def connection_made(self, transport) -> None:
self.__log_debug("connection_made(%s)", transport)
self.transport = transport
def datagram_received(self, data: Union[bytes, Text], addr: Tuple) -> None:
# force IPv6 four-tuple to a two-tuple
addr = (addr[0], addr[1])
data = cast(bytes, data)
try:
message = stun.parse_message(data)
self.__log_debug("< %s %s", addr, message)
except ValueError:
self.receiver.data_received(data, self.local_candidate.component)
return
if (
message.message_class == stun.Class.RESPONSE
or message.message_class == stun.Class.ERROR
) and message.transaction_id in self.transactions:
transaction = self.transactions[message.transaction_id]
transaction.response_received(message, addr)
elif message.message_class == stun.Class.REQUEST:
self.receiver.request_received(message, addr, self, data)
def error_received(self, exc: Exception) -> None:
self.__log_debug("error_received(%s)", exc)
# custom
async def close(self) -> None:
self.transport.close()
await self.__closed
async def request(
self,
request: stun.Message,
addr: Tuple[str, int],
integrity_key: Optional[bytes] = None,
retransmissions=None,
) -> Tuple[stun.Message, Tuple[str, int]]:
"""
Execute a STUN transaction and return the response.
"""
assert request.transaction_id not in self.transactions
if integrity_key is not None:
request.add_message_integrity(integrity_key)
transaction = stun.Transaction(
request, addr, self, retransmissions=retransmissions
)
self.transactions[request.transaction_id] = transaction
try:
return await transaction.run()
finally:
del self.transactions[request.transaction_id]
async def send_data(self, data: bytes, addr: Tuple[str, int]) -> None:
self.transport.sendto(data, addr)
def send_stun(self, message: stun.Message, addr: Tuple[str, int]) -> None:
"""
Send a STUN message.
"""
self.__log_debug("> %s %s", addr, message)
self.transport.sendto(bytes(message), addr)
def __log_debug(self, msg: str, *args) -> None:
logger.debug("%s %s " + msg, self.receiver, self, *args)
def __repr__(self) -> str:
return "protocol(%s)" % self.id
class ConnectionEvent:
pass
class ConnectionClosed(ConnectionEvent):
pass
class Connection:
"""
An ICE connection for a single media stream.
:param ice_controlling: Whether the local peer has the controlling role.
:param components: The number of components.
:param stun_server: The address of the STUN server or `None`.
:param turn_server: The address of the TURN server or `None`.
:param turn_username: The username for the TURN server.
:param turn_password: The password for the TURN server.
:param turn_ssl: Whether to use TLS for the TURN server.
:param turn_transport: The transport for TURN server, `"udp"` or `"tcp"`.
:param use_ipv4: Whether to use IPv4 candidates.
:param use_ipv6: Whether to use IPv6 candidates.
:param transport_policy: Transport policy.
:param ephemeral_ports: Set of allowed ephemeral local ports to bind to.
"""
def __init__(
self,
ice_controlling: bool,
components: int = 1,
stun_server: Optional[Tuple[str, int]] = None,
turn_server: Optional[Tuple[str, int]] = None,
turn_username: Optional[str] = None,
turn_password: Optional[str] = None,
turn_ssl: bool = False,
turn_transport: str = "udp",
use_ipv4: bool = True,
use_ipv6: bool = True,
transport_policy: TransportPolicy = TransportPolicy.ALL,
ephemeral_ports: Optional[Iterable[int]] = None,
) -> None:
self.ice_controlling = ice_controlling
#: Local username, automatically set to a random value.
self.local_username = random_string(4)
#: Local password, automatically set to a random value.
self.local_password = random_string(22)
#: Whether the remote party is an ICE Lite implementation.
self.remote_is_lite = False
#: Remote username, which you need to set.
self.remote_username: Optional[str] = None
#: Remote password, which you need to set.
self.remote_password: Optional[str] = None
self.stun_server = stun_server
self.turn_server = turn_server
self.turn_username = turn_username
self.turn_password = turn_password
self.turn_ssl = turn_ssl
self.turn_transport = turn_transport
# private
self._closed = False
self._components = set(range(1, components + 1))
self._check_list: List[CandidatePair] = []
self._check_list_done = False
self._check_list_state: asyncio.Queue = asyncio.Queue()
self._early_checks: List[
Tuple[stun.Message, Tuple[str, int], StunProtocol]
] = []
self._early_checks_done = False
self._event_waiter: Optional[asyncio.Future[ConnectionEvent]] = None
self._id = next(connection_id)
self._local_candidates: List[Candidate] = []
self._local_candidates_end = False
self._local_candidates_start = False
self._nominated: Dict[int, CandidatePair] = {}
self._nominating: Set[int] = set()
self._protocols: List[StunProtocol] = []
self._remote_candidates: List[Candidate] = []
self._remote_candidates_end = False
self._query_consent_handle: Optional[asyncio.Future[None]] = None
self._queue: asyncio.Queue = asyncio.Queue()
self._tie_breaker = secrets.randbits(64)
self._use_ipv4 = use_ipv4
self._use_ipv6 = use_ipv6
self._ephemeral_ports = ephemeral_ports
if (
stun_server is None
and turn_server is None
and transport_policy == TransportPolicy.RELAY
):
raise ValueError(
"Relay transport policy requires a STUN and/or TURN server."
)
self._transport_policy = transport_policy
@property
def local_candidates(self) -> List[Candidate]:
"""
Local candidates, automatically set by :meth:`gather_candidates`.
"""
return self._local_candidates[:]
@property
def remote_candidates(self) -> List[Candidate]:
"""
Remote candidates, which you need to populate using
:meth:`add_remote_candidate`.
"""
return self._remote_candidates[:]
async def add_remote_candidate(self, remote_candidate: Candidate) -> None:
"""
Add a remote candidate or signal end-of-candidates.
To signal end-of-candidates, pass `None`.
:param remote_candidate: A :class:`Candidate` instance or `None`.
"""
if self._remote_candidates_end:
raise ValueError("Cannot add remote candidate after end-of-candidates.")
# end-of-candidates
if remote_candidate is None:
self._prune_components()
self._remote_candidates_end = True
return
# resolve mDNS candidate
if mdns.is_mdns_hostname(remote_candidate.host):
mdns_protocol = await get_or_create_mdns_protocol(self)
remote_addr = await mdns_protocol.resolve(remote_candidate.host)
if remote_addr is None:
self.__log_info(
f'Remote candidate "{remote_candidate.host}" could not be resolved'
)
return
self.__log_info(
f'Remote candidate "{remote_candidate.host}" resolved to {remote_addr}'
)
copy_candidate = copy.copy(remote_candidate)
copy_candidate.host = remote_addr
await self.add_remote_candidate(copy_candidate)
return
# validate the remote candidate
try:
validate_remote_candidate(remote_candidate)
except ValueError as e:
self.__log_info(
f'Remote candidate "{remote_candidate.host}" is not valid: {e}'
)
return
self._remote_candidates.append(remote_candidate)
# pair the remote candidate
for protocol in self._protocols:
if protocol.local_candidate.can_pair_with(
remote_candidate
) and not self._find_pair(protocol, remote_candidate):
pair = CandidatePair(protocol, remote_candidate)
self._check_list.append(pair)
self.sort_check_list()
async def gather_candidates(self) -> None:
"""
Gather local candidates.
You **must** call this coroutine before calling :meth:`connect`.
"""
if not self._local_candidates_start:
self._local_candidates_start = True
addresses = get_host_addresses(
use_ipv4=self._use_ipv4, use_ipv6=self._use_ipv6
)
coros = [
self.get_component_candidates(component=component, addresses=addresses)
for component in self._components
]
for candidates in await asyncio.gather(*coros):
self._local_candidates += candidates
self._local_candidates_end = True
def get_default_candidate(self, component: int) -> Optional[Candidate]:
"""
Get the default local candidate for the specified component.
:param component: The component whose default candidate is requested.
"""
for candidate in sorted(self._local_candidates, key=lambda x: x.priority):
if candidate.component == component:
return candidate
return None
async def connect(self) -> None:
"""
Perform ICE handshake.
This coroutine returns if a candidate pair was successfuly nominated
and raises an exception otherwise.
"""
if not self._local_candidates_end:
raise ConnectionError("Local candidates gathering was not performed")
if self.remote_username is None or self.remote_password is None:
raise ConnectionError("Remote username or password is missing")
# 5.7.1. Forming Candidate Pairs
for remote_candidate in self._remote_candidates:
for protocol in self._protocols:
if protocol.local_candidate.can_pair_with(
remote_candidate
) and not self._find_pair(protocol, remote_candidate):
pair = CandidatePair(protocol, remote_candidate)
self._check_list.append(pair)
self.sort_check_list()
self._unfreeze_initial()
# handle early checks
for early_check in self._early_checks:
self.check_incoming(*early_check)
self._early_checks = []
self._early_checks_done = True
# perform checks
while True:
if not self.check_periodic():
break
await asyncio.sleep(0.02)
# wait for completion
if self._check_list:
res = await self._check_list_state.get()
else:
res = ICE_FAILED
# cancel remaining checks
for check in self._check_list:
if check.handle:
check.handle.cancel()
if res != ICE_COMPLETED:
raise ConnectionError("ICE negotiation failed")
# start consent freshness tests
self._query_consent_handle = asyncio.ensure_future(self.query_consent())
async def close(self) -> None:
"""
Close the connection.
"""
# stop consent freshness tests
if self._query_consent_handle and not self._query_consent_handle.done():
self._query_consent_handle.cancel()
try:
await self._query_consent_handle
except asyncio.CancelledError:
pass
# stop check list
if self._check_list and not self._check_list_done:
await self._check_list_state.put(ICE_FAILED)
# unreference mDNS
await unref_mdns_protocol(self)
self._nominated.clear()
for protocol in self._protocols:
await protocol.close()
self._protocols.clear()
self._local_candidates.clear()
# emit event
if not self._closed:
self._emit_event(ConnectionClosed())
self._closed = True
async def get_event(self) -> Optional[ConnectionEvent]:
"""
Return the next `ConnectionEvent` or `None` if the connection is
already closed.
This method may only be called once at a time.
"""
assert self._event_waiter is None, "already awaiting event"
if self._closed:
return None
loop = asyncio.get_event_loop()
self._event_waiter = loop.create_future()
return await asyncio.shield(self._event_waiter)
async def recv(self) -> bytes:
"""
Receive the next datagram.
The return value is a `bytes` object representing the data received.
If the connection is not established, a `ConnectionError` is raised.
"""
data, component = await self.recvfrom()
return data
async def recvfrom(self) -> Tuple[bytes, int]:
"""
Receive the next datagram.
The return value is a `(bytes, component)` tuple where `bytes` is a
bytes object representing the data received and `component` is the
component on which the data was received.
If the connection is not established, a `ConnectionError` is raised.
"""
if not len(self._nominated):
raise ConnectionError("Cannot receive data, not connected")
result = await self._queue.get()
if result[0] is None:
raise ConnectionError("Connection lost while receiving data")
return result
async def send(self, data: bytes) -> None:
"""
Send a datagram on the first component.
If the connection is not established, a `ConnectionError` is raised.
:param data: The data to be sent.
"""
await self.sendto(data, 1)
async def sendto(self, data: bytes, component: int) -> None:
"""
Send a datagram on the specified component.
If the connection is not established, a `ConnectionError` is raised.
:param data: The data to be sent.
:param component: The component on which to send the data.
"""
active_pair = self._nominated.get(component)
if active_pair:
await active_pair.protocol.send_data(data, active_pair.remote_addr)
else:
raise ConnectionError("Cannot send data, not connected")
def set_selected_pair(
self, component: int, local_foundation: str, remote_foundation: str
) -> None:
"""
Force the selected candidate pair.
If the remote party does not support ICE, you should using this
instead of calling :meth:`connect`.
"""
# find local candidate
protocol = None
for p in self._protocols:
if (
p.local_candidate.component == component
and p.local_candidate.foundation == local_foundation
):
protocol = p
break
# find remote candidate
remote_candidate = None
for c in self._remote_candidates:
if c.component == component and c.foundation == remote_foundation:
remote_candidate = c
assert protocol and remote_candidate
self._nominated[component] = CandidatePair(protocol, remote_candidate)
# private
def build_request(self, pair: CandidatePair, nominate: bool) -> stun.Message:
tx_username = "%s:%s" % (self.remote_username, self.local_username)
request = stun.Message(
message_method=stun.Method.BINDING, message_class=stun.Class.REQUEST
)
request.attributes["USERNAME"] = tx_username
request.attributes["PRIORITY"] = candidate_priority(pair.component, "prflx")
if self.ice_controlling:
request.attributes["ICE-CONTROLLING"] = self._tie_breaker
if nominate:
request.attributes["USE-CANDIDATE"] = None
else:
request.attributes["ICE-CONTROLLED"] = self._tie_breaker
return request
def check_complete(self, pair: CandidatePair) -> None:
pair.handle = None
if pair.state == CandidatePair.State.SUCCEEDED:
if pair.nominated:
self._nominated[pair.component] = pair
# 8.1.2. Updating States
#
# The agent MUST remove all Waiting and Frozen pairs in the check
# list and triggered check queue for the same component as the
# nominated pairs for that media stream.
for p in self._check_list:
if p.component == pair.component and p.state in [
CandidatePair.State.WAITING,
CandidatePair.State.FROZEN,
]:
self.check_state(p, CandidatePair.State.FAILED)
# Once there is at least one nominated pair in the valid list for
# every component of at least one media stream and the state of the
# check list is Running:
if len(self._nominated) == len(self._components):
if not self._check_list_done:
self.__log_info("ICE completed")
asyncio.ensure_future(self._check_list_state.put(ICE_COMPLETED))
self._check_list_done = True
return
# 7.1.3.2.3. Updating Pair States
for p in self._check_list:
if (
p.local_candidate.foundation == pair.local_candidate.foundation
and p.state == CandidatePair.State.FROZEN
):
self.check_state(p, CandidatePair.State.WAITING)
for p in self._check_list:
if p.state not in [
CandidatePair.State.SUCCEEDED,
CandidatePair.State.FAILED,
]:
return
if not self.ice_controlling:
for p in self._check_list:
if p.state == CandidatePair.State.SUCCEEDED:
return
if not self._check_list_done:
self.__log_info("ICE failed")
asyncio.ensure_future(self._check_list_state.put(ICE_FAILED))
self._check_list_done = True
def check_incoming(
self, message: stun.Message, addr: Tuple[str, int], protocol: StunProtocol
) -> None:
"""
Handle a succesful incoming check.
"""
component = protocol.local_candidate.component
# find remote candidate
remote_candidate = None
for c in self._remote_candidates:
if c.host == addr[0] and c.port == addr[1]:
remote_candidate = c
assert remote_candidate.component == component
break
if remote_candidate is None:
# 7.2.1.3. Learning Peer Reflexive Candidates
remote_candidate = Candidate(
foundation=random_string(10),
component=component,
transport="udp",
priority=message.attributes["PRIORITY"],
host=addr[0],
port=addr[1],
type="prflx",
)
self._remote_candidates.append(remote_candidate)
self.__log_info("Discovered peer reflexive candidate %s", remote_candidate)
# find pair
pair = self._find_pair(protocol, remote_candidate)
if pair is None:
pair = CandidatePair(protocol, remote_candidate)
pair.state = CandidatePair.State.WAITING
self._check_list.append(pair)
self.sort_check_list()
# triggered check
if pair.state in [CandidatePair.State.WAITING, CandidatePair.State.FAILED]:
pair.handle = asyncio.ensure_future(self.check_start(pair))
# 7.2.1.5. Updating the Nominated Flag
if "USE-CANDIDATE" in message.attributes and not self.ice_controlling:
pair.remote_nominated = True
if pair.state == CandidatePair.State.SUCCEEDED:
pair.nominated = True
self.check_complete(pair)
def check_periodic(self) -> bool:
# find the highest-priority pair that is in the waiting state
for pair in self._check_list:
if pair.state == CandidatePair.State.WAITING:
pair.handle = asyncio.ensure_future(self.check_start(pair))
return True
# find the highest-priority pair that is in the frozen state
for pair in self._check_list:
if pair.state == CandidatePair.State.FROZEN:
pair.handle = asyncio.ensure_future(self.check_start(pair))
return True
# if we expect more candidates, keep going
if not self._remote_candidates_end:
return not self._check_list_done
return False
async def check_start(self, pair: CandidatePair) -> None:
"""
Starts a check.
"""
self.check_state(pair, CandidatePair.State.IN_PROGRESS)
nominate = self.ice_controlling and not self.remote_is_lite
request = self.build_request(pair, nominate=nominate)
try:
response, addr = await pair.protocol.request(
request,
pair.remote_addr,
integrity_key=self.remote_password.encode("utf8"),
)
except stun.TransactionError as exc:
# 7.1.3.1. Failure Cases
if (
exc.response
and exc.response.attributes.get("ERROR-CODE", (None, None))[0] == 487
):
if "ICE-CONTROLLING" in request.attributes:
self.switch_role(ice_controlling=False)
elif "ICE-CONTROLLED" in request.attributes:
self.switch_role(ice_controlling=True)
return await self.check_start(pair)
else:
self.check_state(pair, CandidatePair.State.FAILED)
self.check_complete(pair)
return
# check remote address matches
if addr != pair.remote_addr:
self.__log_info("Check %s failed : source address mismatch", pair)
self.check_state(pair, CandidatePair.State.FAILED)
self.check_complete(pair)
return
# success
if nominate or pair.remote_nominated:
# nominated by agressive nomination or the remote party
pair.nominated = True
elif self.ice_controlling and pair.component not in self._nominating:
# perform regular nomination
self.__log_info("Check %s nominating pair", pair)
self._nominating.add(pair.component)
request = self.build_request(pair, nominate=True)
try:
await pair.protocol.request(
request,
pair.remote_addr,
integrity_key=self.remote_password.encode("utf8"),
)
except stun.TransactionError:
self.__log_info("Check %s failed : could not nominate pair", pair)
self.check_state(pair, CandidatePair.State.FAILED)
self.check_complete(pair)
return
pair.nominated = True
self.check_state(pair, CandidatePair.State.SUCCEEDED)
self.check_complete(pair)
def check_state(self, pair: CandidatePair, state: CandidatePair.State) -> None:
"""
Updates the state of a check.
"""
self.__log_info("Check %s %s -> %s", pair, pair.state, state)
pair.state = state
def _emit_event(self, event: ConnectionEvent) -> None:
if self._event_waiter is not None:
waiter = self._event_waiter
self._event_waiter = None
waiter.set_result(event)
def _find_pair(
self, protocol: StunProtocol, remote_candidate: Candidate
) -> Optional[CandidatePair]:
"""
Find a candidate pair in the check list.
"""
for pair in self._check_list:
if pair.protocol == protocol and pair.remote_candidate == remote_candidate:
return pair
return None
async def get_component_candidates(
self, component: int, addresses: List[str], timeout: int = 5
) -> List[Candidate]:
candidates = []
# gather host candidates
host_protocols = []
for address in addresses:
# create transport
try:
transport, protocol = await create_datagram_endpoint(
lambda: StunProtocol(self), local_address=address, local_ports=self._ephemeral_ports)
sock = transport.get_extra_info("socket")
if sock is not None:
sock.setsockopt(
socket.SOL_SOCKET, socket.SO_RCVBUF, turn.UDP_SOCKET_BUFFER_SIZE
)
except OSError as exc:
self.__log_info("Could not bind to %s - %s", address, exc)
continue
host_protocols.append(protocol)
# add host candidate
candidate_address = protocol.transport.get_extra_info("sockname")
protocol.local_candidate = Candidate(
foundation=candidate_foundation("host", "udp", candidate_address[0]),
component=component,
transport="udp",
priority=candidate_priority(component, "host"),
host=candidate_address[0],
port=candidate_address[1],
type="host",
)
if self._transport_policy == TransportPolicy.ALL:
candidates.append(protocol.local_candidate)
self._protocols += host_protocols
# query STUN server for server-reflexive candidates (IPv4 only)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | true |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/turn.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/turn.py | import asyncio
import hashlib
import logging
import socket
import struct
import time
from typing import (
Any,
Callable,
Dict,
List,
Optional,
Text,
Tuple,
TypeVar,
Union,
cast,
)
from . import stun
from .utils import random_transaction_id
logger = logging.getLogger(__name__)
DEFAULT_CHANNEL_REFRESH_TIME = 500
DEFAULT_ALLOCATION_LIFETIME = 600
TCP_TRANSPORT = 0x06000000
UDP_TRANSPORT = 0x11000000
UDP_SOCKET_BUFFER_SIZE = 262144
_ProtocolT = TypeVar("_ProtocolT", bound=asyncio.BaseProtocol)
def is_channel_data(data: bytes) -> bool:
return (data[0] & 0xC0) == 0x40
def make_integrity_key(username: str, realm: str, password: str) -> bytes:
return hashlib.md5(":".join([username, realm, password]).encode("utf8")).digest()
class TurnStreamMixin:
datagram_received: Callable
transport: asyncio.BaseTransport
def data_received(self, data: bytes) -> None:
if not hasattr(self, "buffer"):
self.buffer = b""
self.buffer += data
while len(self.buffer) >= 4:
_, length = struct.unpack("!HH", self.buffer[0:4])
length += stun.padding_length(length)
if is_channel_data(self.buffer):
full_length = 4 + length
else:
full_length = 20 + length
if len(self.buffer) < full_length:
break
addr = self.transport.get_extra_info("peername")
self.datagram_received(self.buffer[0:full_length], addr)
self.buffer = self.buffer[full_length:]
def _padded(self, data: bytes) -> bytes:
# TCP and TCP-over-TLS must pad messages to 4-byte boundaries.
padding = stun.padding_length(len(data))
if padding:
data += bytes(padding)
return data
class TurnClientMixin:
_send: Callable
def __init__(
self,
server: Tuple[str, int],
username: Optional[str],
password: Optional[str],
lifetime: int,
channel_refresh_time: int,
) -> None:
self.channel_refresh_at: Dict[int, float] = {}
self.channel_to_peer: Dict[int, Tuple[str, int]] = {}
self.peer_connect_waiters: Dict[
Tuple[str, int], List[asyncio.Future[None]]
] = {}
self.peer_to_channel: Dict[Tuple[str, int], int] = {}
self.channel_number = 0x4000
self.channel_refresh_time = channel_refresh_time
self.integrity_key: Optional[bytes] = None
self.lifetime = lifetime
self.nonce: Optional[bytes] = None
self.password = password
self.receiver = None
self.realm: Optional[str] = None
self.refresh_handle: Optional[asyncio.Future] = None
self.relayed_address: Optional[Tuple[str, int]] = None
self.server = server
self.transactions: Dict[bytes, stun.Transaction] = {}
self.username = username
async def channel_bind(self, channel_number: int, addr: Tuple[str, int]) -> None:
request = stun.Message(
message_method=stun.Method.CHANNEL_BIND, message_class=stun.Class.REQUEST
)
request.attributes["CHANNEL-NUMBER"] = channel_number
request.attributes["XOR-PEER-ADDRESS"] = addr
await self.request_with_retry(request)
logger.info("TURN channel bound %d %s", channel_number, addr)
async def connect(self) -> Tuple[str, int]:
"""
Create a TURN allocation.
"""
request = stun.Message(
message_method=stun.Method.ALLOCATE, message_class=stun.Class.REQUEST
)
request.attributes["LIFETIME"] = self.lifetime
request.attributes["REQUESTED-TRANSPORT"] = UDP_TRANSPORT
response, _ = await self.request_with_retry(request)
time_to_expiry = response.attributes["LIFETIME"]
self.relayed_address = response.attributes["XOR-RELAYED-ADDRESS"]
logger.info(
"TURN allocation created %s (expires in %d seconds)",
self.relayed_address,
time_to_expiry,
)
# periodically refresh allocation
self.refresh_handle = asyncio.ensure_future(self.refresh(time_to_expiry))
return self.relayed_address
def connection_lost(self, exc: Exception) -> None:
logger.debug("%s connection_lost(%s)", self, exc)
if self.receiver:
self.receiver.connection_lost(exc)
def connection_made(self, transport) -> None:
logger.debug("%s connection_made(%s)", self, transport)
self.transport = transport
def datagram_received(self, data: Union[bytes, Text], addr) -> None:
data = cast(bytes, data)
# demultiplex channel data
if len(data) >= 4 and is_channel_data(data):
channel, length = struct.unpack("!HH", data[0:4])
if len(data) >= length + 4 and self.receiver:
peer_address = self.channel_to_peer.get(channel)
if peer_address:
payload = data[4 : 4 + length]
self.receiver.datagram_received(payload, peer_address)
return
try:
message = stun.parse_message(data)
logger.debug("%s < %s %s", self, addr, message)
except ValueError:
return
if (
message.message_class == stun.Class.RESPONSE
or message.message_class == stun.Class.ERROR
) and message.transaction_id in self.transactions:
transaction = self.transactions[message.transaction_id]
transaction.response_received(message, addr)
async def delete(self) -> None:
"""
Delete the TURN allocation.
"""
if self.refresh_handle:
self.refresh_handle.cancel()
self.refresh_handle = None
request = stun.Message(
message_method=stun.Method.REFRESH, message_class=stun.Class.REQUEST
)
request.attributes["LIFETIME"] = 0
try:
await self.request_with_retry(request)
except stun.TransactionError:
# we do not care, we need to shutdown
pass
logger.info("TURN allocation deleted %s", self.relayed_address)
self.transport.close()
async def refresh(self, time_to_expiry) -> None:
"""
Periodically refresh the TURN allocation.
"""
while True:
await asyncio.sleep(5 / 6 * time_to_expiry)
request = stun.Message(
message_method=stun.Method.REFRESH, message_class=stun.Class.REQUEST
)
request.attributes["LIFETIME"] = self.lifetime
response, _ = await self.request_with_retry(request)
time_to_expiry = response.attributes["LIFETIME"]
logger.info(
"TURN allocation refreshed %s (expires in %d seconds)",
self.relayed_address,
time_to_expiry,
)
async def request(
self, request: stun.Message
) -> Tuple[stun.Message, Tuple[str, int]]:
"""
Execute a STUN transaction and return the response.
"""
assert request.transaction_id not in self.transactions
if self.integrity_key:
self.__add_authentication(request)
transaction = stun.Transaction(request, self.server, self)
self.transactions[request.transaction_id] = transaction
try:
return await transaction.run()
finally:
del self.transactions[request.transaction_id]
async def request_with_retry(
self, request: stun.Message
) -> Tuple[stun.Message, Tuple[str, int]]:
"""
Execute a STUN transaction and return the response.
On recoverable errors it will retry the request.
"""
try:
response, addr = await self.request(request)
except stun.TransactionFailed as e:
error_code = e.response.attributes["ERROR-CODE"][0]
if (
"NONCE" in e.response.attributes
and self.username is not None
and self.password is not None
and (
(error_code == 401 and "REALM" in e.response.attributes)
or (error_code == 438 and self.realm is not None)
)
):
# update long-term credentials
self.nonce = e.response.attributes["NONCE"]
if error_code == 401:
self.realm = e.response.attributes["REALM"]
self.integrity_key = make_integrity_key(
self.username, self.realm, self.password
)
# retry request with authentication
request.transaction_id = random_transaction_id()
response, addr = await self.request(request)
else:
raise
return response, addr
async def send_data(self, data: bytes, addr: Tuple[str, int]) -> None:
"""
Send data to a remote host via the TURN server.
"""
# if a channel is being bound for the peer, wait
if addr in self.peer_connect_waiters:
loop = asyncio.get_event_loop()
waiter = loop.create_future()
self.peer_connect_waiters[addr].append(waiter)
await waiter
channel = self.peer_to_channel.get(addr)
now = time.time()
if channel is None:
self.peer_connect_waiters[addr] = []
channel = self.channel_number
self.channel_number += 1
# bind channel
await self.channel_bind(channel, addr)
# update state
self.channel_refresh_at[channel] = now + self.channel_refresh_time
self.channel_to_peer[channel] = addr
self.peer_to_channel[addr] = channel
# notify waiters
for waiter in self.peer_connect_waiters.pop(addr):
waiter.set_result(None)
elif now > self.channel_refresh_at[channel]:
# refresh channel
await self.channel_bind(channel, addr)
# update state
self.channel_refresh_at[channel] = now + self.channel_refresh_time
header = struct.pack("!HH", channel, len(data))
self._send(header + data)
def send_stun(self, message: stun.Message, addr: Tuple[str, int]) -> None:
"""
Send a STUN message to the TURN server.
"""
logger.debug("%s > %s %s", self, addr, message)
self._send(bytes(message))
def __add_authentication(self, request: stun.Message) -> None:
request.attributes["USERNAME"] = self.username
request.attributes["NONCE"] = self.nonce
request.attributes["REALM"] = self.realm
request.add_message_integrity(self.integrity_key)
class TurnClientTcpProtocol(TurnClientMixin, TurnStreamMixin, asyncio.Protocol):
"""
Protocol for handling TURN over TCP.
"""
def _send(self, data: bytes) -> None:
self.transport.write(self._padded(data))
def __repr__(self) -> str:
return "turn/tcp"
class TurnClientUdpProtocol(TurnClientMixin, asyncio.DatagramProtocol):
"""
Protocol for handling TURN over UDP.
"""
def _send(self, data: bytes) -> None:
self.transport.sendto(data)
def __repr__(self) -> str:
return "turn/udp"
class TurnTransport:
"""
Behaves like a Datagram transport, but uses a TURN allocation.
"""
def __init__(self, protocol, inner_protocol) -> None:
self.protocol = protocol
self.__inner_protocol = inner_protocol
self.__inner_protocol.receiver = protocol
self.__relayed_address = None
def close(self) -> None:
"""
Close the transport.
After the TURN allocation has been deleted, the protocol's
`connection_lost()` method will be called with None as its argument.
"""
asyncio.ensure_future(self.__inner_protocol.delete())
def get_extra_info(self, name: str, default: Any = None) -> Any:
"""
Return optional transport information.
- `'related_address'`: the related address
- `'sockname'`: the relayed address
"""
if name == "related_address":
return self.__inner_protocol.transport.get_extra_info("sockname")
elif name == "sockname":
return self.__relayed_address
return default
def sendto(self, data: bytes, addr: Tuple[str, int]) -> None:
"""
Sends the `data` bytes to the remote peer given `addr`.
This will bind a TURN channel as necessary.
"""
asyncio.ensure_future(self.__inner_protocol.send_data(data, addr))
async def _connect(self) -> None:
self.__relayed_address = await self.__inner_protocol.connect()
self.protocol.connection_made(self)
async def create_turn_endpoint(
protocol_factory: Callable[[], _ProtocolT],
server_addr: Tuple[str, int],
username: Optional[str],
password: Optional[str],
lifetime: int = DEFAULT_ALLOCATION_LIFETIME,
channel_refresh_time: int = DEFAULT_CHANNEL_REFRESH_TIME,
ssl: bool = False,
transport: str = "udp",
) -> Tuple[TurnTransport, _ProtocolT]:
"""
Create datagram connection relayed over TURN.
"""
loop = asyncio.get_event_loop()
inner_protocol: asyncio.BaseProtocol
inner_transport: asyncio.BaseTransport
if transport == "tcp":
inner_transport, inner_protocol = await loop.create_connection(
lambda: TurnClientTcpProtocol(
server_addr,
username=username,
password=password,
lifetime=lifetime,
channel_refresh_time=channel_refresh_time,
),
host=server_addr[0],
port=server_addr[1],
ssl=ssl,
)
else:
inner_transport, inner_protocol = await loop.create_datagram_endpoint(
lambda: TurnClientUdpProtocol(
server_addr,
username=username,
password=password,
lifetime=lifetime,
channel_refresh_time=channel_refresh_time,
),
remote_addr=server_addr,
)
sock = inner_transport.get_extra_info("socket")
if sock is not None:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, UDP_SOCKET_BUFFER_SIZE)
try:
protocol = protocol_factory()
turn_transport = TurnTransport(protocol, inner_protocol)
await turn_transport._connect()
except Exception:
inner_transport.close()
raise
return turn_transport, protocol
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/utils.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/utils.py | import asyncio
import os
import random
import secrets
import string
from typing import Iterable, Optional, Tuple
def random_string(length: int) -> str:
allchar = string.ascii_letters + string.digits
return "".join(secrets.choice(allchar) for x in range(length))
def random_transaction_id() -> bytes:
return os.urandom(12)
async def create_datagram_endpoint(protocol_factory,
remote_addr: Tuple[str, int] = None,
local_address: str = None,
local_ports: Optional[Iterable[int]] = None,
):
"""
Asynchronousley create a datagram endpoint.
:param protocol_factory: Callable returning a protocol instance.
:param remote_addr: Remote address and port.
:param local_address: Local address to bind to.
:param local_ports: Set of allowed local ports to bind to.
"""
if local_ports is not None:
ports = list(local_ports)
random.shuffle(ports)
else:
ports = (0,)
loop = asyncio.get_event_loop()
for port in ports:
try:
print(ports)
transport, protocol = await loop.create_datagram_endpoint(
protocol_factory, remote_addr=remote_addr, local_addr=(local_address, port)
)
return transport, protocol
except OSError as exc:
if port == ports[-1]:
# this was the last port, give up
raise exc
raise ValueError("local_ports must not be empty")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/__init__.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/__init__.py | # flake8: noqa
import logging
from .about import __version__
from .candidate import Candidate
from .ice import Connection, ConnectionClosed, TransportPolicy
# Set default logging handler to avoid "No handler found" warnings.
logging.getLogger(__name__).addHandler(logging.NullHandler())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/about.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/about.py | __author__ = "Jeremy Lainé"
__email__ = "jeremy.laine@m4x.org"
__license__ = "BSD"
__summary__ = "An implementation of Interactive Connectivity Establishment (RFC 5245)"
__title__ = "aioice"
__uri__ = "https://github.com/aiortc/aioice"
__version__ = "0.8.0"
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/mdns.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/mdns.py | import asyncio
import re
import socket
import sys
import uuid
from typing import Dict, List, Optional, Set, Text, Tuple, Union, cast
import dns.exception
import dns.flags
import dns.message
import dns.name
import dns.rdata
import dns.rdataclass
import dns.rdataset
import dns.rdatatype
import dns.zone
MDNS_ADDRESS = "224.0.0.251"
MDNS_PORT = 5353
MDNS_HOSTNAME_RE = re.compile(r"^[a-zA-Z0-9-]{1,63}\.local$")
MDNS_RDCLASS = dns.rdataclass.IN | 0x8000
def create_mdns_hostname():
return str(uuid.uuid4()) + ".local"
def is_mdns_hostname(name: str) -> bool:
return MDNS_HOSTNAME_RE.match(name) is not None
class MDnsProtocol(asyncio.DatagramProtocol):
def __init__(self, tx_transport: asyncio.DatagramTransport) -> None:
self.__closed: asyncio.Future[bool] = asyncio.Future()
self.zone = dns.zone.Zone("", relativize=False, rdclass=MDNS_RDCLASS)
self.queries: Dict[dns.name.Name, Set[asyncio.Future[str]]] = {}
self.rx_transport: Optional[asyncio.DatagramTransport] = None
self.tx_transport = tx_transport
def connection_lost(self, exc: Exception) -> None:
# abort any outstanding queries
for name, futures in list(self.queries.items()):
for future in futures:
future.set_exception(asyncio.TimeoutError)
self.__closed.set_result(True)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
self.rx_transport = cast(asyncio.DatagramTransport, transport)
def datagram_received(self, data: Union[bytes, Text], addr: Tuple) -> None:
# parse message
try:
message = dns.message.from_wire(cast(bytes, data))
except dns.exception.FormError:
return
if isinstance(message, dns.message.QueryMessage):
# answer question
for question in message.question:
rdtypes: List[int] = []
if question.rdtype in (
dns.rdatatype.ANY,
dns.rdatatype.A,
dns.rdatatype.AAAA,
):
rdtypes += [dns.rdatatype.A, dns.rdatatype.AAAA]
response = dns.message.QueryMessage(id=0)
response.flags |= dns.flags.QR
response.flags |= dns.flags.AA
for rdtype in rdtypes:
try:
response.answer.append(
self.zone.find_rrset(name=question.name, rdtype=rdtype)
)
except KeyError:
continue
if response.answer:
self.tx_transport.sendto(
response.to_wire(), (MDNS_ADDRESS, MDNS_PORT)
)
# handle answer
for answer in message.answer:
for item in answer:
item = item.to_generic()
if (
isinstance(item, dns.rdata.GenericRdata)
and item.rdclass == MDNS_RDCLASS
and item.rdtype in (dns.rdatatype.A, dns.rdatatype.AAAA)
):
if item.rdtype == dns.rdatatype.A:
result = socket.inet_ntop(socket.AF_INET, item.data)
else:
result = socket.inet_ntop(socket.AF_INET6, item.data)
for future in self.queries.pop(answer.name, []):
future.set_result(result)
# custom
async def close(self) -> None:
self.rx_transport.close()
self.tx_transport.close()
await self.__closed
async def publish(self, hostname: str, addr: str) -> None:
name = dns.name.from_text(hostname)
try:
data = socket.inet_pton(socket.AF_INET, addr)
rdtype = dns.rdatatype.A
except OSError:
data = socket.inet_pton(socket.AF_INET6, addr)
rdtype = dns.rdatatype.AAAA
rdata = dns.rdata.GenericRdata(rdclass=MDNS_RDCLASS, rdtype=rdtype, data=data)
self.zone.replace_rdataset(name, dns.rdataset.from_rdata(120, rdata))
async def resolve(
self, hostname: str, timeout: Optional[float] = 1.0
) -> Optional[str]:
name = dns.name.from_text(hostname)
future: asyncio.Future[str] = asyncio.Future()
if name in self.queries:
# a query for this name is already pending
self.queries[name].add(future)
else:
# no query for this name is pending, send a request
self.queries[name] = set([future])
message = dns.message.make_query(name, rdtype=dns.rdatatype.A)
message.id = 0
message.flags = 0
self.tx_transport.sendto(message.to_wire(), (MDNS_ADDRESS, MDNS_PORT))
try:
return await asyncio.wait_for(future, timeout=timeout)
except asyncio.TimeoutError:
return None
finally:
if name in self.queries:
self.queries[name].discard(future)
if not self.queries[name]:
del self.queries[name]
async def create_mdns_protocol() -> MDnsProtocol:
"""
Using a single socket works fine on Linux, but on OS X we need to use
separate sockets for sending and receiving.
"""
loop = asyncio.get_event_loop()
# sender
tx_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
tx_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if hasattr(socket, "SO_REUSEPORT"):
tx_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
tx_sock.bind(("", MDNS_PORT))
tx_transport, _ = await loop.create_datagram_endpoint(
lambda: asyncio.DatagramProtocol(),
sock=tx_sock,
)
# receiver
rx_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
rx_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if hasattr(socket, "SO_REUSEPORT"):
rx_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
rx_sock.setsockopt(
socket.IPPROTO_IP,
socket.IP_ADD_MEMBERSHIP,
socket.inet_aton(MDNS_ADDRESS) + b"\x00\x00\x00\x00",
)
if sys.platform == "win32":
rx_sock.bind(("", MDNS_PORT))
else:
rx_sock.bind((MDNS_ADDRESS, MDNS_PORT))
_, protocol = await loop.create_datagram_endpoint(
lambda: MDnsProtocol(
tx_transport=cast(asyncio.DatagramTransport, tx_transport)
),
sock=rx_sock,
)
return protocol
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/candidate.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/src/aioice/candidate.py | import hashlib
import ipaddress
from typing import Optional
def candidate_foundation(
candidate_type: str, candidate_transport: str, base_address: str
) -> str:
"""
See RFC 5245 - 4.1.1.3. Computing Foundations
"""
key = "%s|%s|%s" % (candidate_type, candidate_transport, base_address)
return hashlib.md5(key.encode("ascii")).hexdigest()
def candidate_priority(
candidate_component: int, candidate_type: str, local_pref: int = 65535
) -> int:
"""
See RFC 5245 - 4.1.2.1. Recommended Formula
"""
if candidate_type == "host":
type_pref = 126
elif candidate_type == "prflx":
type_pref = 110
elif candidate_type == "srflx":
type_pref = 100
else:
type_pref = 0
return (1 << 24) * type_pref + (1 << 8) * local_pref + (256 - candidate_component)
class Candidate:
"""
An ICE candidate.
"""
def __init__(
self,
foundation: str,
component: int,
transport: str,
priority: int,
host: str,
port: int,
type: str,
related_address: Optional[str] = None,
related_port: Optional[int] = None,
tcptype: Optional[str] = None,
generation: Optional[int] = None,
) -> None:
self.foundation = foundation
self.component = component
self.transport = transport
self.priority = priority
self.host = host
self.port = port
self.type = type
self.related_address = related_address
self.related_port = related_port
self.tcptype = tcptype
self.generation = generation
@classmethod
def from_sdp(cls, sdp):
"""
Parse a :class:`Candidate` from SDP.
.. code-block:: python
Candidate.from_sdp(
'6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0')
"""
bits = sdp.split()
if len(bits) < 8:
raise ValueError("SDP does not have enough properties")
kwargs = {
"foundation": bits[0],
"component": int(bits[1]),
"transport": bits[2],
"priority": int(bits[3]),
"host": bits[4],
"port": int(bits[5]),
"type": bits[7],
}
for i in range(8, len(bits) - 1, 2):
if bits[i] == "raddr":
kwargs["related_address"] = bits[i + 1]
elif bits[i] == "rport":
kwargs["related_port"] = int(bits[i + 1])
elif bits[i] == "tcptype":
kwargs["tcptype"] = bits[i + 1]
elif bits[i] == "generation":
kwargs["generation"] = int(bits[i + 1])
return Candidate(**kwargs)
def to_sdp(self) -> str:
"""
Return a string representation suitable for SDP.
"""
sdp = "%s %d %s %d %s %d typ %s" % (
self.foundation,
self.component,
self.transport,
self.priority,
self.host,
self.port,
self.type,
)
if self.related_address is not None:
sdp += " raddr %s" % self.related_address
if self.related_port is not None:
sdp += " rport %s" % self.related_port
if self.tcptype is not None:
sdp += " tcptype %s" % self.tcptype
if self.generation is not None:
sdp += " generation %d" % self.generation
return sdp
def can_pair_with(self, other) -> bool:
"""
A local candidate is paired with a remote candidate if and only if
the two candidates have the same component ID and have the same IP
address version.
"""
a = ipaddress.ip_address(self.host)
b = ipaddress.ip_address(other.host)
return (
self.component == other.component
and self.transport.lower() == other.transport.lower()
and a.version == b.version
)
def __repr__(self) -> str:
return "Candidate(%s)" % self.to_sdp()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_ice.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_ice.py | import asyncio
import functools
import os
import random
import socket
import unittest
from unittest import mock
from aioice import Candidate, TransportPolicy, ice, mdns, stun
from .turnserver import run_turn_server
from .utils import asynctest, invite_accept
RUNNING_ON_CI = os.environ.get("GITHUB_ACTIONS") == "true"
async def delay(coro):
await asyncio.sleep(1)
await coro()
class ProtocolMock:
local_candidate = Candidate(
foundation="some-foundation",
component=1,
transport="udp",
priority=1234,
host="1.2.3.4",
port=1234,
type="host",
)
sent_message = None
async def request(self, message, addr, integrity_key=None):
return (self.response_message, self.response_addr)
def send_stun(self, message, addr):
self.sent_message = message
class IceComponentTest(unittest.TestCase):
@asynctest
async def test_peer_reflexive(self):
connection = ice.Connection(ice_controlling=True)
connection.remote_password = "remote-password"
connection.remote_username = "remote-username"
protocol = ProtocolMock()
request = stun.Message(
message_method=stun.Method.BINDING, message_class=stun.Class.REQUEST
)
request.attributes["PRIORITY"] = 456789
connection.check_incoming(request, ("2.3.4.5", 2345), protocol)
self.assertIsNone(protocol.sent_message)
# check we have discovered a peer-reflexive candidate
self.assertEqual(len(connection.remote_candidates), 1)
candidate = connection.remote_candidates[0]
self.assertEqual(candidate.component, 1)
self.assertEqual(candidate.transport, "udp")
self.assertEqual(candidate.priority, 456789)
self.assertEqual(candidate.host, "2.3.4.5")
self.assertEqual(candidate.port, 2345)
self.assertEqual(candidate.type, "prflx")
self.assertEqual(candidate.generation, None)
# check a new pair was formed
self.assertEqual(len(connection._check_list), 1)
pair = connection._check_list[0]
self.assertEqual(pair.protocol, protocol)
self.assertEqual(pair.remote_candidate, candidate)
# check a triggered check was scheduled
self.assertIsNotNone(pair.handle)
protocol.response_addr = ("2.3.4.5", 2345)
protocol.response_message = "bad"
await pair.handle
@asynctest
async def test_request_with_invalid_method(self):
connection = ice.Connection(ice_controlling=True)
protocol = ProtocolMock()
request = stun.Message(
message_method=stun.Method.ALLOCATE, message_class=stun.Class.REQUEST
)
connection.request_received(
request, ("2.3.4.5", 2345), protocol, bytes(request)
)
self.assertIsNotNone(protocol.sent_message)
self.assertEqual(protocol.sent_message.message_method, stun.Method.ALLOCATE)
self.assertEqual(protocol.sent_message.message_class, stun.Class.ERROR)
self.assertEqual(
protocol.sent_message.attributes["ERROR-CODE"], (400, "Bad Request")
)
@asynctest
async def test_response_with_invalid_address(self):
connection = ice.Connection(ice_controlling=True)
connection.remote_password = "remote-password"
connection.remote_username = "remote-username"
protocol = ProtocolMock()
protocol.response_addr = ("3.4.5.6", 3456)
protocol.response_message = "bad"
pair = ice.CandidatePair(
protocol,
Candidate(
foundation="some-foundation",
component=1,
transport="udp",
priority=2345,
host="2.3.4.5",
port=2345,
type="host",
),
)
self.assertEqual(
repr(pair), "CandidatePair(('1.2.3.4', 1234) -> ('2.3.4.5', 2345))"
)
await connection.check_start(pair)
self.assertEqual(pair.state, ice.CandidatePair.State.FAILED)
class IceConnectionTest(unittest.TestCase):
def assertCandidateTypes(self, conn, expected):
types = set([c.type for c in conn.local_candidates])
self.assertEqual(types, expected)
def tearDown(self):
ice.CONSENT_FAILURES = 6
ice.CONSENT_INTERVAL = 5
stun.RETRY_MAX = 6
@mock.patch("netifaces.interfaces")
@mock.patch("netifaces.ifaddresses")
def test_get_host_addresses(self, mock_ifaddresses, mock_interfaces):
mock_interfaces.return_value = ["eth0"]
mock_ifaddresses.return_value = {
socket.AF_INET: [{"addr": "127.0.0.1"}, {"addr": "1.2.3.4"}],
socket.AF_INET6: [
{"addr": "::1"},
{"addr": "2a02:0db8:85a3:0000:0000:8a2e:0370:7334"},
{"addr": "fe80::1234:5678:9abc:def0%eth0"},
],
}
# IPv4 only
addresses = ice.get_host_addresses(use_ipv4=True, use_ipv6=False)
self.assertEqual(addresses, ["1.2.3.4"])
# IPv6 only
addresses = ice.get_host_addresses(use_ipv4=False, use_ipv6=True)
self.assertEqual(addresses, ["2a02:0db8:85a3:0000:0000:8a2e:0370:7334"])
# both
addresses = ice.get_host_addresses(use_ipv4=True, use_ipv6=True)
self.assertEqual(
addresses, ["1.2.3.4", "2a02:0db8:85a3:0000:0000:8a2e:0370:7334"]
)
@asynctest
async def test_close(self):
conn_a = ice.Connection(ice_controlling=True)
# close
event, _ = await asyncio.gather(conn_a.get_event(), conn_a.close())
self.assertTrue(isinstance(event, ice.ConnectionClosed))
# no more events
event = await conn_a.get_event()
self.assertIsNone(event)
# close again
await conn_a.close()
@asynctest
async def test_connect(self):
conn_a = ice.Connection(ice_controlling=True)
conn_b = ice.Connection(ice_controlling=False)
# invite / accept
await invite_accept(conn_a, conn_b)
# we should only have host candidates
self.assertCandidateTypes(conn_a, set(["host"]))
self.assertCandidateTypes(conn_b, set(["host"]))
# there should be a default candidate for component 1
candidate = conn_a.get_default_candidate(1)
self.assertIsNotNone(candidate)
self.assertEqual(candidate.type, "host")
# there should not be a default candidate for component 2
candidate = conn_a.get_default_candidate(2)
self.assertIsNone(candidate)
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_close(self):
conn_a = ice.Connection(ice_controlling=True)
conn_b = ice.Connection(ice_controlling=False)
# invite / accept
await invite_accept(conn_a, conn_b)
# close while connecting
await conn_b.close()
done, pending = await asyncio.wait(
[
asyncio.ensure_future(conn_a.connect()),
asyncio.ensure_future(delay(conn_a.close)),
]
)
for task in pending:
task.cancel()
self.assertEqual(len(done), 2)
exceptions = [x.exception() for x in done if x.exception()]
self.assertEqual(len(exceptions), 1)
self.assertTrue(isinstance(exceptions[0], ConnectionError))
@asynctest
async def test_connect_early_checks(self):
conn_a = ice.Connection(ice_controlling=True)
conn_b = ice.Connection(ice_controlling=False)
# invite / accept
await invite_accept(conn_a, conn_b)
# connect
await conn_a.connect()
await asyncio.sleep(1)
await conn_b.connect()
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_early_checks_2(self):
conn_a = ice.Connection(ice_controlling=True)
conn_b = ice.Connection(ice_controlling=False)
# both sides gather local candidates and exchange credentials
await conn_a.gather_candidates()
await conn_b.gather_candidates()
conn_a.remote_username = conn_b.local_username
conn_a.remote_password = conn_b.local_password
conn_b.remote_username = conn_a.local_username
conn_b.remote_password = conn_a.local_password
async def connect_b():
# side B receives offer and connects
for candidate in conn_a.local_candidates:
await conn_b.add_remote_candidate(candidate)
await conn_b.add_remote_candidate(None)
await conn_b.connect()
# side A receives candidates
for candidate in conn_b.local_candidates:
await conn_a.add_remote_candidate(candidate)
await conn_a.add_remote_candidate(None)
# The sequence is:
# - side A starts connecting immediately, but has no candidates
# - side B receives candidates and connects
# - side A receives candidates, and connection completes
await asyncio.gather(conn_a.connect(), connect_b())
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_two_components(self):
conn_a = ice.Connection(ice_controlling=True, components=2)
conn_b = ice.Connection(ice_controlling=False, components=2)
# invite / accept
await invite_accept(conn_a, conn_b)
# we should only have host candidates
self.assertCandidateTypes(conn_a, set(["host"]))
self.assertCandidateTypes(conn_b, set(["host"]))
# there should be a default candidate for component 1
candidate = conn_a.get_default_candidate(1)
self.assertIsNotNone(candidate)
self.assertEqual(candidate.type, "host")
# there should be a default candidate for component 2
candidate = conn_a.get_default_candidate(2)
self.assertIsNotNone(candidate)
self.assertEqual(candidate.type, "host")
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
self.assertEqual(conn_a._components, set([1, 2]))
self.assertEqual(conn_b._components, set([1, 2]))
# send data a -> b (component 1)
await conn_a.sendto(b"howdee", 1)
data, component = await conn_b.recvfrom()
self.assertEqual(data, b"howdee")
self.assertEqual(component, 1)
# send data b -> a (component 1)
await conn_b.sendto(b"gotcha", 1)
data, component = await conn_a.recvfrom()
self.assertEqual(data, b"gotcha")
self.assertEqual(component, 1)
# send data a -> b (component 2)
await conn_a.sendto(b"howdee 2", 2)
data, component = await conn_b.recvfrom()
self.assertEqual(data, b"howdee 2")
self.assertEqual(component, 2)
# send data b -> a (component 2)
await conn_b.sendto(b"gotcha 2", 2)
data, component = await conn_a.recvfrom()
self.assertEqual(data, b"gotcha 2")
self.assertEqual(component, 2)
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_two_components_vs_one_component(self):
"""
It is possible that some of the local candidates won't get paired with
remote candidates, and some of the remote candidates won't get paired
with local candidates. This can happen if one agent doesn't include
candidates for the all of the components for a media stream. If this
happens, the number of components for that media stream is effectively
reduced, and considered to be equal to the minimum across both agents
of the maximum component ID provided by each agent across all
components for the media stream.
"""
conn_a = ice.Connection(ice_controlling=True, components=2)
conn_b = ice.Connection(ice_controlling=False, components=1)
# invite / accept
await invite_accept(conn_a, conn_b)
self.assertTrue(len(conn_a.local_candidates) > 0)
for candidate in conn_a.local_candidates:
self.assertEqual(candidate.type, "host")
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
self.assertEqual(conn_a._components, set([1]))
self.assertEqual(conn_b._components, set([1]))
# send data a -> b (component 1)
await conn_a.sendto(b"howdee", 1)
data, component = await conn_b.recvfrom()
self.assertEqual(data, b"howdee")
self.assertEqual(component, 1)
# send data b -> a (component 1)
await conn_b.sendto(b"gotcha", 1)
data, component = await conn_a.recvfrom()
self.assertEqual(data, b"gotcha")
self.assertEqual(component, 1)
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_to_ice_lite(self):
conn_a = ice.Connection(ice_controlling=True)
conn_a.remote_is_lite = True
conn_b = ice.Connection(ice_controlling=False)
# invite / accept
await invite_accept(conn_a, conn_b)
# we should only have host candidates
self.assertCandidateTypes(conn_a, set(["host"]))
self.assertCandidateTypes(conn_b, set(["host"]))
# there should be a default candidate for component 1
candidate = conn_a.get_default_candidate(1)
self.assertIsNotNone(candidate)
self.assertEqual(candidate.type, "host")
# there should not be a default candidate for component 2
candidate = conn_a.get_default_candidate(2)
self.assertIsNone(candidate)
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_to_ice_lite_nomination_fails(self):
def mock_request_received(self, message, addr, protocol, raw_data):
if "USE-CANDIDATE" in message.attributes:
self.respond_error(message, addr, protocol, (500, "Internal Error"))
else:
self.real_request_received(message, addr, protocol, raw_data)
conn_a = ice.Connection(ice_controlling=True)
conn_a.remote_is_lite = True
conn_b = ice.Connection(ice_controlling=False)
conn_b.real_request_received = conn_b.request_received
conn_b.request_received = functools.partial(mock_request_received, conn_b)
# invite / accept
await invite_accept(conn_a, conn_b)
# connect
with self.assertRaises(ConnectionError) as cm:
await asyncio.gather(conn_a.connect(), conn_b.connect())
self.assertEqual(str(cm.exception), "ICE negotiation failed")
# close
await conn_a.close()
await conn_b.close()
@unittest.skipIf(RUNNING_ON_CI, "CI lacks ipv6")
@asynctest
async def test_connect_ipv6(self):
conn_a = ice.Connection(ice_controlling=True, use_ipv4=False, use_ipv6=True)
conn_b = ice.Connection(ice_controlling=False, use_ipv4=False, use_ipv6=True)
# invite / accept
await invite_accept(conn_a, conn_b)
self.assertTrue(len(conn_a.local_candidates) > 0)
for candidate in conn_a.local_candidates:
self.assertEqual(candidate.type, "host")
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_reverse_order(self):
conn_a = ice.Connection(ice_controlling=True)
conn_b = ice.Connection(ice_controlling=False)
# invite / accept
await invite_accept(conn_a, conn_b)
# introduce a delay so that B's checks complete before A's
await asyncio.gather(delay(conn_a.connect), conn_b.connect())
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_invalid_password(self):
conn_a = ice.Connection(ice_controlling=True)
conn_b = ice.Connection(ice_controlling=False)
# invite
await conn_a.gather_candidates()
for candidate in conn_a.local_candidates:
await conn_b.add_remote_candidate(candidate)
await conn_b.add_remote_candidate(None)
conn_b.remote_username = conn_a.local_username
conn_b.remote_password = conn_a.local_password
# accept
await conn_b.gather_candidates()
for candidate in conn_b.local_candidates:
await conn_a.add_remote_candidate(candidate)
await conn_a.add_remote_candidate(None)
conn_a.remote_username = conn_b.local_username
conn_a.remote_password = "wrong-password"
# connect
done, pending = await asyncio.wait(
[
asyncio.ensure_future(conn_a.connect()),
asyncio.ensure_future(conn_b.connect()),
],
return_when=asyncio.FIRST_EXCEPTION,
)
for task in pending:
task.cancel()
self.assertEqual(len(done), 1)
self.assertTrue(isinstance(done.pop().exception(), ConnectionError))
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_invalid_username(self):
conn_a = ice.Connection(ice_controlling=True)
conn_b = ice.Connection(ice_controlling=False)
# invite
await conn_a.gather_candidates()
for candidate in conn_a.local_candidates:
await conn_b.add_remote_candidate(candidate)
await conn_b.add_remote_candidate(None)
conn_b.remote_username = conn_a.local_username
conn_b.remote_password = conn_a.local_password
# accept
await conn_b.gather_candidates()
for candidate in conn_b.local_candidates:
await conn_a.add_remote_candidate(candidate)
await conn_a.add_remote_candidate(None)
conn_a.remote_username = "wrong-username"
conn_a.remote_password = conn_b.local_password
# connect
done, pending = await asyncio.wait(
[
asyncio.ensure_future(conn_a.connect()),
asyncio.ensure_future(conn_b.connect()),
]
)
for task in pending:
task.cancel()
self.assertEqual(len(done), 2)
self.assertTrue(isinstance(done.pop().exception(), ConnectionError))
self.assertTrue(isinstance(done.pop().exception(), ConnectionError))
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_no_gather(self):
"""
If local candidates gathering was not performed, connect fails.
"""
conn = ice.Connection(ice_controlling=True)
await conn.add_remote_candidate(
Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
)
await conn.add_remote_candidate(None)
conn.remote_username = "foo"
conn.remote_password = "bar"
with self.assertRaises(ConnectionError) as cm:
await conn.connect()
self.assertEqual(
str(cm.exception), "Local candidates gathering was not performed"
)
await conn.close()
@asynctest
async def test_connect_no_local_candidates(self):
"""
If local candidates gathering yielded no candidates, connect fails.
"""
conn = ice.Connection(ice_controlling=True)
conn._local_candidates_end = True
await conn.add_remote_candidate(
Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
)
await conn.add_remote_candidate(None)
conn.remote_username = "foo"
conn.remote_password = "bar"
with self.assertRaises(ConnectionError) as cm:
await conn.connect()
self.assertEqual(str(cm.exception), "ICE negotiation failed")
await conn.close()
@asynctest
async def test_connect_no_remote_candidates(self):
"""
If no remote candidates were provided, connect fails.
"""
conn = ice.Connection(ice_controlling=True)
await conn.gather_candidates()
await conn.add_remote_candidate(None)
conn.remote_username = "foo"
conn.remote_password = "bar"
with self.assertRaises(ConnectionError) as cm:
await conn.connect()
self.assertEqual(str(cm.exception), "ICE negotiation failed")
await conn.close()
@asynctest
async def test_connect_no_remote_credentials(self):
"""
If remote credentials have not been provided, connect fails.
"""
conn = ice.Connection(ice_controlling=True)
await conn.gather_candidates()
await conn.add_remote_candidate(
Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
)
await conn.add_remote_candidate(None)
with self.assertRaises(ConnectionError) as cm:
await conn.connect()
self.assertEqual(str(cm.exception), "Remote username or password is missing")
await conn.close()
@asynctest
async def test_connect_role_conflict_both_controlling(self):
conn_a = ice.Connection(ice_controlling=True)
conn_b = ice.Connection(ice_controlling=True)
# set tie breaker for a deterministic outcome
conn_a._tie_breaker = 1
conn_b._tie_breaker = 2
# invite / accept
await invite_accept(conn_a, conn_b)
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
self.assertFalse(conn_a.ice_controlling)
self.assertTrue(conn_b.ice_controlling)
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_role_conflict_both_controlled(self):
conn_a = ice.Connection(ice_controlling=False)
conn_b = ice.Connection(ice_controlling=False)
# set tie breaker for a deterministic outcome
conn_a._tie_breaker = 1
conn_b._tie_breaker = 2
# invite / accept
await invite_accept(conn_a, conn_b)
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
self.assertFalse(conn_a.ice_controlling)
self.assertTrue(conn_b.ice_controlling)
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_timeout(self):
# lower STUN retries
stun.RETRY_MAX = 1
conn = ice.Connection(ice_controlling=True)
await conn.gather_candidates()
await conn.add_remote_candidate(
Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
)
await conn.add_remote_candidate(None)
conn.remote_username = "foo"
conn.remote_password = "bar"
with self.assertRaises(ConnectionError) as cm:
await conn.connect()
self.assertEqual(str(cm.exception), "ICE negotiation failed")
await conn.close()
@asynctest
async def test_connect_with_stun_server(self):
async with run_turn_server() as stun_server:
conn_a = ice.Connection(
ice_controlling=True, stun_server=stun_server.udp_address
)
conn_b = ice.Connection(ice_controlling=False)
# invite / accept
await invite_accept(conn_a, conn_b)
# we whould have both host and server-reflexive candidates
self.assertCandidateTypes(conn_a, set(["host", "srflx"]))
self.assertCandidateTypes(conn_b, set(["host"]))
# the default candidate should be server-reflexive
candidate = conn_a.get_default_candidate(1)
self.assertIsNotNone(candidate)
self.assertEqual(candidate.type, "srflx")
self.assertIsNotNone(candidate.related_address)
self.assertIsNotNone(candidate.related_port)
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_with_stun_server_dns_lookup_error(self):
conn_a = ice.Connection(ice_controlling=True, stun_server=("invalid.", 1234))
conn_b = ice.Connection(ice_controlling=False)
# invite / accept
await invite_accept(conn_a, conn_b)
# we whould have only host candidates
self.assertCandidateTypes(conn_a, set(["host"]))
self.assertCandidateTypes(conn_b, set(["host"]))
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_with_stun_server_timeout(self):
async with run_turn_server() as stun_server:
# immediately stop turn server
await stun_server.close()
conn_a = ice.Connection(
ice_controlling=True, stun_server=stun_server.udp_address
)
conn_b = ice.Connection(ice_controlling=False)
# invite / accept
await invite_accept(conn_a, conn_b)
# we whould have only host candidates
self.assertCandidateTypes(conn_a, set(["host"]))
self.assertCandidateTypes(conn_b, set(["host"]))
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@unittest.skipIf(RUNNING_ON_CI, "CI lacks ipv6")
@asynctest
async def test_connect_with_stun_server_ipv6(self):
async with run_turn_server() as stun_server:
conn_a = ice.Connection(
ice_controlling=True,
stun_server=stun_server.udp_address,
use_ipv4=False,
use_ipv6=True,
)
conn_b = ice.Connection(
ice_controlling=False, use_ipv4=False, use_ipv6=True
)
# invite / accept
await invite_accept(conn_a, conn_b)
# we only want host candidates : no STUN for IPv6
self.assertTrue(len(conn_a.local_candidates) > 0)
for candidate in conn_a.local_candidates:
self.assertEqual(candidate.type, "host")
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_with_turn_server_tcp(self):
async with run_turn_server(users={"foo": "bar"}) as turn_server:
# create connections
conn_a = ice.Connection(
ice_controlling=True,
turn_server=turn_server.tcp_address,
turn_username="foo",
turn_password="bar",
turn_transport="tcp",
)
conn_b = ice.Connection(ice_controlling=False)
# invite / accept
await invite_accept(conn_a, conn_b)
# we whould have both host and relayed candidates
self.assertCandidateTypes(conn_a, set(["host", "relay"]))
self.assertCandidateTypes(conn_b, set(["host"]))
# the default candidate should be relayed
candidate = conn_a.get_default_candidate(1)
self.assertIsNotNone(candidate)
self.assertEqual(candidate.type, "relay")
self.assertIsNotNone(candidate.related_address)
self.assertIsNotNone(candidate.related_port)
# connect
await asyncio.gather(conn_a.connect(), conn_b.connect())
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
@asynctest
async def test_connect_with_turn_server_udp(self):
async with run_turn_server(users={"foo": "bar"}) as turn_server:
# create connections
conn_a = ice.Connection(
ice_controlling=True,
turn_server=turn_server.udp_address,
turn_username="foo",
turn_password="bar",
)
conn_b = ice.Connection(ice_controlling=False)
# invite / accept
await invite_accept(conn_a, conn_b)
# we whould have both host and relayed candidates
self.assertCandidateTypes(conn_a, set(["host", "relay"]))
self.assertCandidateTypes(conn_b, set(["host"]))
# the default candidate should be relayed
candidate = conn_a.get_default_candidate(1)
self.assertIsNotNone(candidate)
self.assertEqual(candidate.type, "relay")
self.assertIsNotNone(candidate.related_address)
self.assertIsNotNone(candidate.related_port)
# connect
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | true |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_candidate.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_candidate.py | import unittest
from aioice import Candidate
class CandidateTest(unittest.TestCase):
def test_can_pair_ipv4(self):
candidate_a = Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
candidate_b = Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 12345 typ host generation 0"
)
self.assertTrue(candidate_a.can_pair_with(candidate_b))
def test_can_pair_ipv4_case_insensitive(self):
candidate_a = Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
candidate_b = Candidate.from_sdp(
"6815297761 1 UDP 659136 1.2.3.4 12345 typ host generation 0"
)
self.assertTrue(candidate_a.can_pair_with(candidate_b))
def test_can_pair_ipv6(self):
candidate_a = Candidate.from_sdp(
"6815297761 1 udp 659136 2a02:0db8:85a3:0000:0000:8a2e:0370:7334 31102"
" typ host generation 0"
)
candidate_b = Candidate.from_sdp(
"6815297761 1 udp 659136 2a02:0db8:85a3:0000:0000:8a2e:0370:7334 12345"
" typ host generation 0"
)
self.assertTrue(candidate_a.can_pair_with(candidate_b))
def test_cannot_pair_ipv4_ipv6(self):
candidate_a = Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
candidate_b = Candidate.from_sdp(
"6815297761 1 udp 659136 2a02:0db8:85a3:0000:0000:8a2e:0370:7334 12345"
" typ host generation 0"
)
self.assertFalse(candidate_a.can_pair_with(candidate_b))
def test_cannot_pair_different_components(self):
candidate_a = Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
candidate_b = Candidate.from_sdp(
"6815297761 2 udp 659136 1.2.3.4 12345 typ host generation 0"
)
self.assertFalse(candidate_a.can_pair_with(candidate_b))
def test_cannot_pair_different_transports(self):
candidate_a = Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
candidate_b = Candidate.from_sdp(
"6815297761 1 tcp 659136 1.2.3.4 12345 typ host generation 0 tcptype active"
)
self.assertFalse(candidate_a.can_pair_with(candidate_b))
def test_from_sdp_udp(self):
candidate = Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
self.assertEqual(candidate.foundation, "6815297761")
self.assertEqual(candidate.component, 1)
self.assertEqual(candidate.transport, "udp")
self.assertEqual(candidate.priority, 659136)
self.assertEqual(candidate.host, "1.2.3.4")
self.assertEqual(candidate.port, 31102)
self.assertEqual(candidate.type, "host")
self.assertEqual(candidate.generation, 0)
self.assertEqual(
candidate.to_sdp(),
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0",
)
def test_from_sdp_udp_srflx(self):
candidate = Candidate.from_sdp(
"1 1 UDP 1686052863 1.2.3.4 42705 typ srflx raddr 192.168.1.101 rport 42705"
)
self.assertEqual(candidate.foundation, "1")
self.assertEqual(candidate.component, 1)
self.assertEqual(candidate.transport, "UDP")
self.assertEqual(candidate.priority, 1686052863)
self.assertEqual(candidate.host, "1.2.3.4")
self.assertEqual(candidate.port, 42705)
self.assertEqual(candidate.type, "srflx")
self.assertEqual(candidate.related_address, "192.168.1.101")
self.assertEqual(candidate.related_port, 42705)
self.assertEqual(candidate.generation, None)
self.assertEqual(
candidate.to_sdp(),
"1 1 UDP 1686052863 1.2.3.4 42705 typ srflx raddr 192.168.1.101 rport 42705",
)
def test_from_sdp_tcp(self):
candidate = Candidate.from_sdp(
"1936595596 1 tcp 1518214911 1.2.3.4 9 typ host "
"tcptype active generation 0 network-id 1 network-cost 10"
)
self.assertEqual(candidate.foundation, "1936595596")
self.assertEqual(candidate.component, 1)
self.assertEqual(candidate.transport, "tcp")
self.assertEqual(candidate.priority, 1518214911)
self.assertEqual(candidate.host, "1.2.3.4")
self.assertEqual(candidate.port, 9)
self.assertEqual(candidate.type, "host")
self.assertEqual(candidate.tcptype, "active")
self.assertEqual(candidate.generation, 0)
self.assertEqual(
candidate.to_sdp(),
"1936595596 1 tcp 1518214911 1.2.3.4 9 typ host tcptype active generation 0",
)
def test_from_sdp_no_generation(self):
candidate = Candidate.from_sdp("6815297761 1 udp 659136 1.2.3.4 31102 typ host")
self.assertEqual(candidate.foundation, "6815297761")
self.assertEqual(candidate.component, 1)
self.assertEqual(candidate.transport, "udp")
self.assertEqual(candidate.priority, 659136)
self.assertEqual(candidate.host, "1.2.3.4")
self.assertEqual(candidate.port, 31102)
self.assertEqual(candidate.type, "host")
self.assertEqual(candidate.generation, None)
self.assertEqual(
candidate.to_sdp(), "6815297761 1 udp 659136 1.2.3.4 31102 typ host"
)
def test_from_sdp_truncated(self):
with self.assertRaises(ValueError):
Candidate.from_sdp("6815297761 1 udp 659136 1.2.3.4 31102 typ")
def test_repr(self):
candidate = Candidate.from_sdp(
"6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0"
)
self.assertEqual(
repr(candidate),
"Candidate(6815297761 1 udp 659136 1.2.3.4 31102 typ host generation 0)",
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_ice_trickle.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_ice_trickle.py | import asyncio
import unittest
from aioice import ice
from .utils import asynctest
class IceTrickleTest(unittest.TestCase):
def assertCandidateTypes(self, conn, expected):
types = set([c.type for c in conn.local_candidates])
self.assertEqual(types, expected)
@asynctest
async def test_connect(self):
conn_a = ice.Connection(ice_controlling=True)
conn_b = ice.Connection(ice_controlling=False)
# invite
await conn_a.gather_candidates()
conn_b.remote_username = conn_a.local_username
conn_b.remote_password = conn_a.local_password
# accept
await conn_b.gather_candidates()
conn_a.remote_username = conn_b.local_username
conn_a.remote_password = conn_b.local_password
# we should only have host candidates
self.assertCandidateTypes(conn_a, set(["host"]))
self.assertCandidateTypes(conn_b, set(["host"]))
# there should be a default candidate for component 1
candidate = conn_a.get_default_candidate(1)
self.assertIsNotNone(candidate)
self.assertEqual(candidate.type, "host")
# there should not be a default candidate for component 2
candidate = conn_a.get_default_candidate(2)
self.assertIsNone(candidate)
async def add_candidates_later(a, b):
await asyncio.sleep(0.1)
for candidate in b.local_candidates:
await a.add_remote_candidate(candidate)
await asyncio.sleep(0.1)
await a.add_remote_candidate(None)
# connect
await asyncio.gather(
conn_a.connect(),
conn_b.connect(),
add_candidates_later(conn_a, conn_b),
add_candidates_later(conn_b, conn_a),
)
# send data a -> b
await conn_a.send(b"howdee")
data = await conn_b.recv()
self.assertEqual(data, b"howdee")
# send data b -> a
await conn_b.send(b"gotcha")
data = await conn_a.recv()
self.assertEqual(data, b"gotcha")
# close
await conn_a.close()
await conn_b.close()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/turnserver.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/turnserver.py | import argparse
import asyncio
import contextlib
import logging
import os
import ssl
import struct
import time
from typing import Optional, Tuple
from aioice import stun
from aioice.ice import get_host_addresses
from aioice.turn import (
DEFAULT_ALLOCATION_LIFETIME,
UDP_TRANSPORT,
TurnStreamMixin,
is_channel_data,
make_integrity_key,
)
from aioice.utils import random_string
logger = logging.getLogger("turn")
CHANNEL_RANGE = range(0x4000, 0x7FFF)
ROOT = os.path.dirname(__file__)
CERT_FILE = os.path.join(ROOT, "turnserver.crt")
KEY_FILE = os.path.join(ROOT, "turnserver.key")
def create_self_signed_cert(name="localhost"):
from OpenSSL import crypto
# create key pair
key = crypto.PKey()
key.generate_key(crypto.TYPE_RSA, 2048)
# create self-signed certificate
cert = crypto.X509()
cert.get_subject().CN = name
cert.set_serial_number(1000)
cert.gmtime_adj_notBefore(0)
cert.gmtime_adj_notAfter(10 * 365 * 86400)
cert.set_issuer(cert.get_subject())
cert.set_pubkey(key)
cert.sign(key, "sha1")
with open(CERT_FILE, "wb") as fp:
fp.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
with open(KEY_FILE, "wb") as fp:
fp.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, key))
class Allocation(asyncio.DatagramProtocol):
def __init__(self, client_address, client_protocol, expiry, username):
self.channel_to_peer = {}
self.peer_to_channel = {}
self.client_address = client_address
self.client_protocol = client_protocol
self.expiry = expiry
self.username = username
def connection_made(self, transport):
self.relayed_address = transport.get_extra_info("sockname")
self.transport = transport
def datagram_received(self, data, addr):
"""
Relay data from peer to client.
"""
channel = self.peer_to_channel.get(addr)
if channel:
self.client_protocol._send(
struct.pack("!HH", channel, len(data)) + data, self.client_address
)
class TurnServerMixin:
def __init__(self, server):
self.server = server
def connection_made(self, transport):
self.transport = transport
def datagram_received(self, data, addr):
# demultiplex channel data
if len(data) >= 4 and is_channel_data(data):
channel, length = struct.unpack("!HH", data[0:4])
allocation = self.server.allocations.get((self, addr))
if len(data) >= length + 4 and allocation:
peer_address = allocation.channel_to_peer.get(channel)
if peer_address:
payload = data[4 : 4 + length]
allocation.transport.sendto(payload, peer_address)
return
try:
message = stun.parse_message(data)
except ValueError:
return
logger.debug("< %s %s", addr, message)
assert message.message_class == stun.Class.REQUEST
if message.message_method == stun.Method.BINDING:
response = self.handle_binding(message, addr)
self.send_stun(response, addr)
return
# generate failure for test purposes
if self.server.simulated_failure:
response = self.error_response(message, *self.server.simulated_failure)
self.server.simulated_failure = None
self.send_stun(response, addr)
return
if "USERNAME" not in message.attributes:
response = self.error_response(message, 401, "Unauthorized")
response.attributes["NONCE"] = random_string(16).encode("ascii")
response.attributes["REALM"] = self.server.realm
self.send_stun(response, addr)
return
# check credentials
username = message.attributes["USERNAME"]
password = self.server.users[username]
integrity_key = make_integrity_key(username, self.server.realm, password)
try:
stun.parse_message(data, integrity_key=integrity_key)
except ValueError:
return
if message.message_method == stun.Method.ALLOCATE:
asyncio.ensure_future(self.handle_allocate(message, addr, integrity_key))
return
elif message.message_method == stun.Method.REFRESH:
response = self.handle_refresh(message, addr)
elif message.message_method == stun.Method.CHANNEL_BIND:
response = self.handle_channel_bind(message, addr)
else:
response = self.error_response(
message, 400, "Unsupported STUN request method"
)
response.add_message_integrity(integrity_key)
self.send_stun(response, addr)
async def handle_allocate(self, message, addr, integrity_key):
key = (self, addr)
if key in self.server.allocations:
response = self.error_response(message, 437, "Allocation already exists")
elif "REQUESTED-TRANSPORT" not in message.attributes:
response = self.error_response(
message, 400, "Missing REQUESTED-TRANSPORT attribute"
)
elif message.attributes["REQUESTED-TRANSPORT"] != UDP_TRANSPORT:
response = self.error_response(
message, 442, "Unsupported transport protocol"
)
else:
lifetime = message.attributes.get("LIFETIME", DEFAULT_ALLOCATION_LIFETIME)
lifetime = min(lifetime, self.server.maximum_lifetime)
# create allocation
loop = asyncio.get_event_loop()
_, allocation = await loop.create_datagram_endpoint(
lambda: Allocation(
client_address=addr,
client_protocol=self,
expiry=time.time() + lifetime,
username=message.attributes["USERNAME"],
),
local_addr=("127.0.0.1", 0),
)
self.server.allocations[key] = allocation
logger.info("Allocation created %s", allocation.relayed_address)
# build response
response = stun.Message(
message_method=message.message_method,
message_class=stun.Class.RESPONSE,
transaction_id=message.transaction_id,
)
response.attributes["LIFETIME"] = lifetime
response.attributes["XOR-MAPPED-ADDRESS"] = addr
response.attributes["XOR-RELAYED-ADDRESS"] = allocation.relayed_address
# send response
response.add_message_integrity(integrity_key)
self.send_stun(response, addr)
def handle_binding(self, message, addr):
response = stun.Message(
message_method=message.message_method,
message_class=stun.Class.RESPONSE,
transaction_id=message.transaction_id,
)
response.attributes["XOR-MAPPED-ADDRESS"] = addr
return response
def handle_channel_bind(self, message, addr):
try:
key = (self, addr)
allocation = self.server.allocations[key]
except KeyError:
return self.error_response(message, 437, "Allocation does not exist")
if message.attributes["USERNAME"] != allocation.username:
return self.error_response(message, 441, "Wrong credentials")
for attr in ["CHANNEL-NUMBER", "XOR-PEER-ADDRESS"]:
if attr not in message.attributes:
return self.error_response(message, 400, "Missing %s attribute" % attr)
channel = message.attributes["CHANNEL-NUMBER"]
peer_address = message.attributes["XOR-PEER-ADDRESS"]
if channel not in CHANNEL_RANGE:
return self.error_response(
message, 400, "Channel number is outside valid range"
)
if allocation.channel_to_peer.get(channel) not in [None, peer_address]:
return self.error_response(
message, 400, "Channel is already bound to another peer"
)
if allocation.peer_to_channel.get(peer_address) not in [None, channel]:
return self.error_response(
message, 400, "Peer is already bound to another channel"
)
# register channel
allocation.channel_to_peer[channel] = peer_address
allocation.peer_to_channel[peer_address] = channel
# build response
response = stun.Message(
message_method=message.message_method,
message_class=stun.Class.RESPONSE,
transaction_id=message.transaction_id,
)
return response
def handle_refresh(self, message, addr):
try:
key = (self, addr)
allocation = self.server.allocations[key]
except KeyError:
return self.error_response(message, 437, "Allocation does not exist")
if message.attributes["USERNAME"] != allocation.username:
return self.error_response(message, 441, "Wrong credentials")
if "LIFETIME" not in message.attributes:
return self.error_response(message, 400, "Missing LIFETIME attribute")
# refresh allocation
lifetime = min(message.attributes["LIFETIME"], self.server.maximum_lifetime)
if lifetime:
logger.info("Allocation refreshed %s", allocation.relayed_address)
allocation.expiry = time.time() + lifetime
else:
logger.info("Allocation deleted %s", allocation.relayed_address)
self.server._remove_allocation(key)
# build response
response = stun.Message(
message_method=message.message_method,
message_class=stun.Class.RESPONSE,
transaction_id=message.transaction_id,
)
response.attributes["LIFETIME"] = lifetime
return response
def error_response(self, request, code, message):
"""
Build an error response for the given request.
"""
response = stun.Message(
message_method=request.message_method,
message_class=stun.Class.ERROR,
transaction_id=request.transaction_id,
)
response.attributes["ERROR-CODE"] = (code, message)
return response
def send_stun(self, message, addr):
logger.debug("> %s %s", addr, message)
self._send(bytes(message), addr)
class TurnServerTcpProtocol(TurnServerMixin, TurnStreamMixin, asyncio.Protocol):
def _send(self, data, addr):
self.transport.write(self._padded(data))
class TurnServerUdpProtocol(TurnServerMixin, asyncio.DatagramProtocol):
def _send(self, data, addr):
self.transport.sendto(data, addr)
class TurnServer:
"""
STUN / TURN server.
"""
def __init__(self, realm="test", users={}):
self.allocations = {}
self.maximum_lifetime = 3600
self.realm = realm
self.simulated_failure: Optional[Tuple[int, str]] = None
self.users = users
self._expire_handle = None
async def close(self):
# stop expiry loop
self._expire_handle.cancel()
# close allocations
for key in list(self.allocations.keys()):
self._remove_allocation(key)
# shutdown servers
self.tcp_server.close()
self.tls_server.close()
self.udp_server.transport.close()
await asyncio.gather(
self.tcp_server.wait_closed(), self.tls_server.wait_closed()
)
async def listen(self, port=0, tls_port=0):
loop = asyncio.get_event_loop()
hostaddr = get_host_addresses(use_ipv4=True, use_ipv6=False)[0]
# listen for TCP
self.tcp_server = await loop.create_server(
lambda: TurnServerTcpProtocol(server=self), host=hostaddr, port=port
)
self.tcp_address = self.tcp_server.sockets[0].getsockname()
logger.info("Listening for TCP on %s", self.tcp_address)
# listen for UDP
transport, self.udp_server = await loop.create_datagram_endpoint(
lambda: TurnServerUdpProtocol(server=self), local_addr=(hostaddr, port)
)
self.udp_address = transport.get_extra_info("sockname")
logger.info("Listening for UDP on %s", self.udp_address)
# listen for TLS
ssl_context = ssl.SSLContext(protocol=ssl.PROTOCOL_TLS_SERVER)
ssl_context.load_cert_chain(CERT_FILE, KEY_FILE)
self.tls_server = await loop.create_server(
lambda: TurnServerTcpProtocol(server=self),
host=hostaddr,
port=tls_port,
ssl=ssl_context,
)
self.tls_address = self.tls_server.sockets[0].getsockname()
logger.info("Listening for TLS on %s", self.tls_address)
# start expiry loop
self._expire_handle = asyncio.ensure_future(self._expire_allocations())
async def _expire_allocations(self):
while True:
now = time.time()
for key, allocation in list(self.allocations.items()):
if allocation.expiry < now:
logger.info("Allocation expired %s", allocation.relayed_address)
self.server._remove_allocation(key)
await asyncio.sleep(1)
def _remove_allocation(self, key):
allocation = self.allocations.pop(key)
allocation.transport.close()
@contextlib.asynccontextmanager
async def run_turn_server(**kwargs):
server = TurnServer(**kwargs)
await server.listen()
try:
yield server
finally:
await server.close()
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="STUN / TURN server")
parser.add_argument("--verbose", "-v", action="count")
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
srv = TurnServer(realm="test", users={"foo": "bar"})
loop = asyncio.get_event_loop()
loop.run_until_complete(srv.listen(port=3478, tls_port=5349))
loop.run_forever()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_turn.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_turn.py | import asyncio
import ssl
import unittest
from aioice import stun, turn
from .echoserver import run_echo_server
from .turnserver import run_turn_server
from .utils import asynctest, read_message
PROTOCOL_KWARGS = {
"username": "foo",
"password": "bar",
"lifetime": turn.DEFAULT_ALLOCATION_LIFETIME,
"channel_refresh_time": turn.DEFAULT_CHANNEL_REFRESH_TIME,
}
class DummyClientProtocol(asyncio.DatagramProtocol):
def __init__(self):
self.received = []
def datagram_received(self, data, addr):
self.received.append((data, addr))
class TurnClientTcpProtocolTest(unittest.TestCase):
def setUp(self):
class MockProtocol:
def get_extra_info(self, name):
return ("1.2.3.4", 1234)
self.protocol = turn.TurnClientTcpProtocol(("1.2.3.4", 1234), **PROTOCOL_KWARGS)
self.protocol.connection_made(MockProtocol())
def test_receive_stun_fragmented(self):
data = read_message("binding_request.bin")
self.protocol.data_received(data[0:10])
self.protocol.data_received(data[10:])
def test_receive_junk(self):
self.protocol.data_received(b"\x00" * 20)
def test_repr(self):
self.assertEqual(repr(self.protocol), "turn/tcp")
class TurnClientUdpProtocolTest(unittest.TestCase):
def setUp(self):
self.protocol = turn.TurnClientUdpProtocol(("1.2.3.4", 1234), **PROTOCOL_KWARGS)
def test_receive_junk(self):
self.protocol.datagram_received(b"\x00" * 20, ("1.2.3.4", 1234))
def test_repr(self):
self.assertEqual(repr(self.protocol), "turn/udp")
class TurnTest(unittest.TestCase):
@asynctest
async def test_tcp_transport(self):
await self._test_transport("tcp", "tcp_address")
@asynctest
async def test_tls_transport(self):
ssl_context = ssl.SSLContext(protocol=ssl.PROTOCOL_TLS_CLIENT)
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
await self._test_transport("tcp", "tls_address", ssl=ssl_context)
@asynctest
async def test_udp_transport(self):
await self._test_transport("udp", "udp_address")
async def _test_transport(self, transport, server_addr_attr, ssl=False):
await self._test_transport_ok(
transport=transport, server_addr_attr=server_addr_attr, ssl=ssl
)
await self._test_transport_ok_multi(
transport=transport, server_addr_attr=server_addr_attr, ssl=ssl
)
await self._test_transport_allocate_failure(
transport=transport, server_addr_attr=server_addr_attr, ssl=ssl
)
await self._test_transport_delete_failure(
transport=transport, server_addr_attr=server_addr_attr, ssl=ssl
)
async def _test_transport_ok(self, *, transport, server_addr_attr, ssl):
async with run_turn_server(realm="test", users={"foo": "bar"}) as turn_server:
transport, protocol = await turn.create_turn_endpoint(
DummyClientProtocol,
server_addr=getattr(turn_server, server_addr_attr),
username="foo",
password="bar",
channel_refresh_time=5,
lifetime=6,
ssl=ssl,
transport=transport,
)
self.assertIsNone(transport.get_extra_info("peername"))
self.assertIsNotNone(transport.get_extra_info("sockname"))
async with run_echo_server() as echo_server:
# bind channel, send ping, expect pong
transport.sendto(b"ping", echo_server.udp_address)
await asyncio.sleep(1)
self.assertEqual(
protocol.received, [(b"ping", echo_server.udp_address)]
)
# wait some more to allow allocation refresh
protocol.received.clear()
await asyncio.sleep(5)
# refresh channel, send ping, expect pong
transport.sendto(b"ping", echo_server.udp_address)
await asyncio.sleep(1)
self.assertEqual(
protocol.received, [(b"ping", echo_server.udp_address)]
)
# close
transport.close()
await asyncio.sleep(0)
async def _test_transport_ok_multi(self, *, transport, server_addr_attr, ssl):
async with run_turn_server(realm="test", users={"foo": "bar"}) as turn_server:
transport, protocol = await turn.create_turn_endpoint(
DummyClientProtocol,
server_addr=getattr(turn_server, server_addr_attr),
username="foo",
password="bar",
channel_refresh_time=5,
lifetime=6,
ssl=ssl,
transport=transport,
)
self.assertIsNone(transport.get_extra_info("peername"))
self.assertIsNotNone(transport.get_extra_info("sockname"))
# Bind channel, send ping, expect pong.
#
# We use different lengths to trigger both padded an unpadded
# ChannelData messages over TCP.
async with run_echo_server() as echo_server1:
async with run_echo_server() as echo_server2:
transport.sendto(b"ping", echo_server1.udp_address) # never padded
transport.sendto(b"ping11", echo_server1.udp_address)
transport.sendto(b"ping20", echo_server2.udp_address)
transport.sendto(b"ping21", echo_server2.udp_address)
await asyncio.sleep(1)
self.assertEqual(
sorted(protocol.received),
[
(b"ping", echo_server1.udp_address),
(b"ping11", echo_server1.udp_address),
(b"ping20", echo_server2.udp_address),
(b"ping21", echo_server2.udp_address),
],
)
# close
transport.close()
await asyncio.sleep(0)
async def _test_transport_allocate_failure(
self, *, transport, server_addr_attr, ssl
):
async with run_turn_server(realm="test", users={"foo": "bar"}) as turn_server:
# make the server reject the ALLOCATE request
turn_server.simulated_failure = (403, "Forbidden")
with self.assertRaises(stun.TransactionFailed) as cm:
await turn.create_turn_endpoint(
DummyClientProtocol,
server_addr=getattr(turn_server, server_addr_attr),
username="foo",
password="bar",
ssl=ssl,
transport=transport,
)
self.assertEqual(str(cm.exception), "STUN transaction failed (403 - Forbidden)")
async def _test_transport_delete_failure(self, *, transport, server_addr_attr, ssl):
async with run_turn_server(realm="test", users={"foo": "bar"}) as turn_server:
transport, protocol = await turn.create_turn_endpoint(
DummyClientProtocol,
server_addr=getattr(turn_server, server_addr_attr),
username="foo",
password="bar",
ssl=ssl,
transport=transport,
)
self.assertIsNone(transport.get_extra_info("peername"))
self.assertIsNotNone(transport.get_extra_info("sockname"))
# make the server reject the final REFRESH request
turn_server.simulated_failure = (403, "Forbidden")
# close client
transport.close()
await asyncio.sleep(0)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/utils.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/utils.py | import asyncio
import functools
import logging
import os
def asynctest(coro):
@functools.wraps(coro)
def wrap(*args, **kwargs):
asyncio.run(coro(*args, **kwargs))
return wrap
async def invite_accept(conn_a, conn_b):
# invite
await conn_a.gather_candidates()
for candidate in conn_a.local_candidates:
await conn_b.add_remote_candidate(candidate)
await conn_b.add_remote_candidate(None)
conn_b.remote_username = conn_a.local_username
conn_b.remote_password = conn_a.local_password
# accept
await conn_b.gather_candidates()
for candidate in conn_b.local_candidates:
await conn_a.add_remote_candidate(candidate)
await conn_a.add_remote_candidate(None)
conn_a.remote_username = conn_b.local_username
conn_a.remote_password = conn_b.local_password
def read_message(name):
path = os.path.join(os.path.dirname(__file__), "data", name)
with open(path, "rb") as fp:
return fp.read()
if os.environ.get("AIOICE_DEBUG"):
logging.basicConfig(level=logging.DEBUG)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_mdns.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_mdns.py | import asyncio
import contextlib
import unittest
from aioice import mdns
from .utils import asynctest
@contextlib.asynccontextmanager
async def querier_and_responder():
querier = await mdns.create_mdns_protocol()
responder = await mdns.create_mdns_protocol()
try:
yield querier, responder
finally:
await querier.close()
await responder.close()
class MdnsTest(unittest.TestCase):
@asynctest
async def test_receive_junk(self):
async with querier_and_responder() as (querier, _):
querier.datagram_received(b"junk", None)
@asynctest
async def test_resolve_bad(self):
hostname = mdns.create_mdns_hostname()
async with querier_and_responder() as (querier, _):
result = await querier.resolve(hostname)
self.assertEqual(result, None)
@asynctest
async def test_resolve_close(self):
hostname = mdns.create_mdns_hostname()
# close the querier while the query is ongoing
async with querier_and_responder() as (querier, _):
result = await asyncio.gather(
querier.resolve(hostname, timeout=None), querier.close()
)
self.assertEqual(result, [None, None])
@asynctest
async def test_resolve_good_ipv4(self):
hostaddr = "1.2.3.4"
hostname = mdns.create_mdns_hostname()
async with querier_and_responder() as (querier, responder):
await responder.publish(hostname, hostaddr)
result = await querier.resolve(hostname)
self.assertEqual(result, hostaddr)
@asynctest
async def test_resolve_good_ipv6(self):
hostaddr = "::ffff:1.2.3.4"
hostname = mdns.create_mdns_hostname()
async with querier_and_responder() as (querier, responder):
await responder.publish(hostname, hostaddr)
result = await querier.resolve(hostname)
self.assertEqual(result, hostaddr)
@asynctest
async def test_resolve_simultaneous_bad(self):
hostname = mdns.create_mdns_hostname()
async with querier_and_responder() as (querier, _):
results = await asyncio.gather(
querier.resolve(hostname), querier.resolve(hostname)
)
self.assertEqual(results, [None, None])
@asynctest
async def test_resolve_simultaneous_good(self):
hostaddr = "1.2.3.4"
hostname = mdns.create_mdns_hostname()
async with querier_and_responder() as (querier, responder):
await responder.publish(hostname, hostaddr)
results = await asyncio.gather(
querier.resolve(hostname), querier.resolve(hostname)
)
self.assertEqual(results, [hostaddr, hostaddr])
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_stun.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_stun.py | import unittest
from binascii import unhexlify
from collections import OrderedDict
from aioice import stun
from .utils import asynctest, read_message
class AttributeTest(unittest.TestCase):
def test_unpack_error_code(self):
data = unhexlify("00000457526f6c6520436f6e666c696374")
code, reason = stun.unpack_error_code(data)
self.assertEqual(code, 487)
self.assertEqual(reason, "Role Conflict")
def test_unpack_error_code_too_short(self):
data = unhexlify("000004")
with self.assertRaises(ValueError) as cm:
stun.unpack_error_code(data)
self.assertEqual(str(cm.exception), "STUN error code is less than 4 bytes")
def test_unpack_xor_address_ipv4(self):
transaction_id = unhexlify("b7e7a701bc34d686fa87dfae")
address, port = stun.unpack_xor_address(
unhexlify("0001a147e112a643"), transaction_id
)
self.assertEqual(address, "192.0.2.1")
self.assertEqual(port, 32853)
def test_unpack_xor_address_ipv4_truncated(self):
transaction_id = unhexlify("b7e7a701bc34d686fa87dfae")
with self.assertRaises(ValueError) as cm:
stun.unpack_xor_address(unhexlify("0001a147e112a6"), transaction_id)
self.assertEqual(str(cm.exception), "STUN address has invalid length for IPv4")
def test_unpack_xor_address_ipv6(self):
transaction_id = unhexlify("b7e7a701bc34d686fa87dfae")
address, port = stun.unpack_xor_address(
unhexlify("0002a1470113a9faa5d3f179bc25f4b5bed2b9d9"), transaction_id
)
self.assertEqual(address, "2001:db8:1234:5678:11:2233:4455:6677")
self.assertEqual(port, 32853)
def test_unpack_xor_address_ipv6_truncated(self):
transaction_id = unhexlify("b7e7a701bc34d686fa87dfae")
with self.assertRaises(ValueError) as cm:
stun.unpack_xor_address(
unhexlify("0002a1470113a9faa5d3f179bc25f4b5bed2b9"), transaction_id
)
self.assertEqual(str(cm.exception), "STUN address has invalid length for IPv6")
def test_unpack_xor_address_too_short(self):
transaction_id = unhexlify("b7e7a701bc34d686fa87dfae")
with self.assertRaises(ValueError) as cm:
stun.unpack_xor_address(unhexlify("0001"), transaction_id)
self.assertEqual(str(cm.exception), "STUN address length is less than 4 bytes")
def test_unpack_xor_address_unknown_protocol(self):
transaction_id = unhexlify("b7e7a701bc34d686fa87dfae")
with self.assertRaises(ValueError) as cm:
stun.unpack_xor_address(unhexlify("0003a147e112a643"), transaction_id)
self.assertEqual(str(cm.exception), "STUN address has unknown protocol")
def test_pack_error_code(self):
data = stun.pack_error_code((487, "Role Conflict"))
self.assertEqual(data, unhexlify("00000457526f6c6520436f6e666c696374"))
def test_pack_xor_address_ipv4(self):
transaction_id = unhexlify("b7e7a701bc34d686fa87dfae")
data = stun.pack_xor_address(("192.0.2.1", 32853), transaction_id)
self.assertEqual(data, unhexlify("0001a147e112a643"))
def test_pack_xor_address_ipv6(self):
transaction_id = unhexlify("b7e7a701bc34d686fa87dfae")
data = stun.pack_xor_address(
("2001:db8:1234:5678:11:2233:4455:6677", 32853), transaction_id
)
self.assertEqual(data, unhexlify("0002a1470113a9faa5d3f179bc25f4b5bed2b9d9"))
def test_pack_xor_address_unknown_protocol(self):
transaction_id = unhexlify("b7e7a701bc34d686fa87dfae")
with self.assertRaises(ValueError) as cm:
stun.pack_xor_address(("foo", 32853), transaction_id)
self.assertEqual(
str(cm.exception), "'foo' does not appear to be an IPv4 or IPv6 address"
)
class MessageTest(unittest.TestCase):
def test_binding_request(self):
data = read_message("binding_request.bin")
message = stun.parse_message(data)
self.assertEqual(message.message_method, stun.Method.BINDING)
self.assertEqual(message.message_class, stun.Class.REQUEST)
self.assertEqual(message.transaction_id, b"Nvfx3lU7FUBF")
self.assertEqual(message.attributes, OrderedDict())
self.assertEqual(bytes(message), data)
self.assertEqual(
repr(message),
"Message(message_method=Method.BINDING, message_class=Class.REQUEST, "
"transaction_id=b'Nvfx3lU7FUBF')",
)
def test_binding_request_ice_controlled(self):
data = read_message("binding_request_ice_controlled.bin")
message = stun.parse_message(data)
self.assertEqual(message.message_method, stun.Method.BINDING)
self.assertEqual(message.message_class, stun.Class.REQUEST)
self.assertEqual(message.transaction_id, b"wxaNbAdXjwG3")
self.assertEqual(
message.attributes,
OrderedDict(
[
("USERNAME", "AYeZ:sw7YvCSbcVex3bhi"),
("PRIORITY", 1685987071),
("SOFTWARE", "FreeSWITCH (-37-987c9b9 64bit)"),
("ICE-CONTROLLED", 5491930053772927353),
(
"MESSAGE-INTEGRITY",
unhexlify("1963108a4f764015a66b3fea0b1883dfde1436c8"),
),
("FINGERPRINT", 3230414530),
]
),
)
self.assertEqual(bytes(message), data)
def test_binding_request_ice_controlled_bad_fingerprint(self):
data = read_message("binding_request_ice_controlled.bin")[0:-1] + b"z"
with self.assertRaises(ValueError) as cm:
stun.parse_message(data)
self.assertEqual(str(cm.exception), "STUN message fingerprint does not match")
def test_binding_request_ice_controlled_bad_integrity(self):
data = read_message("binding_request_ice_controlled.bin")
with self.assertRaises(ValueError) as cm:
stun.parse_message(data, integrity_key=b"bogus-key")
self.assertEqual(str(cm.exception), "STUN message integrity does not match")
def test_binding_request_ice_controlling(self):
data = read_message("binding_request_ice_controlling.bin")
message = stun.parse_message(data)
self.assertEqual(message.message_method, stun.Method.BINDING)
self.assertEqual(message.message_class, stun.Class.REQUEST)
self.assertEqual(message.transaction_id, b"JEwwUxjLWaa2")
self.assertEqual(
message.attributes,
OrderedDict(
[
("USERNAME", "sw7YvCSbcVex3bhi:AYeZ"),
("ICE-CONTROLLING", 5943294521425135761),
("USE-CANDIDATE", None),
("PRIORITY", 1853759231),
(
"MESSAGE-INTEGRITY",
unhexlify("c87b58eccbacdbc075d497ad0c965a82937ab587"),
),
("FINGERPRINT", 1347006354),
]
),
)
def test_binding_response(self):
data = read_message("binding_response.bin")
message = stun.parse_message(data)
self.assertEqual(message.message_method, stun.Method.BINDING)
self.assertEqual(message.message_class, stun.Class.RESPONSE)
self.assertEqual(message.transaction_id, b"Nvfx3lU7FUBF")
self.assertEqual(
message.attributes,
OrderedDict(
[
("XOR-MAPPED-ADDRESS", ("80.200.136.90", 53054)),
("MAPPED-ADDRESS", ("80.200.136.90", 53054)),
("RESPONSE-ORIGIN", ("52.17.36.97", 3478)),
("OTHER-ADDRESS", ("52.17.36.97", 3479)),
("SOFTWARE", "Citrix-3.2.4.5 'Marshal West'"),
]
),
)
self.assertEqual(bytes(message), data)
def test_message_body_length_mismatch(self):
data = read_message("binding_response.bin") + b"123"
with self.assertRaises(ValueError) as cm:
stun.parse_message(data)
self.assertEqual(str(cm.exception), "STUN message length does not match")
def test_message_shorter_than_header(self):
with self.assertRaises(ValueError) as cm:
stun.parse_message(b"123")
self.assertEqual(str(cm.exception), "STUN message length is less than 20 bytes")
def test_message_with_unknown_method(self):
with self.assertRaises(ValueError) as cm:
stun.parse_message(bytes(20))
self.assertEqual(str(cm.exception), "0 is not a valid Method")
class TransactionTest(unittest.TestCase):
def setUp(self):
stun.RETRY_MAX = 0
stun.RETRY_RTO = 0
def tearDown(self):
stun.RETRY_MAX = 6
stun.RETRY_RTO = 0.5
@asynctest
async def test_timeout(self):
class DummyProtocol:
def send_stun(self, message, address):
pass
request = stun.Message(
message_method=stun.Method.BINDING, message_class=stun.Class.REQUEST
)
transaction = stun.Transaction(request, ("127.0.0.1", 1234), DummyProtocol())
# timeout
with self.assertRaises(stun.TransactionTimeout):
await transaction.run()
# receive response after timeout
response = stun.Message(
message_method=stun.Method.BINDING, message_class=stun.Class.RESPONSE
)
transaction.response_received(response, ("127.0.0.1", 1234))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/__init__.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_exceptions.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/test_exceptions.py | import unittest
from aioice import stun
class ExceptionTest(unittest.TestCase):
def test_transaction_failed(self):
response = stun.Message(
message_method=stun.Method.BINDING, message_class=stun.Class.RESPONSE
)
response.attributes["ERROR-CODE"] = (487, "Role Conflict")
exc = stun.TransactionFailed(response)
self.assertEqual(str(exc), "STUN transaction failed (487 - Role Conflict)")
def test_transaction_timeout(self):
exc = stun.TransactionTimeout()
self.assertEqual(str(exc), "STUN transaction timed out")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/echoserver.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/tests/echoserver.py | import asyncio
import contextlib
class EchoServerProtocol(asyncio.DatagramProtocol):
def connection_made(self, transport):
self.transport = transport
def datagram_received(self, data, addr):
self.transport.sendto(data, addr)
class EchoServer:
async def close(self):
self.udp_server.transport.close()
async def listen(self, host="127.0.0.1", port=0):
loop = asyncio.get_event_loop()
# listen for UDP
transport, self.udp_server = await loop.create_datagram_endpoint(
EchoServerProtocol, local_addr=(host, port)
)
self.udp_address = transport.get_extra_info("sockname")
@contextlib.asynccontextmanager
async def run_echo_server(**kwargs):
server = EchoServer(**kwargs)
await server.listen()
try:
yield server
finally:
await server.close()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/docs/conf.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/docs/conf.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# aioice documentation build configuration file, created by
# sphinx-quickstart on Thu Feb 8 17:22:14 2018.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys, os
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('..'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx_autodoc_typehints',
'sphinxcontrib.asyncio',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'aioice'
copyright = u'2018-2019, Jeremy Lainé'
author = u'Jeremy Lainé'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = ''
# The full version, including alpha/beta/rc tags.
release = ''
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'alabaster'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
html_theme_options = {
'description': 'A library for Interactive Connectivity Establishment in Python.',
'github_button': True,
'github_user': 'aiortc',
'github_repo': 'aioice',
}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
#
# This is required for the alabaster theme
# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
html_sidebars = {
'**': [
'about.html',
'navigation.html',
'relations.html',
'searchbox.html',
]
}
# -- Options for HTMLHelp output ------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = 'aioicedoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'aioice.tex', 'aioice Documentation',
u'Jeremy Lainé', 'manual'),
]
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'aioice', 'aioice Documentation',
[author], 1)
]
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'aioice', 'aioice Documentation',
author, 'aioice', 'One line description of project.',
'Miscellaneous'),
]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/examples/ice-client.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/examples/ice-client.py | #!/usr/bin/env python
import argparse
import asyncio
import json
import logging
import websockets
import aioice
STUN_SERVER = ("stun.l.google.com", 19302)
WEBSOCKET_URI = "ws://127.0.0.1:8765"
async def offer(options):
connection = aioice.Connection(
ice_controlling=True, components=options.components, stun_server=STUN_SERVER
)
await connection.gather_candidates()
websocket = await websockets.connect(WEBSOCKET_URI)
# send offer
await websocket.send(
json.dumps(
{
"candidates": [c.to_sdp() for c in connection.local_candidates],
"password": connection.local_password,
"username": connection.local_username,
}
)
)
# await answer
message = json.loads(await websocket.recv())
print("received answer", message)
for c in message["candidates"]:
await connection.add_remote_candidate(aioice.Candidate.from_sdp(c))
await connection.add_remote_candidate(None)
connection.remote_username = message["username"]
connection.remote_password = message["password"]
await websocket.close()
await connection.connect()
print("connected")
# send data
data = b"hello"
component = 1
print("sending %s on component %d" % (repr(data), component))
await connection.sendto(data, component)
data, component = await connection.recvfrom()
print("received %s on component %d" % (repr(data), component))
await asyncio.sleep(5)
await connection.close()
async def answer(options):
connection = aioice.Connection(
ice_controlling=False, components=options.components, stun_server=STUN_SERVER
)
await connection.gather_candidates()
websocket = await websockets.connect(WEBSOCKET_URI)
# await offer
message = json.loads(await websocket.recv())
print("received offer", message)
for c in message["candidates"]:
await connection.add_remote_candidate(aioice.Candidate.from_sdp(c))
await connection.add_remote_candidate(None)
connection.remote_username = message["username"]
connection.remote_password = message["password"]
# send answer
await websocket.send(
json.dumps(
{
"candidates": [c.to_sdp() for c in connection.local_candidates],
"password": connection.local_password,
"username": connection.local_username,
}
)
)
await websocket.close()
await connection.connect()
print("connected")
# echo data back
data, component = await connection.recvfrom()
print("echoing %s on component %d" % (repr(data), component))
await connection.sendto(data, component)
await asyncio.sleep(5)
await connection.close()
parser = argparse.ArgumentParser(description="ICE tester")
parser.add_argument("action", choices=["offer", "answer"])
parser.add_argument("--components", type=int, default=1)
options = parser.parse_args()
logging.basicConfig(level=logging.DEBUG)
if options.action == "offer":
asyncio.get_event_loop().run_until_complete(offer(options))
else:
asyncio.get_event_loop().run_until_complete(answer(options))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/examples/signaling-server.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/examples/signaling-server.py | #!/usr/bin/env python
#
# Simple websocket server to perform signaling.
#
import asyncio
import binascii
import os
import websockets
clients = {}
async def echo(websocket, path):
client_id = binascii.hexlify(os.urandom(8))
clients[client_id] = websocket
try:
async for message in websocket:
for c in clients.values():
if c != websocket:
await c.send(message)
finally:
clients.pop(client_id)
asyncio.get_event_loop().run_until_complete(websockets.serve(echo, "0.0.0.0", 8765))
asyncio.get_event_loop().run_forever()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/zone.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/zone.py | from typing import Union
from .name import Name
from .rdataclass import IN
from .rdataset import Rdataset
from .rrset import RRset
class Zone:
def __init__(
self, origin: str, rdclass: int = IN, relativize: bool = False
) -> None:
...
def find_rrset(self, name: Union[Name, str], rdtype: int) -> RRset:
...
def replace_rdataset(self, name: Union[Name, str], replacement: Rdataset) -> None:
...
...
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/rdata.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/rdata.py | from typing import Any
class Rdata:
rdclass: int
rdtype: int
...
def to_generic(self) -> GenericRdata:
...
class GenericRdata(Rdata):
data: bytes
...
def __init__(self, rdclass: int, rdtype: int, data: bytes) -> None:
...
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/rdataset.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/rdataset.py | from typing import Optional
from .rdata import Rdata
class Rdataset:
...
def from_rdata(ttl: int, *rdatas: Rdata) -> Rdataset:
...
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/rrset.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/rrset.py | from typing import Iterator, List
from .name import Name
from .rdata import Rdata
class RRset:
name: Name
rdtype: int
def __iter__(self) -> Iterator[Rdata]:
...
...
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/rdatatype.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/rdatatype.py | import enum
class RdataType(enum.IntEnum):
...
A: RdataType
AAAA: RdataType
ANY: RdataType
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/message.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/message.py | from typing import List, Optional, Union
from .name import Name
from .rrset import RRset
class Message:
id: int
flags: int
answer: List[RRset]
question: List[RRset]
def __init__(self, id: Optional[int] = None) -> None:
...
def to_wire(self) -> bytes:
...
...
class QueryMessage(Message):
...
def from_wire(wire: bytes) -> Message:
...
def make_query(qname: Union[Name, str], rdtype: Union[int, str]) -> QueryMessage:
...
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/flags.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/flags.py | import enum
class Flag(enum.IntFlag):
...
AA: Flag
QR: Flag
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/__init__.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/rdataclass.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/rdataclass.py | import enum
class RdataClass(enum.IntEnum):
...
IN: RdataClass
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/name.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aioice/stubs/dns/name.py | class Name:
...
def from_text(text: str) -> Name:
...
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/crypto/badprime/task.py | ctfs/WMCTF/2023/crypto/badprime/task.py | from Crypto.Util.number import *
from secret import flag
M = 0x7cda79f57f60a9b65478052f383ad7dadb714b4f4ac069997c7ff23d34d075fca08fdf20f95fbc5f0a981d65c3a3ee7ff74d769da52e948d6b0270dd736ef61fa99a54f80fb22091b055885dc22b9f17562778dfb2aeac87f51de339f71731d207c0af3244d35129feba028a48402247f4ba1d2b6d0755baff6
def getMyprime(BIT):
while True:
p = int(pow(65537, getRandomRange(M>>1, M), M)) + getRandomInteger(BIT-int(M).bit_length()) * M
if isPrime(p):
return p
p = getMyprime(1024)
q = getPrime(1024)
n = p * q
m = bytes_to_long(flag)
print("Try to crack the bad RSA")
print("Public key:", n)
print("The flag(encrypted):", pow(m, 65537, n))
print("Well well, I will give you the hint if you please me ^_^")
leak = int(input("Gift window:"))
if M % leak == 0:
print("This is the gift for you: ", p % leak)
else:
print("I don't like this gift!") | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/crypto/signin/task.py | ctfs/WMCTF/2023/crypto/signin/task.py | from Crypto.Util.number import *
from random import randrange
from secret import flag
def pr(msg):
print(msg)
pr(br"""
....''''''....
.`",:;;II;II;;;;:,"^'.
'"IlllI;;;;;;;;;;;;;Il!!l;^.
`l><>!!!!!!!!iiiii!!!!!!!!i><!".
':>?]__++~~~~~<<<<<<<<<<<<<<<<~~+__i".
.:i+}{]?-__+++~~~~~~<<<<<~~~~~~+_-?[\1_!^
.;<_}\{]-_++~<<<<<<<<<<<<<<<<<<<~+-?]\|]+<^
.!-{t|[?-}(|((){_<<<<<<<<<_}1)))1}??]{t|]_"
!)nf}]-?/\){]]]_<<<<<<<<<_]]}}{\/?-][)vf?`
'!tX/}]--<]{\Un[~~<<<<<~~<~-11Yz)<--?[{vv[".
.<{xJt}]?!ibm0%&Ci><<<<<<<<!0kJW%w+:-?[{uu)},
!1fLf}]_::xmqQj["I~<<<<<<>"(ZqOu{I^<?[{cc)[`
`}|x\}]_+<!<+~<<__~<<<<<<+_<<_+<><++-[1j/(>
!\j/{]-++___--_+~~<i;I>~~~__-______?}(jf}`
;~(|}?_++++~~++~+]-++]?+++~~~~+++-[1/]>^
;\([?__+_-?]?-_-----__-]?-_+++-]{/].
l||}?__/rjffcCQQQQQLUxffjf}+-]1\?'
,[\)[?}}-__[/nzXXvj)?__]{??}((>.
.I[|(1{]_+~~~<~~<<<~+_[}1(1+^
,~{|\)}]_++++++-?}1)1?!`
."!_]{11))1{}]-+i:'
.`^","^`'.
""".decode())
def gen_prime(bit):
while 1:
P = getPrime(bit)
if len(bin(P)) - 2 == bit:
return P
pq_bit = 512
offset = 16
P,Q = [gen_prime(pq_bit) for i in range(2)]
N = P * Q
gift = int(bin(P ^ (Q >> offset))[2+offset:],2)
pr(N)
pr(gift)
inpP = int(input())
if inpP != P:
pr(b"you lose!")
exit()
secret = randrange(0,P)
bs = [randrange(0,P) for _ in range(38)]
results = [(bi * secret) % P for bi in bs]
rs = [ri & (2 ** offset - 1) for ri in results]
pr(bs)
pr(rs)
inpsecret = int(input())
if inpsecret == secret:
pr(flag) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/crypto/welcomesigner2/task.py | ctfs/WMCTF/2023/crypto/welcomesigner2/task.py | from Crypto.Util.number import *
from Crypto.Cipher import AES
from hashlib import md5
import random
flag = b"***********************************"
def pad(message):
return message + b"\x00"*((16-len(message)%16)%16)
def myfastexp(m,d,N,j,N_):
A = 1
B = m
d = bin(d)[2:][::-1]
n = len(d)
N = N
for i in range(n):
if d[i] == '1':
A = A * B % N
# a fault occurs j steps before the end of the exponentiation
if i >= n-1-j:
N = N_
B = B**2 % N
return A
def encrypt(message,key):
key = bytes.fromhex(md5(str(key).encode()).hexdigest())
enc = AES.new(key,mode=AES.MODE_ECB)
c = enc.encrypt(pad(message))
return c
border = "|"
print(border*75)
print(border, "Hi all, I have another algorithm that can quickly calculate powers. ", border)
print(border, "But still there's something wrong with it. Your task is to get ", border)
print(border, "its private key,and decrypt the cipher to cat the flag ^-^ ", border)
print(border*75)
while True:
# generate
p = getPrime(512)
q = getPrime(512)
n = p*q
e = 17
if GCD(e,(p-1)*(q-1)) == 1:
d = inverse(e,(p-1)*(q-1))
n_ = n
break
n_ = n
msg = bytes_to_long(b"Welcome_come_to_WMCTF")
sig = pow(msg,d,n)
assert sig == myfastexp(msg,d,n,0,n_)
CHANGE = True
while True:
try:
ans = input("| Options: \n|\t[G]et data \n|\t[S]ignatrue \n|\t[F]ault injection \n|\t[Q]uit\n").lower().strip()
if ans == 'f':
if CHANGE:
print(border,"You have one chance to change one byte of N. ")
temp,index = input("bytes, and index:").strip().split(",")
assert 0<= int(temp) <=255
assert 0<= int(index) <= 1023
n_ = n ^ (int(temp)<<int(index))
print(border,f"[+] update: n_ -> \"{n_}\"")
CHANGE = False
else:
print(border,"Greedy...")
elif ans == 'g':
print(border,f"n = {n}")
print(border,f"flag_ciphertext = {encrypt(flag,d).hex()}")
elif ans == 's':
index = input("Where your want to interfere:").strip()
sig_ = myfastexp(msg,d,n,int(index),n_)
print(border,f"signature of \"Welcome_come_to_WMCTF\" is {sig_}")
elif ans == 'q':
quit()
except Exception as e:
print(border,"Err...")
quit()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/WMCTF/2023/crypto/welcomesigner1/task.py | ctfs/WMCTF/2023/crypto/welcomesigner1/task.py | from Crypto.Util.number import *
from Crypto.Cipher import AES
from hashlib import md5
from sympy import isprime
from tqdm import tqdm
import random
flag = b"***********************************"
def pad(message):
return message + b"\x00"*((16-len(message)%16)%16)
def myfastexp(m,d,N,j,N_):
A = 1
d = bin(d)[2:][::-1]
n = len(d)
for i in range(n-1,-1,-1):
if i < j:
#print(A)
N = N_
A = A*A % N
if d[i] == "1":
A = A * m % N
return A
def encrypt(message,key):
key = bytes.fromhex(md5(str(key).encode()).hexdigest())
enc = AES.new(key,mode=AES.MODE_ECB)
c = enc.encrypt(pad(message))
return c
border = "|"
print(border*75)
print(border, "Hi all, I have created an algorithm that can quickly calculate powers. ", border)
print(border, "But it looks like there's something wrong with it. Your task is to get ", border)
print(border, "its private key,and decrypt the cipher to cat the flag ^-^ ", border)
print(border*75)
while True:
# generate
p = getPrime(512)
q = getPrime(512)
n = p*q
e = 17
if GCD(e,(p-1)*(q-1)) == 1:
d = inverse(e,(p-1)*(q-1))
n_ = n
break
msg = bytes_to_long(b"Welcome_come_to_WMCTF")
sig = pow(msg,d,n)
CHANGE = True
while True:
try:
ans = input("| Options: \n|\t[G]et data \n|\t[S]ignatrue \n|\t[F]ault injection \n|\t[Q]uit\n").lower().strip()
if ans == 'f':
if CHANGE:
print(border,"You have one chance to change one byte of N. ")
temp,index = input("bytes, and index:").strip().split(",")
assert 0<= int(temp) <=255
assert 0<= int(index) <= 1023
n_ = n ^ (int(temp)<<int(index))
print(border,f"[+] update: n_ -> \"{n_}\"")
CHANGE = False
else:
print(border,"Greedy...")
elif ans == 'g':
print(border,f"n = {n}")
print(border,f"flag_ciphertext = {encrypt(flag,d).hex()}")
elif ans == 's':
index = input("Where your want to interfere:").strip()
sig_ = myfastexp(msg,d,n,int(index),n_)
print(border,f"signature of \"Welcome_come_to_WMCTF\" is {sig_}")
elif ans == 'q':
quit()
except Exception as e:
print(border,"Err...")
quit()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Shakti/2021/crypto/z3r000/challenge.py | ctfs/Shakti/2021/crypto/z3r000/challenge.py | from Crypto.Util.number import *
from secret import flag
p = getPrime(1024)
q = getPrime(1024)
n = p*q
e = 3
flag = flag + "\x00"*200
ct = pow(bytes_to_long(flag),e,n)
print(n)
print(ct)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Shakti/2021/crypto/Awesome_encryption_Scheme/encryptor.py | ctfs/Shakti/2021/crypto/Awesome_encryption_Scheme/encryptor.py | from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from hashlib import md5
from os import urandom
from flag import flag
keys = [md5(urandom(3)).digest() for _ in range(2)]
def bytexor(da,ta): return bytes(i^j for i,j in zip(da,ta))
def get_ciphers(iv1, iv2):
return [
AES.new(keys[0], mode=AES.MODE_CBC, iv=iv1),
AES.new(keys[1], mode=AES.MODE_CFB, iv=iv2, segment_size=8*16),
]
def encrypt(m: bytes, iv1: bytes, iv2: bytes) -> bytes:
m = pad(m,32)
ciphers = get_ciphers(iv1, iv2)
c = m
for cipher in ciphers:
c = b''.join(i[16:]+bytexor(i[:16],cipher.encrypt(i[16:])) for i in [c[i:i+32] for i in range(0,len(c),32)])
return c
plaintext = f'finally now i am able to send my secret with double security and double trust, {flag}'.encode()
iv1, iv2 = urandom(16),urandom(16)
ciphertext = encrypt(plaintext, iv1, iv2)
ciphertext = b":".join([x.hex().encode() for x in [iv1, iv2, ciphertext]])
open('encrypted','wb').write(ciphertext) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Shakti/2021/crypto/Drag_away_the_crib/ciphers.py | ctfs/Shakti/2021/crypto/Drag_away_the_crib/ciphers.py | c_message = "27c2b40fc28cc3aa72c3a3c2954873c283c39934056bc3a8317c5fc2b251"
c_flag = "4dc3af10c287c3a474c3b2c39c5f68c385c391381634c3bb07705ec2a02fc2a50bc39cc39a7cc3b4c39c5e3d"
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Shakti/2021/crypto/Drag_away_the_crib/generate.py | ctfs/Shakti/2021/crypto/Drag_away_the_crib/generate.py |
# test = ####REDACTED####
#What a wonderful welcome message to the CTF to test
#flag = ###REDACTED#####
import os
import base64
from itertools import cycle
key = os.urandom(20)
def xor(a,b) :
return ''.join(chr(ord(i)^j) for i,j in zip(a,cycle(b)))
c1 = base64.b16encode(xor(test,key).encode())
c2 = base64.b16encode(xor(flag,key).encode())
#Hint : Would it matter if my welcome message and flag share a word? Meh..who cares..I've used a strong key
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Shakti/2021/crypto/Rand-S-A/challenge.py | ctfs/Shakti/2021/crypto/Rand-S-A/challenge.py | import random
from Crypto.Util.number import *
from secret import flag, x
mod = 124912888168404777121624746046278221478415741204063939426455884264204774777990089137717126267769
g = 3
h = pow(g,x,mod)
def keyGen(x):
random.seed(x)
p = random.randint(2**511,2**512 - 1)
while isPrime(p) != 1:
p = random.randint(2**511,2**512 - 1)
q = random.randint(2**511,2**512 - 1)
while isPrime(q) != 1 and q != p:
q = random.randint(2**511,2**512 - 1)
e = 65537
phin = (p-1)*(q-1)
if GCD(e,phin) == 1:
return p,q
p,q = keyGen(x)
n = p*q
e = 65537
flag = bytes_to_long(flag)
ct = pow(flag,e,n)
print("g: " + str(g))
print("h: " + str(h))
print "n: " + str(n)
print "ct: " + str(ct)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Shakti/2025/rev/gooGOOgaaGAA/googoogaagaa.py | ctfs/Shakti/2025/rev/gooGOOgaaGAA/googoogaagaa.py | def gaga(text, key):
result = []
for i in range(len(text)):
result += chr(ord(text[i]) ^ ord(key[i % len(key)]))
return result
key = "IWANTMOMOS"
encrypted= [':', '?', ' ', '%', ' ', '$', ',', '9', ')', '(', '+', 'c', '#', '7', '\x06', '~', '9', '\x12', '~', ' ', '\x16', '4', '4', ':', 'g', '0']
inp= input("> ")
if (gaga(inp, key)==encrypted):
print("YOU DID ITTT :))")
else:
print("try again :(") | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Shakti/2025/crypto/Erasure_Failed/cipher.py | ctfs/Shakti/2025/crypto/Erasure_Failed/cipher.py | from secret import e,msg
from Crypto.Util.number import*
from gmpy2 import *
from Crypto.PublicKey import RSA
p = getPrime(2048)
q = getPrime(2048)
n = p*q
m = bytes_to_long(msg)
ct = pow(m,e,n)
with open("ciphertext.txt", "w") as f:
f.write(ct)
key = RSA.construct((int(n), int(e), int(d), int(p), int(q)))
pem = key.export_key('PEM')
with open("private_key.pem", "wb") as f:
f.write(pem) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Shakti/2025/web/Hooman/app.py | ctfs/Shakti/2025/web/Hooman/app.py | from flask import Flask, request, redirect, render_template, make_response
import jwt
app = Flask(__name__)
SECRET_KEY = 'Youcanneverhavethis'
@app.route('/login', methods=['POST', 'GET'])
def login():
error = None
if request.method == 'POST':
data = request.json if request.is_json else request.form
username = data.get('username')
if not username:
error = 'Username required'
return render_template('login.html', error=error)
token = jwt.encode({'username': username, 'are_you_hooman': False}, SECRET_KEY, algorithm='HS256')
resp = make_response(redirect('/login'))
resp.set_cookie('token', token)
return resp
else:
token = request.cookies.get('token')
if token:
try:
decoded = jwt.decode(token, key=None,options={"verify_signature": False})
if decoded.get('are_you_hooman'):
return redirect('/hooman')
error = "Nah, you ain't hooman T^T"
except jwt.InvalidTokenError:
error = "Invalid token"
return render_template('login.html', error=error)
@app.route('/hooman')
def hooman():
token = request.cookies.get('token')
if not token:
return 'No token provided', 401
try:
decoded = jwt.decode(token, key=None,options={"verify_signature": False})
if decoded.get('are_you_hooman'):
return '''
<html>
<head><title>Hooman</title></head>
<body style="background-color: #333; color: #f0f0f0; font-family: Arial; display: flex; justify-content: center; align-items: center; height: 100vh;">
<h1>Hiii hoomann a message for ya! shaktictf{f4k3_fl4g}</h1>
</body>
</html>
'''
return 'Nah, you ain\'t hooman T^T', 401
except jwt.InvalidTokenError:
return 'Invalid token', 401
if __name__ == '__main__':
app.run(host="0.0.0.0",port=5000) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/misc/Sqlmap_as_a_Service/server.py | ctfs/Bauhinia/2023/misc/Sqlmap_as_a_Service/server.py | from flask import Flask, request
from urllib.parse import urlencode
from urllib.request import urlopen
import subprocess
import os
G_SITEKEY = os.getenv("G_SITEKEY", '"><script>document.write("reCAPTCHA is broken")</script>')
G_SECRET = os.getenv("G_SECRET", "Victoria's Secret")
app = Flask(__name__)
def escapeshellcmd(cmd):
bad = "&#;`|*?~<>^()[]}{$\\,\n\xff'\""
mad = ["\\"+c for c in bad]
return cmd.translate(str.maketrans(dict(zip(bad,mad))))
@app.route("/", methods=["GET", "POST"])
def index():
if request.method == "POST":
if "g-recaptcha-response" not in request.form or request.form["g-recaptcha-response"] == "":
return "Bad reCAPTCHA"
data = urlencode({"secret": G_SECRET, "response": request.form["g-recaptcha-response"]}).encode('ascii')
try:
fetch = urlopen("https://www.google.com/recaptcha/api/siteverify", data).read().decode("utf-8")
except Exception as e:
return str(e)
if '"success": true' not in fetch:
return "reCAPTCHA is broken"
argv = escapeshellcmd(request.form["argv"])
if "eval" in argv:
payload = argv[argv.find("eval")+5:].split()[0]
return "<script>for(;;){try{eval(prompt('eval','%s'))}catch(e){}}</script>" % payload
if "alert" in argv:
payload = argv[argv.find("alert")+6:].split()[0]
return "<script>for(;;){alert('%s')}</script>" % payload
if "proxy" in argv:
return "<script>location='http://squid:3128'</script>"
command = "python sqlmap.py --proxy=http://squid:3128 %s" % argv
print(request.remote_addr + ": " + command, flush=True)
try:
out = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT, timeout=180, cwd="/sqlmap-dev")
except subprocess.CalledProcessError as e:
out = e.output
return "<code>%s</code><hr /><plaintext>%s" % (command, out.decode("utf-8"))
else:
return """<html>
<head>
<title>Sqlmap as a Service</title>
<script src="https://www.google.com/recaptcha/api.js" async defer></script>
</head>
<body>
<h2>Sqlmap as a Service</h2>
<form method="post">
<p style="font-family:Courier New;background:#CCCCCC;font-size:14pt;padding:0.25em">
python sqlmap.py --proxy=http://squid:3128
<input style="font-family:Courier New;background:#CCCCCC;font-size:14pt;border:0;width:63%%" name="argv" placeholder="-u http://menazon.ozetta.net/search.php --answers=Y --data=search=Y">
</p>
<div class="g-recaptcha" data-sitekey="%s"></div>
<p><input type="submit"></p>
</form>
<p>Remarks:
<ul>
<li style="color:red">Do not scan others without permission. Your IP will be reported if we receive abuse complains. </li>
<li>Timeout in 180 seconds </li>
<li>Reborn every 30 minutes </li>
<li>To prevent hackers like you hacking the service, the keywords <code style="color:red">eval</code>, <code style="color:red">alert</code> and <code style="color:red">proxy</code> are blocked. </li>
</ul>
</p>
</body>
</html>""" % G_SITEKEY
if __name__ == "__main__":
app.run(host="0.0.0.0", port=3306) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/pwn/Disconnect/src/setup.py | ctfs/Bauhinia/2023/pwn/Disconnect/src/setup.py | import subprocess
import os, sys
import tempfile
import time
def receive_data():
# Ask the user to provide the data length
data_length = int(input("Enter the data length: "))
if data_length > 0x100000:
print("File size too large")
return -1
# Receive the data from stdin
data = sys.stdin.buffer.read(data_length)
# Create a temp file with a random name
temp_file = tempfile.NamedTemporaryFile(delete=False)
filename = temp_file.name
# Write the data to the temp file
temp_file.write(data)
# Close the temp file
temp_file.close()
os.chmod(filename, 0o661)
pid = subprocess.Popen(["sudo", "-u", "limiteduser", "/sandbox", filename], stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
time.sleep(6)
pid.kill()
os.remove(filename)
if __name__ == "__main__":
receive_data()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/pwn/Pyjail_3/chall.py | ctfs/Bauhinia/2023/pwn/Pyjail_3/chall.py | backup_len = len
backup_eval = eval
backup_print = print
backup_input = input
globals()['__builtins__'].__dict__.clear()
while True:
input = backup_input()
if backup_len(input) > 78 or '[' in input or ']' in input or '{' in input or '}' in input:
backup_print('[You failed to break the jail]')
else:
backup_print(backup_eval(input,{'__builtins__':{}},{})) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/pwn/Image_Factory/src/nc_pow_guard.py | ctfs/Bauhinia/2023/pwn/Image_Factory/src/nc_pow_guard.py | #!/usr/bin/env python3
import secrets
import hashlib
from time import time
class NcPowser:
def __init__(self, difficulty=22, prefix_length=16):
self.difficulty = difficulty
self.prefix_length = prefix_length
def get_challenge(self):
return secrets.token_urlsafe(self.prefix_length)[:self.prefix_length].replace('-', 'b').replace('_', 'a')
def verify_hash(self, prefix, answer):
h = hashlib.sha256()
h.update((prefix + answer).encode())
bits = ''.join(bin(i)[2:].zfill(8) for i in h.digest())
return bits.startswith('0' * self.difficulty)
if __name__ == '__main__':
powser = NcPowser()
prefix = powser.get_challenge()
print(f'''
sha256({prefix} + ???) == {'0'*powser.difficulty}({powser.difficulty})...
''')
answer = input("??? = ")
exit(not(powser.verify_hash(prefix, answer))) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/Crypto_Chef/FruitHill.py | ctfs/Bauhinia/2023/crypto/Crypto_Chef/FruitHill.py | # Found a fruit hill!
# Let's use the fruits here too!
import galois # galois is used just because it's more lightweighted when compared to sage
import numpy as np
class Fruit:
def __init__(self, q, n, secret_sauce):
self.n = n
self.GF = galois.GF(q)
self.SS = self.GF(secret_sauce)
self.madness = 0
self.tolerance = 100
# Do you know what is msg? msg makes everything good. If your dish is not delicious, add msg.
# If your life is not good, add msg, it will be a lot better.
def cook(self, msg):
if self.madness >= self.tolerance:
print("I feel like you are not trying to learn with me but just want to steal my secret sauce from me!")
raise Exception("Bad guy.")
assert len(msg) == self.n
self.madness += 3.84
msg = self.GF(msg)
tastyDish = self.SS @ msg
return tastyDish
# Verify whether you really add the msg in that tasty dish!
def verify(self, tastyDish, msg):
tastyDish = self.GF(tastyDish)
msg = self.GF(msg)
taste = np.linalg.inv(self.SS) @ tastyDish
return np.all(taste == msg)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/Crypto_Chef/OV.py | ctfs/Bauhinia/2023/crypto/Crypto_Chef/OV.py | # Found an Orange Vessel!
# Let's use the seasoning in it too!
import galois # galois is used just because it's more lightweighted when compared to sage
import numpy as np
class OilVinegar:
class LFSRSalt:
def __init__(self, q, water_tap, salt):
self.GF = galois.GF(2)
self.q = q
self.k = self.q.bit_length() - 1
assert self.q == 2**self.k
self.water_tap = self.GF(water_tap)
self.lfsr = galois.FLFSR.Taps(self.GF(water_tap), self.GF([(c >> (self.k - i - 1)) & 1 for c in salt.view(np.ndarray) for i in range(self.k)]))
def step(self, num):
rtn = []
for _ in range(num):
elem = 0
for _ in range(self.k):
elem <<= 1
elem |= int(self.lfsr.step(1))
rtn.append(elem)
return galois.GF(self.q)(rtn)
def __init__(self, q, o, v, water_tap, salt, pepper, secret_sauce):
self.o = o
self.v = v
self.n = o + v
self.GF = galois.GF(q)
self.SS = self.GF(secret_sauce)
self.pepper = self.GF(pepper)
self.lfsr_salt = self.LFSRSalt(q, water_tap, self.GF(salt))
self.F, self.pub = self.genkey()
def genkey(self):
F_quad = self.GF.Zeros((self.o, self.n, self.n))
pub_quad = self.GF.Zeros((self.o, self.n, self.n))
for i in range(self.o):
B0 = self.GF.Zeros((self.o, self.o))
B1 = self.GF.Random((self.o, self.v))
B2 = self.GF.Random((self.v, self.o))
B3 = self.GF.Random((self.v, self.v))
Fi = self.GF(np.block([[B0, B1], [B2, B3]]))
F_quad[i] = Fi
pub_quad[i] = self.SS.transpose() @ Fi @ self.SS # matmul
F_lin = self.GF.Random((self.o, self.n))
pub_lin = F_lin @ self.SS
F_const = self.GF.Random(self.o)
pub_const = F_const.copy()
return (F_const, F_lin, F_quad), (pub_const, pub_lin, pub_quad)
def findOil(self, vinegar, msg):
A = self.GF.Zeros((self.o, self.o))
b = msg.copy()
for i in range(self.o):
quadOil = np.sum((self.F[2][i][:self.o, -self.v:] + self.F[2][i].transpose()[:self.o, -self.v:]) * vinegar, axis = 1)
quadConst = vinegar @ self.F[2][i][-self.v:, -self.v:] @ vinegar
linOil = self.F[1][i][:self.o]
linConst = self.F[1][i][-self.v:] @ vinegar
A[i] = quadOil + linOil
b[i] -= quadConst + linConst + self.F[0][i]
if np.linalg.matrix_rank(A) < self.o:
return None
return np.linalg.solve(A, b)
# Do you know what is msg? msg makes everything good. If your dish is not delicious, add msg.
# If your life is not good, add msg, it will be a lot better.
def cook(self, msg):
assert len(msg) == self.o
msg = self.GF(msg)
vinegar = np.append(self.pepper, self.lfsr_salt.step(self.v // 2))
oil = self.findOil(vinegar, msg)
while oil is None:
vinegar = np.append(self.pepper, self.lfsr_salt.step(self.v // 2))
oil = self.findOil(vinegar, msg)
tastyDish = np.linalg.inv(self.SS) @ np.append(oil, vinegar)
return tastyDish
# Verify whether you really add the msg in that tasty dish!
def verify(self, tastyDish, msg):
tastyDish = self.GF(tastyDish)
msg = self.GF(msg)
taste = self.pub[0]
taste += self.pub[1] @ tastyDish
for i in range(self.o):
taste[i] += tastyDish @ self.pub[2][i] @ tastyDish
return np.all(taste == msg)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/Crypto_Chef/chall.py | ctfs/Bauhinia/2023/crypto/Crypto_Chef/chall.py | import galois
import numpy as np
import base64
from OV import OilVinegar
from FruitHill import Fruit
from secret import WATER_TAP, flag
def getPepperOrSalt(q, v):
return galois.GF(q).Random(v // 2)
def getSauce(q, n):
secret_sauce = galois.GF(q).Random((n, n))
while np.linalg.matrix_rank(secret_sauce) < n:
secret_sauce = galois.GF(q).Random((n, n))
return secret_sauce
def vec2Hex(vec):
vec = np.char.mod('%x', vec.view(np.ndarray))
return ''.join(vec)
def encodeRecipe2Pub(recipe2):
return ':'.join([vec2Hex(pub.flatten()) for pub in recipe2.pub])
def printRecipesPub(recipe1, recipe2):
print("=========================================================================")
print(f"Recipe 1: Sorry this recipe is highly secret so I cannot give you any info about it!")
print(f"Recipe 2: {encodeRecipe2Pub(recipe2)}")
print("=========================================================================")
def main():
k = 4
q = 2**k
o = 16
v = 16
n = o + v
assert len(WATER_TAP) == (k * (v // 2)) # WATER_TAP is ont-hot encoding of the water tabs
salt = getPepperOrSalt(q, v)
pepper = getPepperOrSalt(q, v)
secret_sauce = getSauce(q, n)
recipe1 = Fruit(q, n, secret_sauce)
recipe2 = OilVinegar(q, o, v, WATER_TAP, salt, pepper, secret_sauce)
print("Please give me the following two dishes!")
print("1. Cooked with recipe 1 using the MSG 'cryptochefisgood'")
print("2. Cooked with recipe 2 using the MSG 'ilovemsg'")
print("Oh yes, unlike other chef, I am very strict on it.")
print("I won't check whether you have added the MSG in the dish, but would require you to have the EXACT SAME dish as mine!")
print("Of course, you can cook a few dishes with me to learn my style first.")
comm_limit = 38
exam_status = [False, False]
try:
for comm_count in range(1, comm_limit + 1):
cmd = input(f"[{comm_count}/{comm_limit}] > ")
args = cmd.split(' ')
if args[0] == 'pub':
printRecipesPub(recipe1, recipe2)
elif args[0] == 'cook':
rec, msg_hex = int(args[1]), args[2]
if rec != 1 and rec != 2:
raise Exception("Invalid recipe!")
recipe = recipe1 if rec == 1 else recipe2
msg = bytes.fromhex(msg_hex)
if msg == b'cryptochefisgood' or msg == b'ilovemsg':
raise Exception("Sorry, but you have to learn the dishes yourself!")
msg_vec = [int(c, 16) for c in msg_hex]
print(f"Cooked dish: {vec2Hex(recipe.cook(msg_vec))}")
elif args[0] == 'check':
rec, sig_hex, msg_hex = int(args[1]), args[2], args[3]
if rec != 1 and rec != 2:
raise Exception("Invalid recipe!")
recipe = recipe1 if rec == 1 else recipe2
sig_vec = [int(c, 16) for c in sig_hex]
msg_vec = [int(c, 16) for c in msg_hex]
if recipe.verify(sig_vec, msg_vec):
print("Yes! This dish is made from that msg.")
else:
print("Hum... Seems a bit off.")
elif args[0] == 'exam':
rec, dish_hex = int(args[1]), args[2]
if rec != 1 and rec != 2:
raise Exception("Invalid recipe!")
recipe = recipe1 if rec == 1 else recipe2
if exam_status[rec - 1]:
print("You have already passed the exam on that recipe! Please choose the another one!")
continue
target_msg = b'cryptochefisgood' if rec == 1 else b'ilovemsg'
target_msg = [int(c, 16) for c in target_msg.hex()]
dish = [int(c, 16) for c in dish_hex]
if not np.array_equal(recipe.cook(target_msg), dish):
print("Hum... Please come again after you have sharpened your cooking skills.")
exit(0)
exam_status[rec - 1] = True
if exam_status[0] and exam_status[1]:
print("Congratulations! You have mastered all the recipes!")
print(f"Here's your reward: {flag}")
exit(0)
else:
print("Nice! You have mastered this recipe!")
print("Please continue on your journey!")
print("Too slow! Please come again after you have sharpened your cooking skills :(")
except Exception:
print("Nope.")
if __name__ == '__main__':
main() | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/Crypto_Chef/PoW.py | ctfs/Bauhinia/2023/crypto/Crypto_Chef/PoW.py | import hashlib
import random
import string
import itertools
LENGTH = 6
letter_set = string.ascii_letters + string.digits
hex_set = "0123456789abcdef"
def PoW_solve(given: str, h: str) -> str:
for ch in itertools.product(hex_set, repeat=LENGTH):
ch = ''.join(ch)
if h == hashlib.md5(f"CHEF:{given}:{ch}".encode()).hexdigest():
return ch
def PoW():
a = ''.join(random.choice(letter_set) for i in range(20))
b = ''.join(random.choice(hex_set) for i in range(LENGTH))
h = hashlib.md5(f"CHEF:{a}:{b}".encode()).hexdigest()
print("======== Proof-of-Work enabled ========")
print(f"Send me a {LENGTH}-digit hex code (in lowercase) such that:")
print(f"md5(\"CHEF:{a}:\" + \"<{LENGTH}-digit hex code>\") = {h}")
ans = input("> ")
if len(ans) != LENGTH:
print("Length must be 6!")
exit()
if h != hashlib.md5(f"CHEF:{a}:{ans}".encode()).hexdigest():
print("Proof-of-Work failed!")
exit()
if __name__ == '__main__':
PoW()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/Crypto_Chef/secret.py | ctfs/Bauhinia/2023/crypto/Crypto_Chef/secret.py | # [!] ATTENTION [!]
# Sample secret.py for local testing only
# This file on the server is different!
import galois
# WATER_TAP on the server side is having a different value, but it's fixed during the whole CTF
WATER_TAP = [0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1]
# flag on the server side is having a different value, get the flag!
flag = 'b6actf{**REDACTED**}' | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/How_to_Stop_Time/chall.py | ctfs/Bauhinia/2023/crypto/How_to_Stop_Time/chall.py | # Since the script is simple, I will just add a lot of useless information to
# distract you all. Good luck identifying whether one is a red herring!
# Although I am using the "os" package, I don't call "os.system". Now give up on
# that wacky thoughts.
import os
# I am using the `random` package, which is known to be using MT19937, a
# reversable pseudorandom number generator. Maybe you can make use of them?
import random
# I sometime receive complaints from players regarding installing random Python
# packages all around. I will refrain from using third-party packages for this
# challenge. Hope that helps!
from mathy import is_prime
def main():
# Please do not submit "flag{this_is_a_fake_flag}" as the flag! This is only
# a placeholder and this is not the REAL flag for the challenge. Go nc to
# the actual server for the actual flag!
flag = os.environ.get('FLAG', 'flag{this_is_a_fake_flag}')
# "Once is happenstance. Twice is coincidence...
# Sixteen times is a recovery of the pseudorandom number generator."
# - "Maybe Someday" on Google CTF 2022
#
# But... How about 256 times? Prediction of pseudorandom number generator?
for _ in range(256):
# I will pregenerate those values ahead. Can you read that before
# sending q?
g = random.getrandbits(512)
x = random.getrandbits(512)
# Yeah, come send me a large-enough prime q!
q = int(input('[<] q = '))
# Told you I need a large-enough prime.
assert q.bit_length() == 512 and is_prime(q)
# I was going to set "p = 2*q + 1" to make p a safe prime... I will just
# changing that to "p = 4*q + 1" to pretend that there is a bug. Let's
# call that a... pseudo-safe prime?
p = 4*q + 1
assert is_prime(p)
print(f'[>] {g = }')
# I intentionally computes g^x mod p between printing g and h. Good luck
# unleashing a timing attack!
h = pow(g, x, p)
print(f'[>] {h = }')
# You have to recover me the "x". Quickly.
_x = int(input('[<] x = '))
assert x == _x
# How should I innotate this? Go grab the flag!
print(f'[*] {flag}')
if __name__ == '__main__':
try:
main()
except:
print('[!] Well played.') | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/How_to_Stop_Time/mathy.py | ctfs/Bauhinia/2023/crypto/How_to_Stop_Time/mathy.py | # Functions copied from "That-crete log" from UIUCTF 2022. Thanks!
def miller_rabin(bases, n):
# I don't know how to annotate this because it involves of a bunch of
# mathematics that I could not understand, but I still want to be verbose.
# Maybe I should link you the wiki page so you could read that...
# https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
if n == 2 or n == 3:
return True
r, s = 0, n - 1
while s % 2 == 0:
r += 1
s //= 2
for b in bases:
x = pow(b, s, n)
if x == 1 or x == n-1:
continue
for _ in range(r - 1):
x = x * x % n
if x == n-1:
break
else:
return False
return True
def is_prime(n):
# bases = [2, 3, 5, 7, 11, 13, 17, 19, 31337] are used by the challenge from
# UIUCTF. That isn't good enough...
# I learned from ICPC that those seven bases blocks every number below 2^64.
bases = [2, 325, 9375, 28178, 450775, 9780504, 1795265022]
# I will also add a bunch of random bases. Well, I really meant it. This is
# how I generate those bases:
# sorted([random.randint(2, 1000000)*2+1 for _ in range(200)])
bases += [
20669, 48929, 57021, 63569, 73307, 86815, 93495, 101303,
124851, 126617, 164415, 171811, 184653, 219385, 221067, 223499,
229897, 234477, 251893, 264151, 295599, 299453, 308525, 316135,
318467, 319081, 326169, 341721, 343699, 351743, 374223, 378375,
387703, 387807, 390443, 417763, 430031, 438233, 440079, 441259,
444591, 465613, 475205, 485841, 501341, 509761, 515577, 528775,
533381, 536401, 558123, 562419, 583397, 606965, 617121, 619821,
625787, 632805, 650751, 689307, 695181, 695725, 704809, 706557,
720371, 729335, 737269, 741827, 743969, 745609, 750425, 764843,
768725, 782945, 789713, 794851, 832829, 849477, 849917, 872481,
880381, 880601, 882991, 891339, 892581, 897917, 900497, 902791,
907839, 908069, 910733, 936747, 945849, 952533, 965837, 967739,
1007573, 1018197, 1022845, 1027277, 1027963, 1044711, 1050091, 1050839,
1053395, 1060643, 1070551, 1080385, 1087593, 1095565, 1111439, 1141847,
1146745, 1168487, 1176229, 1180219, 1187279, 1203567, 1204739, 1207205,
1212905, 1233043, 1252625, 1256889, 1272399, 1298475, 1302085, 1305033,
1309991, 1325833, 1334399, 1340793, 1355737, 1365593, 1376389, 1381963,
1390677, 1405539, 1421269, 1426487, 1433469, 1448275, 1458545, 1462879,
1464553, 1482773, 1486655, 1504839, 1512277, 1517895, 1526807, 1532327,
1543995, 1545351, 1553127, 1563397, 1572205, 1573891, 1583443, 1595567,
1603263, 1609551, 1631223, 1633943, 1650589, 1677741, 1681935, 1696649,
1713355, 1715365, 1730819, 1741045, 1745279, 1751007, 1758715, 1778157,
1779521, 1785051, 1789451, 1789671, 1790781, 1791763, 1812959, 1823427,
1824907, 1842549, 1846559, 1847019, 1865431, 1879215, 1895455, 1930981,
1932295, 1940509, 1957911, 1976957, 1986973, 1992813, 1993333, 1994939
]
# We should be able to find all composite numbers smaller than 65536 with
# this sieve. Well, we don't do Miller-Rabin for every numbers; or it will
# be too time-consuming.
for i in range(2, min(256, n)):
if n % i == 0:
return False
# Although I don't know why they used 256 (instead of 65536) here, I will
# just stick to that.
if n < 256:
return True
# Now we use Miller-Rabin for the large numbers.
return miller_rabin(bases, n)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/grhkms_babyRSA/chall.py | ctfs/Bauhinia/2023/crypto/grhkms_babyRSA/chall.py | from math import gcd
from Crypto.Util.number import getPrime, getRandomNBitInteger, bytes_to_long
from secret import flag
lcm = lambda u, v: u*v//gcd(u, v)
bits = 1024
given = bits // 5
e_bits = bits // 12
mask = (1 << given) - 1
while True:
p = getPrime(bits // 2)
q = getPrime(bits // 2)
N = p * q
if N.bit_length() != bits:
continue
l = lcm(p - 1, q - 1)
e = getRandomNBitInteger(e_bits)
if gcd(e, l) > 1:
continue
d = pow(e, -1, l)
dp = int(d % (p - 1))
dq = int(d % (q - 1))
break
l_dp = dp & mask
l_dq = dq & mask
print(f'{N = }')
print(f'{e = }')
print(f'{l_dp = }')
print(f'{l_dq = }')
flag = bytes_to_long(flag)
ct = pow(flag, e, N)
print(f'{ct = }')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/YADE_Yet_Another_Diophantine_Equation/chall.py | ctfs/Bauhinia/2023/crypto/YADE_Yet_Another_Diophantine_Equation/chall.py | # TODO: Generate equation dynamically
# Load equation
with open("equation.py", "r") as eq_file:
eq_str = eq_file.read().strip()
print("Equation:", eq_str)
exec(eq_str)
assert "d" in globals(), "Contact admin."
seen = set()
for _ in range(1000):
a, b, c = [int(input(": ")) for _ in range(3)]
assert all(2**2048 < abs(d) < 10**4300 for d in [a, b, c])
assert (a, b, c) not in seen
assert d(a, b, c) == 0
seen.add((a, b, c))
print(open("flag.txt", "r").read())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/YADE_Yet_Another_Diophantine_Equation/yade_9bcc242c79329e1aacc1575d3a60e25f/chall.py | ctfs/Bauhinia/2023/crypto/YADE_Yet_Another_Diophantine_Equation/yade_9bcc242c79329e1aacc1575d3a60e25f/chall.py | # TODO: Generate equation dynamically
# Load equation
with open("equation.py", "r") as eq_file:
eq_str = eq_file.read().strip()
print("Equation:", eq_str)
exec(eq_str)
assert "d" in globals(), "Contact admin."
seen = set()
for _ in range(1000):
a, b, c = [int(input(": ")) for _ in range(3)]
assert all(2**2048 < abs(d) < 10**4300 for d in [a, b, c])
assert (a, b, c) not in seen
assert d(a, b, c) == 0
seen.add((a, b, c))
print(open("flag.txt", "r").read())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/crypto/Quantum_Entanglement/chall.py | ctfs/Bauhinia/2023/crypto/Quantum_Entanglement/chall.py | from qiskit import QuantumCircuit, QuantumRegister, Aer, ClassicalRegister
from bitarray import bitarray
import os
# Quantum is truly random
def generateTrulyRandomSeq(n: int) -> list:
qr = QuantumRegister(1)
cr = ClassicalRegister(n)
qc = QuantumCircuit(qr, cr)
for i in range(n):
# Apply H-gate
qc.h(0)
# Measure the qubit
qc.measure(0, i)
sv_sim = Aer.get_backend('qasm_simulator')
# I afraid using too much urandom will draw all the entropy so I decided to use quantum (which is truly random as urandom too!)
job = sv_sim.run(qc, seed_simulator=int.from_bytes(os.urandom(8), 'big') & 0x7FFFFFFFFFFFFFFF, shots=1)
res = list(job.result().get_counts().keys())[0]
return res
def main():
seq_per_file = 3
enc_filenames = ['quantum.jpg', 'flag']
read_files = []
for fn in enc_filenames:
with open(fn, 'rb') as f:
arr = bitarray()
arr.fromfile(f)
read_files.append(arr)
len_seq = sum(map(len, read_files)) * seq_per_file
seq = generateTrulyRandomSeq(len_seq)
head = 0
for i in range(len(enc_filenames)):
pt = read_files[i]
len_pt = len(pt)
for _ in range(seq_per_file):
assert head + len_pt <= len_seq
stream = seq[head:head+len_pt]
stream = bitarray(stream)
pt ^= stream
head += len_pt
with open(enc_filenames[i] + '.enc', 'wb') as f:
pt.tofile(f)
if __name__ == '__main__':
main()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/web/Kill_T_Browser/server.py | ctfs/Bauhinia/2023/web/Kill_T_Browser/server.py | from flask import Flask, request
from urllib.parse import urlencode
from urllib.request import urlopen
import subprocess
import os
G_SITEKEY = os.getenv("G_SITEKEY", '"><script>document.write("reCAPTCHA is broken")</script>')
G_SECRET = os.getenv("G_SECRET", "Victoria's Secret")
app = Flask(__name__)
def escapeshellarg(arg):
return "'"+arg.replace("'","'\\''")+"'"
@app.route("/", methods=["GET", "POST"])
def index():
if request.method == "POST":
if "g-recaptcha-response" not in request.form or request.form["g-recaptcha-response"] == "":
return "Bad reCAPTCHA"
data = urlencode({"secret": G_SECRET, "response": request.form["g-recaptcha-response"]}).encode('ascii')
try:
fetch = urlopen("https://www.google.com/recaptcha/api/siteverify", data).read().decode("utf-8")
except Exception as e:
return str(e)
if '"success": true' not in fetch:
return "reCAPTCHA is broken"
url = escapeshellarg(request.form["url"])
if url[:8] != "'http://" and url[:9] != "'https://":
return "Invalid URL"
command = "qutebrowser -T -s content.pdfjs true -s content.javascript.can_open_tabs_automatically true -s url.start_pages \"data:text/plain,\" -- %s" % url
print(request.remote_addr + ": " + command, flush=True)
try:
subprocess.run(command, shell=True, timeout=30, cwd="/tmp")
except Exception as e:
pass
return "<title>Kill T Browser</title><code>%s</code><hr />Kyubey should have viewed your webpage." % command
else:
return """<html>
<head>
<title>Kill T Browser</title>
<script src="https://www.google.com/recaptcha/api.js" async defer></script>
</head>
<body>
<h2>Kill T Browser</h2>
<form method="post">
<p style="font-family:Courier New;background:#CCCCCC;font-size:16pt;padding:0.25em">
qutebrowser -T -s content.pdfjs true -s content.javascript.can_open_tabs_automatically true -s url.start_pages "data:text/plain," --
<input style="font-family:Courier New;background:#CCCCCC;font-size:16pt;border:0;width:70%%" name="url" placeholder="http://example.com">
</p>
<div class="g-recaptcha" data-sitekey="%s"></div>
<p><input type="submit"></p>
</form>
<p>Remarks:
<ul>
<li>Timeout in 30 seconds</li>
<li>Reborn every 30 minutes</li>
</ul>
</p>
</body>
</html>""" % G_SITEKEY
if __name__ == "__main__":
app.run(host="0.0.0.0", port=80) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Bauhinia/2023/web/Hansel_and_Gretel/app/app.py | ctfs/Bauhinia/2023/web/Hansel_and_Gretel/app/app.py | from flask import Flask, render_template, session, request, Response
from werkzeug.exceptions import HTTPException
import os
import json
import requests
from random import randint
def set_(src, dst):
for k, v in src.items():
if hasattr(dst, '__getitem__'):
if dst.get(k) and type(v) == dict:
set_(v, dst.get(k))
else:
dst[k] = v
elif hasattr(dst, k) and type(v) == dict:
set_(v, getattr(dst, k))
else:
setattr(dst, k, v)
class Board():
def __init__(self): pass
@property
def pinned_content(self):
return [{
"title": "Our First Adventure!",
"text": "Today we went to the forest and you can't believe what we've got to! It's a house made out of gingerbread, cake and candy! How sweet it is!"
}]
current_content = []
def save(self, data):
data_ = json.loads(data)
if "new_content" not in data_:
raise Exception("There is nothing to save.")
if not isinstance(data_["new_content"], list) and not len(data_["new_content"]) > 0 and not all([isinstance(x, dict) for x in data_["new_content"]]):
raise Exception("\"new_content\" should be a non-empty list of JSON-like objects.")
if not all(["title" in x and "text" in x for x in data_["new_content"]]):
raise Exception("Please check your bulletin format")
set_(data_, self)
def load(self):
res = self.pinned_content
if isinstance(self.current_content, list) and len(self.current_content) > 0 and all(["title" in x and "text" in x for x in self.current_content]):
res.extend(self.current_content)
if hasattr(self, "new_content") and self.new_content is not None:
new_content = getattr(self, "new_content")
self.current_content.extend(new_content)
res.extend(new_content)
self.new_content = None
return res[::-1]
app = Flask(__name__)
app.config["SECRET_KEY"] = str(os.urandom(32))
app.config["SESSION_COOKIE_HTTPONLY"] = False
app.add_template_global(randint)
bulletin_board = Board()
@app.errorhandler(Exception)
def handle_exception(e):
if isinstance(e, HTTPException):
return e
return str(e), 500
@app.after_request
def after_request_callback(response: Response):
if response.status_code >= 500:
updated = render_template("template.html", status=response.status_code, message=response.response[0].decode())
response.set_data(updated)
return response
@app.route("/<path:path>")
def render(path):
if not os.path.exists(f"templates/{path}"):
return render_template("template.html", status=404, message="not found")
return render_template(f"{path}")
@app.route("/")
def index():
session["user"] = "hansel & gretel"
bulletins = requests.post("http://localhost:3000/load_bulletins").json()
return render_template("index.html", bulletins=bulletins)
@app.route("/save_bulletins", methods=["POST"])
def save_bulletins():
if not request.is_json:
raise Exception("Only accept JSON.")
bulletin_board.save(request.data)
return {"message": "Bulletins saved."}, 200, {"Content-Type": "application/json"}
@app.route("/load_bulletins", methods=["POST"])
def load_bulletins():
return bulletin_board.load(), 200, {"Content-Type": "application/json"}
@app.route("/flag")
def flag():
if session.get("user") != "witch":
return render_template("template.html", status=403, message="You are not the witch.")
return render_template("template.html", status=200, message=os.environ["FLAG"])
if __name__ == "__main__":
app.run(host="0.0.0.0", port="3000") | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/SpamAndFlags/2020/Quals/secstore/serve.py | ctfs/SpamAndFlags/2020/Quals/secstore/serve.py | #!/usr/bin/python3 -u
import os
import sys
import random
import subprocess
import string
import shutil
class HashCash(object):
def __init__(self, bits=28):
import random, string
self.rand = ''.join(random.choice(string.ascii_lowercase) for _ in range(8))
self.bits = bits
self.msg = 'Solve PoW with: hashcash -mqb{} {}'.format(bits, self.rand)
def check(self, stamp):
import hashlib
assert stamp.startswith('1:')
assert stamp.split(':')[3] == self.rand
assert int(hashlib.sha1(stamp.encode()).hexdigest(), 16) < 2**(160-self.bits)
@staticmethod
def check_stdin(bits=28):
import sys
hc = HashCash(bits)
print(hc.msg)
sys.stdout.flush()
hc.check(sys.stdin.readline().strip())
def main():
# HashCash.check_stdin()
fsize = int(input("Size of payload in bytes: "))
MAX_SIZE = 10 * 1024 * 1024
data = sys.stdin.buffer.read(fsize)[:MAX_SIZE]
print(f"Read {len(data)} bytes")
os.makedirs("./home/user/")
shutil.copyfile("/app/initramfs.cpio.gz", "./initramfs.cpio.gz")
with open("./home/user/exploit", "wb") as initramfs:
initramfs.write(data)
os.system("chmod 755 ./home/user/exploit && echo ./home/user/exploit | cpio -R +1000:+1000 -H newc -o | gzip -9 >> ./initramfs.cpio.gz");
print("Starting computer...")
os.execvp("/app/qemu-system-aarch64",
["/app/qemu-system-aarch64",
"-machine", "virt",
"-cpu", "max",
"-smp", "2",
"-kernel", "/app/Image",
"-initrd", "./initramfs.cpio.gz",
"-m", "128m",
"-nographic",
"-nic", "none",
"-append", "console=ttyAMA0 oops=panic",
"-monitor", "/dev/null"]
)
if __name__ == "__main__":
main()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/SpamAndFlags/2020/Quals/environmental_issues/challenge.py | ctfs/SpamAndFlags/2020/Quals/environmental_issues/challenge.py | #/usr/bin/env python3
import json
import os.path
import secrets
import subprocess
import sys
import signal
import tempfile
def die(*args, **kwargs):
print("ERROR:", *args, "Goodbye!", **kwargs)
exit(1)
def fix_stupid_python_stuff_and_set_up_alarm():
# Why don't you default to utf8 if there is no LOCALE, python?
sys.stdout.flush()
sys.stdout = open(sys.stdout.buffer.fileno(), 'w', 1, encoding='utf8')
sys.stderr.flush()
sys.stderr = open(sys.stderr.buffer.fileno(), 'w', 1, encoding='utf8')
# Why can't you simply shut up about SIGPIPE, python?
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
signal.signal(signal.SIGALRM, lambda *a: die("Your time is up!"))
signal.alarm(10)
def format_number_list(numbers):
fmt = ", ".join(["%d"] * (len(numbers)-1) + ["and %d"])
return fmt % tuple(sorted(numbers))
def read_solutions(config):
nums = format_number_list(config["flags"])
print("Hello! Send me a json array of [key, val, arg] lists and I will")
print("execute `key=val bash script.sh arg' for each of them. You get")
print("a flag when you have %s solutions with unique keys." % nums)
print("You may need to shutdown the input (send eof, -N in nc).\n")
try:
solutions = json.load(sys.stdin)
except json.decoder.JSONDecodeError:
die("Not a json.");
if not isinstance(solutions, list):
die("The json is not an array.")
if not all(isinstance(e, list) for e in solutions):
die("Some elements of the json array are not lists.");
if not all(len(row) == 3 for row in solutions):
die("Some rows of the json array are too short/long.")
if not all(isinstance(e, str) for row in solutions for e in row):
die("Some elements of the rows of the json array are not strings.")
return solutions
def check(flag, key, val, arg):
try:
ff = tempfile.NamedTemporaryFile("wt", encoding="utf-8")
ff.file.write(flag)
ff.file.flush()
env = {key: val}
cmd = [
"nsjail",
"--mode", "o",
"--time_limit", "5",
"--keep_env",
"-u", "1000",
"-g", "1000",
"-T", "/dev",
"-R", "/bin",
"-R", "/lib",
"-R", "/lib64",
"-R", "/usr",
"-R", "/sbin",
"-R", "{}:/issues.txt".format(os.path.abspath("./issues.txt")),
"-R", "{}:/flag".format(os.path.abspath(ff.name)),
"-R", "{}:/script.sh".format(os.path.abspath("./script.sh")),
"--",
"/bin/bash", "/script.sh", arg,
]
pipe = subprocess.PIPE
sub = subprocess.Popen(cmd, env=env, stdout=pipe, stderr=pipe)
out, err = sub.communicate()
return flag.encode() in out or flag.encode() in err
except KeyboardInterrupt:
raise
except:
return False
finally:
ff.close()
def read_config():
with open("config.json", encoding="utf-8") as f:
config = json.load(f)
config["flags"] = {int(k): v for k, v in config["flags"].items()}
return config
if __name__ == "__main__":
fix_stupid_python_stuff_and_set_up_alarm()
config = read_config()
solutions = read_solutions(config)
seen = set()
good = 0
for i, (key, val, arg) in enumerate(solutions):
if key in seen:
print(i, "FAILURE, already used this key:", repr(key))
continue
seen.add(key)
flag = "FlagFragment{%s}" % secrets.token_hex(32)
if check(flag, key, val, arg):
good += 1
print(i, "success, key was", repr(key))
else:
print(i, "FAILURE, key was", repr(key))
print("\nOverall, you got", good, "right, so you...")
for limit, flag in sorted(config["flags"].items()):
if good >= limit:
print(" ...get a flag for", limit, "unique solutions:", flag)
if good > max(config["flags"]):
print(" ...get a flag for being too good at exploiting:", config["unintended"])
if good < min(config["flags"]):
print(" ...get nothing. Try harder!")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/SpamAndFlags/2020/Quals/secstore2/serve.py | ctfs/SpamAndFlags/2020/Quals/secstore2/serve.py | #!/usr/bin/python3 -u
import os
import sys
import random
import subprocess
import string
import shutil
class HashCash(object):
def __init__(self, bits=28):
import random, string
self.rand = ''.join(random.choice(string.ascii_lowercase) for _ in range(8))
self.bits = bits
self.msg = 'Solve PoW with: hashcash -mqb{} {}'.format(bits, self.rand)
def check(self, stamp):
import hashlib
assert stamp.startswith('1:')
assert stamp.split(':')[3] == self.rand
assert int(hashlib.sha1(stamp.encode()).hexdigest(), 16) < 2**(160-self.bits)
@staticmethod
def check_stdin(bits=28):
import sys
hc = HashCash(bits)
print(hc.msg)
sys.stdout.flush()
hc.check(sys.stdin.readline().strip())
def main():
# HashCash.check_stdin()
fsize = int(input("Size of payload in bytes: "))
MAX_SIZE = 10 * 1024 * 1024
data = sys.stdin.buffer.read(fsize)[:MAX_SIZE]
print(f"Read {len(data)} bytes")
os.makedirs("./home/user/")
shutil.copyfile("/app/initramfs.cpio.gz", "./initramfs.cpio.gz")
with open("./home/user/exploit", "wb") as initramfs:
initramfs.write(data)
os.system("chmod 755 ./home/user/exploit && echo ./home/user/exploit | cpio -R +1000:+1000 -H newc -o | gzip -9 >> ./initramfs.cpio.gz");
print("Starting computer...")
os.execvp("/app/qemu-system-aarch64",
["/app/qemu-system-aarch64",
"-machine", "virt",
"-cpu", "max",
"-smp", "2",
"-kernel", "/app/Image",
"-initrd", "./initramfs.cpio.gz",
"-m", "128m",
"-nographic",
"-nic", "none",
"-append", "console=ttyAMA0 oops=panic",
"-monitor", "/dev/null"]
)
if __name__ == "__main__":
main()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/SpamAndFlags/2020/Quals/regulated_environmental_issues/challenge.py | ctfs/SpamAndFlags/2020/Quals/regulated_environmental_issues/challenge.py | #/usr/bin/env python3
import json
import os.path
import pprint
import secrets
import signal
import subprocess
import sys
import tempfile
def die(*args, **kwargs):
print("ERROR:", *args, "Goodbye!", **kwargs)
exit(1)
def fix_stupid_python_stuff_and_set_up_alarm():
# Why don't you default to utf8 if there is no LOCALE, python?
sys.stdout.flush()
sys.stdout = open(sys.stdout.buffer.fileno(), 'w', 1, encoding='utf8')
sys.stderr.flush()
sys.stderr = open(sys.stderr.buffer.fileno(), 'w', 1, encoding='utf8')
# Why can't you simply shut up about SIGPIPE, python?
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
signal.signal(signal.SIGALRM, lambda *a: die("Your time is up!"))
signal.alarm(10)
def format_number_list(numbers):
fmt = ", ".join(["%d"] * (len(numbers)-1) + ["and %d"])
return fmt % tuple(sorted(numbers))
def read_solutions(config):
nums = format_number_list(config["flags"])
print("Hello! Send me a json array of [key, val, arg] lists and I will")
print("execute `key=val bash script.sh arg' for each of them. You get")
print("a flag when you have %s solutions with unique keys." % nums)
print("You may need to shutdown the input (send eof, -N in nc).\n")
try:
solutions = json.load(sys.stdin)
except json.decoder.JSONDecodeError:
die("Not a json.");
if not isinstance(solutions, list):
die("The json is not an array.")
if not all(isinstance(e, list) for e in solutions):
die("Some elements of the json array are not lists.");
if not all(len(row) == 3 for row in solutions):
die("Some rows of the json array are too short/long.")
if not all(isinstance(e, str) for row in solutions for e in row):
die("Some elements of the rows of the json array are not strings.")
return solutions
def check(flag, key, val, arg):
try:
ff = tempfile.NamedTemporaryFile("wt", encoding="utf-8")
ff.file.write(flag)
ff.file.flush()
env = {key: val}
cmd = [
"nsjail",
"--mode", "o",
"--time_limit", "5",
"--keep_env",
"-u", "1000",
"-g", "1000",
"-T", "/dev",
"-R", "/bin",
"-R", "/lib",
"-R", "/lib64",
"-R", "/usr",
"-R", "/sbin",
"-R", "{}:/issues.txt".format(os.path.abspath("./issues.txt")),
"-R", "{}:/flag".format(os.path.abspath(ff.name)),
"-R", "{}:/script.sh".format(os.path.abspath("./script.sh")),
"--",
"/bin/bash", "/script.sh", arg,
]
pipe = subprocess.PIPE
sub = subprocess.Popen(cmd, env=env, stdout=pipe, stderr=pipe)
out, err = sub.communicate()
return flag.encode() in out or flag.encode() in err
except KeyboardInterrupt:
raise
except:
return False
finally:
ff.close()
def read_config():
with open("config.json", encoding="utf-8") as f:
config = json.load(f)
config["flags"] = {int(k): v for k, v in config["flags"].items()}
return config
if __name__ == "__main__":
fix_stupid_python_stuff_and_set_up_alarm()
config = read_config()
solutions = read_solutions(config)
session = secrets.token_urlsafe(5)
seen = set()
good = 0
for i, (key, val, arg) in enumerate(solutions):
if key in seen:
print(i, "FAILURE, already used this key:", repr(key))
continue
seen.add(key)
flag = "FlagFragment{%s}" % secrets.token_hex(32)
if check(flag, key, val, arg):
good += 1
print(i, "success, key was", repr(key))
print("LOG:%s:%02d:SUCC:%s" % (session, i, repr([key,val,arg])), file=sys.stderr)
else:
print(i, "FAILURE, key was", repr(key))
print("LOG:%s:%02d:FAIL:%s" % (session, i, repr([key,val,arg])), file=sys.stderr)
print("\nOverall, you got", good, "right, so you...")
print("LOG:%s:RESULT:%d" % (session, good), file=sys.stderr)
for limit, flag in sorted(config["flags"].items()):
if good >= limit:
print(" ...get a flag for", limit, "unique solutions:", flag)
if good > max(config["flags"]):
print(" ...get a flag for being too good at exploiting:", config["unintended"])
if good < min(config["flags"]):
print(" ...get nothing. Try harder!")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/K17/2025/crypto/worsehelp/chall.py | ctfs/K17/2025/crypto/worsehelp/chall.py | from Crypto.Util.number import isPrime, getStrongPrime
from os import urandom
from math import gcd
from secrets import FLAG
a, b = map(int, input("Enter your secure parameters a, b (as comma-separated values) to seed the RNG: ").split(","))
if a.bit_length() < 1024 or b.bit_length() < 1024 or not isPrime(a) or isPrime(b):
print("Your parameters are not secure")
quit()
p, q = getStrongPrime(1024), getStrongPrime(1024)
n = p * q
phi = (p - 1) * (q - 1)
# to harden d
r = ((a**2 + b**2 + 3*a + 3*b + a*b) * pow(2 * a * b + 7, -1, phi)) % phi
while gcd(k := int.from_bytes(urandom(32), "big"), phi) != 1:
continue
d = pow(k, r, phi)
d |= 1
e = pow(d, -1, phi)
m = int.from_bytes(FLAG, "big")
c = pow(m, e, n)
print(f"{c = }")
print(f"{e = }")
print(f"{n = }") | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/K17/2025/crypto/pass_me_the_salt/chall.py | ctfs/K17/2025/crypto/pass_me_the_salt/chall.py | from hashlib import sha1
import os
logins = {}
salts = {}
def create_account(login, pwd):
if login in logins.keys():
return False
salt = os.urandom(16)
salted_pwd = salt + (pwd).encode()
passw = sha1(salted_pwd).hexdigest()
logins[login] = passw
salts[login] = salt
return True
def check_login(login, pwd):
if login not in logins:
return False
salt = salts[login]
salted_pwd = salt + bytes.fromhex(pwd)
passw = sha1(salted_pwd).hexdigest()
return passw == logins[login]
def change_password(login, new_pass):
if login not in logins:
return
print(f"Current password: {logins[login]}")
logins[login] = new_pass
if __name__ == "__main__":
create_account("admin", "admin".encode().hex())
while True:
option = input("1. Create Account\n2. Login\n3. Change Password\n(1, 2, 3)> ")
if option == "1":
login = input("Login: ")
pwd = input("Password: ")
if create_account(login, pwd.encode().hex()):
print("Account created!")
else:
print("Could not create account.")
elif option == "2":
login = input("Login: ")
pwd = input("Password: ")
if not check_login(login, pwd):
print("Invalid login or password.")
continue
if login == "admin":
if pwd != "admin".encode().hex():
print(f"Congratulations! Here is your flag: {os.getenv("FLAG")}")
else:
print("Your flag is in another castle...")
else:
print(f"Login successful as {login}!")
elif option == "3":
login = input("Login: ")
new_pass = input("New password: ")
change_password(login, new_pass)
print("Password changed!")
else:
print("Invalid option.")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/K17/2025/crypto/el_camel/chall.py | ctfs/K17/2025/crypto/el_camel/chall.py | from secrets import randbelow
from sympy import isprime
def findGenerator():
while True:
h = randbelow(p)
if pow(h, q, p) != 1:
continue
g = pow(h, 2, p)
if g != 1:
return g
def rng(key):
r = randbelow(p)
c = pow(g, r * x, p)
c += key
return c % p
if __name__ == "__main__":
from secret import FLAG, p, q
assert isprime(p) and isprime(q)
g = findGenerator()
x = randbelow(q)
print(f"""The Mystical El-Camel is in town!
Beat their game to win a special prize...
{p}
{q}
""")
m0 = int(input("How tall do you want the coin to be?> "))
m1 = int(input("How long do you want the coin to be?> "))
m = [m0, m1]
score = 0
symbols_to_index = {'H': 0, 'T': 1}
for _ in range(50):
i = randbelow(2)
c = rng(m[i])
print(c)
print("The coin has been tossed...")
guess = input("Heads or Tails! (H or T)> ")
guess = symbols_to_index.get(guess.upper())
if guess == i:
print("That's correct!\n")
score += 1
else:
print("Incorrect!\n")
if score > 37:
print("ElCamel is impressed! Here is your prize...")
print(FLAG)
else:
print("Better luck next time!")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/K17/2025/crypto/layers/chall.py | ctfs/K17/2025/crypto/layers/chall.py | from Crypto.PublicKey import RSA
from Crypto.Util.Padding import pad, unpad
from Crypto.Util.number import long_to_bytes, bytes_to_long, getPrime
from Crypto.Cipher import AES
from random import randint, randbytes
from secrets import FLAG
class LayeredEncryption:
def __init__(self, p, q, aes_key):
assert len(aes_key) == 16
self.n = p * q
self.aes_key = aes_key
self.e = 65537
self.d = pow(self.e, -1, (p - 1) * (q - 1))
def encrypt(self, m):
iv = randbytes(16)
aes_c = bytes_to_long(iv + AES.new(self.aes_key, AES.MODE_CBC, iv).encrypt(pad(m, 16)))
print(aes_c)
r = randint(1, 2**512 - 1)
ri = pow(r, -1, self.n)
return (r, pow(ri * aes_c, self.e, self.n), pow(ri * aes_c, self.d, self.n)) # salt, encrypted ciphertext, signature of ciphertext
def decrypt(self, r, c, s):
if r < 1 or r >= 2**512:
print("Salt must a positive integer less than 2^512")
elif c != pow(s, self.e * self.e, self.n):
print("Signature is invalid!")
else:
aes_c_bytes = long_to_bytes((pow(c, self.d, self.n) * r) % self.n)
iv, ciphertext = aes_c_bytes[:16], aes_c_bytes[16:]
return unpad(AES.new(self.aes_key, AES.MODE_CBC, iv).decrypt(ciphertext), 16)
e = LayeredEncryption(getPrime(1024), getPrime(1024), randbytes(16))
r, c, s = e.encrypt(FLAG)
print(f"{e.n = }")
print(f"{e.e = }")
print("Welcome to my lair of layers!")
print(f"Foolish traveller! You think you can best all of my schemes!??! Here, a challenge: {(r, c, s)}")
while True:
guess = input("Prithee, tell in a comma-separated triplet, what secret do i hold? ")
try:
if e.decrypt(*map(int, guess.split(","))) == FLAG:
print("yes, AND IT SHALL NEVER SEE THE LIGHT OF DAY!")
else:
print("NAY!")
except:
print(f"what is bro doing 💀")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/K17/2025/crypto/tricks/secrets.py | ctfs/K17/2025/crypto/tricks/secrets.py | FLAG = b"K17{FAKE_FLAG_FOR_TESTING______}"
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/K17/2025/crypto/tricks/chall.py | ctfs/K17/2025/crypto/tricks/chall.py | from Crypto.Util.number import getStrongPrime, long_to_bytes, bytes_to_long
from random import randint
from secrets import FLAG
assert len(FLAG) == 32
class Paillier:
# en.wikipedia.org/wiki/Paillier_cryptosystem
def __init__(self, p, q):
self.n = p * q
self.n2 = pow(self.n, 2)
self.l = (p - 1) * (q - 1)
self.mu = pow(self.l, -1, self.n)
self.g = self.n + 1
self.L = lambda x : (x - 1) // self.n
def encrypt(self, m):
return (pow(randint(1, self.n - 1), self.n, self.n2) * pow(self.g, m, self.n2)) % self.n2
def decrypt(self, c):
return (self.L(pow(c, self.l, self.n2)) * self.mu) % self.n
paillier = Paillier(getStrongPrime(1024), getStrongPrime(1024))
print(f"{paillier.n = }")
print(paillier.encrypt(bytes_to_long(FLAG)))
print("a key property of paillier encryption/decryption is that its homomorphic between the additive/multiplicative on the plaintext/ciphertext space")
print("the ability to anonymously add, or combine, encrypted streams is incredibly useful, one such application being")
print("TRICKS!!!")
print("YOU")
print("CAN")
print("DO")
print("TRICKS!!!!")
print("LET'S SEEE IF YOU CAN DO TRIIIIIICKS!!!!!!!!!!!!!!!!!!!!!!!!")
tricks = {
"cha cha left": lambda x : x + b"\x00", # e.g. pow(x, 256, self.n2)
"wave your hands": lambda x : b"\\_/-\\_/" + x + b"\\_/-\\_/",
"SAY IT THREE TIMES": lambda x : x + x + x
}
print(f"you can {', '.join(tricks.keys())}... yeah that's pretty much it actually")
while True:
trick = input("Which trick do you want to show me? ")
if trick not in tricks:
print("I've never heard of that trick before")
continue
x = int(input("What's the encrypted message you'd like to perform the trick on? "))
y = int(input("What's the encrypted result of the trick? "))
if bytes_to_long(tricks[trick](long_to_bytes(paillier.decrypt(x)))) == paillier.decrypt(y):
print("HOLY SMOKES WHAT A TRICK!!!!!")
else:
print("nup.")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/BRICS+/2023/Quals/ppc/gif0day/server/gifgen.py | ctfs/BRICS+/2023/Quals/ppc/gif0day/server/gifgen.py | import random
from PIL import Image, ImageDraw, ImageFont
BG_COLOR = (255, 255, 255)
fonts = (
'JetBrainsMono-Regular.ttf',
'OpenSans.ttf',
'Roboto-Regular.ttf'
)
FONT = ImageFont.truetype('/fonts/JetBrainsMono-Regular.ttf', size=100)
def load_font():
size = random.randint(95, 115)
return ImageFont.truetype('/fonts/' + random.choice(fonts), size=size)
def random_font_color():
r, g, b = random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)
if r + g + b > 200 * 3:
return random_font_color()
return (r, g, b)
def generate_gif_images(s: str) -> list[Image]:
frames = []
for letter in s:
fnt = load_font()
image = Image.new("RGB", (200, 200), BG_COLOR)
draw = ImageDraw.Draw(image)
for _ in range(500):
rx, ry = random.randint(0, 199), random.randint(0, 199)
image.putpixel((rx, ry), (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)))
draw.text((0, 0), letter, font=fnt, fill=random_font_color())
frames.append(image)
return frames
def generate_gif(s: str, op):
images = generate_gif_images(s)
images[0].save(op, format='GIF', save_all=True, append_images=images[1:], optimize=True, duration=400, loop=False)
if __name__ == '__main__':
generate_gif('test12', 'test.gif')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/BRICS+/2023/Quals/ppc/gif0day/server/gifcrop.py | ctfs/BRICS+/2023/Quals/ppc/gif0day/server/gifcrop.py | import glob
import sys
from PIL import Image, ImageSequence
def crop_image(img: Image) -> Image:
return img.crop((40, 40, 70, 70))
def crop_gif(gif_path: str):
with Image.open(gif_path) as im:
new_frames = ImageSequence.all_frames(im, crop_image)
duration = new_frames[0].info['duration']
new_frames[0].save(gif_path, format='GIF',
save_all=True, append_images=new_frames[1:], optimize=True, duration=duration, loop=False,
append=True)
if __name__ == '__main__':
p = sys.argv[1]
for gif_path in glob.glob(p):
crop_gif(gif_path)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/BRICS+/2023/Quals/ppc/gif0day/server/server.py | ctfs/BRICS+/2023/Quals/ppc/gif0day/server/server.py | import asyncio
import hashlib
import os
import random
import string
import tempfile
import grpclib
from grpclib.server import Server
from grpclib.utils import graceful_exit
from pb import restore_grpc
from pb import restore_pb2
from gifgen import generate_gif
from gifcrop import crop_gif
class RestoreService(restore_grpc.RestoreServiceBase):
def __init__(self, flag: str, num_rounds=10):
self.flag = flag
self.num_rounds = num_rounds
def rnd_uniq_string(self, length: int):
alpha = list(string.ascii_letters + string.digits)
random.shuffle(alpha)
return ''.join(alpha[:length])
def gen_round(self, rnd: int):
content = self.rnd_uniq_string(8)
if rnd == self.num_rounds:
content = self.flag
salt = self.rnd_uniq_string(5)
request = restore_pb2.RestoreRequest(hash=hashlib.md5(f'{content}{salt}'.encode()).hexdigest(), salt=salt)
with tempfile.NamedTemporaryFile(suffix='.gif') as temp:
generate_gif(content, temp.name)
crop_gif(temp.name)
request.gif = open(temp.name, 'rb').read()
return request, content
async def Restore(self, stream: 'grpclib.server.Stream[restore_pb2.Answer, restore_pb2.RestoreRequest]') -> None:
rnd = 0
while rnd <= self.num_rounds:
request, content = self.gen_round(rnd)
await stream.send_message(request)
try:
async with asyncio.timeout(10):
answer = await stream.recv_message()
except asyncio.TimeoutError:
await stream.send_trailing_metadata(status=grpclib.Status.DEADLINE_EXCEEDED, status_message="Too slow!")
return
if answer.answer != content:
await stream.send_trailing_metadata(status=grpclib.Status.INVALID_ARGUMENT,
status_message="Wrong answer!")
return
rnd += 1
await stream.send_trailing_metadata()
return
async def main(*, host='0.0.0.0', port=50051):
server = grpclib.server.Server([RestoreService(flag=os.getenv('FLAG'), num_rounds=100)])
with graceful_exit([server]):
await server.start(host, port)
print(f'Serving on {host}:{port}', flush=True)
await server.wait_closed()
if __name__ == '__main__':
asyncio.run(main())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/BRICS+/2023/Quals/ppc/gif0day/server/pb/restore_grpc.py | ctfs/BRICS+/2023/Quals/ppc/gif0day/server/pb/restore_grpc.py | # Generated by the Protocol Buffers compiler. DO NOT EDIT!
# source: restore.proto
# plugin: grpclib.plugin.main
import abc
import typing
import grpclib.const
import grpclib.client
if typing.TYPE_CHECKING:
import grpclib.server
from . import restore_pb2 as restore_pb2
class RestoreServiceBase(abc.ABC):
@abc.abstractmethod
async def Restore(self, stream: 'grpclib.server.Stream[restore_pb2.Answer, restore_pb2.RestoreRequest]') -> None:
pass
def __mapping__(self) -> typing.Dict[str, grpclib.const.Handler]:
return {
'/restore.RestoreService/Restore': grpclib.const.Handler(
self.Restore,
grpclib.const.Cardinality.STREAM_STREAM,
restore_pb2.Answer,
restore_pb2.RestoreRequest,
),
}
class RestoreServiceStub:
def __init__(self, channel: grpclib.client.Channel) -> None:
self.Restore = grpclib.client.StreamStreamMethod(
channel,
'/restore.RestoreService/Restore',
restore_pb2.Answer,
restore_pb2.RestoreRequest,
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/BRICS+/2023/Quals/ppc/gif0day/server/pb/restore_pb2.py | ctfs/BRICS+/2023/Quals/ppc/gif0day/server/pb/restore_pb2.py | # -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: restore.proto
"""Generated protocol buffer code."""
from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder
# @@protoc_insertion_point(imports)
_sym_db = _symbol_database.Default()
DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\rrestore.proto\x12\x07restore\"\x18\n\x06\x41nswer\x12\x0e\n\x06\x61nswer\x18\x01 \x01(\t\"9\n\x0eRestoreRequest\x12\x0c\n\x04hash\x18\x01 \x01(\t\x12\x0c\n\x04salt\x18\x02 \x01(\t\x12\x0b\n\x03gif\x18\x03 \x01(\x0c\x32K\n\x0eRestoreService\x12\x39\n\x07Restore\x12\x0f.restore.Answer\x1a\x17.restore.RestoreRequest\"\x00(\x01\x30\x01\x62\x06proto3')
_globals = globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'restore_pb2', _globals)
if _descriptor._USE_C_DESCRIPTORS == False:
DESCRIPTOR._options = None
_globals['_ANSWER']._serialized_start=26
_globals['_ANSWER']._serialized_end=50
_globals['_RESTOREREQUEST']._serialized_start=52
_globals['_RESTOREREQUEST']._serialized_end=109
_globals['_RESTORESERVICE']._serialized_start=111
_globals['_RESTORESERVICE']._serialized_end=186
# @@protoc_insertion_point(module_scope)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/BRICS+/2023/Quals/crypto/sqrt/4.py | ctfs/BRICS+/2023/Quals/crypto/sqrt/4.py | from sage.all import *
import hashlib
P = Permutations(256).random_element()
print(P**2)
print([x^y for x,y in zip(hashlib.sha512(str(P).encode()).digest(), open('flag.txt', 'rb').read())])
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/BRICS+/2023/Quals/crypto/arc3/2.py | ctfs/BRICS+/2023/Quals/crypto/arc3/2.py | import random
from secret import flag
def rc4():
S = list(range(256))
random.shuffle(S)
i = random.randrange(256)
j = random.randrange(256)
while True:
i = (i + 1) % 256
j = (j + S[i]) % 256
S[i], S[j] = S[j], S[i]
yield S[(S[i] + S[j]) % 256]
data = b'\x00'*1000 + flag
with open('data.bin','wb') as f:
for i in range(200000):
ciphertext = bytes([x^y for x,y in zip(data, rc4())])
f.write(ciphertext)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/BRICS+/2023/Quals/crypto/sss/3.py | ctfs/BRICS+/2023/Quals/crypto/sss/3.py | FLAG = open('flag.txt', 'rb').read()
import random
import hashlib
MOD = 20000159
N = MOD
K = N - 3
poly = [random.randrange(MOD) for i in range(K)]
print([x^y for x,y in zip(hashlib.sha512(str(poly).encode()).digest(), FLAG)])
def eval_at(poly, x):
t = 1
ret = 0
for k in poly:
ret += t * k
t *= x
t %= MOD
return ret % MOD
shares = [-1] * N
for i in range(N):
if i not in [69, 420, 1337]:
shares[i] = eval_at(poly, i)
print(shares)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HITCON/2021/rev/baba-is-rev/BabaGUI/main.py | ctfs/HITCON/2021/rev/baba-is-rev/BabaGUI/main.py | import pygame
import pyBaba
import config
import sys
import sprites
if len(sys.argv[1]) < 2:
print('Usage: main.py [map]')
sys.exit(1)
game = pyBaba.Game(sys.argv[1])
screen_size = (game.GetMap().GetWidth() * config.BLOCK_SIZE,
game.GetMap().GetHeight() * config.BLOCK_SIZE)
screen = pygame.display.set_mode(
(screen_size[0], screen_size[1]), pygame.DOUBLEBUF)
sprite_loader = sprites.SpriteLoader()
result_image = sprites.ResultImage()
result_image_group = pygame.sprite.Group()
result_image_group.add(result_image)
def draw_obj(x_pos, y_pos):
objects = game.GetMap().At(x_pos, y_pos)
for obj_type in objects.GetTypes():
if pyBaba.IsTextType(obj_type):
obj_image = sprite_loader.text_images[obj_type]
else:
if obj_type == pyBaba.ObjectType.ICON_EMPTY:
continue
obj_image = sprite_loader.icon_images[obj_type]
obj_image.render(screen, (x_pos * config.BLOCK_SIZE,
y_pos * config.BLOCK_SIZE))
def draw():
for y_pos in range(game.GetMap().GetHeight()):
for x_pos in range(game.GetMap().GetWidth()):
draw_obj(x_pos, y_pos)
if __name__ == '__main__':
pygame.init()
pygame.font.init()
clock = pygame.time.Clock()
game_over = False
while True:
if game_over:
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.quit()
sys.exit()
if game.GetPlayState() == pyBaba.PlayState.WON:
result_image_group.update(pyBaba.PlayState.WON, screen_size)
result_image_group.draw(screen)
else:
result_image_group.update(pyBaba.PlayState.LOST, screen_size)
result_image_group.draw(screen)
pygame.display.flip()
continue
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.quit()
sys.exit()
elif event.key == pygame.K_UP:
game.MovePlayer(pyBaba.Direction.UP)
elif event.key == pygame.K_DOWN:
game.MovePlayer(pyBaba.Direction.DOWN)
elif event.key == pygame.K_LEFT:
game.MovePlayer(pyBaba.Direction.LEFT)
elif event.key == pygame.K_RIGHT:
game.MovePlayer(pyBaba.Direction.RIGHT)
elif event.key == pygame.K_x:
game.Undo()
if game.GetPlayState() == pyBaba.PlayState.WON or game.GetPlayState() == pyBaba.PlayState.LOST:
game_over = True
screen.fill(config.COLOR_BACKGROUND)
draw()
pygame.display.flip()
clock.tick(config.FPS)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HITCON/2021/rev/baba-is-rev/BabaGUI/config.py | ctfs/HITCON/2021/rev/baba-is-rev/BabaGUI/config.py | import pygame
FPS = 60
BLOCK_SIZE = 48
COLOR_BACKGROUND = pygame.Color(0, 0, 0)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HITCON/2021/rev/baba-is-rev/BabaGUI/images.py | ctfs/HITCON/2021/rev/baba-is-rev/BabaGUI/images.py | # Original code from https://github.com/nicksandau/GIFImage_ext/blob/master/GIFImage_ext.py
from PIL import Image
import pygame
from pygame.locals import SRCALPHA
import time
class GIFImage(object):
def __init__(self, filename):
self.filename = filename
self.image = Image.open(filename)
self.original_size = self.image.size
#Added by NS *********************
#self.frames = []
self.fps_scale = 1
self.img_scale = 1
#**********************************
self.get_frames()
self.cur = 0
self.ptime = time.time()
self.running = True
self.breakpoint = len(self.frames)-1
self.startpoint = 0
self.reversed = False
def get_rect(self):
return pygame.rect.Rect((0, 0), self.image.size)
def get_frames(self):
image = self.image
#Added by NS ************
self.frames = []
#*************************
pal = image.getpalette()
base_palette = []
for i in range(0, len(pal), 3):
rgb = pal[i:i+3]
base_palette.append(rgb)
all_tiles = []
try:
while 1:
if not image.tile:
image.seek(0)
if image.tile:
all_tiles.append(image.tile[0][3][0])
image.seek(image.tell()+1)
except EOFError:
image.seek(0)
all_tiles = tuple(set(all_tiles))
try:
while 1:
try:
duration = image.info["duration"]
except Exception as e:
print("Error '{0}' occurred. Arguments {1}.",
e.message, e.args)
duration = 100
duration *= .001 # convert to milliseconds!
#Added by NS ************
duration *= self.fps_scale
#*************************
cons = False
x0, y0, x1, y1 = (0, 0) + image.size
if image.tile:
tile = image.tile
else:
image.seek(0)
tile = image.tile
if len(tile) > 0:
x0, y0, x1, y1 = tile[0][1]
if all_tiles:
if all_tiles in ((6,), (7,)):
cons = True
pal = image.getpalette()
palette = []
for i in range(0, len(pal), 3):
rgb = pal[i:i+3]
palette.append(rgb)
elif all_tiles in ((7, 8), (8, 7)):
pal = image.getpalette()
palette = []
for i in range(0, len(pal), 3):
rgb = pal[i:i+3]
palette.append(rgb)
else:
palette = base_palette
else:
palette = base_palette
pi = pygame.image.fromstring(
image.tobytes(), image.size, image.mode)
pi.set_palette(palette)
if "transparency" in image.info:
pi.set_colorkey(image.info["transparency"])
pi2 = pygame.Surface(image.size, SRCALPHA)
if cons:
for i in self.frames:
pi2.blit(i[0], (0, 0))
pi2.blit(pi, (x0, y0), (x0, y0, x1-x0, y1-y0))
self.frames.append([pi2, duration])
image.seek(image.tell()+1)
except EOFError:
pass
def render(self, screen, pos):
if self.running:
if time.time() - self.ptime > self.frames[self.cur][1]:
if self.reversed:
self.cur -= 1
if self.cur < self.startpoint:
self.cur = self.breakpoint
else:
self.cur += 1
if self.cur > self.breakpoint:
self.cur = self.startpoint
self.ptime = time.time()
#Added by NS **************************************
if self.img_scale == 1:
surf = self.frames[self.cur][0]
else:
surf = pygame.transform.scale(self.frames[self.cur][0],
(int(self.image.width * self.img_scale),
int(self.image.height * self.img_scale)))
screen.blit(surf, pos)
#screen.blit(self.frames[self.cur][0], pos)
#***************************************************
def seek(self, num):
self.cur = num
if self.cur < 0:
self.cur = 0
if self.cur >= len(self.frames):
self.cur = len(self.frames)-1
def set_bounds(self, start, end):
if start < 0:
start = 0
if start >= len(self.frames):
start = len(self.frames) - 1
if end < 0:
end = 0
if end >= len(self.frames):
end = len(self.frames) - 1
if end < start:
end = start
self.startpoint = start
self.breakpoint = end
def pause(self):
self.running = False
#added by NS ********************************
def next_frame(self):
if self.running:
self.pause()
else:
self.cur += 1
if self.cur > self.breakpoint:
self.cur = self.startpoint
def prev_frame(self):
if self.running:
self.pause()
else:
self.cur -= 1
if self.cur < 0:
self.cur = self.breakpoint
def slow_down(self):
self.fps_scale += .05 if self.fps_scale != .01 else .04
self.get_frames()
self.seek(self.cur)
def speed_up(self):
if self.fps_scale - .05 <= 0:
self.fps_scale = .01
else:
self.fps_scale -= .25
self.get_frames()
self.seek(self.cur)
def scale(self, scale_factor):
self.img_scale += scale_factor
def reset_scale(self):
self.img_scale = 1
#*********************************************
def play(self):
self.running = True
def rewind(self):
self.seek(0)
def fastforward(self):
self.seek(self.length()-1)
def get_height(self):
return self.image.size[1]
def get_width(self):
return self.image.size[0]
def get_size(self):
return self.image.size
def length(self):
return len(self.frames)
def reverse(self):
self.reversed = not self.reversed
def reset(self):
self.cur = 0
self.ptime = time.time()
self.reversed = False
def copy(self):
new = GIFImage(self.filename)
new.running = self.running
new.breakpoint = self.breakpoint
new.startpoint = self.startpoint
new.cur = self.cur
new.ptime = self.ptime
new.reversed = self.reversed
#Added by NS ****
new.fps_scale = self.fps_scale
#*****************
return new
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HITCON/2021/rev/baba-is-rev/BabaGUI/sprites.py | ctfs/HITCON/2021/rev/baba-is-rev/BabaGUI/sprites.py | import pygame
import pyBaba
from images import GIFImage
class SpriteLoader:
def __init__(self):
self.icon_images = {
pyBaba.ObjectType.ICON_BABA: 'BABA',
pyBaba.ObjectType.ICON_BRICK: 'BRICK',
pyBaba.ObjectType.ICON_FLAG: 'FLAG',
pyBaba.ObjectType.ICON_GRASS: 'GRASS',
pyBaba.ObjectType.ICON_HEDGE: 'HEDGE',
pyBaba.ObjectType.ICON_LAVA: 'LAVA',
pyBaba.ObjectType.ICON_JIJI: 'JIJI',
pyBaba.ObjectType.ICON_ROCK: 'ROCK',
pyBaba.ObjectType.ICON_TILE: 'TILE',
pyBaba.ObjectType.ICON_TREE: 'TREE',
pyBaba.ObjectType.ICON_WALL: 'WALL',
pyBaba.ObjectType.ICON_WATER: 'WATER',
}
for i in self.icon_images:
self.icon_images[i] = GIFImage(
'./sprites/icon/{}.gif'.format(self.icon_images[i]))
self.icon_images[i].scale(1.0)
self.text_images = {
# nonn type
pyBaba.ObjectType.BABA: 'BABA',
pyBaba.ObjectType.BRICK: 'BRICK',
pyBaba.ObjectType.FLAG: 'FLAG',
pyBaba.ObjectType.GRASS: 'GRASS',
pyBaba.ObjectType.HEDGE: 'HEDGE',
pyBaba.ObjectType.LAVA: 'LAVA',
pyBaba.ObjectType.JIJI: 'JIJI',
pyBaba.ObjectType.ROCK: 'ROCK',
pyBaba.ObjectType.TEXT: 'TEXT',
pyBaba.ObjectType.TILE: 'TILE',
pyBaba.ObjectType.TREE: 'TREE',
pyBaba.ObjectType.WALL: 'WALL',
pyBaba.ObjectType.WATER: 'WATER',
# op type
pyBaba.ObjectType.HAS: 'HAS',
pyBaba.ObjectType.IS: 'IS',
pyBaba.ObjectType.AND: 'AND',
pyBaba.ObjectType.NOT: 'NOT',
# property type
pyBaba.ObjectType.YOU: 'YOU',
pyBaba.ObjectType.STOP: 'STOP',
pyBaba.ObjectType.PUSH: 'PUSH',
pyBaba.ObjectType.WIN: 'WIN',
pyBaba.ObjectType.SINK: 'SINK',
pyBaba.ObjectType.HOT: 'HOT',
pyBaba.ObjectType.MELT: 'MELT',
pyBaba.ObjectType.SHUT: 'SHUT',
pyBaba.ObjectType.OPEN: 'OPEN',
}
for i in self.text_images:
self.text_images[i] = GIFImage(
'./sprites/text/{}.gif'.format(self.text_images[i]))
self.text_images[i].scale(1.0)
class ResultImage(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
def update(self, status, screen_size):
if status == pyBaba.PlayState.WON:
self.size = max(screen_size[0], screen_size[1]) // 2
self.image = pygame.transform.scale(pygame.image.load(
'./sprites/won.png'), (self.size, self.size))
self.rect = self.image.get_rect()
self.rect.center = (screen_size[0] // 2, screen_size[1] // 2)
else:
self.size = max(screen_size[0], screen_size[1]) // 2
self.image = pygame.transform.scale(pygame.image.load(
'./sprites/lost.png'), (self.size, self.size))
self.rect = self.image.get_rect()
self.rect.center = (screen_size[0] // 2, screen_size[1] // 2)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HITCON/2021/crypto/dlog/prob.py | ctfs/HITCON/2021/crypto/dlog/prob.py | import os
from Crypto.Util.number import *
from hashlib import *
from binascii import unhexlify
LEN = 17
magic = os.urandom(LEN)
print("Magic:", magic.hex())
print('Coud you use it to solve dlog?')
magic_num = bytes_to_long(magic)
try:
P = int(input('P:>'))
e = int(input('E:>'))
data = unhexlify(input('data:>'))
if P >> (384 - LEN*8) == magic_num and isPrime(P):
data2 = sha384(data).digest()
num1 = bytes_to_long(data)
num2 = bytes_to_long(data2)
if pow(num1, e, P) == num2:
print(open('flag','r').read())
else:
print('try harder!!!')
else:
print('try harder!')
except Exception as e:
print('invalid')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HITCON/2021/crypto/so_easy_rsa/prob.py | ctfs/HITCON/2021/crypto/so_easy_rsa/prob.py | from gmpy2 import next_prime, is_prime
from random import randint
from Crypto.Util.number import bytes_to_long
class Rand:
def __init__(self):
self.seed = randint(2, 2**512)
self.A = next_prime(randint(2, 2**512))
self.B = next_prime(randint(2, 2**512))
self.M = next_prime(randint(2, 2**512))
for _ in range(10000):
self.next()
def next(self):
self.seed = self.seed * self.A + self.B
self.seed = self.seed % self.M
return self.seed
def __str__(self):
return f"{self.A}, {self.B}, {self.M}"
def gen_prime(r):
while True:
v = r.next()
if is_prime(v):
return v
r = Rand()
p,q = gen_prime(r), gen_prime(r)
n = p*q
e = 65537
flag = bytes_to_long(open('flag','rb').read())
val = pow(flag, e, n)
print(n)
print(r)
print(val)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HITCON/2021/crypto/magic_rsa/prob.py | ctfs/HITCON/2021/crypto/magic_rsa/prob.py | import os
from Crypto.Util.number import *
from hashlib import *
from binascii import unhexlify
LEN = 17
magic = os.urandom(LEN)
print("Magic:", magic.hex())
print('Coud you use it to do encryption as hash?')
magic_num = bytes_to_long(magic)
try:
N = int(input('N:>'))
e = int(input('E:>'))
data = unhexlify(input('data:>'))
if N >> (384 - LEN*8) == magic_num:
data2 = sha384(data).digest()
num1 = bytes_to_long(data)
num2 = bytes_to_long(data2)
if pow(num1, e, N) == num2:
print(open('flag','r').read())
else:
print('try harder!!!')
else:
print('try harder!')
except Exception as e:
print('invalid')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HITCON/2021/crypto/a_little_easy_rsa/prob.py | ctfs/HITCON/2021/crypto/a_little_easy_rsa/prob.py | from Crypto.Util.number import *
N = 1024
P = 211
p = getPrime(P)
q = getPrime(N-P)
n = p*q
print(n.bit_length())
d = p
e = inverse(d, (p-1)*(q-1))
flag = bytes_to_long(open('flag','rb').read())
print(n)
print(e)
print(pow(flag, e, n))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.