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/UrchinSecAware/2024/crypto/WarmUp/enc.py | ctfs/UrchinSecAware/2024/crypto/WarmUp/enc.py | from sympy import mod_inverse
def generate_knapsack():
knapsack = [1, 2]
for i in range(6):
knapsack.append(sum(knapsack) + 1)
return knapsack
def convert_to_bits(message):
bits = []
for char in message:
char_bits = bin(ord(char))[2:].zfill(8)
bits.extend([int(b) for b in char_bits])
return bits
def encrypt_message(message, knapsack, m, n):
bits = convert_to_bits(message)
chunk_size = len(knapsack)
chunks = [bits[i:i + chunk_size] for i in range(0, len(bits), chunk_size)]
ciphertext = []
for chunk in chunks:
if len(chunk) < chunk_size:
chunk += [0] * (chunk_size - len(chunk))
c_value = sum(k * b for k, b in zip(knapsack, chunk))
encrypted_value = (c_value * n) % m
ciphertext.append(encrypted_value)
return ciphertext
if __name__ == "__main__":
message = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
knapsack = generate_knapsack()
m = 257
n = random.randint(-1000, 1000)
ciphertext = encrypt_message(message, knapsack, m, n)
print("Ciphertext:", ciphertext) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/UrchinSecAware/2024/crypto/Shifty_Business/script.py | ctfs/UrchinSecAware/2024/crypto/Shifty_Business/script.py | from functools import reduce
def ecv(v):
n = [16, 32, 64, 128]
return reduce(lambda v, s: (v << s) ^ s, n, v)
flag = "urchinsec{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}"
enc = [ecv(ord(char) ** 2) for char in flag]
print(enc)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2024/misc/Really_Only_Echo/server.py | ctfs/PatriotCTF/2024/misc/Really_Only_Echo/server.py | #!/usr/bin/python3
import os,pwd,re
import socketserver, signal
import subprocess
listen = 3333
blacklist = os.popen("ls /bin").read().split("\n")
blacklist.remove("echo")
#print(blacklist)
def filter_check(command):
user_input = command
parsed = command.split()
#Must begin with echo
if not "echo" in parsed:
return False
else:
if ">" in parsed:
#print("HEY! No moving things around.")
req.sendall(b"HEY! No moving things around.\n\n")
return False
else:
parsed = command.replace("$", " ").replace("(", " ").replace(")", " ").replace("|"," ").replace("&", " ").replace(";"," ").replace("<"," ").replace(">"," ").replace("`"," ").split()
#print(parsed)
for i in range(len(parsed)):
if parsed[i] in blacklist:
return False
return True
def backend(req):
req.sendall(b'This is shell made to use only the echo command.\n')
while True:
#print("\nThis is shell made to use only the echo command.")
req.sendall(b'Please input command: ')
user_input = req.recv(4096).strip(b'\n').decode()
print(user_input)
#Check input
if user_input:
if filter_check(user_input):
output = os.popen(user_input).read()
req.sendall((output + '\n').encode())
else:
#print("Those commands don't work.")
req.sendall(b"HEY! I said only echo works.\n\n")
else:
#print("Why no command?")
req.sendall(b"Where\'s the command.\n\n")
class incoming(socketserver.BaseRequestHandler):
def handle(self):
signal.alarm(1500)
req = self.request
backend(req)
class ReusableTCPServer(socketserver.ForkingMixIn, socketserver.TCPServer):
pass
def main():
uid = pwd.getpwnam('ctf')[2]
os.setuid(uid)
socketserver.TCPServer.allow_reuse_address = True
server = ReusableTCPServer(("0.0.0.0", listen), incoming)
server.serve_forever()
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/PatriotCTF/2024/rev/Puzzle_Room/puzzle_room.py | ctfs/PatriotCTF/2024/rev/Puzzle_Room/puzzle_room.py | #!/usr/bin/env python
import time
import random
#### Crypto stuff not important
import base64
import hashlib
from Crypto import Random
from Crypto.Cipher import AES
class AESCipher(object):
def __init__(self, key):
self.bs = AES.block_size
self.key = hashlib.sha256(key.encode()).digest()
def encrypt(self, raw):
raw = self._pad(raw)
iv = Random.new().read(AES.block_size)
cipher = AES.new(self.key, AES.MODE_CBC, iv)
return base64.b64encode(iv + cipher.encrypt(raw.encode()))
def decrypt(self, enc):
enc = base64.b64decode(enc)
iv = enc[: AES.block_size]
cipher = AES.new(self.key, AES.MODE_CBC, iv)
return AESCipher._unpad(cipher.decrypt(enc[AES.block_size :])).decode("utf-8")
def _pad(self, s):
return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)
@staticmethod
def _unpad(s):
return s[: -ord(s[len(s) - 1 :])]
class bcolors:
HEADER = "\033[95m"
OKBLUE = "\033[94m"
OKCYAN = "\033[96m"
OKGREEN = "\033[92m"
WARNING = "\033[93m"
FAIL = "\033[91m"
ENDC = "\033[0m"
BOLD = "\033[1m"
UNDERLINE = "\033[4m"
def slow_print(msg, delay=0.02):
for letter in msg:
time.sleep(delay)
print(letter, end="", flush=True)
print()
def how_did_you_succumb_to_a_trap():
slow_print(
bcolors.FAIL + "FWOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOSH" + bcolors.ENDC,
delay=0.04,
)
ways_to_get_got = [
"Well, you sure found the trap—too bad it found you first.",
"That one step forward just turned you into a well-done adventurer.",
"Turns out not checking for traps does lead to a fiery conclusion.",
"Took one step too many... and now you’re part of the decor.",
"Next time, maybe trust your instincts before you become toast.",
"Maybe next time you’ll sneeze before stepping onto the fire trap.",
"Well, if you were looking for a quick tan, mission accomplished.",
"Looks like you found the fire... with your face.",
"Well, that’s one way to light up the room—too bad it’s you that’s burning.",
"Guess those fire-resistant potions were back in your pack, huh?",
"You just turned 'walking into danger' into 'walking into a bonfire.'",
"At least now we know what happens when you don’t watch your step... you sizzle.",
"You really lit up the room...",
]
slow_print(random.choice(ways_to_get_got))
def how_did_you_avoid_the_fire():
ways_to_avoid = [
"Good thing you sneezed before walking in or you'd be toast!",
"That was close-who knew stopping to tie your boot would keep you safe?",
"You had a bad feeling about this room, and it turns out, you were right!",
"Good thing you hesitated, or else you'd be one roast adventurer",
"You stopped, unsure for just a moment—and that indecision saved your life.",
"That brief moment of doubt was all it took to avoid being incinerated.",
"Lucky that you bent down to adjust your gear—one more step and you'd be fried.",
"That sudden itch you stopped to scratch just saved you from being flame-broiled.",
"Lucky you had to tighten your pack strap—you missed the fire by a heartbeat.",
"Good thing you hesitated—one more step and you'd be barbecue.",
]
slow_print(bcolors.OKGREEN + random.choice(ways_to_avoid) + bcolors.ENDC)
class PathGroup:
tiles = []
current_cordinates = None
path_history = []
def __repr__(self):
return "[X] {} -- {} \n".format(self.tiles, self.path_history)
grid = [
[
"SPHINX",
"urn",
"vulture",
"arch",
"snake",
"urn",
"bug",
"plant",
"arch",
"staff",
"SPHINX",
],
[
"plant",
"foot",
"bug",
"plant",
"vulture",
"foot",
"staff",
"vulture",
"plant",
"foot",
"bug",
],
[
"arch",
"staff",
"urn",
"Shrine",
"Shrine",
"Shrine",
"plant",
"bug",
"staff",
"urn",
"arch",
],
[
"snake",
"vulture",
"foot",
"Shrine",
"Shrine",
"Shrine",
"urn",
"snake",
"vulture",
"foot",
"vulture",
],
[
"staff",
"urn",
"bug",
"Shrine",
"Shrine",
"Shrine",
"foot",
"staff",
"bug",
"snake",
"staff",
],
[
"snake",
"plant",
"bug",
"urn",
"foot",
"vulture",
"bug",
"urn",
"arch",
"foot",
"urn",
],
[
"SPHINX",
"arch",
"staff",
"plant",
"snake",
"staff",
"bug",
"plant",
"vulture",
"snake",
"SPHINX",
],
]
def print_grid_with_path_group(grid, pg):
for i, x in enumerate(grid):
for j, y in enumerate(x):
if (i, j) in pg.path_history:
if (i, j) == pg.path_history[-1]:
print(
bcolors.FAIL + str("YOU").ljust(8, " ") + bcolors.ENDC, end=""
)
else:
print(str("STEP").ljust(8, " "), end="")
else:
print(str(y).ljust(8, " "), end="")
print()
def try_get_tile(tile_tuple):
try:
return grid[tile_tuple[0]][tile_tuple[1]], (tile_tuple[0], tile_tuple[1])
except Exception as e:
return None
def print_current_map():
for x in grid:
for y in x:
print(str(y).ljust(8, " "), end="")
print()
# This is you at (3,10)!
starting_tile = (3, 10)
starting_path = PathGroup()
starting_path.tiles = ["vulture"]
starting_path.current_cordinates = starting_tile
starting_path.path_history = [starting_tile]
def move(path, tile):
sub_path = PathGroup()
sub_path.tiles.append(tile)
sub_path.current_cordinates = tile
sub_path.path_history = path.path_history.copy()
sub_path.path_history.append(tile)
return sub_path
cur_tile = starting_tile
def menu(path):
cur_tile = path.current_cordinates
next_tile = None
while next_tile == None:
print(
bcolors.OKGREEN
+ "\t ------------- The puzzle room layout -------------"
+ bcolors.ENDC
)
print_grid_with_path_group(grid, path)
choice = input("Which direction will you journey next? : ").upper()
# Hope you have python 3.10!
match choice:
case "N":
next_tile = (cur_tile[0] -1, cur_tile[1])
case "S":
next_tile = (cur_tile[0] +1, cur_tile[1])
case "E":
next_tile = (cur_tile[0], cur_tile[1] +1)
case "W":
next_tile = (cur_tile[0], cur_tile[1] -1)
case "NE":
next_tile = (cur_tile[0] -1, cur_tile[1] +1)
case "NW":
next_tile = (cur_tile[0] -1, cur_tile[1] -1)
case "SE":
next_tile = (cur_tile[0] +1, cur_tile[1] +1)
case "SW":
next_tile = (cur_tile[0] +1, cur_tile[1] -1)
case _:
print("That doesn't seem to be a valid direction")
new_path = move(path, next_tile)
return new_path
slow_print(
"With your hulking strength you break down the door to a room clearly designed to hold riches."
)
slow_print(
"The door FLINGS across the room and lands on (3,9) and a massive ray a fire ignites the room."
)
slow_print(".", 0.3)
slow_print("..", 0.3)
slow_print("...", 0.3)
how_did_you_avoid_the_fire()
slow_print(
"Phew, good thing you weren't in the room yet. Clearly it's booby trapped and you step onto the first tile (3,10)"
)
def check_path(path):
for tile in path.path_history:
if tile[1] > 10 or tile[1] < 0:
how_did_you_succumb_to_a_trap()
exit(-1)
if tile[0] > 6 or tile[0] < 0:
how_did_you_succumb_to_a_trap()
exit(-1)
if path.current_cordinates == (3, 9):
slow_print(
"As you step atop the door that triggered the traps in the first place, you think to yourself: 'Should I really have stepped on a space I knew would trigger a trap?'"
)
how_did_you_succumb_to_a_trap()
exit(-1)
if try_get_tile(path.current_cordinates)[0] == "SPHINX":
how_did_you_succumb_to_a_trap()
exit(-1)
if len(set(path.path_history)) != len(path.path_history):
how_did_you_succumb_to_a_trap()
exit(-1)
for tile in path.path_history[:-1]:
if try_get_tile(path.current_cordinates)[0] == try_get_tile(tile)[0]:
how_did_you_succumb_to_a_trap()
exit(-1)
if try_get_tile(path.current_cordinates)[0] != "Shrine" and len(
set([x[1] for x in path.path_history])
) != len([x[1] for x in path.path_history]):
how_did_you_succumb_to_a_trap()
exit(-1)
if try_get_tile(path.current_cordinates)[0] == "Shrine":
key = "".join([try_get_tile(x)[0] for x in path.path_history])
enc_flag = b"FFxxg1OK5sykNlpDI+YF2cqF/tDem3LuWEZRR1bKmfVwzHsOkm+0O4wDxaM8MGFxUsiR7QOv/p904UiSBgyVkhD126VNlNqc8zNjSxgoOgs="
obj = AESCipher(key)
dec_flag = obj.decrypt(enc_flag)
if "pctf" in dec_flag:
slow_print(
bcolors.OKBLUE
+ "You've done it! All the traps depress and a rigid 'click' can be heard as the center chest opens! As you push open the top your prize sits inside!"
+ bcolors.ENDC
)
print(bcolors.OKCYAN + dec_flag + bcolors.ENDC)
exit(0)
else:
slow_print(
"You step onto the center area expecting your prize, but a loud whirling sound is heard instead. The floor plates make a large mechanical click sounds and engage the fire trap once again!"
)
how_did_you_succumb_to_a_trap()
exit(-1)
cur_path = starting_path
while True:
n_path = menu(cur_path)
check_path(n_path)
cur_path = n_path
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2024/crypto/Melting_Tux/half_script.py | ctfs/PatriotCTF/2024/crypto/Melting_Tux/half_script.py | from Cryptodome.Cipher import AES
from Cryptodome.Util.Padding import pad,unpad
import os
from datetime import datetime
import random
# safe key, trust
key = '00000000000000000000000000000000'
def gen_offset():
super_safe_seed = int(datetime.utcnow().timestamp())
random.seed(super_safe_seed)
return random.randint(1000,2000)
def encrypt(raw):
raw = pad(raw,16)
cipher = AES.new(key.encode('utf-8'), AES.MODE_[!garbled!])
return cipher.encrypt(raw)
def decrypt(enc):
cipher = AES.new(key.encode('utf-8'), AES.MODE_[!garbled!])
return unpad(cipher.decrypt(enc),16)
### encrypted past this point, sorry! | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2024/crypto/Protected_Console/cryptor.py | ctfs/PatriotCTF/2024/crypto/Protected_Console/cryptor.py | #!/usr/bin/python3
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from external import *
import socketserver, signal, json, os, re, sys
from io import StringIO
listen = 1337
attempts = 10000
flag = getflag()
guest = b"{'username':'guest_user','role':0}"
def encrypt(key,iv,message):
cipher = AES.new(key, AES.MODE_CBC, iv)
return cipher.encrypt(pad(message,16)).hex()
def ispadding(dec):
pad_b = dec[-2:]
pad_amt = int("0x"+pad_b,16)
valid = pad_b*pad_amt
padding = dec[len(dec)-(pad_amt*2):]
return valid==padding
def decrypt(key,token):
iv = bytes.fromhex(token[:32].decode())
ct = bytes.fromhex(token[32:].decode())
cipher = AES.new(key, AES.MODE_CBC, iv)
dec = cipher.decrypt(ct)
return dec
def admin(tries,req):
key = os.urandom(16)
iv = os.urandom(16)
eg = iv.hex()+encrypt(key,iv,b"print(1337)")
req.sendall(b"====================================================================================================\n")
req.sendall(b"|| ADMIN CONSOLE ||\n")
req.sendall(b"|| RUN ENCRYPTED PYTHON CODE HERE ||\n")
req.sendall(b"====================================================================================================\n")
req.sendall(b" Example: "+str.encode(str(eg))+b"\n")
while tries < attempts:
req.sendall(b'Code ('+str.encode(str(tries))+b'/'+str.encode(str(attempts))+b'): ')
c = req.recv(4096).strip(b'\n')
try:
code = decrypt(key,c)
if ispadding(code.hex()):
code = unpad(code,16)
if re.match(b"print\([0-9a-zA-Z]*\)",code) != None:
old_stdout = sys.stdout
sys.stdout = mystdout = StringIO()
try:
eval(code)
except Exception as e:
print(str(e))
sys.stdout = old_stdout
req.sendall(mystdout.getvalue().encode())
exit()
except:
pass
tries += 1
def serve(req):
tries = 0
req.sendall(b"====================================================================================================\n")
req.sendall(b"|| SECRET LOGIN ||\n")
req.sendall(b"|| AUTHORIZED PERSONNEL ONLY ||\n")
req.sendall(b"|| ||\n")
req.sendall(b"|| PROVIDE SECURE ACCESS TOKEN ||\n")
req.sendall(b"|| ||\n")
req.sendall(b"====================================================================================================\n")
key = os.urandom(16)
iv = os.urandom(16)
guest_enc = iv.hex()+encrypt(key,iv,guest)
req.sendall(b"Guest: "+str.encode(str(guest_enc))+b"\n")
while tries < attempts:
req.sendall(b'Access token ('+str.encode(str(tries))+b'/'+str.encode(str(attempts))+b'): ')
t = req.recv(4096).strip(b'\n')
try:
token = decrypt(key,t)
if ispadding(token.hex()):
token = unpad(token,16)
else:
req.sendall(b"Error!\n")
except Exception as e:
print(str(e))
tries += 1
continue
try:
data = json.loads(token)
if data['username'] == 'administrative_user' and data['role'] == 1:
admin(tries,req)
except:
pass
tries += 1
class incoming(socketserver.BaseRequestHandler):
def handle(self):
signal.alarm(1500)
req = self.request
serve(req)
def main():
socketserver.TCPServer.allow_reuse_address = True
server = ReusableTCPServer(("0.0.0.0", listen), incoming)
server.serve_forever()
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/PatriotCTF/2024/crypto/idk_cipher/encode.py | ctfs/PatriotCTF/2024/crypto/idk_cipher/encode.py |
import base64
"""
********************************************
* *
* *
********************************************
"""
# WARNING: This is a secret key. Do not expose it.
srt_key = 'secretkey' # // TODO: change the placeholder
usr_input = input("\t:"*10)
if len(usr_input) <= 1:
raise ValueError("PT must be greater than 1")
if len(usr_input) % 2 != 0:
raise ValueError("PT can only be an even number")
if not usr_input.isalnum():
raise ValueError("Only alphabets and numbers supported")
# WARNING: Reversing input might expose sensitive information.
rsv_input = usr_input[::-1]
output_arr = []
for i in range(int(len(usr_input) / 2)):
c1 = ord(usr_input[i])
c2 = ord(rsv_input[i])
enc_p1 = chr(c1 ^ ord(srt_key[i % len(srt_key)]))
enc_p2 = chr(c2 ^ ord(srt_key[i % len(srt_key)]))
output_arr.append(enc_p1)
output_arr.append(enc_p2)
# WARNING: Encoded text should not be decoded without proper authorization.
encoded_val = ''.join(output_arr)
b64_enc_val = base64.b64encode(encoded_val.encode())
R = "R"*20
E = "E"*5
EXCLAMATION = "!"*5
print(f"ULTRA SUPE{R} SECUR{E} Encoded Cipher Text{EXCLAMATION}:", b64_enc_val.decode())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2024/crypto/Hard_to_Implement/cryptor.py | ctfs/PatriotCTF/2024/crypto/Hard_to_Implement/cryptor.py | #!/usr/bin/python3
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from Crypto.Random import get_random_bytes
from external import *
import socketserver, signal
listen = 1337
attempts = 1500
flag = getflag()
def encrypt(key,plaintext):
cipher = AES.new(key, AES.MODE_ECB)
pt = pad(plaintext + flag.encode(), 16)
return cipher.encrypt(pt).hex()
def serve(req):
key = get_random_bytes(16)
tries = 0
req.sendall(b"Thank you for using our secure communications channel.\nThis channel uses top-shelf military-grade encryption.\nIf you are not the intended recepient, you can't read our secret.")
while tries < attempts:
req.sendall(b'\n('+str.encode(str(tries))+b'/'+str.encode(str(attempts))+b') ')
req.sendall(b'Send challenge > ')
try:
ct = encrypt(key, req.recv(4096).strip(b'\n'))
req.sendall(b"Response > " + ct.encode() + b'\n')
except Exception as e:
req.sendall(b"An error occured!\n")
tries += 1
req.sendall(b'\nMax attempts exceeded, have a good day.\n')
class incoming(socketserver.BaseRequestHandler):
def handle(self):
signal.alarm(1500)
req = self.request
serve(req)
def main():
socketserver.TCPServer.allow_reuse_address = True
server = ReusableTCPServer(("0.0.0.0", listen), incoming)
server.serve_forever()
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/PatriotCTF/2024/crypto/One_for_you_one_for_me/chal.py | ctfs/PatriotCTF/2024/crypto/One_for_you_one_for_me/chal.py | from flag import FLAG
import secrets
def share_bits_with_you(flag):
# Convert the flag to its binary representation
flag_bits = ''.join(f'{ord(c):08b}' for c in flag)
num_bits = len(flag_bits)
indices = list(range(num_bits))
# Fisher-Yates shuffle to mix up the bits
for i in range(num_bits - 1, 0, -1):
j = secrets.randbelow(i + 1)
indices[i], indices[j] = indices[j], indices[i]
# Split the bits: half for you, half for me :3
boyfriend_indices = indices[:num_bits // 2]
my_indices = indices[num_bits // 2:]
flipped_bits = list(flag_bits)
# You get your bits unchanged
for i in boyfriend_indices:
flipped_bits[i] = flag_bits[i]
# I keep my bits by flipping them, keeping them secret (tehe~)
for i in my_indices:
flipped_bits[i] = '1' if flag_bits[i] == '0' else '0'
# Combine the bits back into a string
flipped_flag = ''.join(flipped_bits)
# Convert the binary string to hexadecimal
hex_result = hex(int(flipped_flag, 2))[2:]
# Pad the hex result with zeros to ensure it matches the correct number of bits
hex_result = hex_result.zfill((num_bits + 3) // 4)
return hex_result
# Share the bits 1000000 times <3 <3 <3
for _ in range(1000000):
result = share_bits_with_you(FLAG)
print(result) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2024/crypto/Scrambler_V2/scramblerv2.py | ctfs/PatriotCTF/2024/crypto/Scrambler_V2/scramblerv2.py | import random as r
import datetime as dt
import time as t
import os
def main():
choice = ""
print(f"Welcome to the Scrambler V2, your one stop encryption tool.")
print(f"What would you like to do?\n")
while choice.lower() != "q":
menu()
choice = input(">>> ")
if choice == "1":
encrypt()
elif choice == "2":
decrypt()
elif choice.lower() == "q":
print(f"Scrambler V2 exiting...")
exit()
else:
print(f"Your choice ({choice}) is not a valid option.\n")
def menu():
print(f"[1] Encrypt file")
print(f"[2] Decrypt file")
print(f"[Q] Exit program\n")
def encrypt():
key, ts = generateKey(r.randint(0, 100), r.randint(0, 200), r.randint(546, 994))
try:
print(f"\nEnter name of file to encrypt:")
encFile = input(">>> ")
path = os.path.dirname(os.path.realpath(__file__))
end = f"\\{encFile}"
path = path + end
with open(path, "r") as f:
lines = f.readlines()
except FileNotFoundError as e:
print(f"The following error occurred: {e}\n")
except PermissionError as e:
print(f"The following error occurred: {e}\n")
except KeyboardInterrupt:
print(f"\nLeaving so soon? Don't you wanna stay???\n")
else:
r.shuffle(lines)
for index, line in enumerate(lines):
l = list(line)
r.shuffle(l)
lines[index] = "".join(l)
int(key) ^ int(key); str(key) + end
path = os.path.dirname(os.path.realpath(__file__))
path = path + "\\encryptedFlag.txt"
with open(path, "w") as o:
o.writelines(lines)
print(f"\nEncryption complete. Creating log file...")
path = os.path.dirname(os.path.realpath(__file__))
path = path + "\\encLog.txt"
with open(path, "w") as l:
l.writelines(f"Encrypted file name: encryptedFlag.txt\nEncyrption completed at {ts}\n")
print(f"Log file created. Have a nice day!\n")
def generateKey(iv, xor1, mod1):
now = dt.datetime.now()
key = now.strftime("%Y%m%d%H%M%S")
ts = f"{key[:4]}/{key[4:6]}/{key[6:8]} {key[8:10]}:{key[10:12]}:{key[12:]}"
int(key) ^ iv; r.seed(int(key)); int(key) ^ xor1; int(key) % mod1
return key, ts
def decrypt():
print(f"\nEnter name of file to decrypt:")
fileName = input(">>> ")
print(f"\nEnter decryption key:")
key = input(">>> ")
end = f"\\{fileName}"
path = os.path.dirname(os.path.realpath(__file__))
path = path + end
try:
with open(path, "r") as i:
lines = i.readlines()
iv: 1 = r.randint(r.randint(-20000, 0), r.randint(0, 20000))
xor1, mod1 = xor1[:] = [[]], []
iv = 0; xor1 = 0; mod1 = 99
except FileNotFoundError as e:
print(f"The following error occurred: {e}\n")
except PermissionError as e:
print(f"The following error occurred: {e}\n")
else:
print(f"Attempting to decrypt file...")
int(key) ^ iv; int(key) ^ xor1; int(key) % mod1
t.sleep(0.6); print(f"."); t.sleep(0.6); print(f"..")
t.sleep(0.6); print(f"..."); t.sleep(0.6)
print(f"Decryption failed.\n")
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/PatriotCTF/2024/crypto/Bit_by_Bit/transmit.py | ctfs/PatriotCTF/2024/crypto/Bit_by_Bit/transmit.py | #!/usr/bin/python3
import sys
blocksize = 16
def loadMessage():
message = ""
with open("message.txt","r",encoding='utf-8') as file:
for line in file:
message += line
while len(message) % blocksize != 0:
message += '0'
return message
def encode(chunk):
start = 120
encoded = 0
for c in chunk:
encoded = encoded | (ord(c)<<start)
start -= 8
return encoded
def transmit():
# Test key
key = 0xadbeefdeadbeefdeadbeef00
iv = 0
msg = loadMessage()
chunks = [msg[i:i+16] for i in range(0,len(msg), 16)]
send = ''
for chunk in chunks:
iv = (iv+1) % 255
curr_k = key+iv
encoded = encode(chunk)
enc = encoded ^ curr_k
foo = hex(enc)[2:]
while len(foo) != 32:
foo = '0'+foo
send += foo
print(send)
sys.exit(0)
if __name__=="__main__":
transmit()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2024/crypto/Textbook_Schnorr_right/chall.py | ctfs/PatriotCTF/2024/crypto/Textbook_Schnorr_right/chall.py | from sage.all import *
import secrets
import hashlib
import sys
import signal
import re
class EllipticCurveCrypto:
"""
Elliptic Curve Cryptography using the secp256k1 curve.
"""
def __init__(self):
self.p = [<REDACTED>]
self.q = [<REDACTED>]
self.K = GF(self.p)
self.a = self.K([<REDACTED>])
self.b = self.K([<REDACTED>])
self.curve = EllipticCurve(self.K, [self.a, self.b])
self.generator = self.curve(
[<REDACTED>],
[<REDACTED>],
)
# Generate private and public keys
self.private_key = secrets.randbelow(self.q)
self.public_key = self.private_key * self.generator
print(f"Public Key: {self.public_key}")
@staticmethod
def bytes_to_int(b):
return int.from_bytes(b, byteorder='big')
@staticmethod
def int_to_bytes(i):
return i.to_bytes((i.bit_length() + 7) // 8, byteorder='big')
def compute_hash(self, target):
hash_int = int(hashlib.sha256(str(target).encode()).hexdigest(), 16)
return hash_int % self.q
def sign(self, message):
r = secrets.randbelow(self.q)
R = r * self.generator
R_int = int(R.xy()[0] + R.xy()[1])
h = self.compute_hash(R_int | message)
s = (r + self.private_key * h) % self.q
return s, R
def verify(self, message, signature):
s, R = signature
R_int = int(R.xy()[0] + R.xy()[1])
h = self.compute_hash(R_int | message)
left_side = s * self.generator
right_side = R + h * self.public_key
return left_side == right_side
class TimeoutInput:
class TimeoutError(Exception):
"""Custom exception for input timeout."""
pass
@staticmethod
def timeout_handler(signum, frame):
raise TimeoutInput.TimeoutError("Input timed out!")
@staticmethod
def get_input(prompt, timeout=10):
"""
Get user input with a timeout.
:param prompt: The prompt to display to the user.
:param timeout: The time limit for input in seconds.
:return: The user's input as a string.
"""
# Set the signal for a timeout
signal.signal(signal.SIGALRM, TimeoutInput.timeout_handler)
signal.alarm(timeout)
try:
user_input = input(prompt)
signal.alarm(0) # Cancel the timer
return user_input
except TimeoutInput.TimeoutError:
print("No input received within the time limit.")
sys.exit(0)
def display_flag():
"""Read and display the flag from the 'flag.txt' file."""
try:
with open('flag.txt', 'r') as f:
flag = f.read().strip()
print(f"Congratulations! Your flag is: {flag}")
except FileNotFoundError:
print("Flag file not found.")
def verify_message(separator, words, signature, ecc_instance):
"""
Verify the provided signature for the message constructed from words and separator.
"""
message_bytes = separator.join(word.encode() for word in words) + separator
message_int = int.from_bytes(message_bytes, byteorder='big')
if ecc_instance.verify(message_int, signature):
display_flag()
sys.exit(0)
else:
print("Verification failed.")
sys.exit(0)
def main():
# Initialize the elliptic curve cryptography instance
ecc = EllipticCurveCrypto()
# Test the signing and verification process
test_message = ecc.bytes_to_int("test".encode())
s_test, R_test = ecc.sign(test_message)
assert ecc.verify(test_message, (s_test, R_test))
# Regular expression patterns for input validation
separator_pattern = re.compile(r'^[0-9a-fA-F]{2}$')
word_pattern = re.compile(r'^[0-9a-fA-F]{6}$')
# Get separator input
separator_hex = TimeoutInput.get_input("Enter separator as a hex value (2 digits): ")
if not separator_pattern.match(separator_hex):
print("Invalid separator format.")
sys.exit(0)
separator = bytes.fromhex(separator_hex)
# Get words input
words_hex = []
for i in range(8):
prompt = f"Enter 3-letter word {i + 1} as a hex value (6 digits): "
word_hex = TimeoutInput.get_input(prompt)
if not word_pattern.match(word_hex):
print("Invalid word format.")
sys.exit(0)
words_hex.append(word_hex)
try:
words = [bytes.fromhex(word_hex).decode('ascii') for word_hex in words_hex]
except ValueError:
print("Invalid ASCII encoding in words.")
sys.exit(0)
if any(len(word) != 3 for word in words):
print("Words must be 3-letter ASCII words.")
sys.exit(0)
# Get signature components
try:
hex_x_R = input("Enter the x-coordinate of signature R (in hex): ")
x_R = int(hex_x_R, 16)
hex_y_R = input("Enter the y-coordinate of signature R (in hex): ")
y_R = int(hex_y_R, 16)
hex_signature_s = input("Enter signature s (in hex): ")
signature_s = int(hex_signature_s, 16)
except ValueError:
print("Invalid input for signature components.")
sys.exit(0)
if not (0 < signature_s < ecc.q):
print("Illegal value of s.")
sys.exit(0)
# Construct the point R
try:
R = ecc.curve(x_R, y_R)
except ValueError:
print("Point R does not lie on the curve.")
sys.exit(0)
# Verify the message and signature
verify_message(separator, words, (signature_s, R), ecc)
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/PatriotCTF/2024/web/Impersonate/app.py | ctfs/PatriotCTF/2024/web/Impersonate/app.py | #!/usr/bin/env python3
from flask import Flask, request, render_template, jsonify, abort, redirect, session
import uuid
import os
from datetime import datetime, timedelta
import hashlib
app = Flask(__name__)
server_start_time = datetime.now()
server_start_str = server_start_time.strftime('%Y%m%d%H%M%S')
secure_key = hashlib.sha256(f'secret_key_{server_start_str}'.encode()).hexdigest()
app.secret_key = secure_key
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(seconds=300)
flag = os.environ.get('FLAG', "flag{this_is_a_fake_flag}")
secret = uuid.UUID('31333337-1337-1337-1337-133713371337')
def is_safe_username(username):
"""Check if the username is alphanumeric and less than 20 characters."""
return username.isalnum() and len(username) < 20
@app.route('/', methods=['GET', 'POST'])
def main():
"""Handle the main page where the user submits their username."""
if request.method == 'GET':
return render_template('index.html')
elif request.method == 'POST':
username = request.values['username']
password = request.values['password']
if not is_safe_username(username):
return render_template('index.html', error='Invalid username')
if not password:
return render_template('index.html', error='Invalid password')
if username.lower().startswith('admin'):
return render_template('index.html', error='Don\'t try to impersonate administrator!')
if not username or not password:
return render_template('index.html', error='Invalid username or password')
uid = uuid.uuid5(secret, username)
session['username'] = username
session['uid'] = str(uid)
return redirect(f'/user/{uid}')
@app.route('/user/<uid>')
def user_page(uid):
"""Display the user's session page based on their UUID."""
try:
uid = uuid.UUID(uid)
except ValueError:
abort(404)
session['is_admin'] = False
return 'Welcome Guest! Sadly, you are not admin and cannot view the flag.'
@app.route('/admin')
def admin_page():
"""Display the admin page if the user is an admin."""
if session.get('is_admin') and uuid.uuid5(secret, 'administrator') and session.get('username') == 'administrator':
return flag
else:
abort(401)
@app.route('/status')
def status():
current_time = datetime.now()
uptime = current_time - server_start_time
formatted_uptime = str(uptime).split('.')[0]
formatted_current_time = current_time.strftime('%Y-%m-%d %H:%M:%S')
status_content = f"""Server uptime: {formatted_uptime}<br>
Server time: {formatted_current_time}
"""
return status_content
if __name__ == '__main__':
app.run("0.0.0.0", port=9999)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2024/web/Open_Seasame/server.py | ctfs/PatriotCTF/2024/web/Open_Seasame/server.py | from flask import Flask, request
import uuid, subprocess
app = Flask(__name__)
SECRET = open("secret.txt", "r").read()
stats = []
@app.route('/', methods=['GET'])
def main():
return 'Hello, World!'
@app.route('/api/stats/<string:id>', methods=['GET'])
def get_stats(id):
for stat in stats:
if stat['id'] == id:
return str(stat['data'])
return '{"error": "Not found"}'
@app.route('/api/stats', methods=['POST'])
def add_stats():
try:
username = request.json['username']
high_score = int(request.json['high_score'])
except:
return '{"error": "Invalid request"}'
id = str(uuid.uuid4())
stats.append({
'id': id,
'data': [username, high_score]
})
return '{"success": "Added", "id": "'+id+'"}'
@app.route('/api/cal', methods=['GET'])
def get_cal():
cookie = request.cookies.get('secret')
if cookie == None:
return '{"error": "Unauthorized"}'
if cookie != SECRET:
return '{"error": "Unauthorized"}'
modifier = request.args.get('modifier','')
return '{"cal": "'+subprocess.getoutput("cal "+modifier)+'"}'
if __name__ == "__main__":
app.run(host='0.0.0.0', port=1337, threaded=True) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2023/misc/ML_Pyjail/MLjail/app.py | ctfs/PatriotCTF/2023/misc/ML_Pyjail/MLjail/app.py | #!/usr/bin/env python3
from mlmodel import endpoint
WARNING = '\033[93m'
ERROR = '\033[91m'
END = '\033[0m'
if __name__ == "__main__":
while True:
user_input = input(">>> ")
classification = endpoint.classify_local(user_input)
if len(classification) == 0:
print(f"{WARNING}Cannot verify...{END}")
continue
intent = dict(classification[0]).get('intent')
if intent == None: continue
try:
if intent == 'good_code':
exec(user_input)
else:
print(f"{ERROR}Bad Code Detected...{END}")
except Exception as e:
print(f"Oops, something broke: \n{ERROR}{e}{END}")
pass
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2023/misc/ML_Pyjail/MLjail/mlmodel/endpoint.py | ctfs/PatriotCTF/2023/misc/ML_Pyjail/MLjail/mlmodel/endpoint.py | import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import numpy
from nltk.stem.lancaster import LancasterStemmer
import nltk
import tensorflow as tf
tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
import tflearn
import pickle
stemmer = LancasterStemmer()
curr_path = os.path.dirname(__file__)
parent_dir = os.path.dirname(curr_path) # Get the parent directory
training_data_path = os.path.join(
parent_dir, 'training_data') # training_data folder
data_pickle_path = os.path.join(training_data_path, 'data.pickle')
tflearn_model_path = os.path.join(training_data_path, 'model.tflearn')
with open(data_pickle_path, "rb") as f:
words, labels, training, output = pickle.load(f)
tf.compat.v1.reset_default_graph()
net = tflearn.input_data(shape=[None, len(training[0])])
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, len(output[0]), activation="softmax")
net = tflearn.regression(net)
model = tflearn.DNN(net)
model.load(tflearn_model_path)
def bow(s, words):
bag = [0 for _ in range(len(words))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) for word in s_words]
for se in s_words:
for i, w in enumerate(words):
if w == se:
bag[i] = 1
return numpy.array(bag)
def classify_local(user_input):
ERROR_THRESHOLD = 0.25
# generate probabilities from the model
results = model.predict([bow(user_input, words)])[0]
# filter out predictions below a threshold, and provide intent index
results = [[i, r] for i, r in enumerate(results) if r > ERROR_THRESHOLD]
# sort by strength of probability
results.sort(key=lambda x: x[1], reverse=True)
return_list = []
for r in results:
return_list.append({"intent": labels[r[0]], "probability": str(r[1])})
# return tuple of intent and probability
return return_list
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2023/rev/Python_Garbage_Compiler/garbage.py | ctfs/PatriotCTF/2023/rev/Python_Garbage_Compiler/garbage.py | import string # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+++++.++++.+++.-.+++.++.<<++.>>-.+.--.---------.+++++.-------.
from random import * # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.++++++++++++.---.--.<<++.>>+++++.-----------------.+++++++++++++.----------.+++++++++++.--.<<.>>----.++++.+++.-.+++.++.<<.++++++++++.
def finalstage(w): # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>.+.+.<<++.>>.+++.+++++.-------------.+++++++++++.+++++++.+.-------------------.++++++.--.<<++++++++.>>++++++++++++++++++.<<+.>------------.
h=0 # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++.<---------.-------------.
w = list(w) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+++++++++++++++++++.<<++.>---------.<.>>-----------.---.++++++++++.+.<<++++++++.>>+++.<<+.
w.reverse() # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+++++++++++++++++++.<<++++++++++++++++.>>-----.-------------.+++++++++++++++++.-----------------.+++++++++++++.+.--------------.<<------.+.
w = "".join(g for g in w) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+++++++++++++++++++.<<++.>---------.<.++..++++++++++++.>>-------------.+++++.------.+++++.<<------.>>-------.<<--------.>>-.+++++++++.+++.<<.>>-----------.<<.>>++.+++++.<<.>>+++++++++.<<+++++++++.
flag = 'flag'.replace('flag', 'galf').replace('galf', '') # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.++++++.-----------.++++++.<<++.>---------.<.+++++++.>>-.++++++.-----------.++++++.<<.+++++++.>>+++++++++++.-------------.+++++++++++.----.-----------.++.++.<<------.-.>>+.++++++.-----------.++++++.<<.+++++.------------.+++++++.>>.------.+++++++++++.------.<<.++.+++++.>>++++++++++++.-------------.+++++++++++.----.-----------.++.++.<<------.-.>>++.------.+++++++++++.------.<<.+++++.------------.+++++++..++.
while h < len(w): # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+++++++++++++++++++.---------------.+.+++.-------.<<++.>>+++.<<.>----------.<.>>++++.-------.+++++++++.<<++++++++.>>+++++++++.<<+.>--.
try: # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++++++.--.+++++++.<------------.
flag += w[h+1] + w[h] # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.++++++.-----------.++++++.<<++.+++++++++++.>---------.<-----------.>>++++++++++++++++.----------------------------.+++++++++++++.<<+++++++++++.++++++.>>-----------.<<-----------------.+++++++++++.-----------.>>++++++++++++++++++++++++++.----------------------------.+++++++++++++.-----------.
except: # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+.+++++++++++++++++++.---------------------.++.+++++++++++.++++.<------------.
flag += w[h] # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.++++++.-----------.++++++.<<++.+++++++++++.>---------.<-----------.>>++++++++++++++++.----------------------------.+++++++++++++.-----------.
h+=2 # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++.<<+++++++++++++.>---------.<+++++++.
print("Final Stage complete") # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++.++.---------.+++++.++++++.<<++++++++++.------.>.>-----------.+++++.-------------.+++++++++++.<<--.>+++++++++++++.>++++++++.<++++++++++++++.++++++.--.<.>--.>-----.--.+++.----.<++.>++++++++.<.<++.+++++++.
return flag # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++++.-------------.+++++++++++++++.+.---.----.<<++.>>--------.++++++.-----------.++++++.
def stage2(b): # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>.+.+.<<++.>>+++++++++++++.+.-------------------.++++++.--.<<++++++++++++++++++.----------.>>---.<<+.>------------.
t = "++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.++++++.-----------.++++++."[-15:(7*9)].strip('-') # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++++++.<<++.>---------.<.++.+++++++++..........>>-------------------------.<+.<.>.<...>.<.......>.<..........>--....<++.>>++.<++....<--..+++.---......+++.-...........+.---......+++.------------.>>--.<<+++++++++++.++++.++++.>----.<-------------.>---.<++.>++.<-.>>++.<<+++++.>>++++++++++++++++++++++.+.--.---------.+++++++.<<------.-.++++++.------.++.
for q in range(len(b)): # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.+++++++++.+++.<<++.>>-.<<.>>--------.+++++.<<.>>++++.-----------------.+++++++++++++.-------.--.<<++++++++.>>+++++++.-------.+++++++++.<<.>>------------.<<+..>------------.
t += chr(ord(b[q])-randint(0,5)) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++++++.<<++.+++++++++++.>---------.<-----------.>>-----------------.+++++.++++++++++.<<++++++++.>>---.+++.--------------.<<.>>--.-------.++++++++++++++++++++++.--------------------.<<+.++++.>>+++++++++++++++++++++.-----------------.+++++++++++++.----------.+++++.+++++.++++++.<<-----.++++++++.----.>--------.<---..
print("Stage 2 complete") # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++.++.---------.+++++.++++++.<<++++++++++.------.>+++++++++++++.>.<++++++++++++++.++++++.--.<--.++++++++++++++++++.------------------.>--.>-----.--.+++.----.<++.>++++++++.<.<++.+++++++.
flag = finalstage(t) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.++++++.-----------.++++++.<<++.>---------.<.>>-.+++.+++++.-------------.+++++++++++.+++++++.+.-------------------.++++++.--.<<++++++++.>>+++++++++++++++.<<+.
return flag # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++++.-------------.+++++++++++++++.+.---.----.<<++.>>--------.++++++.-----------.++++++.
def stage1(a): # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>.+.+.<<++.>>+++++++++++++.+.-------------------.++++++.--.<<+++++++++++++++++.---------.>>----.<<+.>------------.
a = list(a) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>---.<<++.>---------.<.>>+++++++++++.---.++++++++++.+.<<++++++++.>>-------------------.<<+.
b = list(string.ascii_lowercase) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>--.<<++.>---------.<.>>++++++++++.---.++++++++++.+.<<++++++++.>>-.+.--.---------.+++++.-------.<<++++++.>>------.++++++++++++++++++.----------------.++++++..----------.+++++++++++++.+++.++++++++.------------------.+++++++++++++.---------------.--.++++++++++++++++++.--------------.<<-----.
for o in range(len(a)): # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.+++++++++.+++.<<++.>>---.<<.>>------.+++++.<<.>>++++.-----------------.+++++++++++++.-------.--.<<++++++++.>>+++++++.-------.+++++++++.<<.>>-------------.<<+..>------------.
a[o] = chr(ord(a[o])^o) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>---.------.++++++++++++++++++++.------------------.<<++.>---------.<.>>++++++.+++++.++++++++++.<<++++++++.>>---.+++.--------------.<<.>>---.------.++++++++++++++++++++.------------------.<<+.>>+.+++++++++++++++++.<<
z = "".join(x for x in a) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++++++++++++.<<++.>---------.<.++..++++++++++++.>>----------------.+++++.------.+++++.<<------.>>++++++++++.<<--------.>>------------------.+++++++++.+++.<<.>>++++++.<<.>>---------------.+++++.<<.>>-------------.<<+++++++++.
for y in range(len(z)): # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.+++++++++.+++.<<++.>>+++++++.<<.>>----------------.+++++.<<.>>++++.-----------------.+++++++++++++.-------.--.<<++++++++.>>+++++++.-------.+++++++++.<<.>>++++++++++++.<<+..>------------.
b[y%len(b)] = chr((ord(z[y])^ord(a[y]))+len(b)) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>--.-------.++++++++++++++++++++++++++++++.<<+++++++.>>-------------.-------.+++++++++.<<+++.>>------------.<<+.>>-----.<<---------.>---------.<.>>++++++.+++++.++++++++++.<<++++++++..>>---.+++.--------------.<<.>>++++++++++++++++++++++.<++++++++++++++++++++++++++++++.>-.<++.<+.>+.>----------.+++.<++++++.<-.>---.------.>+++++++.<++.<+..++.>>-------------.-------.+++++++++.<<---.>+++++.<+..
print("Stage 1 complete") # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++.++.---------.+++++.++++++.<<++++++++++.------.>+++++++++++++.>.<++++++++++++++.++++++.--.<--.+++++++++++++++++.-----------------.>--.>-----.--.+++.----.<++.>++++++++.<.<++.+++++++.
flag = stage2(z) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.++++++.-----------.++++++.<<++.>---------.<.>>++++++++++++.+.-------------------.++++++.--.<-----------.<++++++++.>>+++++++++++++++++++++.<<+.
return flag # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++++.-------------.+++++++++++++++.+.---.----.<<++.>>--------.++++++.-----------.++++++.
def entry(f): # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>.+.+.<<++.>>-.+++++++++.++++++.--.+++++++.<<++++++++.>>-------------------.<<+.>------------.
seed(10) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+++++++++++++++.--------------..-.<<++++++++++.+++++++++.-.-------.
f = list(f) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.<<++.>---------.<.>>++++++.---.++++++++++.+.<<++++++++.>>--------------.<<+.
f.reverse() # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.<<++++++++++++++++.>>++++++++++++.-------------.+++++++++++++++++.-----------------.+++++++++++++.+.--------------.<<------.+.
f = "".join(i for i in f) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.<<++.>---------.<.++..++++++++++++.>>++++.+++++.------.+++++.<<------.>>-----.<<--------.>>---.+++++++++.+++.<<.>>---------.<<.>>.+++++.<<.>>--------.<<+++++++++.
print("Entry complete") # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++.++.---------.+++++.++++++.<<++++++++++.------.>-.>------.++++++.--.+++++++.<<--.>>----------------------.++++++++++++.--.+++.----.-------.+++++++++++++++.---------------.<<++.+++++++.
flag = stage1(f) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.++++++.-----------.++++++.<<++.>---------.<.>>++++++++++++.+.-------------------.++++++.--.<------------.<++++++++.>>+.<<+.
return flag # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++++.-------------.+++++++++++++++.+.---.----.<<++.>>--------.++++++.-----------.++++++.
if __name__ == '__main__':# ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+++++.---.<<++.>>-------..+++++++++++++++.-------------.++++++++++++.--------.------..<<.>---------..<.+++++++.>>..++++++++++++++.------------.++++++++.+++++.---------------..<<.>---.
input = entry(input("Enter Flag: ")) # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+++++.+++++.++.+++++.-.<<++.>---------.<.>>---------------.+++++++++.++++++.--.+++++++.<<++++++++.>>----------------.+++++.++.+++++.-.<<.------.>++++++++.>------.++++++.---------------.+++++++++++++.<<--.>+.>------.-----------.++++++.<------------.<.++.+++++++..
flag = open('output.txt', 'r').readlines()[0] # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++.++++++.-----------.++++++.<<++.>---------.<.>>++++++++.+.-----------.+++++++++.<<++++++++.-.>>+.++++++.-.----.+++++.-.<<+++++++.>>.++++.----.<<-------.+++++.------------.+++++++.>>--.<<.++.+++++.>>.-------------.----.+++.++++++++.---.+++++.---------.++++++++++++++.<<------.+.>>------------------------.<<+++++++.>>++.
if input == flag: # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+++++.---.<<++.>>+++.+++++.++.+++++.-.<<.>---------..<.>>--------------.++++++.-----------.++++++.<---.
print("What... how?") # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++.++.---------.+++++.++++++.<<++++++++++.------.>+++++++++++++++++.>------------.-------.+++++++++++++++++++.<<++++++++++++...--------------.>>------------.+++++++.++++++++.<------------------------.<++.+++++++.
print("I guess you broke my 'beautiful' code :(") # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++.++.---------.+++++.++++++.<<++++++++++.------.>+++.<--.>>-------------.++++++++++++++.----------------.++++++++++++++..<<.>>++++++.----------.++++++.<<.>>-------------------.++++++++++++++++.---.----.------.<<.>>++++++++.++++++++++++.<<.+++++++.>>-----------------------.+++.----.++++++++++++++++++++.-.-----------.---.+++++++++++++++.---------.<<.-------.>>---------.++++++++++++.-----------.+.<<.>---------------.<++++++++.------.+++++++.
else: # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>+.+++++++.+++++++.--------------.<------------.
print("haha, nope. Try again!") # ++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++.++.---------.+++++.++++++.<<++++++++++.------.>>------------.-------.+++++++.-------.<<++++++++++.------------.>>+++++++++++++.+.+.-----------.<<++++++++++++++.--------------.>++++++++++++++.>+++++++++++++.+++++++.<<.>+++++++++++++.++++++.------.++++++++.+++++.<+.+.+++++++.
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2023/rev/Python_XOR/XOR.py | ctfs/PatriotCTF/2023/rev/Python_XOR/XOR.py | from string import punctuation
alphabet = list(punctuation)
data = "bHEC_T]PLKJ{MW{AdW]Y"
def main():
# For loop goes here
key = ('')
decrypted = ''.join([chr(ord(x) ^ ord(key)) for x in data])
print(decrypted)
main() | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2025/crypto/Cipher_from_Hell/encryptor.py | ctfs/PatriotCTF/2025/crypto/Cipher_from_Hell/encryptor.py | import math, sys
inp = input("Enter your flag... ").encode()
s = int.from_bytes(inp)
o = (
(6, 0, 7),
(8, 2, 1),
(5, 4, 3)
)
c = math.floor(math.log(s, 3))
if not c % 2:
sys.stderr.write("Error: flag length needs to be even (hint: but in what base system?)!\n")
sys.exit(1)
ss = 0
while c > -1:
ss *= 9
ss += o[s//3**c][s%3]
s -= s//3**c*3**c
s //= 3
c -= 2
open("encrypted", 'wb').write(ss.to_bytes(math.ceil(math.log(ss, 256)), byteorder='big')) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2025/crypto/Vibe_Bank_Vault/vibe_vault.py | ctfs/PatriotCTF/2025/crypto/Vibe_Bank_Vault/vibe_vault.py | #!/usr/bin/env python3
"""
Vibe Bank Vault - CTF Challenge
A secure vault built by an intern who "vibe coded" the security layers.
"""
import base64
import sys
import time
import random
import string
import os
import bcrypt
_STATIC_SALT = b"$2b$12$C8YQMlqDyz3vGN9VOGBeGu"
def vibe_hash(data: str) -> str:
"""Internal hash helper."""
payload = data.encode('utf-8')
portion = payload[: len(payload) % 256]
digest = bcrypt.hashpw(portion, _STATIC_SALT)
return f"vb$1${base64.b64encode(digest).decode()}"
# -----------------------------------------------------------------------------
# CHALLENGE CLASS
# -----------------------------------------------------------------------------
class VibeBankVault:
def __init__(self):
self.levels = {
1: self.level_1,
2: self.level_2,
3: self.level_3,
4: self.level_4,
5: self.level_5
}
self.final_flag = os.getenv("FLAG", "CTF{test_flag}")
self.secret = ''.join(random.choices(string.ascii_letters + string.digits, k=140))
self.leak_len = len(self.secret) // 2
self._aux_token = self._prime_channel()
def send(self, msg):
print(msg, flush=True)
def receive(self, timeout=None):
try:
data = sys.stdin.readline()
if not data:
return None
return data.strip()
except Exception:
return None
def _prime_channel(self):
primary = (self.secret + "#SYNC1").encode()
shadow = (self.secret + "#SYNC2").encode()
token = bcrypt.hashpw(primary, bcrypt.gensalt())
return token if bcrypt.checkpw(shadow, token) else None
def _token_accepts(self, candidate: str) -> bool:
if not self._aux_token:
return False
try:
return bcrypt.checkpw(candidate.encode(), self._aux_token)
except Exception:
return False
def run(self):
self.send("""
╔════════════════════════════════════════════════╗
║ X CORP - VIBE BANK VAULT ║
║ "Security through Good Vibes" ║
╚════════════════════════════════════════════════╝
Our new intern Kevin built this 5-layer vault.
He says it's "unhackable" because he used a custom
hashing algorithm he vibe coded it.
Can you break in?
""")
for level in range(1, 6):
self.send(f"\n[🔒] ENTERING VAULT LAYER {level}...")
time.sleep(0.2)
if not self.levels[level]():
self.send("\n[⛔] ACCESS DENIED. The vault slams shut.")
return
self.send(f"\n[✅] LAYER {level} CLEARED!")
time.sleep(0.2)
self.send(f"\n[🏆] CONGRATULATIONS! You have completely compromised the Vibe Bank!")
self.send(f"[*] Here is your reward: {self.final_flag}")
self.send("[*] Kevin has been fired.")
# -------------------------------------------------------------------------
# LEVELS
# -------------------------------------------------------------------------
def level_1(self):
"""
Level 1:
"""
leaked_part = self.secret[:self.leak_len]
target_hash = vibe_hash(self.secret)
self.send("""
Layer 1: The Lobby
Kevin generated a secure random password.
But the sticky note on his monitor shows the first half...
""")
self.send(f"Leaked Note: {leaked_part}")
self.send(f"Target Hash: {target_hash}")
self.send("""
Recover the missing bytes and provide a valid password.
""")
self.send("Enter password: ")
user_input = self.receive(timeout=None)
if not user_input: return False
if vibe_hash(user_input) == target_hash:
return True
else:
self.send("[-] Hash mismatch.")
return False
def level_2(self):
"""
Level 2
"""
# Randomized prefix
rand_suffix = ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
prefix = f"vibe_{rand_suffix}_"
self.send(f"""
Layer 2: The Teller
To get past the teller, you need to prove it!
I'll give you a prefix: '{prefix}'
Send me TWO DIFFERENT strings that start with this prefix....
Format: string1,string2
""")
user_input = self.receive()
if not user_input or ',' not in user_input:
self.send("[-] Invalid format. Use: str1,str2")
return False
s1, s2 = user_input.split(',', 1)
s1, s2 = s1.strip(), s2.strip()
if not s1.startswith(prefix) or not s2.startswith(prefix):
self.send(f"[-] Both strings must start with '{prefix}'")
return False
if s1 == s2:
self.send("[-] Strings must be different.")
return False
if vibe_hash(s1) == vibe_hash(s2):
return True
else:
self.send("[-] Hashes do not match.")
return False
def level_3(self):
"""
Level 3
"""
target_len = random.randint(300, 500)
self.send(f"""
Layer 3: The Manager's Office
The manager's password is very long ({target_len} 'B's).
The system only sees what it wants to see.
Provide a password of 'B's that matches the system's perceived password.
""")
expected_hash = vibe_hash("B" * target_len)
self.send("Enter the equivalent password: ")
user_input = self.receive()
if not user_input: return False
if len(user_input) == target_len:
self.send("[-] That won’t work.”")
return False
if vibe_hash(user_input) == expected_hash:
return True
else:
self.send(f"[-] Failed.")
return False
def level_4(self):
"""
Level 4
"""
pad_len = random.choice([52, 56, 60])
emoji_count = random.randint(3, 6)
self.send(f"""
Layer 4: The Server Room
The target password is: {pad_len} 'C's + {emoji_count} '🔥' emojis.
Something seems off…
Send me the another password that works.
""")
target = "C" * pad_len + "🔥" * emoji_count
target_hash = vibe_hash(target)
self.send("Enter password: ")
user_input = self.receive()
if not user_input: return False
if len(user_input.encode()) > 72:
self.send("[-] I asked for the SHORTEST one (max 72 bytes)!")
return False
if vibe_hash(user_input) == target_hash:
return True
else:
self.send("[-] Hash mismatch.")
return False
def level_5(self):
"""
Level 5
"""
prefix = "XCORP_VAULT_ADMIN"
admin_pw_len = random.randint(200, 300)
total_len = len(prefix) + admin_pw_len
wrap_val = total_len % 256
self.send(f"""
Layer 5: The Vault Door
Administrator handshake in effect.
ID: "{prefix}"
SecretPassword: {admin_pw_len} 'X' characters.
Total Length = {total_len} bytes.
The math is a bit... circular.
Authenticate as admin.
Input your password:
""")
admin_pw = "X" * admin_pw_len
admin_combined = prefix + admin_pw
admin_hash = vibe_hash(admin_combined)
user_input = self.receive()
if not user_input: return False
user_combined = prefix + user_input
user_hash = vibe_hash(user_combined)
if self._token_accepts(user_input):
self.send("[*] Access synchronized.")
return True
if user_hash == admin_hash:
return True
else:
self.send(f"[-] Access Denied.")
return False
if __name__ == "__main__":
VibeBankVault().run()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2022/crypto/ExtremelyCoolBook/server.py | ctfs/PatriotCTF/2022/crypto/ExtremelyCoolBook/server.py | import sys
import socketserver
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
KEY = get_random_bytes(16)
FLAG = "real_flag_is_defined_here"
def encrypt(username,req):
cipher = AES.new(KEY, AES.MODE_ECB)
message = f"{username}, here is your top secret access code for today: {FLAG}"
pad = 16 - (len(message) % 16)
plaintext = message + (chr(pad)*pad)
return cipher.encrypt(plaintext.encode()).hex().encode()
def validate(req):
req.sendall(b'Please input your username to verify your identity. \n~> ')
username = req.recv(256).decode('ascii')
if username.split("\n")[0] == "admin":
enc_message = encrypt(username,req)
req.sendall(b'\n' + b'-' * 64 + b'\n')
req.sendall(b"Here is you encrypted message:\n\n")
req.sendall(enc_message + b'\n')
return True
return False
class RequestHandler(socketserver.StreamRequestHandler):
def handle(self):
result = validate(self.request)
if result is False:
self.request.sendall(b'Invalid username.\n')
class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
if __name__ == '__main__':
host, port = 'chal2.pctf.competitivecyber.club', 10000
sys.stderr.write('Listening {}:{}\n'.format(host, port))
server = ThreadedTCPServer((host, port), RequestHandler)
ThreadedTCPServer.allow_reuse_address = True
ThreadedTCPServer.allow_reuse_port = True
server.serve_forever() | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2022/crypto/Cryptogod/server.py | ctfs/PatriotCTF/2022/crypto/Cryptogod/server.py | import sys
import socketserver
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from Crypto.Random import get_random_bytes
FLAG = "real_flag_is_defined_here"
KEY = get_random_bytes(16)
BS = AES.block_size
IV = b'\x00' * BS
def encrypt(username):
if not isinstance(username, bytes):
username = username.encode()
pt = pad(username, BS)
tag = AES.new(KEY, AES.MODE_CBC, iv=IV).encrypt(pt)
if len(tag) > 16:
tag = tag[-16:]
return tag.hex()
def admit_new_cryptogod(username):
cryptogods.append(username)
MASTER_KEY = encrypt("cryptogodadministrator")
cryptogods = ["cryptogodadministrator"]
class RequestHandler(socketserver.StreamRequestHandler):
def handle(self):
req = self.request
stop = False
req.sendall(b'To be accepted into the sect of the crypto gods, give us a username that will encrypt to ' + MASTER_KEY.encode() + b'\n~> ')
username = req.recv(256)
try:
username = username.decode('ascii')
if username in cryptogods:
req.sendall(b'\n' + b'-' * 48 + b'\n\n')
req.sendall(b"That username already belongs to a crypto god!\n")
stop = True
except:
pass
finally:
if not stop:
if encrypt(username) != MASTER_KEY:
req.sendall(b'\n' + b'-' * 48 + b'\n\n')
req.sendall(b"You are not a crypto god it seems...\n")
else:
admit_new_cryptogod(username)
req.sendall(b'\n' + b'-' * 48 + b'\n\n')
req.sendall(FLAG.encode() + b"\n")
else:
pass
class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
if __name__ == '__main__':
host, port = 'chal2.pctf.competitivecyber.club', 10001
sys.stderr.write('Listening {}:{}\n'.format(host, port))
server = ThreadedTCPServer((host, port), RequestHandler)
ThreadedTCPServer.allow_reuse_address = True
ThreadedTCPServer.allow_reuse_port = True
server.serve_forever() | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2022/crypto/Merkle-Derkle/main.py | ctfs/PatriotCTF/2022/crypto/Merkle-Derkle/main.py | import ast
import string
import random
from hashlib import sha1
from flask import render_template, request, flash, make_response
from app import app
letters = string.ascii_letters
secret = ''.join(random.choice(letters) for i in range(random.randint(15,35)))
def new_user():
user = "admin=False"
data = secret + user
mac = sha1(data.encode()).hexdigest()
cookie_val = user.encode().hex() + "." + mac
return cookie_val
def validate(cookie):
user_hex = cookie.split(".")[0]
user = bytes.fromhex(user_hex)
data = secret.encode() + user
cookie_mac = cookie.split(".")[1]
if cookie_mac != sha1(data).hexdigest():
raise Exception("MAC does not match!")
return ast.literal_eval(user.split(b"=")[-1].decode())
@app.route("/", methods=["GET"])
def base():
if not request.cookies.get('auth'):
resp = make_response(render_template('index.html'))
resp.set_cookie('auth', new_user())
return resp
else:
try:
admin = validate(request.cookies.get('auth'))
except Exception as e:
flash(str(e), 'danger')
return render_template('index.html')
if admin:
return render_template('admin.html')
else:
return render_template('index.html')
if __name__ == "__main__":
app.run(debug=False, host='0.0.0.0', threaded=True) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2022/crypto/ComicallyBadCrypto/main.py | ctfs/PatriotCTF/2022/crypto/ComicallyBadCrypto/main.py | import string
import random
from base64 import b64decode, b64encode
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes
from flask import render_template, request, make_response, redirect
from app import app, confidential_settings, admin
BS = AES.block_size
IV = get_random_bytes(BS)
KEY = get_random_bytes(BS)
BLUE = "#076185"
RAND = ''.join(random.choice(string.ascii_letters) for i in range(BS))
def make_cookie(color):
cookie = f"color:{color}|{RAND}"
cookie += confidential_settings
return encrypt_cookie(cookie)
def encrypt_cookie(cookie: str) -> bytes:
raw = pad(cookie.encode(), BS)
cipher = AES.new(KEY, AES.MODE_CBC, IV).encrypt(raw)
return b64encode(cipher)
def decrypt_cookie(cookie: bytes) -> bytes:
cipher = b64decode(cookie)
raw = AES.new(KEY, AES.MODE_CBC, IV).decrypt(cipher)
return unpad(raw, BS)
@app.route("/", methods=["GET", "POST"])
def base():
if request.method == "GET":
if not request.cookies.get('session'):
resp = make_response(render_template('index.html', color=BLUE))
resp.set_cookie('session', make_cookie(BLUE))
return resp
else:
cookie: bytes = decrypt_cookie(request.cookies.get('session'))
color: string = cookie[6:13].decode()
if admin(cookie) == True:
return render_template('admin.html', color=color)
else:
return render_template('index.html', color=color)
else:
if request.form['color']:
resp = make_response(redirect('/'))
resp.set_cookie('session', make_cookie(request.form['color']))
return resp
else:
return redirect("/")
if __name__ == "__main__":
app.run(debug=False, host='0.0.0.0', threaded=True) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2022/web/ZaaS/upload.py | ctfs/PatriotCTF/2022/web/ZaaS/upload.py | import os
import zipfile
import shutil
from app import app
from flask import flash, redirect, render_template, request, url_for, send_from_directory
from flask_login import current_user, login_required
from werkzeug.utils import secure_filename
@app.route('/upload', methods=['GET', 'POST'])
@login_required
def upload():
if request.method=='POST':
if 'file' not in request.files:
flash('No file part', 'danger')
return redirect(url_for('upload'))
file = request.files['file']
if file.filename == '':
flash('No file selected', 'danger')
return redirect(url_for('upload'))
if not zipfile.is_zipfile(file):
flash('The file you provided is not a zip!', 'danger')
return redirect(url_for('upload'))
filename = secure_filename(file.filename)
upload_dir = app.config['UPLOAD_FOLDER'] + "/" + filename.rsplit('.', 1)[0]
try:
os.makedirs(upload_dir)
except FileExistsError:
flash('An extracted zip with this name already exists', 'danger')
return redirect(url_for('upload'))
with zipfile.ZipFile(file, "r") as zf:
for f in zf.infolist():
with open(os.path.join(upload_dir, f.filename), 'wb') as tf:
tf.write(zf.open(f.filename, 'r').read())
flash(f'Zip sucessfully unzipped. Download it by going to /upload/{filename.rsplit(".", 1)[0]}', 'success')
return redirect(url_for('upload'))
else:
return render_template('upload.html', name=current_user.username)
@app.route('/upload/<dir>', methods=['GET'])
@login_required
def show_unzip(dir):
path = app.config["UPLOAD_FOLDER"] + "/" + dir
if os.path.isdir(path):
files = os.listdir(path)
return render_template('files.html', name=current_user.username, files=files)
elif os.path.isfile(path):
name = dir
return send_from_directory(f'{app.config["UPLOAD_FOLDER"]}', filename=name, as_attachment=True)
else:
flash('That directory does not exist', 'danger')
return redirect(url_for('upload'))
@app.route('/upload/<dir>/<name>', methods=['GET'])
@login_required
def serve_unzip(dir, name):
path = f'{app.config["UPLOAD_FOLDER"]}/{dir}/{name}'
if os.path.isfile(path):
return send_from_directory(f'{app.config["UPLOAD_FOLDER"]}/{dir}', filename=name, as_attachment=True)
else:
flash('That file does not exist', 'danger')
return redirect(url_for('upload'))
@app.route('/delete', methods=['GET'])
@login_required
def delete_uploads():
if os.path.isdir(app.config["UPLOAD_FOLDER"]):
shutil.rmtree(app.config["UPLOAD_FOLDER"])
flash('Deleted all uploads', 'success')
else:
flash('Uploads is already empty', 'warning')
return redirect(url_for('upload')) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2022/web/TaaS/upload.py | ctfs/PatriotCTF/2022/web/TaaS/upload.py | import os
import tarfile
import shutil
from app import app
from flask import flash, redirect, render_template, request, url_for, send_from_directory
from flask_login import current_user, login_required
from werkzeug.utils import secure_filename
@app.route('/upload', methods=['GET', 'POST'])
@login_required
def upload():
if request.method=='POST':
if 'file' not in request.files:
flash('No file part', 'danger')
return redirect(url_for('upload'))
file = request.files['file']
if file.filename == '':
flash('No file selected', 'danger')
return redirect(url_for('upload'))
if not tarfile.is_tarfile(file):
flash('The file you provided is not a tar file!', 'danger')
return redirect(url_for('upload'))
filename = secure_filename(file.filename)
upload_dir = app.config['UPLOAD_FOLDER'] + "/" + filename.rsplit('.', 1)[0]
try:
os.makedirs(upload_dir)
except FileExistsError:
flash('An extracted tar archive with this name already exists', 'danger')
return redirect(url_for('upload'))
tarchive_path = f"{upload_dir}/{filename}"
file.stream.seek(0)
file.save(tarchive_path)
try:
tarchive = tarfile.open(tarchive_path)
for tf in tarchive:
if tf.name != secure_filename(tf.name):
break
tarchive.extract(tf.name, upload_dir)
for tf in tarchive:
if not tf.isreg():
os.remove(f"{upload_dir}/{tf.name}")
tarchive.close()
except Exception as e:
flash('Something went wrong: ' + str(e), 'danger')
return redirect(url_for('upload'))
os.remove(tarchive_path)
flash(f'Tar sucessfully untar\'d. Download the files by going to /upload/{filename.rsplit(".", 1)[0]}', 'success')
return redirect(url_for('upload'))
else:
return render_template('upload.html', name=current_user.username)
@app.route('/upload/<dir>', methods=['GET'])
@login_required
def show_unzip(dir):
path = app.config["UPLOAD_FOLDER"] + "/" + dir
if os.path.isdir(path):
files = os.listdir(path)
return render_template('files.html', name=current_user.username, files=files)
elif os.path.isfile(path):
name = dir
return send_from_directory(f'{app.config["UPLOAD_FOLDER"]}', filename=name, as_attachment=True)
else:
flash('That directory does not exist', 'danger')
return redirect(url_for('upload'))
@app.route('/upload/<dir>/<name>', methods=['GET'])
@login_required
def serve_unzip(dir, name):
path = f'{app.config["UPLOAD_FOLDER"]}/{dir}/{name}'
if os.path.isfile(path):
return send_from_directory(f'{app.config["UPLOAD_FOLDER"]}/{dir}', filename=name, as_attachment=True)
else:
flash('That file does not exist', 'danger')
return redirect(url_for('upload'))
@app.route('/delete', methods=['GET'])
@login_required
def delete_uploads():
if os.path.isdir(app.config["UPLOAD_FOLDER"]):
shutil.rmtree(app.config["UPLOAD_FOLDER"])
flash('Deleted all uploads', 'success')
else:
flash('Uploads is already empty', 'warning')
return redirect(url_for('upload')) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/PatriotCTF/2022/web/ExcellentDatabase/main.py | ctfs/PatriotCTF/2022/web/ExcellentDatabase/main.py | import os
from flask import render_template, redirect, request, session, flash, url_for
from openpyxl import load_workbook
import subprocess
import pandas as pd
from app import app, USERNAMES, PASSWORDS
def add_user(username, password):
DB = load_workbook(filename="db.xlsx")
Users = DB["Users"]
new_row = Users.max_row + 1
Users[f"{USERNAMES}{new_row}"] = username
Users[f"{PASSWORDS}{new_row}"] = password
DB.save(filename="db.xlsx")
def read_db() -> pd.DataFrame:
subprocess.Popen(["libreoffice", "--headless", "--convert-to", "csv", "db.xlsx"], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT).communicate()
df = pd.read_csv("db.csv")
return df
@app.route("/", methods=["POST", "GET"])
def base():
if not session.get("username"):
return redirect(url_for("login"))
else:
Users = read_db()
username = session.get("username")
password = Users.query(f"Username == '{username}'")["Password"].values[0]
return render_template('index.html', name=username, password=password)
@app.route("/admin", methods=["GET"])
def admin():
username = session.get("username")
if username != "admin":
return redirect("/")
else:
return render_template("admin.html", name=username)
@app.route('/login', methods=['GET','POST'])
def login():
if request.method == "GET":
return render_template("login.html")
else:
username = request.form.get("username")
password = request.form.get("password")
Users = read_db()
if username not in Users.Username.values:
flash('Please check your login details and try again.', 'danger')
return redirect(url_for('login'))
elif password != Users.query(f"Username == '{username}'")["Password"].values[0]:
flash('Please check your login details and try again.', 'danger')
return redirect(url_for('login'))
session["username"] = request.form.get("username")
return redirect("/")
@app.route('/signup', methods=['GET','POST'])
def signup():
if request.method=='POST':
username = request.form.get("username")
password = request.form.get("password")
Users = read_db()
if username in Users.Username.values:
flash('Username already exists')
return redirect(url_for('signup'))
else:
add_user(username, password)
session["username"] = username
return redirect("/")
else:
return render_template('signup.html')
@app.route('/logout', methods=['GET'])
def logout():
if request.method=='GET':
username = session.get("username")
session.pop('username', default=None)
return redirect("/")
if __name__ == "__main__":
for f in os.listdir("flask_session"):
os.remove(os.path.join("flask_session", f))
app.run(debug=False, host='0.0.0.0', threaded=True) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/L3akCTF/2024/crypto/Really_Simple_Algorithm/server.py | ctfs/L3akCTF/2024/crypto/Really_Simple_Algorithm/server.py | from Crypto.Util.number import getPrime, bytes_to_long as btl
menu = '''(1) Encrypt Message
(2) Receive Flag
(3) Exit'''
e = 1337
size = 1024
flag = open('flag.txt', 'r').read().rstrip()
print('Welcome to the L3ak Really Simple Algorithm (RSA) Encryption Service™!')
print('Here you can encrypt your own message, or choose to receive the encrypted flag.')
print('Good luck!\n')
while True:
p, q = getPrime(size), getPrime(size)
n = p*q
print(menu)
option = int(input('Select Option: '))
if option == 1:
message = btl(input('Your Message: ').encode())
enc_msg = pow(message, e, n)
print(f'n = {n}')
print(f'c = {enc_msg}')
elif option == 2:
enc_flag = pow(btl(flag.encode()), e, n)
print(f'n = {n}')
print(f'flag = {enc_flag}')
elif option == 3:
print('Goodbye!')
exit()
else:
print('Invalid choice! Please try again.')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/L3akCTF/2024/crypto/Crypto_on_the_rocks/chal.py | ctfs/L3akCTF/2024/crypto/Crypto_on_the_rocks/chal.py | from sage.all import *
from typing import Tuple
import hashlib
from Crypto.Cipher import AES
from Crypto.Util.number import long_to_bytes
from Crypto.Util.Padding import pad
from Crypto.Random import get_random_bytes
import re
p = 0x01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
K = GF(p)
a = K(0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc)
b = K(0x0051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00)
E = EllipticCurve(K, (a, b))
G = E(0x00c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66, 0x011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650)
E.set_order(0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409 * 0x1)
n = G.order()
FLAG: str = open('flag.txt', 'r').read().strip()
KEY: int = randint(1, n - 1)
Q: int = KEY*G
AES_KEY = hashlib.sha256(long_to_bytes(KEY)).digest()
INVALID_ATTEMPTS = 0
def banner() -> str:
banner = """\n
██████████╗░░█████╗░░█████╗░███████╗█
[=] ------------ Menu------------ [=]
[+] !1: Get Public Key [+]
[+] !2: Sign a message [+]
[+] !3: Verify a signature [+]
[+] !4: Get the encrypted flag [+]
[+] !5: Exit [+]
[=] ------------------------------[=]
██████████╗░░█████╗░░█████╗░███████╗█
\r\n"""
return banner
def get_k() -> int:
return int.from_bytes(hashlib.sha512(os.urandom(512//8)).digest(), byteorder='big') % n
def digest(msg) -> int:
if isinstance(msg, str):
msg = msg.encode()
return int.from_bytes(hashlib.sha256(msg).digest(), byteorder='big')
def ecdsa_verify(Q, m, r, s) -> bool:
e = digest(m)
w = pow(s, -1, n)
u1 = int((e * w) % n)
u2 = int((r * w) % n)
P = (u1 * G) + (u2 * Q)
return r == int(P.xy()[0])
def ecdsa_sign(d: int, m: str) -> Tuple[int, int]:
e = digest(m)
k = get_k()
P = k * G
r_i = int(P.xy()[0])
s_i = (pow(k, -1, n) * (e+r_i*d)) % n
return (r_i, s_i)
def send_flag() -> str:
flag = FLAG.encode()
iv = get_random_bytes(16)
cipher = AES.new(AES_KEY, AES.MODE_CBC, iv)
ct = cipher.encrypt(pad(flag, AES.block_size))
return (iv + ct).hex()
def handle_signing() -> tuple:
while True:
try:
inp = input("Enter message to sign. (`!exit`) to return to the main menu.\n\n>> ")
if inp == "!exit":
break
r,s = ecdsa_sign(KEY, inp)
print(f"Signature (r,s): {(r, s)}")
except Exception as e:
print(f"Error during signing: {e}")
continue
def is_valid_format(inp) -> bool:
pattern = r"^\([^,]+,\d+,\d+\)$"
match = re.match(pattern, inp)
return bool(match)
def handle_verfication():
while True:
inp = input("Enter the message you want to verify in the format `message,r,s` (`!exit` to return to the main menu).\n\n>> ")
if inp == '!exit':
break
valid = is_valid_format(inp)
if not valid:
print("Invalid input format. Please try again.\n")
continue
message, r, s = inp.split(',')
print(f"message: {message}\nr: {r}\ns: {s}\n")
try:
i_r, i_s = int(r), int(s)
valid = ecdsa_verify(Q, message, i_r, i_s)
result = "Signature is valid\n" if valid else "Signature is invalid\n"
print(result)
except Exception as e:
print(f"Error during verification: {e}")
continue
def process_option(option: str) -> str:
global INVALID_ATTEMPTS
if option == '!1':
INVALID_ATTEMPTS = 0
public_key_info = f"Public Key (X, Y): {Q.xy()}\n"
print(public_key_info)
elif option == '!2':
INVALID_ATTEMPTS = 0
handle_signing()
elif option == '!3':
INVALID_ATTEMPTS = 0
handle_verfication()
elif option == '!4':
INVALID_ATTEMPTS = 0
enc_flag = send_flag()
print(f"Encrypted Flag: {enc_flag}\n")
elif option == '!5':
print("Goodbye!\n")
return False
else:
INVALID_ATTEMPTS += 1
print("Invalid option... Try again\n")
if INVALID_ATTEMPTS >= 3:
print("Too many invalid attempts. Exiting.\n")
return False
return True
def main():
try:
b = banner()
print(b+"\n")
while True:
inp = input(">> ")
if not process_option(inp):
sys.exit(0)
except Exception as e:
print(f"An error occurred: {e}, please try again later.\n")
pass
finally:
sys.exit(0)
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/L3akCTF/2025/crypto/Lowkey_RSA/lowkey-rsa.py | ctfs/L3akCTF/2025/crypto/Lowkey_RSA/lowkey-rsa.py | from Crypto.Util.number import *
def gen_primes(SIZE):
p = random_prime(1 << (SIZE - 1), 1 << SIZE)
while True:
q = random_prime(1 << (SIZE - 1), 1 << SIZE)
if p < q:
p, q = q, p
if q < p < 2*q:
break
return p, q
nbits = 1024
flag = b"L3AK{<REDACTED>}"
R = RealField(nbits)
p, q = gen_primes(nbits//2)
N = p*q
phi = (p**4-1)*(q**4-1)
N_s = R(N**2)
N_ss = R(N**4)
t = (2*N_ss-49*N_s + 2)/(4*N+170*N_s)
while True:
d = randint(1, round(sqrt(t)) - 1)
if gcd(phi-d, phi) == 1:
break
e = inverse_mod(phi-d, phi)
c = pow(bytes_to_long(flag), e, N)
print(f"e = {e}\nN = {N}\nc = {c}")
'''
e = 370641246943654763647982436393968410523035056803076571952063446221981054741105804986870907803130391736840420704227524827167178043545763070520011423497365360567040835216714988776285676818833967899487393611410406708467049153990487431775151667103817558875154145780446157545062795321820537740212495675608976163877567007753523774447008611976905578477758365862741282887079873779055623972564793977884741350325450634869927603664722967323341473363320613467433998603537242156610765948379449307405122629600556105209482040761323271134932553579828576227233549741862990693111061962892676568398083446001891012661453694340879845386900986024512140441823076068075531089610607812090402852586184229193699718454197060072575595570232588935191272416546819793045623275550409871218062357273309812154110783534714662063322116568964675372602159108306251453500390105034890229052958512010283429459687714879084097494098542745605324460172680461006303552579466987732938596341830436505942616479890554056163452471835707573885837976471753073413505028206370632139586750855217201926605743452826397576584492732225029497982216694648573014796836126574081158869231364821712046050068243878660143909750030922147254462228826952501087389154612318844202411291844150163167021
N = 10222014062768125922601962004686361136447658578111413896046596746110249358112354000488449664371774177977274016313103826803116662735101208575040021998413602496525815373151213550295992813258424882626853824039678993334143891154760939712139640336395595628492284893024078520796288685014103193630287988814952604029
c = 4323184196594280140760873888779221921406692838206184372853784052006066772207175604399047711017170078453742445880600303200397632746051500194774569530024097959399922254605516672962219900174336028512116159752401576376530557036245218800162889461620882177398454137759956927838320086276276377067055171421259852996
'''
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/L3akCTF/2025/crypto/Cat_Whisperer/cat-whisperer.py | ctfs/L3akCTF/2025/crypto/Cat_Whisperer/cat-whisperer.py | import os
import base64
import random
import string
import tempfile
import subprocess
def main():
flag = open("flag.txt", "r").read().rstrip()
assert len(flag) == 42
b64_data = input("Enter your base64-encoded rule file: ")
try:
rule_data = base64.b64decode(b64_data)
except Exception:
print(f"[ERROR] Failed to decode base64")
exit()
if len(rule_data) > 128:
exit()
uid = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
with tempfile.NamedTemporaryFile(delete=False, suffix=".rule") as rule_file:
rule_file.write(rule_data)
rule_path = rule_file.name
try:
# Most of these options are just to make hashcat more resource-friendly on remote
process = subprocess.Popen(
[
"hashcat", "-D", "1","-d", "1", f"--session={uid}", "-m"
"1400", "-w", "1", "-r", rule_path, "--potfile-disable",
"hash.txt", "flag.txt",
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=os.environ
)
for line in process.stdout:
if 'Status' in line.decode():
print(line.decode())
break
process.stdout.close()
process.wait()
except Exception:
print(f'[ERROR] Failed to run hashcat')
finally:
os.remove(rule_path)
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/HKUSTFirebird/2024/misc/Math_Formula/chall.py | ctfs/HKUSTFirebird/2024/misc/Math_Formula/chall.py | from sage.all import *
# In case you don't want to install Sage, you can use https://sagecell.sagemath.org/ and I guarantee Sagemath Cell is sufficient in solving this challenge.
# Also, to someone who doesn't know about Sage, the QQ() below is just a wrapper for rational numbers so that it retains its exact value without the need to deal with float precision error.
flag = b'firebird{***REDACTED***}'
def f(n):
return 1 + sum(floor(QQ((n, sum(floor(cos(QQ((factorial(j - 1) + 1, j)) * pi)**2) * (((-1)**(ceil(QQ(((j - 1), 2)))) + 1) // 2) for j in range(1, i + 1))))**QQ((1, n))) for i in range(1, 2**(n+2) + 1))
output = 1
for i in range(len(flag) - 2):
output *= f(flag[i] * flag[i+1] * flag[i+2])
print(output) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HKUSTFirebird/2024/pwn/trim/env/chall/src/app.py | ctfs/HKUSTFirebird/2024/pwn/trim/env/chall/src/app.py | #!/usr/bin/python3.9
import subprocess
import sys
import tempfile
print("Input your Lua code (End with \"__EOF__\"):", flush=True)
source = ""
while True:
line = sys.stdin.readline()
if line.startswith("__EOF__"):
break
source += line
if len(source) >= 0x2000:
print("[-] Code too long")
exit(1)
with tempfile.NamedTemporaryFile(suffix='.lua') as f:
f.write(source.encode())
f.flush()
try:
subprocess.run(["/home/lua/lua", f.name],
stdin=subprocess.DEVNULL,
stdout=1, # mercy
stderr=subprocess.DEVNULL)
except Exception as e:
print("[-]", e)
else:
print("[+] Done!") | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HKUSTFirebird/2024/rev/Photo_Encryptor/main.py | ctfs/HKUSTFirebird/2024/rev/Photo_Encryptor/main.py | from flask import Flask, render_template, request
import hashlib
from random import *
from PIL import Image
import base64
import io
app = Flask(__name__)
@app.route('/', methods=['GET', 'POST'])
def home():
if request.method == 'GET':
return render_template('index.html', msg='', image_b64='')
image = request.files['file']
im = Image.open(image)
pix = im.load()
width, height = im.size
if (width > 720) or (height > 405):
return render_template('index.html', msg='The image is too large!', image_b64='')
if (im.format != 'PNG'):
return render_template('index.html', msg='You can only upload an PNG image!', image_b64='')
key = '<**CENSORED**>'
seed(hashlib.md5(key.encode()).hexdigest().encode())
for x in range(width):
for y in range(height):
pix[x, y] = (pix[x, y][0] ^ pix[(x+randint(0, width))%width, (y+randint(0, height))%height][0],
pix[x, y][1] ^ pix[(x+randint(0, width))%width, (y+randint(0, height))%height][1],
pix[x, y][2] ^ pix[(x+randint(0, width))%width, (y+randint(0, height))%height][2])
for x in range(width):
for y in range(height):
pix[x, y] = (pix[x, y][0] ^ ord(key[(x+y)%len(key)]),
pix[x, y][1] ^ ord(key[(x+y)%len(key)]),
pix[x, y][2] ^ ord(key[(x+y)%len(key)]))
imgByteArr = io.BytesIO()
im.save(imgByteArr, format='png')
encoded_img_data = base64.b64encode(imgByteArr.getvalue())
return render_template("index.html", msg='Your image has been encrypted!', image_b64=encoded_img_data.decode('utf-8'))
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/HKUSTFirebird/2024/crypto/Goldilocks/chall.py | ctfs/HKUSTFirebird/2024/crypto/Goldilocks/chall.py | import signal
import os
import sys
import random
from Crypto.Util.number import isPrime as is_prime
def tle_handler(*args):
print('⏰')
sys.exit(0)
def main():
# Just to make sure the order is large enough
p = 0xde5831cd21036cbbf072deac86ac1a48f74e3e78bcd916132cf54ee27a80e26021cd0371c698c35ddb6927fdf184a8345c562c4d59d35806177b7931d64390694d105d62a9a67fbf509148a0ab639048b7b6aa6439f31c499006b97d7b2dc4fd7376c0e66dae9972f42d4be2fe835d76cc94a0ecc585009d967fcc7de05cb177
q = 0x6f2c18e69081b65df8396f5643560d247ba71f3c5e6c8b09967aa7713d40713010e681b8e34c61aeedb493fef8c2541a2e2b1626ace9ac030bbdbc98eb21c834a6882eb154d33fdfa848a45055b1c8245bdb55321cf98e24c8035cbebd96e27eb9bb607336d74cb97a16a5f17f41aebb664a507662c2804ecb3fe63ef02e58bb
g = 2
assert is_prime(p)
assert is_prime(q)
assert p == 2*q + 1
assert pow(g, q, p) == 1
signal.signal(signal.SIGALRM, tle_handler)
signal.alarm(3600)
flag = os.environ.get('FLAG', 'firebird{***REDACTED***}')
x = random.getrandbits(48)
y = pow(g, pow(g, x, q), p)
print(f'💬 {y}')
_x = int(input('🥺 '))
assert x == _x
print(f'🏁 {flag}')
if __name__ == '__main__':
try:
main()
except Exception:
print('😒')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HKUSTFirebird/2024/crypto/Vigenere_+_CTR/vigctr.py | ctfs/HKUSTFirebird/2024/crypto/Vigenere_+_CTR/vigctr.py | import secrets
SHIFT = 65
MOD = 26
BLOCKLENGTH = 20
def add(block1,block2):
assert(len(block1)<= len(block2))
assert(len(block2)<= BLOCKLENGTH)
b1upper = block1.upper()
b2upper = block2.upper()
b1 = [ ord(b1upper[i])-SHIFT for i in range(len(block1))]
b2 = [ ord(b2upper[i])-SHIFT for i in range(len(block1))]
s = [ (b1[i] + b2[i]) % MOD for i in range(len(block1))]
slist = [ chr(s[i]+SHIFT) for i in range(len(block1))]
sum = ''.join(slist)
return(sum)
def sub(block1,block2):
assert(len(block1)<= len(block2))
assert(len(block2)<= BLOCKLENGTH)
b1upper = block1.upper()
b2upper = block2.upper()
b1 = [ ord(b1upper[i])-SHIFT for i in range(len(block1))]
b2 = [ ord(b2upper[i])-SHIFT for i in range(len(block1))]
s = [ (b1[i] - b2[i]) % MOD for i in range(len(block1))]
slist = [ chr(s[i]+SHIFT) for i in range(len(block1))]
sum = ''.join(slist)
return(sum)
def get_blocks(s):
blocks = []
i = 0
while(i + BLOCKLENGTH<len(s)):
blocks.append(s[i:i+BLOCKLENGTH])
i = i + BLOCKLENGTH
blocks.append(s[i:len(s)])
return(blocks)
def random_block():
l = []
for _ in range (BLOCKLENGTH):
l.append(chr(secrets.randbelow(MOD)+SHIFT))
b= ''.join(l)
return(b)
def vigenere_enc(block,key):
return(add(block,key))
def vigenere_dec(block,key):
return(sub(block,key))
def ctr(num):
decimal_num = 0
power = len(num) - 1
for digit in num:
decimal_num += (ord(digit) - ord('A')) * (MOD ** power)
power -= 1
decimal_num += 1
result = ""
while decimal_num > 0:
remainder = decimal_num % MOD
result = chr(remainder + ord('A')) + result
decimal_num //= MOD
return(result)
def keygen():
return(random_block())
def get_iv():
return(random_block())
def vigenere_ctr_enc(message, key):
blocks = get_blocks(message)
nonce = get_iv()
ctxt = nonce
for b in blocks:
to_add = vigenere_enc(nonce, key)
ctxt += add(b, to_add)
nonce = ctr(nonce)
return(ctxt)
def vigenere_ctr_dec(ctxt, key):
blocks = get_blocks(ctxt)
nonce = blocks[0]
ptxt = ""
for i in range(1, len(blocks)):
to_add = vigenere_enc(nonce, key)
ptxt += sub(blocks[i], to_add)
nonce = ctr(nonce)
return(ptxt)
def read_flag():
f = open("flag.txt","r")
flag = f.read()
f.close()
return(flag)
if __name__ == "__main__":
KEY = keygen()
FLAGTEXT = read_flag()
CTXT = vigenere_ctr_enc(FLAGTEXT,KEY)
PTXT = vigenere_ctr_dec(CTXT,KEY)
assert(PTXT == FLAGTEXT)
print(CTXT)
# Output : ULDGWMFOXRNTKTVECMMNPQPAJYLJPIXJQUTYRQIQLQSURMZGYUTTPMHOHJAKNQKFFYGTPWXTMFWKHELLZYYFSUDNFKHOZAQIFQDPLUEFFPAILDTXQWWWKIGSVPPTMMWQMODAIBCODZTDSYUQBFSMLSILAZZHVXNTHPUASMZQBBSQZIKHQCLQFQXQAUJGMKACTYBBVMCXUMJOC
# flag is composed of uppercase English characters only without punctuation nor spaces, wrap the flag with 'firebird{...}' before submission | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HKUSTFirebird/2024/crypto/The_Quintessential_Quintuples/chall.py | ctfs/HKUSTFirebird/2024/crypto/The_Quintessential_Quintuples/chall.py | import signal
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import hashlib
import os
import sys
def tle_handler(*args):
print('⏰')
sys.exit(0)
class Quintessential_Quintuples:
modes = (1, 2, 3, 5, 6) # I have no idea why MODE 4 doesn't exist, maybe it's because Yotsuba is the final winner in the comic i guess...
def __init__(self):
self.keys = dict(zip(self.modes, [hashlib.md5(os.urandom(3)).digest() for _ in self.modes]))
def encrypt(self, m: bytes) -> bytes:
c = pad(m, 16)
ivs = []
for mode in self.modes:
if mode == AES.MODE_ECB:
cipher = AES.new(key = self.keys[mode], mode = mode)
c = cipher.encrypt(c)
elif mode == AES.MODE_CBC or mode == AES.MODE_CFB or mode == AES.MODE_OFB:
iv = os.urandom(16)
cipher = AES.new(key = self.keys[mode], mode = mode, iv = iv)
c = cipher.encrypt(c)
ivs.append(iv)
elif mode == AES.MODE_CTR:
nonce = os.urandom(8)
cipher = AES.new(key = self.keys[mode], mode = mode, nonce = nonce)
c = cipher.encrypt(c)
ivs.append(pad(nonce, 16))
return b''.join(ivs) + c
def decrypt(self, c: bytes) -> bytes:
ivs, m = c[:16*4], c[16*4:]
ivs = [ivs[i*16:(i+1)*16] for i in range(4)]
for mode in self.modes[::-1]:
if mode == AES.MODE_ECB:
cipher = AES.new(key = self.keys[mode], mode = mode)
m = cipher.decrypt(m)
elif mode == AES.MODE_CBC or mode == AES.MODE_CFB or mode == AES.MODE_OFB:
iv = ivs.pop()
cipher = AES.new(key = self.keys[mode], mode = mode, iv = iv)
m = cipher.decrypt(m)
elif mode == AES.MODE_CTR:
nonce = unpad(ivs.pop(), 16)
cipher = AES.new(key = self.keys[mode], mode = mode, nonce = nonce)
m = cipher.decrypt(m)
return unpad(m, 16)
def main():
signal.signal(signal.SIGALRM, tle_handler)
signal.alarm(60)
FLAG = os.environ.get('FLAG', 'firebird{***REDACTED***}').encode()
QQ = Quintessential_Quintuples()
commands = {'enc', 'dec', 'flag'}
while True:
command = input('🤖 ')
if command not in commands:
return print('😡')
commands.remove(command)
if command == 'enc':
c = bytes.fromhex(input('💬 '))
c = QQ.encrypt(c)
elif command == 'dec':
c = bytes.fromhex(input('💬 '))
c = QQ.decrypt(c)
elif command == 'flag':
return print(f'🏁 {QQ.encrypt(FLAG).hex()}')
print(f'🔑 {c.hex()}')
if __name__ == '__main__':
try:
main()
except Exception:
print('😒') | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HKUSTFirebird/2024/crypto/Random_Secure_Algorithm_II/chall-2.py | ctfs/HKUSTFirebird/2024/crypto/Random_Secure_Algorithm_II/chall-2.py | from Crypto.Util.number import getPrime
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import signal
import hashlib
import os
import random
def tle_handler(*args):
print('⏰')
sys.exit(0)
class RSA:
def __init__(self, n = 1024):
p = getPrime(n // 2)
q = getPrime(n // 2)
self.n = p * q
self.e = 0x10001
self.d = pow(self.e, -1, (p - 1) * (q - 1))
def encrypt(self, m):
return pow(m, self.e, self.n)
def decrypt(self, c):
return pow(c, self.d, self.n)
def dot_mod(c1, c2, n):
assert len(c1) == len(c2)
return sum(i * j for i, j in zip(c1, c2)) % n
def main():
signal.signal(signal.SIGALRM, tle_handler)
signal.alarm(60)
FLAG = os.environ.get('FLAG', 'firebird{***REDACTED***}').encode()
secret = [os.urandom(8) for _ in range(10)]
iv = os.urandom(16)
enc_flag = iv + AES.new(key = hashlib.sha256(b''.join(secret)).digest(), mode = AES.MODE_CBC, iv = iv).encrypt(pad(FLAG, 16))
print(f'🏁 {enc_flag.hex()}')
rsa = RSA()
print(f'📢 {hex(rsa.n)[2:]}')
enc_secret = []
for block in secret:
enc_secret.append(rsa.encrypt(int.from_bytes(block, 'big')))
enc_s = ':'.join(hex(c)[2:].rjust(1024 // 8 * 2, '0') for c in enc_secret)
print(f'🔑 {enc_s}')
ct = input('🔓 ').strip().replace('-', '').split(':')
pt = [rsa.decrypt(int(c, 16)) for c in ct]
weights = enc_secret
random.shuffle(weights)
res = dot_mod(pt, weights, rsa.n)
print(f'🧾 {hex(res)[2:]}')
if __name__ == '__main__':
try:
main()
except Exception:
print('😒') | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HKUSTFirebird/2024/crypto/Random_Secure_Algorithm_I/chall-1.py | ctfs/HKUSTFirebird/2024/crypto/Random_Secure_Algorithm_I/chall-1.py | from Crypto.Util.number import getPrime
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import signal
import hashlib
import os
import random
def tle_handler(*args):
print('⏰')
sys.exit(0)
class RSA:
def __init__(self, n = 1024):
p = getPrime(n // 2)
q = getPrime(n // 2)
self.n = p * q
self.e = 0x10001
self.d = pow(self.e, -1, (p - 1) * (q - 1))
def encrypt(self, m):
return pow(m, self.e, self.n)
def decrypt(self, c):
return pow(c, self.d, self.n)
def dot_mod(c1, c2, n):
assert len(c1) == len(c2)
return sum(i * j for i, j in zip(c1, c2)) % n
def main():
signal.signal(signal.SIGALRM, tle_handler)
signal.alarm(60)
FLAG = os.environ.get('FLAG', 'firebird{***REDACTED***}').encode()
secret = [os.urandom(8) for _ in range(10)]
iv = os.urandom(16)
enc_flag = iv + AES.new(key = hashlib.sha256(b''.join(secret)).digest(), mode = AES.MODE_CBC, iv = iv).encrypt(pad(FLAG, 16))
print(f'🏁 {enc_flag.hex()}')
rsa = RSA()
print(f'📢 {hex(rsa.n)[2:]}')
enc_secret = []
for block in secret:
enc_secret.append(rsa.encrypt(int.from_bytes(block, 'big')))
enc_s = ':'.join(hex(c)[2:].rjust(1024 // 8 * 2, '0') for c in enc_secret)
print(f'🔑 {enc_s}')
ct = input('🔓 ').strip().replace('-', '').split(':')
pt = [rsa.decrypt(int(c, 16)) for c in ct]
weights = list(range(1, 11))
random.shuffle(weights)
res = dot_mod(pt, weights, rsa.n)
print(f'🧾 {hex(res)[2:]}')
if __name__ == '__main__':
try:
main()
except Exception:
print('😒') | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/HKUSTFirebird/2024/web/infantwaf/proxy/index.py | ctfs/HKUSTFirebird/2024/web/infantwaf/proxy/index.py | from flask import Flask, request, render_template_string
from requests import get
from random import uniform
app = Flask(__name__)
PORT = 80
upstream = 'http://infantwaf.backend'
@app.route('/', methods=['GET'])
def proxy():
q = request.args.get('giveme')
if q is not None:
if q != 'proxy':
return '🈲'
elif 'flag' in request.query_string.decode():
return '🚩'
else:
return get(f'{upstream}/?{request.query_string.decode()}').content
else:
with open("index.html", "r") as fp:
out = fp.read()
return render_template_string(out, text_rot=uniform(-5.0, 5.0), button_rot=uniform(-15.0, 15.0), button_trans=uniform(0.0, 10.0))
if __name__ == '__main__':
app.run(host='0.0.0.0', port=PORT) | 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/app_beta.py | ctfs/WMCTF/2023/pwn/PDC_2_5/app_beta.py | from aiohttp import web
from fastecdsa.curve import P256
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from pysm4 import encrypt_cbc
import aiofiles
import os
import json
import string
import random
import hashlib
import time
import base64
rootKey = "68acba52-7f6f-4274-ab1c-219607dd864e"
pcs = set()
base64_charset = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+/='
PKSK = {"backup":"","admin":""}
def BuildPKSK():
global PKSK
kdf = PBKDF2HMAC(algorithm=hashes.SHA256(),length=32,salt=rootKey.encode(),iterations=480000)
PKSK["backup"] = kdf.derive(rootKey.encode())
kdf = PBKDF2HMAC(algorithm=hashes.SHA256(),length=32,salt=PKSK["backup"],iterations=480000)
PKSK["admin"] = kdf.derive(PKSK["backup"])
def mod_inv(a, m):
return pow(a, m-2, m)
class keyGenerator(object):
def __init__(self, seed):
self.seed = seed
self.P = P256.G
# Only For Beta Version
self.d = 0000000000000000000000000000000000000000000000000000000000000
e = mod_inv(self.d, P256.q)
self.Q = e * self.P
def gen(self, seed=None):
if seed == None:
seed = self.seed
r = (seed * self.P).x
x = (r * self.Q).x
return x & (2**(8 * 30) - 1), r
def update(self, seed):
self.seed = seed
def checkAuth(content):
timestamp = int(round(time.time()) * 1000)
if not isinstance(content,dict):
content = json.loads(content)
signStringEnc = base64.b64decode(content.pop('Token').encode()).decode()
keys = sorted(content.keys())
signString = ""
for key in keys:
signString += f"{key}={content[key]}&"
md5Object = hashlib.md5()
md5Object.update(PKSK[content["username"]])
signValue = md5Object.hexdigest().upper()
signString += signValue
# Release Version a=ApplicationKey
a = 00000000000000000000000000000000000000000000000000000000000
a = a.to_bytes(32, 'big')
signStringEncServer = encrypt_cbc(signString, a[:16], a[16:32])
if signStringEncServer == signStringEnc:
if(timestamp - int(content["timestamp"]) < 600000):
return (content["username"],json.loads(content["data"]))
else:
return ("Hacker","Timeout!")
else:
return ("Hacker","Hacker!")
async def deepConnect(request):
# Will be implemented in the Release Version
# Core Code:
# if isinstance(receiveMessage, str) and receiveMessage.startswith("XXXXXXXXXX"):
# command = message.split("XXXXXXXXXX")[-1]
# if checkAuthRes == "admin":
# outinfo = subprocess.getstatusoutput(("./editDatabase \"" + command + "\""))
# reply = ""
# if outinfo == None:
# reply = "系统无回应"
# else:
# reply = outinfo[-1]
# channel_send(channel, reply.replace('\n',''))
# elif checkAuthRes == "backup":
# reply = f"备份信息如下：{backupStr}"
# channel_send(channel, reply.replace('\n',''))
# else:
# reply = f"权限不足！"
# channel_send(channel, reply.replace('\n',''))
def query_parse(req):
obj = req.query_string
queryitem = []
if obj:
query = req.query.items()
for item in query:
queryitem.append(item)
return dict(queryitem)
else:
return None
async def download(request):
query = query_parse(request)
try:
params = await request.json()
except json.decoder.JSONDecodeError:
content = "非法的访问行为！"
return web.Response(status=403, content_type="text/html", text=content)
if params == {} or "username" not in params.keys() or "timestamp" not in params.keys() or "Token" not in params.keys():
content = "非法的访问行为！"
return web.Response(status=403, content_type="text/html", text=content)
checkAuthRes = checkAuth(params)
if query == None or 'file' not in query.keys():
content = "PDC 已经记录了您这次访问行为，普通民众请勿随意访问此系统！"
return web.Response(status=403, content_type="text/html", text=content)
filename = query.get('file')
file_dir = '/app/download'
file_path = os.path.join(file_dir, filename)
if (filename not in ['editDatabase','ssl.log','app']) or ((filename in ['editDatabase','app']) and (checkAuthRes[0] != 'admin')):
async with aiofiles.open('/dev/urandom', 'rb') as f:
content = await f.read(random.randint(2333,23333))
if content:
md5Object = hashlib.md5()
md5Object.update(filename.encode())
safeFilename = md5Object.hexdigest().upper()
response = web.Response(
content_type='application/octet-stream',
headers={'Content-Disposition': 'attachment;filename={}'.format(safeFilename)},
body=content)
return response
else:
return web.Response(status=404, content_type="text/html", text="文件为空")
else:
if os.path.exists(file_path):
async with aiofiles.open(file_path, 'rb') as f:
content = await f.read()
if content:
response = web.Response(
content_type='application/octet-stream',
headers={'Content-Disposition': 'attachment;filename={}'.format(filename)},
body=content)
return response
else:
return web.Response(status=404, content_type="text/html", text="文件为空")
else:
return web.Response(status=404, content_type="text/html", text="文件未找到")
async def index(request):
content = "欢迎访问行星防御理事会(PDC)面壁人作战方案管理系统！\n"
content += "您需要进一步建立深层通信信道进行交互！ \n"
content += "/* Beta Version */ \n"
return web.Response(content_type="text/html", text=content)
if __name__ == "__main__":
s = "XXX" # Only For Beta Version
E = keyGenerator(s)
leakFirst, newState = E.gen()
E.update(newState)
leakSecond, newState = E.gen()
observed = (leakFirst << (2 * 8)) | (leakSecond >> (28 * 8))
backupStr = f"{E.d}-{observed}"
BuildPKSK()
E.update(newState)
ApplicationKey, _ = E.gen()
app = web.Application()
app.on_shutdown.append(on_shutdown)
app.router.add_get("/", index)
app.router.add_post("/download", download)
app.router.add_post("/deepConnect", deepConnect)
web.run_app(
app, access_log=None, host='0.0.0.0', port='23333'
) | 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/setup.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/setup.py | import os.path
import setuptools
root_dir = os.path.abspath(os.path.dirname(__file__))
about = {}
about_file = os.path.join(root_dir, "src", "aiortc", "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()
cffi_modules = [
"src/_cffi_src/build_opus.py:ffibuilder",
"src/_cffi_src/build_vpx.py:ffibuilder",
]
install_requires = [
"aioice>=0.7.5,<0.8.0",
"av>=9.0.0,<11.0.0",
"cffi>=1.0.0",
"cryptography>=2.2",
'dataclasses; python_version < "3.7"',
"google-crc32c>=1.1",
"pyee>=9.0.0",
"pylibsrtp>=0.5.6",
"pyopenssl>=23.0.0",
]
extras_require = {
'dev': [
'aiohttp>=3.7.0',
'coverage>=5.0',
'numpy>=1.19.0',
]
}
# Do not build cffi modules on readthedocs as we lack the codec development files.
if os.environ.get("READTHEDOCS") == "True":
cffi_modules = []
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",
],
cffi_modules=cffi_modules,
package_dir={"": "src"},
packages=["aiortc", "aiortc.codecs", "aiortc.contrib"],
python_requires=">=3.7",
setup_requires=["cffi>=1.0.0"],
install_requires=install_requires,
extras_require=extras_require,
)
| 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/scripts/fetch-vendor.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/scripts/fetch-vendor.py | import argparse
import logging
import json
import os
import platform
import shutil
import struct
import subprocess
def get_platform():
system = platform.system()
machine = platform.machine()
if system == "Linux":
return f"manylinux_{machine}"
elif system == "Darwin":
# cibuildwheel sets ARCHFLAGS:
# https://github.com/pypa/cibuildwheel/blob/5255155bc57eb6224354356df648dc42e31a0028/cibuildwheel/macos.py#L207-L220
if "ARCHFLAGS" in os.environ:
machine = os.environ["ARCHFLAGS"].split()[1]
return f"macosx_{machine}"
elif system == "Windows":
if struct.calcsize("P") * 8 == 64:
return "win_amd64"
else:
return "win32"
else:
raise Exception(f"Unsupported system {system}")
parser = argparse.ArgumentParser(description="Fetch and extract tarballs")
parser.add_argument("destination_dir")
parser.add_argument("--cache-dir", default="tarballs")
parser.add_argument("--config-file", default=os.path.splitext(__file__)[0] + ".json")
args = parser.parse_args()
logging.basicConfig(level=logging.INFO)
# read config file
with open(args.config_file, "r") as fp:
config = json.load(fp)
# create fresh destination directory
logging.info("Creating directory %s" % args.destination_dir)
if os.path.exists(args.destination_dir):
shutil.rmtree(args.destination_dir)
os.makedirs(args.destination_dir)
for url_template in config["urls"]:
tarball_url = url_template.replace("{platform}", get_platform())
# download tarball
tarball_name = tarball_url.split("/")[-1]
tarball_file = os.path.join(args.cache_dir, tarball_name)
if not os.path.exists(tarball_file):
logging.info("Downloading %s" % tarball_url)
if not os.path.exists(args.cache_dir):
os.mkdir(args.cache_dir)
subprocess.check_call(
["curl", "--location", "--output", tarball_file, "--silent", tarball_url]
)
# extract tarball
logging.info("Extracting %s" % tarball_name)
subprocess.check_call(["tar", "-C", args.destination_dir, "-xf", tarball_file])
| 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/src/aiortc/rtcsessiondescription.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcsessiondescription.py | from dataclasses import dataclass
@dataclass
class RTCSessionDescription:
"""
The :class:`RTCSessionDescription` dictionary describes one end of a
connection and how it's configured.
"""
sdp: str
type: str
def __post_init__(self):
if self.type not in {"offer", "pranswer", "answer", "rollback"}:
raise ValueError(
f"'type' must be in ['offer', 'pranswer', 'answer', 'rollback'] (got '{self.type}')"
)
| 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/src/aiortc/rtcrtpparameters.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcrtpparameters.py | from dataclasses import dataclass, field
from typing import Dict, List, Optional, Union
ParametersDict = Dict[str, Union[int, str, None]]
@dataclass
class RTCRtpCodecCapability:
"""
The :class:`RTCRtpCodecCapability` dictionary provides information on
codec capabilities.
"""
mimeType: str
"The codec MIME media type/subtype, for instance `'audio/PCMU'`."
clockRate: int
"The codec clock rate expressed in Hertz."
channels: Optional[int] = None
"The number of channels supported (e.g. two for stereo)."
parameters: ParametersDict = field(default_factory=dict)
"Codec-specific parameters available for signaling."
@property
def name(self):
return self.mimeType.split("/")[1]
@dataclass
class RTCRtpCodecParameters:
"""
The :class:`RTCRtpCodecParameters` dictionary provides information on
codec settings.
"""
mimeType: str
"The codec MIME media type/subtype, for instance `'audio/PCMU'`."
clockRate: int
"The codec clock rate expressed in Hertz."
channels: Optional[int] = None
"The number of channels supported (e.g. two for stereo)."
payloadType: Optional[int] = None
"The value that goes in the RTP Payload Type Field."
rtcpFeedback: List["RTCRtcpFeedback"] = field(default_factory=list)
"Transport layer and codec-specific feedback messages for this codec."
parameters: ParametersDict = field(default_factory=dict)
"Codec-specific parameters available for signaling."
@property
def name(self):
return self.mimeType.split("/")[1]
def __str__(self):
s = f"{self.name}/{self.clockRate}"
if self.channels == 2:
s += "/2"
return s
@dataclass
class RTCRtpRtxParameters:
ssrc: int
@dataclass
class RTCRtpCodingParameters:
ssrc: int
payloadType: int
rtx: Optional[RTCRtpRtxParameters] = None
class RTCRtpDecodingParameters(RTCRtpCodingParameters):
pass
class RTCRtpEncodingParameters(RTCRtpCodingParameters):
pass
@dataclass
class RTCRtpHeaderExtensionCapability:
"""
The :class:`RTCRtpHeaderExtensionCapability` dictionary provides information
on a supported header extension.
"""
uri: str
"The URI of the RTP header extension."
@dataclass
class RTCRtpHeaderExtensionParameters:
"""
The :class:`RTCRtpHeaderExtensionParameters` dictionary enables a header
extension to be configured for use within an :class:`RTCRtpSender` or
:class:`RTCRtpReceiver`.
"""
id: int
"The value that goes in the packet."
uri: str
"The URI of the RTP header extension."
@dataclass
class RTCRtpCapabilities:
"""
The :class:`RTCRtpCapabilities` dictionary provides information about
support codecs and header extensions.
"""
codecs: List[RTCRtpCodecCapability] = field(default_factory=list)
"A list of :class:`RTCRtpCodecCapability`."
headerExtensions: List[RTCRtpHeaderExtensionCapability] = field(
default_factory=list
)
"A list of :class:`RTCRtpHeaderExtensionCapability`."
@dataclass
class RTCRtcpFeedback:
"""
The :class:`RTCRtcpFeedback` dictionary provides information on RTCP feedback messages.
"""
type: str
parameter: Optional[str] = None
@dataclass
class RTCRtcpParameters:
"""
The :class:`RTCRtcpParameters` dictionary provides information on RTCP settings.
"""
cname: Optional[str] = None
"The Canonical Name (CNAME) used by RTCP."
mux: bool = False
"Whether RTP and RTCP are multiplexed."
ssrc: Optional[int] = None
"The Synchronization Source identifier."
@dataclass
class RTCRtpParameters:
"""
The :class:`RTCRtpParameters` dictionary describes the configuration of
an :class:`RTCRtpReceiver` or an :class:`RTCRtpSender`.
"""
codecs: List[RTCRtpCodecParameters] = field(default_factory=list)
"A list of :class:`RTCRtpCodecParameters` to send or receive."
headerExtensions: List[RTCRtpHeaderExtensionParameters] = field(
default_factory=list
)
"A list of :class:`RTCRtpHeaderExtensionParameters`."
muxId: str = ""
"The muxId assigned to the RTP stream, if any, empty string if unset."
rtcp: RTCRtcpParameters = field(default_factory=RTCRtcpParameters)
"Parameters to configure RTCP."
@dataclass
class RTCRtpReceiveParameters(RTCRtpParameters):
encodings: List[RTCRtpDecodingParameters] = field(default_factory=list)
@dataclass
class RTCRtpSendParameters(RTCRtpParameters):
encodings: List[RTCRtpEncodingParameters] = field(default_factory=list)
| 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/src/aiortc/rtcsctptransport.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcsctptransport.py | import asyncio
import enum
import hmac
import logging
import math
import os
import time
from collections import deque
from dataclasses import dataclass, field
from struct import pack, unpack_from
from typing import (
Any,
Callable,
Deque,
Dict,
Iterator,
List,
Optional,
Set,
Tuple,
cast,
no_type_check,
)
from google_crc32c import value as crc32c
from pyee.asyncio import AsyncIOEventEmitter
from .exceptions import InvalidStateError
from .rtcdatachannel import RTCDataChannel, RTCDataChannelParameters
from .rtcdtlstransport import RTCDtlsTransport
from .utils import random32, uint16_add, uint16_gt, uint32_gt, uint32_gte
logger = logging.getLogger(__name__)
# local constants
COOKIE_LENGTH = 24
COOKIE_LIFETIME = 60
MAX_STREAMS = 65535
USERDATA_MAX_LENGTH = 1200
# protocol constants
SCTP_CAUSE_INVALID_STREAM = 0x0001
SCTP_CAUSE_STALE_COOKIE = 0x0003
SCTP_DATA_LAST_FRAG = 0x01
SCTP_DATA_FIRST_FRAG = 0x02
SCTP_DATA_UNORDERED = 0x04
SCTP_MAX_ASSOCIATION_RETRANS = 10
SCTP_MAX_BURST = 4
SCTP_MAX_INIT_RETRANS = 8
SCTP_RTO_ALPHA = 1 / 8
SCTP_RTO_BETA = 1 / 4
SCTP_RTO_INITIAL = 3.0
SCTP_RTO_MIN = 1
SCTP_RTO_MAX = 60
SCTP_TSN_MODULO = 2**32
RECONFIG_MAX_STREAMS = 135
# parameters
SCTP_STATE_COOKIE = 0x0007
SCTP_STR_RESET_OUT_REQUEST = 0x000D
SCTP_STR_RESET_RESPONSE = 0x0010
SCTP_STR_RESET_ADD_OUT_STREAMS = 0x0011
SCTP_SUPPORTED_CHUNK_EXT = 0x8008
SCTP_PRSCTP_SUPPORTED = 0xC000
# data channel constants
DATA_CHANNEL_ACK = 2
DATA_CHANNEL_OPEN = 3
DATA_CHANNEL_RELIABLE = 0x00
DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT = 0x01
DATA_CHANNEL_PARTIAL_RELIABLE_TIMED = 0x02
DATA_CHANNEL_RELIABLE_UNORDERED = 0x80
DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT_UNORDERED = 0x81
DATA_CHANNEL_PARTIAL_RELIABLE_TIMED_UNORDERED = 0x82
WEBRTC_DCEP = 50
WEBRTC_STRING = 51
WEBRTC_BINARY = 53
WEBRTC_STRING_EMPTY = 56
WEBRTC_BINARY_EMPTY = 57
def chunk_type(chunk) -> str:
return chunk.__class__.__name__
def decode_params(body: bytes) -> List[Tuple[int, bytes]]:
params = []
pos = 0
while pos <= len(body) - 4:
param_type, param_length = unpack_from("!HH", body, pos)
params.append((param_type, body[pos + 4 : pos + param_length]))
pos += param_length + padl(param_length)
return params
def encode_params(params: List[Tuple[int, bytes]]) -> bytes:
body = b""
padding = b""
for param_type, param_value in params:
param_length = len(param_value) + 4
body += padding
body += pack("!HH", param_type, param_length) + param_value
padding = b"\x00" * padl(param_length)
return body
def padl(length: int) -> int:
m = length % 4
return 4 - m if m else 0
def tsn_minus_one(a: int) -> int:
return (a - 1) % SCTP_TSN_MODULO
def tsn_plus_one(a: int) -> int:
return (a + 1) % SCTP_TSN_MODULO
class Chunk:
type = -1
def __init__(self, flags: int = 0, body: bytes = b"") -> None:
self.flags = flags
self.body = body
def __bytes__(self) -> bytes:
body = self.body
data = pack("!BBH", self.type, self.flags, len(body) + 4) + body
data += b"\x00" * padl(len(body))
return data
def __repr__(self) -> str:
return f"{chunk_type(self)}(flags={self.flags})"
class BaseParamsChunk(Chunk):
def __init__(self, flags: int = 0, body: Optional[bytes] = None) -> None:
self.flags = flags
if body:
self.params = decode_params(body)
else:
self.params = []
@property
def body(self) -> bytes: # type: ignore
return encode_params(self.params)
class AbortChunk(BaseParamsChunk):
type = 6
class CookieAckChunk(Chunk):
type = 11
class CookieEchoChunk(Chunk):
type = 10
class DataChunk(Chunk):
type = 0
def __init__(self, flags: int = 0, body: Optional[bytes] = None) -> None:
self.flags = flags
if body:
(self.tsn, self.stream_id, self.stream_seq, self.protocol) = unpack_from(
"!LHHL", body
)
self.user_data = body[12:]
else:
self.tsn = 0
self.stream_id = 0
self.stream_seq = 0
self.protocol = 0
self.user_data = b""
def __bytes__(self) -> bytes:
length = 16 + len(self.user_data)
data = (
pack(
"!BBHLHHL",
self.type,
self.flags,
length,
self.tsn,
self.stream_id,
self.stream_seq,
self.protocol,
)
+ self.user_data
)
if length % 4:
data += b"\x00" * padl(length)
return data
def __repr__(self) -> str:
return (
f"DataChunk(flags={self.flags}, tsn={self.tsn}, "
f"stream_id={self.stream_id}, stream_seq={self.stream_seq})"
)
class ErrorChunk(BaseParamsChunk):
type = 9
class ForwardTsnChunk(Chunk):
type = 192
def __init__(self, flags: int = 0, body: Optional[bytes] = None) -> None:
self.flags = flags
self.streams: List[Tuple[int, int]] = []
if body:
self.cumulative_tsn = unpack_from("!L", body, 0)[0]
pos = 4
while pos < len(body):
self.streams.append(
cast(Tuple[int, int], unpack_from("!HH", body, pos))
)
pos += 4
else:
self.cumulative_tsn = 0
@property
def body(self) -> bytes: # type: ignore
body = pack("!L", self.cumulative_tsn)
for stream_id, stream_seq in self.streams:
body += pack("!HH", stream_id, stream_seq)
return body
def __repr__(self) -> str:
return f"ForwardTsnChunk(cumulative_tsn={self.cumulative_tsn}, streams={self.streams})"
class HeartbeatChunk(BaseParamsChunk):
type = 4
class HeartbeatAckChunk(BaseParamsChunk):
type = 5
class BaseInitChunk(Chunk):
def __init__(self, flags: int = 0, body: Optional[bytes] = None) -> None:
self.flags = flags
if body:
(
self.initiate_tag,
self.advertised_rwnd,
self.outbound_streams,
self.inbound_streams,
self.initial_tsn,
) = unpack_from("!LLHHL", body)
self.params = decode_params(body[16:])
else:
self.initiate_tag = 0
self.advertised_rwnd = 0
self.outbound_streams = 0
self.inbound_streams = 0
self.initial_tsn = 0
self.params = []
@property
def body(self) -> bytes: # type: ignore
body = pack(
"!LLHHL",
self.initiate_tag,
self.advertised_rwnd,
self.outbound_streams,
self.inbound_streams,
self.initial_tsn,
)
body += encode_params(self.params)
return body
class InitChunk(BaseInitChunk):
type = 1
class InitAckChunk(BaseInitChunk):
type = 2
class ReconfigChunk(BaseParamsChunk):
type = 130
class SackChunk(Chunk):
type = 3
def __init__(self, flags=0, body=None):
self.flags = flags
self.gaps = []
self.duplicates = []
if body:
(
self.cumulative_tsn,
self.advertised_rwnd,
nb_gaps,
nb_duplicates,
) = unpack_from("!LLHH", body)
pos = 12
for i in range(nb_gaps):
self.gaps.append(unpack_from("!HH", body, pos))
pos += 4
for i in range(nb_duplicates):
self.duplicates.append(unpack_from("!L", body, pos)[0])
pos += 4
else:
self.cumulative_tsn = 0
self.advertised_rwnd = 0
def __bytes__(self) -> bytes:
length = 16 + 4 * (len(self.gaps) + len(self.duplicates))
data = pack(
"!BBHLLHH",
self.type,
self.flags,
length,
self.cumulative_tsn,
self.advertised_rwnd,
len(self.gaps),
len(self.duplicates),
)
for gap in self.gaps:
data += pack("!HH", *gap)
for tsn in self.duplicates:
data += pack("!L", tsn)
return data
def __repr__(self) -> str:
return (
f"SackChunk(flags={self.flags}, advertised_rwnd={self.advertised_rwnd}, "
f"cumulative_tsn={self.cumulative_tsn}, gaps={self.gaps})"
)
class ShutdownChunk(Chunk):
type = 7
def __init__(self, flags=0, body=None):
self.flags = flags
if body:
self.cumulative_tsn = unpack_from("!L", body)[0]
else:
self.cumulative_tsn = 0
@property
def body(self) -> bytes: # type: ignore
return pack("!L", self.cumulative_tsn)
def __repr__(self) -> str:
return (
f"ShutdownChunk(flags={self.flags}, cumulative_tsn={self.cumulative_tsn})"
)
class ShutdownAckChunk(Chunk):
type = 8
class ShutdownCompleteChunk(Chunk):
type = 14
CHUNK_CLASSES = [
DataChunk,
InitChunk,
InitAckChunk,
SackChunk,
HeartbeatChunk,
HeartbeatAckChunk,
AbortChunk,
ShutdownChunk,
ShutdownAckChunk,
ErrorChunk,
CookieEchoChunk,
CookieAckChunk,
ShutdownCompleteChunk,
ReconfigChunk,
ForwardTsnChunk,
]
CHUNK_TYPES = dict((cls.type, cls) for cls in CHUNK_CLASSES)
def parse_packet(data: bytes) -> Tuple[int, int, int, List[Any]]:
length = len(data)
if length < 12:
raise ValueError("SCTP packet length is less than 12 bytes")
source_port, destination_port, verification_tag = unpack_from("!HHL", data)
# verify checksum
checksum = unpack_from("<L", data, 8)[0]
if checksum != crc32c(data[0:8] + b"\x00\x00\x00\x00" + data[12:]):
raise ValueError("SCTP packet has invalid checksum")
chunks = []
pos = 12
while pos <= length - 4:
chunk_type, chunk_flags, chunk_length = unpack_from("!BBH", data, pos)
chunk_body = data[pos + 4 : pos + chunk_length]
chunk_cls = CHUNK_TYPES.get(chunk_type)
if chunk_cls:
chunks.append(chunk_cls(flags=chunk_flags, body=chunk_body))
pos += chunk_length + padl(chunk_length)
return source_port, destination_port, verification_tag, chunks
def serialize_packet(
source_port: int, destination_port: int, verification_tag: int, chunk: Chunk
) -> bytes:
header = pack("!HHL", source_port, destination_port, verification_tag)
data = bytes(chunk)
checksum = crc32c(header + b"\x00\x00\x00\x00" + data)
return header + pack("<L", checksum) + data
# RFC 6525
@dataclass
class StreamResetOutgoingParam:
request_sequence: int
response_sequence: int
last_tsn: int
streams: List[bytes] = field(default_factory=list)
def __bytes__(self) -> bytes:
data = pack(
"!LLL", self.request_sequence, self.response_sequence, self.last_tsn
)
for stream in self.streams:
data += pack("!H", stream)
return data
@classmethod
def parse(cls, data):
request_sequence, response_sequence, last_tsn = unpack_from("!LLL", data)
streams = []
for pos in range(12, len(data), 2):
streams.append(unpack_from("!H", data, pos)[0])
return cls(
request_sequence=request_sequence,
response_sequence=response_sequence,
last_tsn=last_tsn,
streams=streams,
)
@dataclass
class StreamAddOutgoingParam:
request_sequence: int
new_streams: int
def __bytes__(self) -> bytes:
data = pack("!LHH", self.request_sequence, self.new_streams, 0)
return data
@classmethod
def parse(cls, data):
request_sequence, new_streams, reserved = unpack_from("!LHH", data)
return cls(request_sequence=request_sequence, new_streams=new_streams)
@dataclass
class StreamResetResponseParam:
response_sequence: int
result: int
def __bytes__(self) -> bytes:
return pack("!LL", self.response_sequence, self.result)
@classmethod
def parse(cls, data):
response_sequence, result = unpack_from("!LL", data)
return cls(response_sequence=response_sequence, result=result)
RECONFIG_PARAM_TYPES = {
13: StreamResetOutgoingParam,
16: StreamResetResponseParam,
17: StreamAddOutgoingParam,
}
class InboundStream:
def __init__(self) -> None:
self.reassembly: List[DataChunk] = []
self.sequence_number = 0
def add_chunk(self, chunk: DataChunk) -> None:
if not self.reassembly or uint32_gt(chunk.tsn, self.reassembly[-1].tsn):
self.reassembly.append(chunk)
return
for i, rchunk in enumerate(self.reassembly):
# should never happen, the chunk should have been eliminated
# as a duplicate when _mark_received() is called
assert rchunk.tsn != chunk.tsn, "duplicate chunk in reassembly"
if uint32_gt(rchunk.tsn, chunk.tsn):
self.reassembly.insert(i, chunk)
break
def pop_messages(self) -> Iterator[Tuple[int, int, bytes]]:
pos = 0
start_pos = None
while pos < len(self.reassembly):
chunk = self.reassembly[pos]
if start_pos is None:
ordered = not (chunk.flags & SCTP_DATA_UNORDERED)
if not (chunk.flags & SCTP_DATA_FIRST_FRAG):
if ordered:
break
else:
pos += 1
continue
if ordered and uint16_gt(chunk.stream_seq, self.sequence_number):
break
expected_tsn = chunk.tsn
start_pos = pos
elif chunk.tsn != expected_tsn:
if ordered:
break
else:
start_pos = None
pos += 1
continue
if chunk.flags & SCTP_DATA_LAST_FRAG:
user_data = b"".join(
[c.user_data for c in self.reassembly[start_pos : pos + 1]]
)
self.reassembly = (
self.reassembly[:start_pos] + self.reassembly[pos + 1 :]
)
if ordered and chunk.stream_seq == self.sequence_number:
self.sequence_number = uint16_add(self.sequence_number, 1)
pos = start_pos
yield (chunk.stream_id, chunk.protocol, user_data)
else:
pos += 1
expected_tsn = tsn_plus_one(expected_tsn)
def prune_chunks(self, tsn: int) -> int:
"""
Prune chunks up to the given TSN.
"""
pos = -1
size = 0
for i, chunk in enumerate(self.reassembly):
if uint32_gte(tsn, chunk.tsn):
pos = i
size += len(chunk.user_data)
else:
break
self.reassembly = self.reassembly[pos + 1 :]
return size
@dataclass
class RTCSctpCapabilities:
"""
The :class:`RTCSctpCapabilities` dictionary provides information about the
capabilities of the :class:`RTCSctpTransport`.
"""
maxMessageSize: int
"""
The maximum size of data that the implementation can send or
0 if the implementation can handle messages of any size.
"""
class RTCSctpTransport(AsyncIOEventEmitter):
"""
The :class:`RTCSctpTransport` interface includes information relating to
Stream Control Transmission Protocol (SCTP) transport.
:param transport: An :class:`RTCDtlsTransport`.
"""
def __init__(self, transport: RTCDtlsTransport, port: int = 5000) -> None:
if transport.state == "closed":
raise InvalidStateError
super().__init__()
self._association_state = self.State.CLOSED
self.__log_debug: Callable[..., None] = lambda *args: None
self.__started = False
self.__state = "new"
self.__transport = transport
self._loop = asyncio.get_event_loop()
self._hmac_key = os.urandom(16)
self._local_partial_reliability = True
self._local_port = port
self._local_verification_tag = random32()
self._remote_extensions: List[int] = []
self._remote_partial_reliability = False
self._remote_port: Optional[int] = None
self._remote_verification_tag = 0
# inbound
self._advertised_rwnd = 1024 * 1024
self._inbound_streams: Dict[int, InboundStream] = {}
self._inbound_streams_count = 0
self._inbound_streams_max = MAX_STREAMS
self._last_received_tsn: Optional[int] = None
self._sack_duplicates: List[int] = []
self._sack_misordered: Set[int] = set()
self._sack_needed = False
# outbound
self._cwnd = 3 * USERDATA_MAX_LENGTH
self._fast_recovery_exit = None
self._fast_recovery_transmit = False
self._forward_tsn_chunk: Optional[ForwardTsnChunk] = None
self._flight_size = 0
self._local_tsn = random32()
self._last_sacked_tsn = tsn_minus_one(self._local_tsn)
self._advanced_peer_ack_tsn = tsn_minus_one(self._local_tsn)
self._outbound_queue: Deque[DataChunk] = deque()
self._outbound_stream_seq: Dict[int, int] = {}
self._outbound_streams_count = MAX_STREAMS
self._partial_bytes_acked = 0
self._sent_queue: Deque[DataChunk] = deque()
# reconfiguration
self._reconfig_queue: List[int] = []
self._reconfig_request = None
self._reconfig_request_seq = self._local_tsn
self._reconfig_response_seq = 0
# rtt calculation
self._srtt: Optional[float] = None
self._rttvar: Optional[float] = None
# timers
self._rto = SCTP_RTO_INITIAL
self._t1_chunk: Optional[Chunk] = None
self._t1_failures = 0
self._t1_handle: Optional[asyncio.TimerHandle] = None
self._t2_chunk: Optional[Chunk] = None
self._t2_failures = 0
self._t2_handle: Optional[asyncio.TimerHandle] = None
self._t3_handle: Optional[asyncio.TimerHandle] = None
# data channels
self._data_channel_id: Optional[int] = None
self._data_channel_queue: Deque[Tuple[RTCDataChannel, int, bytes]] = deque()
self._data_channels: Dict[int, RTCDataChannel] = {}
# FIXME: this is only used by RTCPeerConnection
self._bundled = False
self.mid: Optional[str] = None
@property
def is_server(self) -> bool:
return self.transport.transport.role != "controlling"
@property
def maxChannels(self) -> Optional[int]:
"""
The maximum number of :class:`RTCDataChannel` that can be used simultaneously.
"""
if self._inbound_streams_count:
return min(self._inbound_streams_count, self._outbound_streams_count)
return None
@property
def port(self) -> int:
"""
The local SCTP port number used for data channels.
"""
return self._local_port
@property
def state(self) -> str:
"""
The current state of the SCTP transport.
"""
return self.__state
@property
def transport(self):
"""
The :class:`RTCDtlsTransport` over which SCTP data is transmitted.
"""
return self.__transport
@classmethod
def getCapabilities(cls) -> RTCSctpCapabilities:
"""
Retrieve the capabilities of the transport.
:rtype: RTCSctpCapabilities
"""
return RTCSctpCapabilities(maxMessageSize=65536)
def setTransport(self, transport) -> None:
self.__transport = transport
async def start(self, remoteCaps: RTCSctpCapabilities, remotePort: int) -> None:
"""
Start the transport.
"""
if not self.__started:
self.__started = True
self.__state = "connecting"
self._remote_port = remotePort
# configure logging
if logger.isEnabledFor(logging.DEBUG):
prefix = "RTCSctpTransport(%s) " % (
self.is_server and "server" or "client"
)
self.__log_debug = lambda msg, *args: logger.debug(prefix + msg, *args)
# initialise local channel ID counter
# one side should be using even IDs, the other odd IDs
if self.is_server:
self._data_channel_id = 0
else:
self._data_channel_id = 1
self.__transport._register_data_receiver(self)
if not self.is_server:
await self._init()
async def stop(self) -> None:
"""
Stop the transport.
"""
if self._association_state != self.State.CLOSED:
await self._abort()
self.__transport._unregister_data_receiver(self)
self._set_state(self.State.CLOSED)
async def _abort(self) -> None:
"""
Abort the association.
"""
chunk = AbortChunk()
try:
await self._send_chunk(chunk)
except ConnectionError:
pass
async def _init(self) -> None:
"""
Initialize the association.
"""
chunk = InitChunk()
chunk.initiate_tag = self._local_verification_tag
chunk.advertised_rwnd = self._advertised_rwnd
chunk.outbound_streams = self._outbound_streams_count
chunk.inbound_streams = self._inbound_streams_max
chunk.initial_tsn = self._local_tsn
self._set_extensions(chunk.params)
await self._send_chunk(chunk)
# start T1 timer and enter COOKIE-WAIT state
self._t1_start(chunk)
self._set_state(self.State.COOKIE_WAIT)
def _flight_size_decrease(self, chunk: DataChunk) -> None:
self._flight_size = max(0, self._flight_size - chunk._book_size) # type: ignore
def _flight_size_increase(self, chunk: DataChunk) -> None:
self._flight_size += chunk._book_size # type: ignore
def _get_extensions(self, params: List[Tuple[int, bytes]]) -> None:
"""
Gets what extensions are supported by the remote party.
"""
for k, v in params:
if k == SCTP_PRSCTP_SUPPORTED:
self._remote_partial_reliability = True
elif k == SCTP_SUPPORTED_CHUNK_EXT:
self._remote_extensions = list(v)
def _set_extensions(self, params: List[Tuple[int, bytes]]) -> None:
"""
Sets what extensions are supported by the local party.
"""
extensions = []
if self._local_partial_reliability:
params.append((SCTP_PRSCTP_SUPPORTED, b""))
extensions.append(ForwardTsnChunk.type)
extensions.append(ReconfigChunk.type)
params.append((SCTP_SUPPORTED_CHUNK_EXT, bytes(extensions)))
def _get_inbound_stream(self, stream_id: int) -> InboundStream:
"""
Get or create the inbound stream with the specified ID.
"""
if stream_id not in self._inbound_streams:
self._inbound_streams[stream_id] = InboundStream()
return self._inbound_streams[stream_id]
def _get_timestamp(self) -> int:
return int(time.time())
async def _handle_data(self, data):
"""
Handle data received from the network.
"""
try:
_, _, verification_tag, chunks = parse_packet(data)
except ValueError:
return
# is this an init?
init_chunk = len([x for x in chunks if isinstance(x, InitChunk)])
if init_chunk:
assert len(chunks) == 1
expected_tag = 0
else:
expected_tag = self._local_verification_tag
# verify tag
if verification_tag != expected_tag:
self.__log_debug(
"Bad verification tag %d vs %d", verification_tag, expected_tag
)
return
# handle chunks
for chunk in chunks:
await self._receive_chunk(chunk)
# send SACK if needed
if self._sack_needed:
await self._send_sack()
@no_type_check
def _maybe_abandon(self, chunk: DataChunk) -> bool:
"""
Determine if a chunk needs to be marked as abandoned.
If it does, it marks the chunk and any other chunk belong to the same
message as abandoned.
"""
if chunk._abandoned:
return True
abandon = (
chunk._max_retransmits is not None
and chunk._sent_count > chunk._max_retransmits
) or (chunk._expiry is not None and chunk._expiry < time.time())
if not abandon:
return False
chunk_pos = self._sent_queue.index(chunk)
for pos in range(chunk_pos, -1, -1):
ochunk = self._sent_queue[pos]
ochunk._abandoned = True
ochunk._retransmit = False
if ochunk.flags & SCTP_DATA_FIRST_FRAG:
break
for pos in range(chunk_pos, len(self._sent_queue)):
ochunk = self._sent_queue[pos]
ochunk._abandoned = True
ochunk._retransmit = False
if ochunk.flags & SCTP_DATA_LAST_FRAG:
break
return True
def _mark_received(self, tsn: int) -> bool:
"""
Mark an incoming data TSN as received.
"""
# it's a duplicate
if uint32_gte(self._last_received_tsn, tsn) or tsn in self._sack_misordered:
self._sack_duplicates.append(tsn)
return True
# consolidate misordered entries
self._sack_misordered.add(tsn)
for tsn in sorted(self._sack_misordered):
if tsn == tsn_plus_one(self._last_received_tsn):
self._last_received_tsn = tsn
else:
break
# filter out obsolete entries
def is_obsolete(x):
return uint32_gt(x, self._last_received_tsn)
self._sack_duplicates = list(filter(is_obsolete, self._sack_duplicates))
self._sack_misordered = set(filter(is_obsolete, self._sack_misordered))
return False
async def _receive(self, stream_id: int, pp_id: int, data: bytes) -> None:
"""
Receive data stream -> ULP.
"""
await self._data_channel_receive(stream_id, pp_id, data)
async def _receive_chunk(self, chunk):
"""
Handle an incoming chunk.
"""
self.__log_debug("< %s", chunk)
# common
if isinstance(chunk, DataChunk):
await self._receive_data_chunk(chunk)
elif isinstance(chunk, SackChunk):
await self._receive_sack_chunk(chunk)
elif isinstance(chunk, ForwardTsnChunk):
await self._receive_forward_tsn_chunk(chunk)
elif isinstance(chunk, HeartbeatChunk):
ack = HeartbeatAckChunk()
ack.params = chunk.params
await self._send_chunk(ack)
elif isinstance(chunk, AbortChunk):
self.__log_debug("x Association was aborted by remote party")
self._set_state(self.State.CLOSED)
elif isinstance(chunk, ShutdownChunk):
self._t2_cancel()
self._set_state(self.State.SHUTDOWN_RECEIVED)
ack = ShutdownAckChunk()
await self._send_chunk(ack)
self._t2_start(ack)
self._set_state(self.State.SHUTDOWN_ACK_SENT)
elif (
isinstance(chunk, ShutdownCompleteChunk)
and self._association_state == self.State.SHUTDOWN_ACK_SENT
):
self._t2_cancel()
self._set_state(self.State.CLOSED)
elif (
isinstance(chunk, ReconfigChunk)
and self._association_state == self.State.ESTABLISHED
):
for param in chunk.params:
cls = RECONFIG_PARAM_TYPES.get(param[0])
if cls:
await self._receive_reconfig_param(cls.parse(param[1]))
# server
elif isinstance(chunk, InitChunk) and self.is_server:
self._last_received_tsn = tsn_minus_one(chunk.initial_tsn)
self._reconfig_response_seq = tsn_minus_one(chunk.initial_tsn)
self._remote_verification_tag = chunk.initiate_tag
self._ssthresh = chunk.advertised_rwnd
self._get_extensions(chunk.params)
self.__log_debug(
"- Peer supports %d outbound streams, %d max inbound streams",
chunk.outbound_streams,
chunk.inbound_streams,
)
self._inbound_streams_count = min(
chunk.outbound_streams, self._inbound_streams_max
)
self._outbound_streams_count = min(
self._outbound_streams_count, chunk.inbound_streams
)
ack = InitAckChunk()
ack.initiate_tag = self._local_verification_tag
ack.advertised_rwnd = self._advertised_rwnd
ack.outbound_streams = self._outbound_streams_count
ack.inbound_streams = self._inbound_streams_max
ack.initial_tsn = self._local_tsn
self._set_extensions(ack.params)
# generate state cookie
cookie = pack("!L", self._get_timestamp())
cookie += hmac.new(self._hmac_key, cookie, "sha1").digest()
ack.params.append((SCTP_STATE_COOKIE, cookie))
await self._send_chunk(ack)
elif isinstance(chunk, CookieEchoChunk) and self.is_server:
# check state cookie MAC
cookie = chunk.body
if (
len(cookie) != COOKIE_LENGTH
or hmac.new(self._hmac_key, cookie[0:4], "sha1").digest() != cookie[4:]
):
self.__log_debug("x State cookie is invalid")
return
# check state cookie lifetime
now = self._get_timestamp()
stamp = unpack_from("!L", cookie)[0]
if stamp < now - COOKIE_LIFETIME or stamp > now:
self.__log_debug("x State cookie has expired")
error = ErrorChunk()
error.params.append((SCTP_CAUSE_STALE_COOKIE, b"\x00" * 8))
await self._send_chunk(error)
return
ack = CookieAckChunk()
await self._send_chunk(ack)
self._set_state(self.State.ESTABLISHED)
# client
elif (
isinstance(chunk, InitAckChunk)
and self._association_state == self.State.COOKIE_WAIT
):
# cancel T1 timer and process chunk
self._t1_cancel()
self._last_received_tsn = tsn_minus_one(chunk.initial_tsn)
self._reconfig_response_seq = tsn_minus_one(chunk.initial_tsn)
self._remote_verification_tag = chunk.initiate_tag
self._ssthresh = chunk.advertised_rwnd
self._get_extensions(chunk.params)
self.__log_debug(
"- Peer supports %d outbound streams, %d max inbound streams",
chunk.outbound_streams,
chunk.inbound_streams,
)
self._inbound_streams_count = min(
chunk.outbound_streams, self._inbound_streams_max
)
self._outbound_streams_count = min(
self._outbound_streams_count, chunk.inbound_streams
)
echo = CookieEchoChunk()
for k, v in chunk.params:
if k == SCTP_STATE_COOKIE:
echo.body = v
break
await self._send_chunk(echo)
# start T1 timer and enter COOKIE-ECHOED state
self._t1_start(echo)
self._set_state(self.State.COOKIE_ECHOED)
elif (
isinstance(chunk, CookieAckChunk)
and self._association_state == self.State.COOKIE_ECHOED
):
# cancel T1 timer and enter ESTABLISHED state
self._t1_cancel()
self._set_state(self.State.ESTABLISHED)
elif isinstance(chunk, ErrorChunk) and self._association_state in [
self.State.COOKIE_WAIT,
self.State.COOKIE_ECHOED,
]:
self._t1_cancel()
self._set_state(self.State.CLOSED)
| 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/aiortc/src/aiortc/rtcrtptransceiver.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcrtptransceiver.py | import logging
from typing import List, Optional
from .codecs import get_capabilities
from .rtcdtlstransport import RTCDtlsTransport
from .rtcrtpparameters import (
RTCRtpCodecCapability,
RTCRtpCodecParameters,
RTCRtpHeaderExtensionParameters,
)
from .rtcrtpreceiver import RTCRtpReceiver
from .rtcrtpsender import RTCRtpSender
from .sdp import DIRECTIONS
logger = logging.getLogger(__name__)
class RTCRtpTransceiver:
"""
The RTCRtpTransceiver interface describes a permanent pairing of an
:class:`RTCRtpSender` and an :class:`RTCRtpReceiver`, along with some
shared state.
"""
def __init__(
self,
kind: str,
receiver: RTCRtpReceiver,
sender: RTCRtpSender,
direction: str = "sendrecv",
):
self.__direction = direction
self.__kind = kind
self.__mid: Optional[str] = None
self.__mline_index: Optional[int] = None
self.__receiver = receiver
self.__sender = sender
self.__stopped = False
self._currentDirection: Optional[str] = None
self._offerDirection: Optional[str] = None
self._preferred_codecs: List[RTCRtpCodecCapability] = []
self._transport: RTCDtlsTransport = None
# FIXME: this is only used by RTCPeerConnection
self._bundled = False
self._codecs: List[RTCRtpCodecParameters] = []
self._headerExtensions: List[RTCRtpHeaderExtensionParameters] = []
@property
def currentDirection(self) -> Optional[str]:
"""
The currently negotiated direction of the transceiver.
One of `'sendrecv'`, `'sendonly'`, `'recvonly'`, `'inactive'` or `None`.
"""
return self._currentDirection
@property
def direction(self) -> str:
"""
The preferred direction of the transceiver, which will be used in
:meth:`RTCPeerConnection.createOffer` and :meth:`RTCPeerConnection.createAnswer`.
One of `'sendrecv'`, `'sendonly'`, `'recvonly'` or `'inactive'`.
"""
return self.__direction
@direction.setter
def direction(self, direction: str) -> None:
assert direction in DIRECTIONS
self.__direction = direction
@property
def kind(self) -> str:
return self.__kind
@property
def mid(self) -> Optional[str]:
return self.__mid
@property
def receiver(self) -> RTCRtpReceiver:
"""
The :class:`RTCRtpReceiver` that handles receiving and decoding
incoming media.
"""
return self.__receiver
@property
def sender(self) -> RTCRtpSender:
"""
The :class:`RTCRtpSender` responsible for encoding and sending
data to the remote peer.
"""
return self.__sender
@property
def stopped(self) -> bool:
return self.__stopped
def setCodecPreferences(self, codecs: List[RTCRtpCodecCapability]) -> None:
"""
Override the default codec preferences.
See :meth:`RTCRtpSender.getCapabilities` and :meth:`RTCRtpReceiver.getCapabilities`
for the supported codecs.
:param codecs: A list of :class:`RTCRtpCodecCapability`, in decreasing order
of preference. If empty, restores the default preferences.
"""
if not codecs:
self._preferred_codecs = []
capabilities = get_capabilities(self.kind).codecs
unique: List[RTCRtpCodecCapability] = []
for codec in reversed(codecs):
if codec not in capabilities:
raise ValueError("Codec is not in capabilities")
if codec not in unique:
unique.insert(0, codec)
self._preferred_codecs = unique
async def stop(self):
"""
Permanently stops the :class:`RTCRtpTransceiver`.
"""
await self.__receiver.stop()
await self.__sender.stop()
self.__stopped = True
def _set_mid(self, mid: str) -> None:
self.__mid = mid
def _get_mline_index(self) -> Optional[int]:
return self.__mline_index
def _set_mline_index(self, idx: int) -> None:
self.__mline_index = idx
| 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/src/aiortc/rtcdatachannel.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcdatachannel.py | import logging
from dataclasses import dataclass
from typing import Optional, Union
from pyee.asyncio import AsyncIOEventEmitter
from .exceptions import InvalidStateError
logger = logging.getLogger(__name__)
@dataclass
class RTCDataChannelParameters:
"""
The :class:`RTCDataChannelParameters` dictionary describes the
configuration of an :class:`RTCDataChannel`.
"""
label: str = ""
"A name describing the data channel."
maxPacketLifeTime: Optional[int] = None
"The maximum time in milliseconds during which transmissions are attempted."
maxRetransmits: Optional[int] = None
"The maximum number of retransmissions that are attempted."
ordered: bool = True
"Whether the data channel guarantees in-order delivery of messages."
protocol: str = ""
"The name of the subprotocol in use."
negotiated: bool = False
"""
Whether data channel will be negotiated out of-band, where both sides
create data channel with an agreed-upon ID."""
id: Optional[int] = None
"""
An numeric ID for the channel; permitted values are 0-65534.
If you don't include this option, the user agent will select an ID for you.
Must be set when negotiating out-of-band.
"""
class RTCDataChannel(AsyncIOEventEmitter):
"""
The :class:`RTCDataChannel` interface represents a network channel which
can be used for bidirectional peer-to-peer transfers of arbitrary data.
:param transport: An :class:`RTCSctpTransport`.
:param parameters: An :class:`RTCDataChannelParameters`.
"""
def __init__(
self, transport, parameters: RTCDataChannelParameters, send_open: bool = True
) -> None:
super().__init__()
self.__bufferedAmount = 0
self.__bufferedAmountLowThreshold = 0
self.__id = parameters.id
self.__parameters = parameters
self.__readyState = "connecting"
self.__transport = transport
self.__send_open = send_open
if self.__parameters.negotiated and (
self.__id is None or self.__id < 0 or self.__id > 65534
):
raise ValueError(
"ID must be in range 0-65534 "
"if data channel is negotiated out-of-band"
)
if not self.__parameters.negotiated:
if self.__send_open:
self.__send_open = False
self.__transport._data_channel_open(self)
else:
self.__transport._data_channel_add_negotiated(self)
@property
def bufferedAmount(self) -> int:
"""
The number of bytes of data currently queued to be sent over the data channel.
"""
return self.__bufferedAmount
@property
def bufferedAmountLowThreshold(self) -> int:
"""
The number of bytes of buffered outgoing data that is considered "low".
"""
return self.__bufferedAmountLowThreshold
@bufferedAmountLowThreshold.setter
def bufferedAmountLowThreshold(self, value: int) -> None:
if value < 0 or value > 4294967295:
raise ValueError(
"bufferedAmountLowThreshold must be in range 0 - 4294967295"
)
self.__bufferedAmountLowThreshold = value
@property
def negotiated(self) -> bool:
"""
Whether data channel was negotiated out-of-band.
"""
return self.__parameters.negotiated
@property
def id(self) -> Optional[int]:
"""
An ID number which uniquely identifies the data channel.
"""
return self.__id
@property
def label(self) -> str:
"""
A name describing the data channel.
These labels are not required to be unique.
"""
return self.__parameters.label
@property
def ordered(self) -> bool:
"""
Indicates whether or not the data channel guarantees in-order delivery of messages.
"""
return self.__parameters.ordered
@property
def maxPacketLifeTime(self) -> Optional[int]:
"""
The maximum time in milliseconds during which transmissions are attempted.
"""
return self.__parameters.maxPacketLifeTime
@property
def maxRetransmits(self) -> Optional[int]:
"""
"The maximum number of retransmissions that are attempted.
"""
return self.__parameters.maxRetransmits
@property
def protocol(self) -> str:
"""
The name of the subprotocol in use.
"""
return self.__parameters.protocol
@property
def readyState(self) -> str:
"""
A string indicating the current state of the underlying data transport.
"""
return self.__readyState
@property
def transport(self):
"""
The :class:`RTCSctpTransport` over which data is transmitted.
"""
return self.__transport
def close(self) -> None:
"""
Close the data channel.
"""
self.transport._data_channel_close(self)
def send(self, data: Union[bytes, str]) -> None:
"""
Send `data` across the data channel to the remote peer.
"""
if self.readyState != "open":
raise InvalidStateError
if not isinstance(data, (str, bytes)):
raise ValueError(f"Cannot send unsupported data type: {type(data)}")
self.transport._data_channel_send(self, data)
def _addBufferedAmount(self, amount: int) -> None:
crosses_threshold = (
self.__bufferedAmount > self.bufferedAmountLowThreshold
and self.__bufferedAmount + amount <= self.bufferedAmountLowThreshold
)
self.__bufferedAmount += amount
if crosses_threshold:
self.emit("bufferedamountlow")
def _setId(self, id: int) -> None:
self.__id = id
def _setReadyState(self, state: str) -> None:
if state != self.__readyState:
self.__log_debug("- %s -> %s", self.__readyState, state)
self.__readyState = state
if state == "open":
self.emit("open")
elif state == "closed":
self.emit("close")
# no more events will be emitted, so remove all event listeners
# to facilitate garbage collection.
self.remove_all_listeners()
def __log_debug(self, msg: str, *args) -> None:
logger.debug(f"RTCDataChannel(%s) {msg}", self.__id, *args)
| 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/src/aiortc/rtcicetransport.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcicetransport.py | import asyncio
import logging
import re
from dataclasses import dataclass
from typing import Any, Dict, List, Optional
from aioice import Candidate, Connection, ConnectionClosed
from pyee.asyncio import AsyncIOEventEmitter
from .exceptions import InvalidStateError
from .rtcconfiguration import RTCIceServer
STUN_REGEX = re.compile(
r"(?P<scheme>stun|stuns)\:(?P<host>[^?:]+)(\:(?P<port>[0-9]+?))?"
# RFC 7064 does not define a "transport" option but some providers
# include it, so just ignore it
r"(\?transport=.*)?"
)
TURN_REGEX = re.compile(
r"(?P<scheme>turn|turns)\:(?P<host>[^?:]+)(\:(?P<port>[0-9]+?))?"
r"(\?transport=(?P<transport>.*))?"
)
logger = logging.getLogger(__name__)
@dataclass
class RTCIceCandidate:
"""
The :class:`RTCIceCandidate` interface represents a candidate Interactive
Connectivity Establishment (ICE) configuration which may be used to
establish an RTCPeerConnection.
"""
component: int
foundation: str
ip: str
port: int
priority: int
protocol: str
type: str
relatedAddress: Optional[str] = None
relatedPort: Optional[int] = None
sdpMid: Optional[str] = None
sdpMLineIndex: Optional[int] = None
tcpType: Optional[str] = None
@dataclass
class RTCIceParameters:
"""
The :class:`RTCIceParameters` dictionary includes the ICE username
fragment and password and other ICE-related parameters.
"""
usernameFragment: Optional[str] = None
"ICE username fragment."
password: Optional[str] = None
"ICE password."
iceLite: bool = False
def candidate_from_aioice(x: Candidate) -> RTCIceCandidate:
return RTCIceCandidate(
component=x.component,
foundation=x.foundation,
ip=x.host,
port=x.port,
priority=x.priority,
protocol=x.transport,
relatedAddress=x.related_address,
relatedPort=x.related_port,
tcpType=x.tcptype,
type=x.type,
)
def candidate_to_aioice(x: RTCIceCandidate) -> Candidate:
return Candidate(
component=x.component,
foundation=x.foundation,
host=x.ip,
port=x.port,
priority=x.priority,
related_address=x.relatedAddress,
related_port=x.relatedPort,
transport=x.protocol,
tcptype=x.tcpType,
type=x.type,
)
def connection_kwargs(servers: List[RTCIceServer]) -> Dict[str, Any]:
kwargs: Dict[str, Any] = {}
for server in servers:
if isinstance(server.urls, list):
uris = server.urls
else:
uris = [server.urls]
for uri in uris:
parsed = parse_stun_turn_uri(uri)
if parsed["scheme"] == "stun":
# only a single STUN server is supported
if "stun_server" in kwargs:
continue
kwargs["stun_server"] = (parsed["host"], parsed["port"])
elif parsed["scheme"] in ["turn", "turns"]:
# only a single TURN server is supported
if "turn_server" in kwargs:
continue
# only 'udp' and 'tcp' transports are supported
if parsed["scheme"] == "turn" and parsed["transport"] not in [
"udp",
"tcp",
]:
continue
elif parsed["scheme"] == "turns" and parsed["transport"] != "tcp":
continue
# only 'password' credentialType is supported
if server.credentialType != "password":
continue
kwargs["turn_server"] = (parsed["host"], parsed["port"])
kwargs["turn_ssl"] = parsed["scheme"] == "turns"
kwargs["turn_transport"] = parsed["transport"]
kwargs["turn_username"] = server.username
kwargs["turn_password"] = server.credential
return kwargs
def parse_stun_turn_uri(uri: str) -> Dict[str, Any]:
if uri.startswith("stun"):
match = STUN_REGEX.fullmatch(uri)
elif uri.startswith("turn"):
match = TURN_REGEX.fullmatch(uri)
else:
raise ValueError("malformed uri: invalid scheme")
if not match:
raise ValueError("malformed uri")
# set port
parsed: Dict[str, Any] = match.groupdict()
if parsed["port"]:
parsed["port"] = int(parsed["port"])
elif parsed["scheme"] in ["stuns", "turns"]:
parsed["port"] = 5349
else:
parsed["port"] = 3478
# set transport
if parsed["scheme"] == "turn" and not parsed["transport"]:
parsed["transport"] = "udp"
elif parsed["scheme"] == "turns" and not parsed["transport"]:
parsed["transport"] = "tcp"
return parsed
class RTCIceGatherer(AsyncIOEventEmitter):
"""
The :class:`RTCIceGatherer` interface gathers local host, server reflexive
and relay candidates, as well as enabling the retrieval of local
Interactive Connectivity Establishment (ICE) parameters which can be
exchanged in signaling.
"""
def __init__(self, iceServers: Optional[List[RTCIceServer]] = None) -> None:
super().__init__()
if iceServers is None:
iceServers = self.getDefaultIceServers()
ice_kwargs = connection_kwargs(iceServers)
self._connection = Connection(ice_controlling=False, **ice_kwargs)
self._remote_candidates_end = False
self.__state = "new"
@property
def state(self) -> str:
"""
The current state of the ICE gatherer.
"""
return self.__state
async def gather(self) -> None:
"""
Gather ICE candidates.
"""
if self.__state == "new":
self.__setState("gathering")
await self._connection.gather_candidates()
self.__setState("completed")
@classmethod
def getDefaultIceServers(cls) -> List[RTCIceServer]:
"""
Return the list of default :class:`RTCIceServer`.
"""
return [RTCIceServer("stun:stun.l.google.com:19302")]
def getLocalCandidates(self) -> List[RTCIceCandidate]:
"""
Retrieve the list of valid local candidates associated with the ICE
gatherer.
"""
return [candidate_from_aioice(x) for x in self._connection.local_candidates]
def getLocalParameters(self) -> RTCIceParameters:
"""
Retrieve the ICE parameters of the ICE gatherer.
:rtype: RTCIceParameters
"""
return RTCIceParameters(
usernameFragment=self._connection.local_username,
password=self._connection.local_password,
)
def __setState(self, state: str) -> None:
self.__state = state
self.emit("statechange")
class RTCIceTransport(AsyncIOEventEmitter):
"""
The :class:`RTCIceTransport` interface allows an application access to
information about the Interactive Connectivity Establishment (ICE)
transport over which packets are sent and received.
:param gatherer: An :class:`RTCIceGatherer`.
"""
def __init__(self, gatherer: RTCIceGatherer) -> None:
super().__init__()
self.__iceGatherer = gatherer
self.__monitor_task: Optional[asyncio.Future[None]] = None
self.__start: Optional[asyncio.Event] = None
self.__state = "new"
self._connection = gatherer._connection
self._role_set = False
# expose recv / send methods
self._recv = self._connection.recv
self._send = self._connection.send
@property
def iceGatherer(self) -> RTCIceGatherer:
"""
The ICE gatherer passed in the constructor.
"""
return self.__iceGatherer
@property
def role(self) -> str:
"""
The current role of the ICE transport.
Either `'controlling'` or `'controlled'`.
"""
if self._connection.ice_controlling:
return "controlling"
else:
return "controlled"
@property
def state(self) -> str:
"""
The current state of the ICE transport.
"""
return self.__state
async def addRemoteCandidate(self, candidate: Optional[RTCIceCandidate]) -> None:
"""
Add a remote candidate.
:param candidate: The new candidate or `None` to signal end of candidates.
"""
if not self.__iceGatherer._remote_candidates_end:
if candidate is None:
self.__iceGatherer._remote_candidates_end = True
await self._connection.add_remote_candidate(None)
else:
await self._connection.add_remote_candidate(
candidate_to_aioice(candidate)
)
def getRemoteCandidates(self) -> List[RTCIceCandidate]:
"""
Retrieve the list of candidates associated with the remote
:class:`RTCIceTransport`.
"""
return [candidate_from_aioice(x) for x in self._connection.remote_candidates]
async def start(self, remoteParameters: RTCIceParameters) -> None:
"""
Initiate connectivity checks.
:param remoteParameters: The :class:`RTCIceParameters` associated with
the remote :class:`RTCIceTransport`.
"""
if self.state == "closed":
raise InvalidStateError("RTCIceTransport is closed")
# handle the case where start is already in progress
if self.__start is not None:
await self.__start.wait()
return
self.__start = asyncio.Event()
self.__monitor_task = asyncio.ensure_future(self._monitor())
self.__setState("checking")
self._connection.remote_is_lite = remoteParameters.iceLite
self._connection.remote_username = remoteParameters.usernameFragment
self._connection.remote_password = remoteParameters.password
try:
await self._connection.connect()
except ConnectionError:
self.__setState("failed")
else:
self.__setState("completed")
self.__start.set()
async def stop(self) -> None:
"""
Irreversibly stop the :class:`RTCIceTransport`.
"""
if self.state != "closed":
self.__setState("closed")
await self._connection.close()
if self.__monitor_task is not None:
await self.__monitor_task
self.__monitor_task = None
async def _monitor(self) -> None:
while True:
event = await self._connection.get_event()
if isinstance(event, ConnectionClosed):
if self.state == "completed":
self.__setState("failed")
return
def __log_debug(self, msg: str, *args) -> None:
logger.debug(f"RTCIceTransport(%s) {msg}", self.role, *args)
def __setState(self, state: str) -> None:
if state != self.__state:
self.__log_debug("- %s -> %s", self.__state, state)
self.__state = state
self.emit("statechange")
# no more events will be emitted, so remove all event listeners
# to facilitate garbage collection.
if state == "closed":
self.iceGatherer.remove_all_listeners()
self.remove_all_listeners()
| 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/src/aiortc/rtcrtpreceiver.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcrtpreceiver.py | import asyncio
import datetime
import logging
import queue
import random
import threading
import time
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Set
from av.frame import Frame
from . import clock
from .codecs import depayload, get_capabilities, get_decoder, is_rtx
from .exceptions import InvalidStateError
from .jitterbuffer import JitterBuffer
from .mediastreams import MediaStreamError, MediaStreamTrack
from .rate import RemoteBitrateEstimator
from .rtcdtlstransport import RTCDtlsTransport
from .rtcrtpparameters import (
RTCRtpCapabilities,
RTCRtpCodecParameters,
RTCRtpReceiveParameters,
)
from .rtp import (
RTCP_PSFB_APP,
RTCP_PSFB_PLI,
RTCP_RTPFB_NACK,
RTP_HISTORY_SIZE,
AnyRtcpPacket,
RtcpByePacket,
RtcpPsfbPacket,
RtcpReceiverInfo,
RtcpRrPacket,
RtcpRtpfbPacket,
RtcpSrPacket,
RtpPacket,
clamp_packets_lost,
pack_remb_fci,
unwrap_rtx,
)
from .stats import (
RTCInboundRtpStreamStats,
RTCRemoteOutboundRtpStreamStats,
RTCStatsReport,
)
from .utils import uint16_add, uint16_gt
logger = logging.getLogger(__name__)
def decoder_worker(loop, input_q, output_q):
codec_name = None
decoder = None
while True:
task = input_q.get()
if task is None:
# inform the track that is has ended
asyncio.run_coroutine_threadsafe(output_q.put(None), loop)
break
codec, encoded_frame = task
if codec.name != codec_name:
decoder = get_decoder(codec)
codec_name = codec.name
for frame in decoder.decode(encoded_frame):
# pass the decoded frame to the track
asyncio.run_coroutine_threadsafe(output_q.put(frame), loop)
if decoder is not None:
del decoder
class NackGenerator:
def __init__(self) -> None:
self.max_seq: Optional[int] = None
self.missing: Set[int] = set()
def add(self, packet: RtpPacket) -> bool:
"""
Mark a new packet as received, and deduce missing packets.
"""
missed = False
if self.max_seq is None:
self.max_seq = packet.sequence_number
return missed
# mark missing packets
if uint16_gt(packet.sequence_number, self.max_seq):
seq = uint16_add(self.max_seq, 1)
while uint16_gt(packet.sequence_number, seq):
self.missing.add(seq)
missed = True
seq = uint16_add(seq, 1)
self.max_seq = packet.sequence_number
else:
self.missing.discard(packet.sequence_number)
# limit number of tracked packets
self.truncate()
return missed
def truncate(self) -> None:
"""
Limit the number of missing packets we track.
Otherwise, the size of RTCP FB messages grows indefinitely.
"""
if self.max_seq is not None:
min_seq = uint16_add(self.max_seq, -RTP_HISTORY_SIZE)
for seq in list(self.missing):
if uint16_gt(min_seq, seq):
self.missing.discard(seq)
class StreamStatistics:
def __init__(self, clockrate: int) -> None:
self.base_seq: Optional[int] = None
self.max_seq: Optional[int] = None
self.cycles = 0
self.packets_received = 0
# jitter
self._clockrate = clockrate
self._jitter_q4 = 0
self._last_arrival: Optional[int] = None
self._last_timestamp: Optional[int] = None
# fraction lost
self._expected_prior = 0
self._received_prior = 0
def add(self, packet: RtpPacket) -> None:
in_order = self.max_seq is None or uint16_gt(
packet.sequence_number, self.max_seq
)
self.packets_received += 1
if self.base_seq is None:
self.base_seq = packet.sequence_number
if in_order:
arrival = int(time.time() * self._clockrate)
if self.max_seq is not None and packet.sequence_number < self.max_seq:
self.cycles += 1 << 16
self.max_seq = packet.sequence_number
if packet.timestamp != self._last_timestamp and self.packets_received > 1:
diff = abs(
(arrival - self._last_arrival)
- (packet.timestamp - self._last_timestamp)
)
self._jitter_q4 += diff - ((self._jitter_q4 + 8) >> 4)
self._last_arrival = arrival
self._last_timestamp = packet.timestamp
@property
def fraction_lost(self) -> int:
expected_interval = self.packets_expected - self._expected_prior
self._expected_prior = self.packets_expected
received_interval = self.packets_received - self._received_prior
self._received_prior = self.packets_received
lost_interval = expected_interval - received_interval
if expected_interval == 0 or lost_interval <= 0:
return 0
else:
return (lost_interval << 8) // expected_interval
@property
def jitter(self) -> int:
return self._jitter_q4 >> 4
@property
def packets_expected(self) -> int:
return self.cycles + self.max_seq - self.base_seq + 1
@property
def packets_lost(self) -> int:
return clamp_packets_lost(self.packets_expected - self.packets_received)
class RemoteStreamTrack(MediaStreamTrack):
def __init__(self, kind: str, id: Optional[str] = None) -> None:
super().__init__()
self.kind = kind
if id is not None:
self._id = id
self._queue: asyncio.Queue = asyncio.Queue()
async def recv(self) -> Frame:
"""
Receive the next frame.
"""
if self.readyState != "live":
raise MediaStreamError
frame = await self._queue.get()
if frame is None:
self.stop()
raise MediaStreamError
return frame
class TimestampMapper:
def __init__(self) -> None:
self._last: Optional[int] = None
self._origin: Optional[int] = None
def map(self, timestamp: int) -> int:
if self._origin is None:
# first timestamp
self._origin = timestamp
elif timestamp < self._last:
# RTP timestamp wrapped
self._origin -= 1 << 32
self._last = timestamp
return timestamp - self._origin
@dataclass
class RTCRtpContributingSource:
"""
The :class:`RTCRtpContributingSource` dictionary contains information about
a contributing source (CSRC).
"""
timestamp: datetime.datetime
"The timestamp associated with this source."
source: int
"The CSRC identifier associated with this source."
@dataclass
class RTCRtpSynchronizationSource:
"""
The :class:`RTCRtpSynchronizationSource` dictionary contains information about
a synchronization source (SSRC).
"""
timestamp: datetime.datetime
"The timestamp associated with this source."
source: int
"The SSRC identifier associated with this source."
class RTCRtpReceiver:
"""
The :class:`RTCRtpReceiver` interface manages the reception and decoding
of data for a :class:`MediaStreamTrack`.
:param kind: The kind of media (`'audio'` or `'video'`).
:param transport: An :class:`RTCDtlsTransport`.
"""
def __init__(self, kind: str, transport: RTCDtlsTransport) -> None:
if transport.state == "closed":
raise InvalidStateError
self.__active_ssrc: Dict[int, datetime.datetime] = {}
self.__codecs: Dict[int, RTCRtpCodecParameters] = {}
self.__decoder_queue: queue.Queue = queue.Queue()
self.__decoder_thread: Optional[threading.Thread] = None
self.__kind = kind
if kind == "audio":
self.__jitter_buffer = JitterBuffer(capacity=16, prefetch=4)
self.__nack_generator = None
self.__remote_bitrate_estimator = None
else:
self.__jitter_buffer = JitterBuffer(capacity=128, is_video=True)
self.__nack_generator = NackGenerator()
self.__remote_bitrate_estimator = RemoteBitrateEstimator()
self._track: Optional[RemoteStreamTrack] = None
self.__rtcp_exited = asyncio.Event()
self.__rtcp_started = asyncio.Event()
self.__rtcp_task: Optional[asyncio.Future[None]] = None
self.__rtx_ssrc: Dict[int, int] = {}
self.__started = False
self.__stats = RTCStatsReport()
self.__timestamp_mapper = TimestampMapper()
self.__transport = transport
# RTCP
self.__lsr: Dict[int, int] = {}
self.__lsr_time: Dict[int, float] = {}
self.__remote_streams: Dict[int, StreamStatistics] = {}
self.__rtcp_ssrc: Optional[int] = None
# logging
self.__log_debug: Callable[..., None] = lambda *args: None
if logger.isEnabledFor(logging.DEBUG):
self.__log_debug = lambda msg, *args: logger.debug(
f"RTCRtpReceiver(%s) {msg}", self.__kind, *args
)
@property
def track(self) -> MediaStreamTrack:
"""
The :class:`MediaStreamTrack` which is being handled by the receiver.
"""
return self._track
@property
def transport(self) -> RTCDtlsTransport:
"""
The :class:`RTCDtlsTransport` over which the media for the receiver's
track is received.
"""
return self.__transport
@classmethod
def getCapabilities(self, kind) -> Optional[RTCRtpCapabilities]:
"""
Returns the most optimistic view of the system's capabilities for
receiving media of the given `kind`.
:rtype: :class:`RTCRtpCapabilities`
"""
return get_capabilities(kind)
async def getStats(self) -> RTCStatsReport:
"""
Returns statistics about the RTP receiver.
:rtype: :class:`RTCStatsReport`
"""
for ssrc, stream in self.__remote_streams.items():
self.__stats.add(
RTCInboundRtpStreamStats(
# RTCStats
timestamp=clock.current_datetime(),
type="inbound-rtp",
id="inbound-rtp_" + str(id(self)),
# RTCStreamStats
ssrc=ssrc,
kind=self.__kind,
transportId=self.transport._stats_id,
# RTCReceivedRtpStreamStats
packetsReceived=stream.packets_received,
packetsLost=stream.packets_lost,
jitter=stream.jitter,
# RTPInboundRtpStreamStats
)
)
self.__stats.update(self.transport._get_stats())
return self.__stats
def getSynchronizationSources(self) -> List[RTCRtpSynchronizationSource]:
"""
Returns a :class:`RTCRtpSynchronizationSource` for each unique SSRC identifier
received in the last 10 seconds.
"""
cutoff = clock.current_datetime() - datetime.timedelta(seconds=10)
sources = []
for source, timestamp in self.__active_ssrc.items():
if timestamp >= cutoff:
sources.append(
RTCRtpSynchronizationSource(source=source, timestamp=timestamp)
)
return sources
async def receive(self, parameters: RTCRtpReceiveParameters) -> None:
"""
Attempt to set the parameters controlling the receiving of media.
:param parameters: The :class:`RTCRtpParameters` for the receiver.
"""
if not self.__started:
for codec in parameters.codecs:
self.__codecs[codec.payloadType] = codec
for encoding in parameters.encodings:
if encoding.rtx:
self.__rtx_ssrc[encoding.rtx.ssrc] = encoding.ssrc
# start decoder thread
self.__decoder_thread = threading.Thread(
target=decoder_worker,
name=self.__kind + "-decoder",
args=(
asyncio.get_event_loop(),
self.__decoder_queue,
self._track._queue,
),
)
self.__decoder_thread.start()
self.__transport._register_rtp_receiver(self, parameters)
self.__rtcp_task = asyncio.ensure_future(self._run_rtcp())
self.__started = True
def setTransport(self, transport: RTCDtlsTransport) -> None:
self.__transport = transport
async def stop(self) -> None:
"""
Irreversibly stop the receiver.
"""
if self.__started:
self.__transport._unregister_rtp_receiver(self)
self.__stop_decoder()
# shutdown RTCP task
await self.__rtcp_started.wait()
self.__rtcp_task.cancel()
await self.__rtcp_exited.wait()
def _handle_disconnect(self) -> None:
self.__stop_decoder()
async def _handle_rtcp_packet(self, packet: AnyRtcpPacket) -> None:
self.__log_debug("< %s", packet)
if isinstance(packet, RtcpSrPacket):
self.__stats.add(
RTCRemoteOutboundRtpStreamStats(
# RTCStats
timestamp=clock.current_datetime(),
type="remote-outbound-rtp",
id=f"remote-outbound-rtp_{id(self)}",
# RTCStreamStats
ssrc=packet.ssrc,
kind=self.__kind,
transportId=self.transport._stats_id,
# RTCSentRtpStreamStats
packetsSent=packet.sender_info.packet_count,
bytesSent=packet.sender_info.octet_count,
# RTCRemoteOutboundRtpStreamStats
remoteTimestamp=clock.datetime_from_ntp(
packet.sender_info.ntp_timestamp
),
)
)
self.__lsr[packet.ssrc] = (
(packet.sender_info.ntp_timestamp) >> 16
) & 0xFFFFFFFF
self.__lsr_time[packet.ssrc] = time.time()
elif isinstance(packet, RtcpByePacket):
self.__stop_decoder()
async def _handle_rtp_packet(self, packet: RtpPacket, arrival_time_ms: int) -> None:
"""
Handle an incoming RTP packet.
"""
self.__log_debug("< %s", packet)
# feed bitrate estimator
if self.__remote_bitrate_estimator is not None:
if packet.extensions.abs_send_time is not None:
remb = self.__remote_bitrate_estimator.add(
abs_send_time=packet.extensions.abs_send_time,
arrival_time_ms=arrival_time_ms,
payload_size=len(packet.payload) + packet.padding_size,
ssrc=packet.ssrc,
)
if self.__rtcp_ssrc is not None and remb is not None:
# send Receiver Estimated Maximum Bitrate feedback
rtcp_packet = RtcpPsfbPacket(
fmt=RTCP_PSFB_APP,
ssrc=self.__rtcp_ssrc,
media_ssrc=0,
fci=pack_remb_fci(*remb),
)
await self._send_rtcp(rtcp_packet)
# keep track of sources
self.__active_ssrc[packet.ssrc] = clock.current_datetime()
# check the codec is known
codec = self.__codecs.get(packet.payload_type)
if codec is None:
self.__log_debug(
"x RTP packet with unknown payload type %d", packet.payload_type
)
return
# feed RTCP statistics
if packet.ssrc not in self.__remote_streams:
self.__remote_streams[packet.ssrc] = StreamStatistics(codec.clockRate)
self.__remote_streams[packet.ssrc].add(packet)
# unwrap retransmission packet
if is_rtx(codec):
original_ssrc = self.__rtx_ssrc.get(packet.ssrc)
if original_ssrc is None:
self.__log_debug("x RTX packet from unknown SSRC %d", packet.ssrc)
return
if len(packet.payload) < 2:
return
codec = self.__codecs[codec.parameters["apt"]]
packet = unwrap_rtx(
packet, payload_type=codec.payloadType, ssrc=original_ssrc
)
# send NACKs for any missing any packets
if self.__nack_generator is not None and self.__nack_generator.add(packet):
await self._send_rtcp_nack(
packet.ssrc, sorted(self.__nack_generator.missing)
)
# parse codec-specific information
try:
if packet.payload:
packet._data = depayload(codec, packet.payload) # type: ignore
else:
packet._data = b"" # type: ignore
except ValueError as exc:
self.__log_debug("x RTP payload parsing failed: %s", exc)
return
# try to re-assemble encoded frame
pli_flag, encoded_frame = self.__jitter_buffer.add(packet)
# check if the PLI should be sent
if pli_flag:
await self._send_rtcp_pli(packet.ssrc)
# if we have a complete encoded frame, decode it
if encoded_frame is not None and self.__decoder_thread:
encoded_frame.timestamp = self.__timestamp_mapper.map(
encoded_frame.timestamp
)
self.__decoder_queue.put((codec, encoded_frame))
async def _run_rtcp(self) -> None:
self.__log_debug("- RTCP started")
self.__rtcp_started.set()
try:
while True:
# The interval between RTCP packets is varied randomly over the
# range [0.5, 1.5] times the calculated interval.
await asyncio.sleep(0.5 + random.random())
# RTCP RR
reports = []
for ssrc, stream in self.__remote_streams.items():
lsr = 0
dlsr = 0
if ssrc in self.__lsr:
lsr = self.__lsr[ssrc]
delay = time.time() - self.__lsr_time[ssrc]
if delay > 0 and delay < 65536:
dlsr = int(delay * 65536)
reports.append(
RtcpReceiverInfo(
ssrc=ssrc,
fraction_lost=stream.fraction_lost,
packets_lost=stream.packets_lost,
highest_sequence=stream.max_seq,
jitter=stream.jitter,
lsr=lsr,
dlsr=dlsr,
)
)
if self.__rtcp_ssrc is not None and reports:
packet = RtcpRrPacket(ssrc=self.__rtcp_ssrc, reports=reports)
await self._send_rtcp(packet)
except asyncio.CancelledError:
pass
self.__log_debug("- RTCP finished")
self.__rtcp_exited.set()
async def _send_rtcp(self, packet) -> None:
self.__log_debug("> %s", packet)
try:
await self.transport._send_rtp(bytes(packet))
except ConnectionError:
pass
async def _send_rtcp_nack(self, media_ssrc: int, lost: List[int]) -> None:
"""
Send an RTCP packet to report missing RTP packets.
"""
if self.__rtcp_ssrc is not None:
packet = RtcpRtpfbPacket(
fmt=RTCP_RTPFB_NACK, ssrc=self.__rtcp_ssrc, media_ssrc=media_ssrc
)
packet.lost = lost
await self._send_rtcp(packet)
async def _send_rtcp_pli(self, media_ssrc: int) -> None:
"""
Send an RTCP packet to report picture loss.
"""
if self.__rtcp_ssrc is not None:
packet = RtcpPsfbPacket(
fmt=RTCP_PSFB_PLI, ssrc=self.__rtcp_ssrc, media_ssrc=media_ssrc
)
await self._send_rtcp(packet)
def _set_rtcp_ssrc(self, ssrc: int) -> None:
self.__rtcp_ssrc = ssrc
def __stop_decoder(self) -> None:
"""
Stop the decoder thread, which will in turn stop the track.
"""
if self.__decoder_thread:
self.__decoder_queue.put(None)
self.__decoder_thread.join()
self.__decoder_thread = 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/src/aiortc/rtp.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtp.py | import math
import os
import struct
from dataclasses import dataclass, field
from struct import pack, unpack, unpack_from
from typing import Any, List, Optional, Tuple, Union
from av import AudioFrame
from .rtcrtpparameters import RTCRtpParameters
# used for NACK and retransmission
RTP_HISTORY_SIZE = 128
# reserved to avoid confusion with RTCP
FORBIDDEN_PAYLOAD_TYPES = range(72, 77)
DYNAMIC_PAYLOAD_TYPES = range(96, 128)
RTP_HEADER_LENGTH = 12
RTCP_HEADER_LENGTH = 4
PACKETS_LOST_MIN = -(1 << 23)
PACKETS_LOST_MAX = (1 << 23) - 1
RTCP_SR = 200
RTCP_RR = 201
RTCP_SDES = 202
RTCP_BYE = 203
RTCP_RTPFB = 205
RTCP_PSFB = 206
RTCP_RTPFB_NACK = 1
RTCP_PSFB_PLI = 1
RTCP_PSFB_SLI = 2
RTCP_PSFB_RPSI = 3
RTCP_PSFB_APP = 15
@dataclass
class HeaderExtensions:
abs_send_time: Optional[int] = None
audio_level: Any = None
mid: Any = None
repaired_rtp_stream_id: Any = None
rtp_stream_id: Any = None
transmission_offset: Optional[int] = None
transport_sequence_number: Optional[int] = None
class HeaderExtensionsMap:
def __init__(self) -> None:
self.__ids = HeaderExtensions()
def configure(self, parameters: RTCRtpParameters) -> None:
for ext in parameters.headerExtensions:
if ext.uri == "urn:ietf:params:rtp-hdrext:sdes:mid":
self.__ids.mid = ext.id
elif ext.uri == "urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id":
self.__ids.repaired_rtp_stream_id = ext.id
elif ext.uri == "urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id":
self.__ids.rtp_stream_id = ext.id
elif (
ext.uri == "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time"
):
self.__ids.abs_send_time = ext.id
elif ext.uri == "urn:ietf:params:rtp-hdrext:toffset":
self.__ids.transmission_offset = ext.id
elif ext.uri == "urn:ietf:params:rtp-hdrext:ssrc-audio-level":
self.__ids.audio_level = ext.id
elif (
ext.uri
== "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01"
):
self.__ids.transport_sequence_number = ext.id
def get(self, extension_profile: int, extension_value: bytes) -> HeaderExtensions:
values = HeaderExtensions()
for x_id, x_value in unpack_header_extensions(
extension_profile, extension_value
):
if x_id == self.__ids.mid:
values.mid = x_value.decode("utf8")
elif x_id == self.__ids.repaired_rtp_stream_id:
values.repaired_rtp_stream_id = x_value.decode("ascii")
elif x_id == self.__ids.rtp_stream_id:
values.rtp_stream_id = x_value.decode("ascii")
elif x_id == self.__ids.abs_send_time:
values.abs_send_time = unpack("!L", b"\00" + x_value)[0]
elif x_id == self.__ids.transmission_offset:
values.transmission_offset = unpack("!l", x_value + b"\00")[0] >> 8
elif x_id == self.__ids.audio_level:
vad_level = unpack("!B", x_value)[0]
values.audio_level = (vad_level & 0x80 == 0x80, vad_level & 0x7F)
elif x_id == self.__ids.transport_sequence_number:
values.transport_sequence_number = unpack("!H", x_value)[0]
return values
def set(self, values: HeaderExtensions):
extensions = []
if values.mid is not None and self.__ids.mid:
extensions.append((self.__ids.mid, values.mid.encode("utf8")))
if (
values.repaired_rtp_stream_id is not None
and self.__ids.repaired_rtp_stream_id
):
extensions.append(
(
self.__ids.repaired_rtp_stream_id,
values.repaired_rtp_stream_id.encode("ascii"),
)
)
if values.rtp_stream_id is not None and self.__ids.rtp_stream_id:
extensions.append(
(self.__ids.rtp_stream_id, values.rtp_stream_id.encode("ascii"))
)
if values.abs_send_time is not None and self.__ids.abs_send_time:
extensions.append(
(self.__ids.abs_send_time, pack("!L", values.abs_send_time)[1:])
)
if values.transmission_offset is not None and self.__ids.transmission_offset:
extensions.append(
(
self.__ids.transmission_offset,
pack("!l", values.transmission_offset << 8)[0:2],
)
)
if values.audio_level is not None and self.__ids.audio_level:
extensions.append(
(
self.__ids.audio_level,
pack(
"!B",
(0x80 if values.audio_level[0] else 0)
| (values.audio_level[1] & 0x7F),
),
)
)
if (
values.transport_sequence_number is not None
and self.__ids.transport_sequence_number
):
extensions.append(
(
self.__ids.transport_sequence_number,
pack("!H", values.transport_sequence_number),
)
)
return pack_header_extensions(extensions)
def clamp_packets_lost(count: int) -> int:
return max(PACKETS_LOST_MIN, min(count, PACKETS_LOST_MAX))
def pack_packets_lost(count: int) -> bytes:
return pack("!l", count)[1:]
def unpack_packets_lost(d: bytes) -> int:
if d[0] & 0x80:
d = b"\xff" + d
else:
d = b"\x00" + d
return unpack("!l", d)[0]
def pack_rtcp_packet(packet_type: int, count: int, payload: bytes) -> bytes:
assert len(payload) % 4 == 0
return pack("!BBH", (2 << 6) | count, packet_type, len(payload) // 4) + payload
def pack_remb_fci(bitrate: int, ssrcs: List[int]) -> bytes:
"""
Pack the FCI for a Receiver Estimated Maximum Bitrate report.
https://tools.ietf.org/html/draft-alvestrand-rmcat-remb-03
"""
data = b"REMB"
exponent = 0
mantissa = bitrate
while mantissa > 0x3FFFF:
mantissa >>= 1
exponent += 1
data += pack(
"!BBH", len(ssrcs), (exponent << 2) | (mantissa >> 16), (mantissa & 0xFFFF)
)
for ssrc in ssrcs:
data += pack("!L", ssrc)
return data
def unpack_remb_fci(data: bytes) -> Tuple[int, List[int]]:
"""
Unpack the FCI for a Receiver Estimated Maximum Bitrate report.
https://tools.ietf.org/html/draft-alvestrand-rmcat-remb-03
"""
if len(data) < 8 or data[0:4] != b"REMB":
raise ValueError("Invalid REMB prefix")
exponent = (data[5] & 0xFC) >> 2
mantissa = ((data[5] & 0x03) << 16) | (data[6] << 8) | data[7]
bitrate = mantissa << exponent
pos = 8
ssrcs = []
for r in range(data[4]):
ssrcs.append(unpack_from("!L", data, pos)[0])
pos += 4
return (bitrate, ssrcs)
def is_rtcp(msg: bytes) -> bool:
return len(msg) >= 2 and msg[1] >= 192 and msg[1] <= 208
def padl(length: int) -> int:
"""
Return amount of padding needed for a 4-byte multiple.
"""
return 4 * ((length + 3) // 4) - length
def unpack_header_extensions(
extension_profile: int, extension_value: bytes
) -> List[Tuple[int, bytes]]:
"""
Parse header extensions according to RFC 5285.
"""
extensions = []
pos = 0
if extension_profile == 0xBEDE:
# One-Byte Header
while pos < len(extension_value):
# skip padding byte
if extension_value[pos] == 0:
pos += 1
continue
x_id = (extension_value[pos] & 0xF0) >> 4
x_length = (extension_value[pos] & 0x0F) + 1
pos += 1
if len(extension_value) < pos + x_length:
raise ValueError("RTP one-byte header extension value is truncated")
x_value = extension_value[pos : pos + x_length]
extensions.append((x_id, x_value))
pos += x_length
elif extension_profile == 0x1000:
# Two-Byte Header
while pos < len(extension_value):
# skip padding byte
if extension_value[pos] == 0:
pos += 1
continue
if len(extension_value) < pos + 2:
raise ValueError("RTP two-byte header extension is truncated")
x_id, x_length = unpack_from("!BB", extension_value, pos)
pos += 2
if len(extension_value) < pos + x_length:
raise ValueError("RTP two-byte header extension value is truncated")
x_value = extension_value[pos : pos + x_length]
extensions.append((x_id, x_value))
pos += x_length
return extensions
def pack_header_extensions(extensions: List[Tuple[int, bytes]]) -> Tuple[int, bytes]:
"""
Serialize header extensions according to RFC 5285.
"""
extension_profile = 0
extension_value = b""
if not extensions:
return extension_profile, extension_value
one_byte = True
for x_id, x_value in extensions:
x_length = len(x_value)
assert x_id > 0 and x_id < 256
assert x_length >= 0 and x_length < 256
if x_id > 14 or x_length == 0 or x_length > 16:
one_byte = False
if one_byte:
# One-Byte Header
extension_profile = 0xBEDE
extension_value = b""
for x_id, x_value in extensions:
x_length = len(x_value)
extension_value += pack("!B", (x_id << 4) | (x_length - 1))
extension_value += x_value
else:
# Two-Byte Header
extension_profile = 0x1000
extension_value = b""
for x_id, x_value in extensions:
x_length = len(x_value)
extension_value += pack("!BB", x_id, x_length)
extension_value += x_value
extension_value += b"\x00" * padl(len(extension_value))
return extension_profile, extension_value
def compute_audio_level_dbov(frame: AudioFrame):
"""
Compute the energy level as spelled out in RFC 6465, Appendix A.
"""
MAX_SAMPLE_VALUE = 32767
MAX_AUDIO_LEVEL = 0
MIN_AUDIO_LEVEL = -127
rms = 0
buf = bytes(frame.planes[0])
s = struct.Struct("h")
for unpacked in s.iter_unpack(buf):
sample = unpacked[0]
rms += sample * sample
rms = math.sqrt(rms / (frame.samples * MAX_SAMPLE_VALUE * MAX_SAMPLE_VALUE))
if rms > 0:
db = 20 * math.log10(rms)
db = max(db, MIN_AUDIO_LEVEL)
db = min(db, MAX_AUDIO_LEVEL)
else:
db = MIN_AUDIO_LEVEL
return round(db)
@dataclass
class RtcpReceiverInfo:
ssrc: int
fraction_lost: int
packets_lost: int
highest_sequence: int
jitter: int
lsr: int
dlsr: int
def __bytes__(self) -> bytes:
data = pack("!LB", self.ssrc, self.fraction_lost)
data += pack_packets_lost(self.packets_lost)
data += pack("!LLLL", self.highest_sequence, self.jitter, self.lsr, self.dlsr)
return data
@classmethod
def parse(cls, data: bytes):
ssrc, fraction_lost = unpack("!LB", data[0:5])
packets_lost = unpack_packets_lost(data[5:8])
highest_sequence, jitter, lsr, dlsr = unpack("!LLLL", data[8:])
return cls(
ssrc=ssrc,
fraction_lost=fraction_lost,
packets_lost=packets_lost,
highest_sequence=highest_sequence,
jitter=jitter,
lsr=lsr,
dlsr=dlsr,
)
@dataclass
class RtcpSenderInfo:
ntp_timestamp: int
rtp_timestamp: int
packet_count: int
octet_count: int
def __bytes__(self) -> bytes:
return pack(
"!QLLL",
self.ntp_timestamp,
self.rtp_timestamp,
self.packet_count,
self.octet_count,
)
@classmethod
def parse(cls, data: bytes):
ntp_timestamp, rtp_timestamp, packet_count, octet_count = unpack("!QLLL", data)
return cls(
ntp_timestamp=ntp_timestamp,
rtp_timestamp=rtp_timestamp,
packet_count=packet_count,
octet_count=octet_count,
)
@dataclass
class RtcpSourceInfo:
ssrc: int
items: List[Tuple[Any, bytes]]
@dataclass
class RtcpByePacket:
sources: List[int]
def __bytes__(self) -> bytes:
payload = b"".join([pack("!L", ssrc) for ssrc in self.sources])
return pack_rtcp_packet(RTCP_BYE, len(self.sources), payload)
@classmethod
def parse(cls, data: bytes, count: int):
if len(data) < 4 * count:
raise ValueError("RTCP bye length is invalid")
if count > 0:
sources = list(unpack_from("!" + ("L" * count), data, 0))
else:
sources = []
return cls(sources=sources)
@dataclass
class RtcpPsfbPacket:
"""
Payload-Specific Feedback Message (RFC 4585).
"""
fmt: int
ssrc: int
media_ssrc: int
fci: bytes = b""
def __bytes__(self) -> bytes:
payload = pack("!LL", self.ssrc, self.media_ssrc) + self.fci
return pack_rtcp_packet(RTCP_PSFB, self.fmt, payload)
@classmethod
def parse(cls, data: bytes, fmt: int):
if len(data) < 8:
raise ValueError("RTCP payload-specific feedback length is invalid")
ssrc, media_ssrc = unpack("!LL", data[0:8])
fci = data[8:]
return cls(fmt=fmt, ssrc=ssrc, media_ssrc=media_ssrc, fci=fci)
@dataclass
class RtcpRrPacket:
ssrc: int
reports: List[RtcpReceiverInfo] = field(default_factory=list)
def __bytes__(self) -> bytes:
payload = pack("!L", self.ssrc)
for report in self.reports:
payload += bytes(report)
return pack_rtcp_packet(RTCP_RR, len(self.reports), payload)
@classmethod
def parse(cls, data: bytes, count: int):
if len(data) != 4 + 24 * count:
raise ValueError("RTCP receiver report length is invalid")
ssrc = unpack("!L", data[0:4])[0]
pos = 4
reports = []
for r in range(count):
reports.append(RtcpReceiverInfo.parse(data[pos : pos + 24]))
pos += 24
return cls(ssrc=ssrc, reports=reports)
@dataclass
class RtcpRtpfbPacket:
"""
Generic RTP Feedback Message (RFC 4585).
"""
fmt: int
ssrc: int
media_ssrc: int
# generick NACK
lost: List[int] = field(default_factory=list)
def __bytes__(self) -> bytes:
payload = pack("!LL", self.ssrc, self.media_ssrc)
if self.lost:
pid = self.lost[0]
blp = 0
for p in self.lost[1:]:
d = p - pid - 1
if d < 16:
blp |= 1 << d
else:
payload += pack("!HH", pid, blp)
pid = p
blp = 0
payload += pack("!HH", pid, blp)
return pack_rtcp_packet(RTCP_RTPFB, self.fmt, payload)
@classmethod
def parse(cls, data: bytes, fmt: int):
if len(data) < 8 or len(data) % 4:
raise ValueError("RTCP RTP feedback length is invalid")
ssrc, media_ssrc = unpack("!LL", data[0:8])
lost = []
for pos in range(8, len(data), 4):
pid, blp = unpack("!HH", data[pos : pos + 4])
lost.append(pid)
for d in range(0, 16):
if (blp >> d) & 1:
lost.append(pid + d + 1)
return cls(fmt=fmt, ssrc=ssrc, media_ssrc=media_ssrc, lost=lost)
@dataclass
class RtcpSdesPacket:
chunks: List[RtcpSourceInfo] = field(default_factory=list)
def __bytes__(self) -> bytes:
payload = b""
for chunk in self.chunks:
payload += pack("!L", chunk.ssrc)
for d_type, d_value in chunk.items:
payload += pack("!BB", d_type, len(d_value)) + d_value
payload += b"\x00\x00"
while len(payload) % 4:
payload += b"\x00"
return pack_rtcp_packet(RTCP_SDES, len(self.chunks), payload)
@classmethod
def parse(cls, data: bytes, count: int):
pos = 0
chunks = []
for r in range(count):
if len(data) < pos + 4:
raise ValueError("RTCP SDES source is truncated")
ssrc = unpack_from("!L", data, pos)[0]
pos += 4
items = []
while pos < len(data) - 1:
d_type, d_length = unpack_from("!BB", data, pos)
pos += 2
if len(data) < pos + d_length:
raise ValueError("RTCP SDES item is truncated")
d_value = data[pos : pos + d_length]
pos += d_length
if d_type == 0:
break
else:
items.append((d_type, d_value))
chunks.append(RtcpSourceInfo(ssrc=ssrc, items=items))
return cls(chunks=chunks)
@dataclass
class RtcpSrPacket:
ssrc: int
sender_info: RtcpSenderInfo
reports: List[RtcpReceiverInfo] = field(default_factory=list)
def __bytes__(self) -> bytes:
payload = pack("!L", self.ssrc)
payload += bytes(self.sender_info)
for report in self.reports:
payload += bytes(report)
return pack_rtcp_packet(RTCP_SR, len(self.reports), payload)
@classmethod
def parse(cls, data: bytes, count: int):
if len(data) != 24 + 24 * count:
raise ValueError("RTCP sender report length is invalid")
ssrc = unpack_from("!L", data)[0]
sender_info = RtcpSenderInfo.parse(data[4:24])
pos = 24
reports = []
for r in range(count):
reports.append(RtcpReceiverInfo.parse(data[pos : pos + 24]))
pos += 24
return RtcpSrPacket(ssrc=ssrc, sender_info=sender_info, reports=reports)
AnyRtcpPacket = Union[
RtcpByePacket,
RtcpPsfbPacket,
RtcpRrPacket,
RtcpRtpfbPacket,
RtcpSdesPacket,
RtcpSrPacket,
]
class RtcpPacket:
@classmethod
def parse(cls, data: bytes) -> List[AnyRtcpPacket]:
pos = 0
packets = []
while pos < len(data):
if len(data) < pos + RTCP_HEADER_LENGTH:
raise ValueError(
f"RTCP packet length is less than {RTCP_HEADER_LENGTH} bytes"
)
v_p_count, packet_type, length = unpack("!BBH", data[pos : pos + 4])
version = v_p_count >> 6
padding = (v_p_count >> 5) & 1
count = v_p_count & 0x1F
if version != 2:
raise ValueError("RTCP packet has invalid version")
pos += 4
end = pos + length * 4
if len(data) < end:
raise ValueError("RTCP packet is truncated")
payload = data[pos:end]
pos = end
if padding:
if not payload or not payload[-1] or payload[-1] > len(payload):
raise ValueError("RTCP packet padding length is invalid")
payload = payload[0 : -payload[-1]]
if packet_type == RTCP_BYE:
packets.append(RtcpByePacket.parse(payload, count))
elif packet_type == RTCP_SDES:
packets.append(RtcpSdesPacket.parse(payload, count))
elif packet_type == RTCP_SR:
packets.append(RtcpSrPacket.parse(payload, count))
elif packet_type == RTCP_RR:
packets.append(RtcpRrPacket.parse(payload, count))
elif packet_type == RTCP_RTPFB:
packets.append(RtcpRtpfbPacket.parse(payload, count))
elif packet_type == RTCP_PSFB:
packets.append(RtcpPsfbPacket.parse(payload, count))
return packets
class RtpPacket:
def __init__(
self,
payload_type: int = 0,
marker: int = 0,
sequence_number: int = 0,
timestamp: int = 0,
ssrc: int = 0,
payload: bytes = b"",
) -> None:
self.version = 2
self.marker = marker
self.payload_type = payload_type
self.sequence_number = sequence_number
self.timestamp = timestamp
self.ssrc = ssrc
self.csrc: List[int] = []
self.extensions = HeaderExtensions()
self.payload = payload
self.padding_size = 0
def __repr__(self) -> str:
return (
f"RtpPacket(seq={self.sequence_number}, ts={self.timestamp}, "
f"marker={self.marker}, payload={self.payload_type}, {len(self.payload)} bytes)"
)
@classmethod
def parse(cls, data: bytes, extensions_map=HeaderExtensionsMap()):
if len(data) < RTP_HEADER_LENGTH:
raise ValueError(
f"RTP packet length is less than {RTP_HEADER_LENGTH} bytes"
)
v_p_x_cc, m_pt, sequence_number, timestamp, ssrc = unpack("!BBHLL", data[0:12])
version = v_p_x_cc >> 6
padding = (v_p_x_cc >> 5) & 1
extension = (v_p_x_cc >> 4) & 1
cc = v_p_x_cc & 0x0F
if version != 2:
raise ValueError("RTP packet has invalid version")
if len(data) < RTP_HEADER_LENGTH + 4 * cc:
raise ValueError("RTP packet has truncated CSRC")
packet = cls(
marker=(m_pt >> 7),
payload_type=(m_pt & 0x7F),
sequence_number=sequence_number,
timestamp=timestamp,
ssrc=ssrc,
)
pos = RTP_HEADER_LENGTH
for i in range(0, cc):
packet.csrc.append(unpack_from("!L", data, pos)[0])
pos += 4
if extension:
if len(data) < pos + 4:
raise ValueError("RTP packet has truncated extension profile / length")
extension_profile, extension_length = unpack_from("!HH", data, pos)
extension_length *= 4
pos += 4
if len(data) < pos + extension_length:
raise ValueError("RTP packet has truncated extension value")
extension_value = data[pos : pos + extension_length]
pos += extension_length
packet.extensions = extensions_map.get(extension_profile, extension_value)
if padding:
padding_len = data[-1]
if not padding_len or padding_len > len(data) - pos:
raise ValueError("RTP packet padding length is invalid")
packet.padding_size = padding_len
packet.payload = data[pos:-padding_len]
else:
packet.payload = data[pos:]
return packet
def serialize(self, extensions_map=HeaderExtensionsMap()) -> bytes:
extension_profile, extension_value = extensions_map.set(self.extensions)
has_extension = bool(extension_value)
padding = self.padding_size > 0
data = pack(
"!BBHLL",
(self.version << 6)
| (padding << 5)
| (has_extension << 4)
| len(self.csrc),
(self.marker << 7) | self.payload_type,
self.sequence_number,
self.timestamp,
self.ssrc,
)
for csrc in self.csrc:
data += pack("!L", csrc)
if has_extension:
data += pack("!HH", extension_profile, len(extension_value) >> 2)
data += extension_value
data += self.payload
if padding:
data += os.urandom(self.padding_size - 1)
data += bytes([self.padding_size])
return data
def unwrap_rtx(rtx: RtpPacket, payload_type: int, ssrc: int) -> RtpPacket:
"""
Recover initial packet from a retransmission packet.
"""
packet = RtpPacket(
payload_type=payload_type,
marker=rtx.marker,
sequence_number=unpack("!H", rtx.payload[0:2])[0],
timestamp=rtx.timestamp,
ssrc=ssrc,
payload=rtx.payload[2:],
)
packet.csrc = rtx.csrc
packet.extensions = rtx.extensions
return packet
def wrap_rtx(
packet: RtpPacket, payload_type: int, sequence_number: int, ssrc: int
) -> RtpPacket:
"""
Create a retransmission packet from a lost packet.
"""
rtx = RtpPacket(
payload_type=payload_type,
marker=packet.marker,
sequence_number=sequence_number,
timestamp=packet.timestamp,
ssrc=ssrc,
payload=pack("!H", packet.sequence_number) + packet.payload,
)
rtx.csrc = packet.csrc
rtx.extensions = packet.extensions
return rtx
| 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/src/aiortc/exceptions.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/exceptions.py | class InternalError(Exception):
pass
class InvalidAccessError(Exception):
pass
class InvalidStateError(Exception):
pass
class OperationError(Exception):
pass
| 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/src/aiortc/jitterbuffer.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/jitterbuffer.py | from typing import List, Optional, Tuple
from .rtp import RtpPacket
from .utils import uint16_add
MAX_MISORDER = 100
class JitterFrame:
def __init__(self, data: bytes, timestamp: int) -> None:
self.data = data
self.timestamp = timestamp
class JitterBuffer:
def __init__(
self, capacity: int, prefetch: int = 0, is_video: bool = False
) -> None:
assert capacity & (capacity - 1) == 0, "capacity must be a power of 2"
self._capacity = capacity
self._origin: Optional[int] = None
self._packets: List[Optional[RtpPacket]] = [None for i in range(capacity)]
self._prefetch = prefetch
self._is_video = is_video
@property
def capacity(self) -> int:
return self._capacity
def add(self, packet: RtpPacket) -> Tuple[bool, Optional[JitterFrame]]:
pli_flag = False
if self._origin is None:
self._origin = packet.sequence_number
delta = 0
misorder = 0
else:
delta = uint16_add(packet.sequence_number, -self._origin)
misorder = uint16_add(self._origin, -packet.sequence_number)
if misorder < delta:
if misorder >= MAX_MISORDER:
self.remove(self.capacity)
self._origin = packet.sequence_number
delta = misorder = 0
if self._is_video:
pli_flag = True
else:
return pli_flag, None
if delta >= self.capacity:
# remove just enough frames to fit the received packets
excess = delta - self.capacity + 1
if self.smart_remove(excess):
self._origin = packet.sequence_number
if self._is_video:
pli_flag = True
pos = packet.sequence_number % self._capacity
self._packets[pos] = packet
return pli_flag, self._remove_frame(packet.sequence_number)
def _remove_frame(self, sequence_number: int) -> Optional[JitterFrame]:
frame = None
frames = 0
packets = []
remove = 0
timestamp = None
for count in range(self.capacity):
pos = (self._origin + count) % self._capacity
packet = self._packets[pos]
if packet is None:
break
if timestamp is None:
timestamp = packet.timestamp
elif packet.timestamp != timestamp:
# we now have a complete frame, only store the first one
if frame is None:
frame = JitterFrame(
data=b"".join([x._data for x in packets]), timestamp=timestamp
)
remove = count
# check we have prefetched enough
frames += 1
if frames >= self._prefetch:
self.remove(remove)
return frame
# start a new frame
packets = []
timestamp = packet.timestamp
packets.append(packet)
return None
def remove(self, count: int) -> None:
assert count <= self._capacity
for i in range(count):
pos = self._origin % self._capacity
self._packets[pos] = None
self._origin = uint16_add(self._origin, 1)
def smart_remove(self, count: int) -> bool:
"""
smart_remove makes sure that all packages belonging to the same frame are removed
it prevents sending corrupted frames to decoder
"""
timestamp = None
for i in range(self._capacity):
pos = self._origin % self._capacity
packet = self._packets[pos]
if packet is not None:
if i >= count and timestamp != packet.timestamp:
break
timestamp = packet.timestamp
self._packets[pos] = None
self._origin = uint16_add(self._origin, 1)
if i == self._capacity - 1:
return True
return False
| 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/src/aiortc/rtcdtlstransport.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcdtlstransport.py | import asyncio
import binascii
import datetime
import enum
import logging
import os
import traceback
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Set, Type, TypeVar
import pylibsrtp
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ec
from OpenSSL import SSL, crypto
from pyee.asyncio import AsyncIOEventEmitter
from pylibsrtp import Policy, Session
from . import clock, rtp
from .rtcicetransport import RTCIceTransport
from .rtcrtpparameters import RTCRtpReceiveParameters, RTCRtpSendParameters
from .rtp import (
AnyRtcpPacket,
RtcpByePacket,
RtcpPacket,
RtcpPsfbPacket,
RtcpRrPacket,
RtcpRtpfbPacket,
RtcpSrPacket,
RtpPacket,
is_rtcp,
)
from .stats import RTCStatsReport, RTCTransportStats
SRTP_KEY_LEN = 16
SRTP_SALT_LEN = 14
CERTIFICATE_T = TypeVar("CERTIFICATE_T", bound="RTCCertificate")
logger = logging.getLogger(__name__)
# Log TLS secrets to a file, similar to browsers
SSLKEYLOGFILE = os.getenv("SSLKEYLOGFILE")
if SSLKEYLOGFILE:
logger.warning("Logging all TLS keys to %s", SSLKEYLOGFILE)
def DTLSv1_get_timeout(self):
ptv_sec = SSL._ffi.new("time_t *")
ptv_usec = SSL._ffi.new("long *")
if SSL._lib.Cryptography_DTLSv1_get_timeout(self._ssl, ptv_sec, ptv_usec):
return ptv_sec[0] + (ptv_usec[0] / 1000000)
else:
return None
def DTLSv1_handle_timeout(self):
SSL._lib.DTLSv1_handle_timeout(self._ssl)
def certificate_digest(x509: crypto.X509) -> str:
return x509.digest("SHA256").decode("ascii")
def generate_certificate(key: ec.EllipticCurvePrivateKey) -> x509.Certificate:
name = x509.Name(
[
x509.NameAttribute(
x509.NameOID.COMMON_NAME,
binascii.hexlify(os.urandom(16)).decode("ascii"),
)
]
)
builder = (
x509.CertificateBuilder()
.subject_name(name)
.issuer_name(name)
.public_key(key.public_key())
.serial_number(x509.random_serial_number())
.not_valid_before(datetime.datetime.utcnow() - datetime.timedelta(days=1))
.not_valid_after(datetime.datetime.utcnow() + datetime.timedelta(days=30))
)
return builder.sign(key, hashes.SHA256(), default_backend())
def get_srtp_key_salt(src, idx: int) -> bytes:
key_start = idx * SRTP_KEY_LEN
salt_start = 2 * SRTP_KEY_LEN + idx * SRTP_SALT_LEN
return (
src[key_start : key_start + SRTP_KEY_LEN]
+ src[salt_start : salt_start + SRTP_SALT_LEN]
)
def tls_keylog(ssl, line):
if SSLKEYLOGFILE:
with open(SSLKEYLOGFILE, "ab") as f:
f.write(line)
f.write(b"\n")
class State(enum.Enum):
NEW = 0
CONNECTING = 1
CONNECTED = 2
CLOSED = 3
FAILED = 4
@dataclass
class RTCDtlsFingerprint:
"""
The :class:`RTCDtlsFingerprint` dictionary includes the hash function
algorithm and certificate fingerprint.
"""
algorithm: str
"The hash function name, for instance `'sha-256'`."
value: str
"The fingerprint value."
class RTCCertificate:
"""
The :class:`RTCCertificate` interface enables the certificates used by an
:class:`RTCDtlsTransport`.
To generate a certificate and the corresponding private key use :func:`generateCertificate`.
"""
def __init__(self, key: crypto.PKey, cert: crypto.X509) -> None:
self._key = key
self._cert = cert
@property
def expires(self) -> datetime.datetime:
"""
The date and time after which the certificate will be considered invalid.
"""
return self._cert.to_cryptography().not_valid_after.replace(
tzinfo=datetime.timezone.utc
)
def getFingerprints(self) -> List[RTCDtlsFingerprint]:
"""
Returns the list of certificate fingerprints, one of which is computed
with the digest algorithm used in the certificate signature.
"""
return [
RTCDtlsFingerprint(
algorithm="sha-256",
value=certificate_digest(self._cert),
)
]
@classmethod
def generateCertificate(cls: Type[CERTIFICATE_T]) -> CERTIFICATE_T:
"""
Create and return an X.509 certificate and corresponding private key.
:rtype: RTCCertificate
"""
key = ec.generate_private_key(ec.SECP256R1(), default_backend())
cert = generate_certificate(key)
return cls(
key=crypto.PKey.from_cryptography_key(key),
cert=crypto.X509.from_cryptography(cert),
)
def _create_ssl_context(self) -> SSL.Context:
ctx = SSL.Context(SSL.DTLS_METHOD)
ctx.set_verify(
SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, lambda *args: 1
)
if SSLKEYLOGFILE:
ctx.set_keylog_callback(tls_keylog)
ctx.use_certificate(self._cert)
ctx.use_privatekey(self._key)
ctx.set_cipher_list(b"HIGH:!CAMELLIA:!aNULL")
ctx.set_tlsext_use_srtp(b"SRTP_AES128_CM_SHA1_80")
return ctx
@dataclass
class RTCDtlsParameters:
"""
The :class:`RTCDtlsParameters` dictionary includes information relating to
DTLS configuration.
"""
fingerprints: List[RTCDtlsFingerprint] = field(default_factory=list)
"List of :class:`RTCDtlsFingerprint`, one fingerprint for each certificate."
role: str = "auto"
"The DTLS role, with a default of auto."
class RtpRouter:
"""
Router to associate RTP/RTCP packets with streams.
https://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-53
"""
def __init__(self) -> None:
self.receivers: Set = set()
self.senders: Dict[int, Any] = {}
self.mid_table: Dict[str, Any] = {}
self.ssrc_table: Dict[int, Any] = {}
self.payload_type_table: Dict[int, Set] = {}
def register_receiver(
self,
receiver,
ssrcs: List[int],
payload_types: List[int],
mid: Optional[str] = None,
):
self.receivers.add(receiver)
if mid is not None:
self.mid_table[mid] = receiver
for ssrc in ssrcs:
self.ssrc_table[ssrc] = receiver
for payload_type in payload_types:
if payload_type not in self.payload_type_table:
self.payload_type_table[payload_type] = set()
self.payload_type_table[payload_type].add(receiver)
def register_sender(self, sender, ssrc: int) -> None:
self.senders[ssrc] = sender
def route_rtcp(self, packet: AnyRtcpPacket) -> Set:
recipients = set()
def add_recipient(recipient) -> None:
if recipient is not None:
recipients.add(recipient)
# route to RTP receiver
if isinstance(packet, RtcpSrPacket):
add_recipient(self.ssrc_table.get(packet.ssrc))
elif isinstance(packet, RtcpByePacket):
for source in packet.sources:
add_recipient(self.ssrc_table.get(source))
# route to RTP sender
if isinstance(packet, (RtcpRrPacket, RtcpSrPacket)):
for report in packet.reports:
add_recipient(self.senders.get(report.ssrc))
elif isinstance(packet, (RtcpPsfbPacket, RtcpRtpfbPacket)):
add_recipient(self.senders.get(packet.media_ssrc))
# for REMB packets, media_ssrc is always 0, we need to look into the FCI
if isinstance(packet, RtcpPsfbPacket) and packet.fmt == rtp.RTCP_PSFB_APP:
try:
for ssrc in rtp.unpack_remb_fci(packet.fci)[1]:
add_recipient(self.senders.get(ssrc))
except ValueError:
pass
return recipients
def route_rtp(self, packet: RtpPacket) -> Optional[Any]:
ssrc_receiver = self.ssrc_table.get(packet.ssrc)
pt_receivers = self.payload_type_table.get(packet.payload_type, set())
# the SSRC and payload type are known and match
if ssrc_receiver is not None and ssrc_receiver in pt_receivers:
return ssrc_receiver
# the SSRC is unknown but the payload type matches, update the SSRC table
if ssrc_receiver is None and len(pt_receivers) == 1:
pt_receiver = list(pt_receivers)[0]
self.ssrc_table[packet.ssrc] = pt_receiver
return pt_receiver
# discard the packet
return None
def unregister_receiver(self, receiver) -> None:
self.receivers.discard(receiver)
self.__discard(self.mid_table, receiver)
self.__discard(self.ssrc_table, receiver)
for pt, receivers in self.payload_type_table.items():
receivers.discard(receiver)
def unregister_sender(self, sender) -> None:
self.__discard(self.senders, sender)
def __discard(self, d: Dict, value: Any) -> None:
for k, v in list(d.items()):
if v == value:
d.pop(k)
class RTCDtlsTransport(AsyncIOEventEmitter):
"""
The :class:`RTCDtlsTransport` object includes information relating to
Datagram Transport Layer Security (DTLS) transport.
:param transport: An :class:`RTCIceTransport`.
:param certificates: A list of :class:`RTCCertificate` (only one is allowed currently).
"""
def __init__(
self, transport: RTCIceTransport, certificates: List[RTCCertificate]
) -> None:
assert len(certificates) == 1
certificate = certificates[0]
super().__init__()
self.encrypted = False
self._data_receiver = None
self._role = "auto"
self._rtp_header_extensions_map = rtp.HeaderExtensionsMap()
self._rtp_router = RtpRouter()
self._state = State.NEW
self._stats_id = "transport_" + str(id(self))
self._task: Optional[asyncio.Future[None]] = None
self._transport = transport
# counters
self.__rx_bytes = 0
self.__rx_packets = 0
self.__tx_bytes = 0
self.__tx_packets = 0
# SRTP
self._rx_srtp: Session = None
self._tx_srtp: Session = None
# SSL init
self.ssl = SSL.Connection(certificate._create_ssl_context())
self.__local_certificate = certificate
@property
def state(self) -> str:
"""
The current state of the DTLS transport.
One of `'new'`, `'connecting'`, `'connected'`, `'closed'` or `'failed'`.
"""
return str(self._state)[6:].lower()
@property
def transport(self):
"""
The associated :class:`RTCIceTransport` instance.
"""
return self._transport
def getLocalParameters(self) -> RTCDtlsParameters:
"""
Get the local parameters of the DTLS transport.
:rtype: :class:`RTCDtlsParameters`
"""
return RTCDtlsParameters(
fingerprints=self.__local_certificate.getFingerprints()
)
async def start(self, remoteParameters: RTCDtlsParameters) -> None:
"""
Start DTLS transport negotiation with the parameters of the remote
DTLS transport.
:param remoteParameters: An :class:`RTCDtlsParameters`.
"""
assert self._state == State.NEW
assert len(remoteParameters.fingerprints)
# For WebRTC, the DTLS role is explicitly determined as part of the
# offer / answer exchange.
#
# For ORTC however, we determine the DTLS role based on the ICE role.
if self._role == "auto":
if self.transport.role == "controlling":
self._set_role("server")
else:
self._set_role("client")
if self._role == "server":
self.ssl.set_accept_state()
else:
self.ssl.set_connect_state()
self._set_state(State.CONNECTING)
try:
while not self.encrypted:
try:
self.ssl.do_handshake()
except SSL.WantReadError:
await self._write_ssl()
await self._recv_next()
except SSL.Error as exc:
self.__log_debug("x DTLS handshake failed (error %s)", exc)
self._set_state(State.FAILED)
return
else:
self.encrypted = True
except ConnectionError:
self.__log_debug("x DTLS handshake failed (connection error)")
self._set_state(State.FAILED)
return
# check remote fingerprint
x509 = self.ssl.get_peer_certificate()
remote_fingerprint = certificate_digest(x509)
fingerprint_is_valid = False
for f in remoteParameters.fingerprints:
if (
f.algorithm.lower() == "sha-256"
and f.value.lower() == remote_fingerprint.lower()
):
fingerprint_is_valid = True
break
if not fingerprint_is_valid:
self.__log_debug("x DTLS handshake failed (fingerprint mismatch)")
self._set_state(State.FAILED)
return
# generate keying material
view = self.ssl.export_keying_material(
b"EXTRACTOR-dtls_srtp", 2 * (SRTP_KEY_LEN + SRTP_SALT_LEN)
)
if self._role == "server":
srtp_tx_key = get_srtp_key_salt(view, 1)
srtp_rx_key = get_srtp_key_salt(view, 0)
else:
srtp_tx_key = get_srtp_key_salt(view, 0)
srtp_rx_key = get_srtp_key_salt(view, 1)
rx_policy = Policy(key=srtp_rx_key, ssrc_type=Policy.SSRC_ANY_INBOUND)
rx_policy.allow_repeat_tx = True
rx_policy.window_size = 1024
self._rx_srtp = Session(rx_policy)
tx_policy = Policy(key=srtp_tx_key, ssrc_type=Policy.SSRC_ANY_OUTBOUND)
tx_policy.allow_repeat_tx = True
tx_policy.window_size = 1024
self._tx_srtp = Session(tx_policy)
# start data pump
self.__log_debug("- DTLS handshake complete")
self._set_state(State.CONNECTED)
self._task = asyncio.ensure_future(self.__run())
async def stop(self) -> None:
"""
Stop and close the DTLS transport.
"""
if self._task is not None:
self._task.cancel()
self._task = None
if self._state in [State.CONNECTING, State.CONNECTED]:
try:
self.ssl.shutdown()
except SSL.Error:
pass
try:
await self._write_ssl()
except ConnectionError:
pass
self.__log_debug("- DTLS shutdown complete")
async def __run(self) -> None:
try:
while True:
await self._recv_next()
except ConnectionError:
for receiver in self._rtp_router.receivers:
receiver._handle_disconnect()
except Exception as exc:
if not isinstance(exc, asyncio.CancelledError):
self.__log_warning(traceback.format_exc())
raise exc
finally:
self._set_state(State.CLOSED)
def _get_stats(self) -> RTCStatsReport:
report = RTCStatsReport()
report.add(
RTCTransportStats(
# RTCStats
timestamp=clock.current_datetime(),
type="transport",
id=self._stats_id,
# RTCTransportStats,
packetsSent=self.__tx_packets,
packetsReceived=self.__rx_packets,
bytesSent=self.__tx_bytes,
bytesReceived=self.__rx_bytes,
iceRole=self.transport.role,
dtlsState=self.state,
)
)
return report
async def _handle_rtcp_data(self, data: bytes) -> None:
try:
packets = RtcpPacket.parse(data)
except ValueError as exc:
self.__log_debug("x RTCP parsing failed: %s", exc)
return
for packet in packets:
# route RTCP packet
for recipient in self._rtp_router.route_rtcp(packet):
await recipient._handle_rtcp_packet(packet)
async def _handle_rtp_data(self, data: bytes, arrival_time_ms: int) -> None:
try:
packet = RtpPacket.parse(data, self._rtp_header_extensions_map)
except ValueError as exc:
self.__log_debug("x RTP parsing failed: %s", exc)
return
# route RTP packet
receiver = self._rtp_router.route_rtp(packet)
if receiver is not None:
await receiver._handle_rtp_packet(packet, arrival_time_ms=arrival_time_ms)
async def _recv_next(self) -> None:
# get timeout
timeout = None
if not self.encrypted:
timeout = DTLSv1_get_timeout(self.ssl)
# receive next datagram
if timeout is not None:
try:
data = await asyncio.wait_for(self.transport._recv(), timeout=timeout)
except asyncio.TimeoutError:
self.__log_debug("x DTLS handling timeout")
DTLSv1_handle_timeout(self.ssl)
await self._write_ssl()
return
else:
data = await self.transport._recv()
self.__rx_bytes += len(data)
self.__rx_packets += 1
first_byte = data[0]
if first_byte > 19 and first_byte < 64:
# DTLS
self.ssl.bio_write(data)
try:
data = self.ssl.recv(1500)
except SSL.ZeroReturnError:
data = None
except SSL.Error:
data = b""
await self._write_ssl()
if data is None:
self.__log_debug("- DTLS shutdown by remote party")
raise ConnectionError
elif data and self._data_receiver:
await self._data_receiver._handle_data(data)
elif first_byte > 127 and first_byte < 192 and self._rx_srtp:
# SRTP / SRTCP
arrival_time_ms = clock.current_ms()
try:
if is_rtcp(data):
data = self._rx_srtp.unprotect_rtcp(data)
await self._handle_rtcp_data(data)
else:
data = self._rx_srtp.unprotect(data)
await self._handle_rtp_data(data, arrival_time_ms=arrival_time_ms)
except pylibsrtp.Error as exc:
self.__log_debug("x SRTP unprotect failed: %s", exc)
def _register_data_receiver(self, receiver) -> None:
assert self._data_receiver is None
self._data_receiver = receiver
def _register_rtp_receiver(
self, receiver, parameters: RTCRtpReceiveParameters
) -> None:
ssrcs = set()
for encoding in parameters.encodings:
ssrcs.add(encoding.ssrc)
self._rtp_header_extensions_map.configure(parameters)
self._rtp_router.register_receiver(
receiver,
ssrcs=list(ssrcs),
payload_types=[codec.payloadType for codec in parameters.codecs],
mid=parameters.muxId,
)
def _register_rtp_sender(self, sender, parameters: RTCRtpSendParameters) -> None:
self._rtp_header_extensions_map.configure(parameters)
self._rtp_router.register_sender(sender, ssrc=sender._ssrc)
async def _send_data(self, data: bytes) -> None:
if self._state != State.CONNECTED:
raise ConnectionError("Cannot send encrypted data, not connected")
self.ssl.send(data)
await self._write_ssl()
async def _send_rtp(self, data: bytes) -> None:
if self._state != State.CONNECTED:
raise ConnectionError("Cannot send encrypted RTP, not connected")
if is_rtcp(data):
data = self._tx_srtp.protect_rtcp(data)
else:
data = self._tx_srtp.protect(data)
await self.transport._send(data)
self.__tx_bytes += len(data)
self.__tx_packets += 1
def _set_role(self, role: str) -> None:
self._role = role
def _set_state(self, state: State) -> None:
if state != self._state:
self.__log_debug("- %s -> %s", self._state, state)
self._state = state
self.emit("statechange")
def _unregister_data_receiver(self, receiver) -> None:
if self._data_receiver == receiver:
self._data_receiver = None
def _unregister_rtp_receiver(self, receiver) -> None:
self._rtp_router.unregister_receiver(receiver)
def _unregister_rtp_sender(self, sender) -> None:
self._rtp_router.unregister_sender(sender)
async def _write_ssl(self) -> None:
"""
Flush outgoing data which OpenSSL put in our BIO to the transport.
"""
try:
data = self.ssl.bio_read(1500)
except SSL.Error:
data = b""
if data:
await self.transport._send(data)
self.__tx_bytes += len(data)
self.__tx_packets += 1
def __log_debug(self, msg: str, *args) -> None:
logger.debug(f"RTCDtlsTransport(%s) {msg}", self._role, *args)
def __log_warning(self, msg: str, *args) -> None:
logger.warning(f"RTCDtlsTransport(%s) {msg}", self._role, *args)
| 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/src/aiortc/events.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/events.py | from dataclasses import dataclass
from .mediastreams import MediaStreamTrack
from .rtcrtpreceiver import RTCRtpReceiver
from .rtcrtptransceiver import RTCRtpTransceiver
@dataclass
class RTCTrackEvent:
"""
This event is fired on :class:`RTCPeerConnection` when a new
:class:`MediaStreamTrack` is added by the remote party.
"""
receiver: RTCRtpReceiver
"The :class:`RTCRtpReceiver` associated with the event."
track: MediaStreamTrack
"The :class:`MediaStreamTrack` associated with the event."
transceiver: RTCRtpTransceiver
"The :class:`RTCRtpTransceiver` associated with the event."
| 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/src/aiortc/mediastreams.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/mediastreams.py | import asyncio
import fractions
import time
import uuid
from abc import ABCMeta, abstractmethod
from typing import Tuple, Union
from av import AudioFrame, VideoFrame
from av.frame import Frame
from av.packet import Packet
from pyee.asyncio import AsyncIOEventEmitter
AUDIO_PTIME = 0.020 # 20ms audio packetization
VIDEO_CLOCK_RATE = 90000
VIDEO_PTIME = 1 / 30 # 30fps
VIDEO_TIME_BASE = fractions.Fraction(1, VIDEO_CLOCK_RATE)
def convert_timebase(
pts: int, from_base: fractions.Fraction, to_base: fractions.Fraction
) -> int:
if from_base != to_base:
pts = int(pts * from_base / to_base)
return pts
class MediaStreamError(Exception):
pass
class MediaStreamTrack(AsyncIOEventEmitter, metaclass=ABCMeta):
"""
A single media track within a stream.
"""
kind = "unknown"
def __init__(self) -> None:
super().__init__()
self.__ended = False
self._id = str(uuid.uuid4())
@property
def id(self) -> str:
"""
An automatically generated globally unique ID.
"""
return self._id
@property
def readyState(self) -> str:
return "ended" if self.__ended else "live"
@abstractmethod
async def recv(self) -> Union[Frame, Packet]:
"""
Receive the next :class:`~av.audio.frame.AudioFrame`, :class:`~av.video.frame.VideoFrame`
or :class:`~av.packet.Packet`
"""
def stop(self) -> None:
if not self.__ended:
self.__ended = True
self.emit("ended")
# no more events will be emitted, so remove all event listeners
# to facilitate garbage collection.
self.remove_all_listeners()
class AudioStreamTrack(MediaStreamTrack):
"""
A dummy audio track which reads silence.
"""
kind = "audio"
_start: float
_timestamp: int
async def recv(self) -> Frame:
"""
Receive the next :class:`~av.audio.frame.AudioFrame`.
The base implementation just reads silence, subclass
:class:`AudioStreamTrack` to provide a useful implementation.
"""
if self.readyState != "live":
raise MediaStreamError
sample_rate = 8000
samples = int(AUDIO_PTIME * sample_rate)
if hasattr(self, "_timestamp"):
self._timestamp += samples
wait = self._start + (self._timestamp / sample_rate) - time.time()
await asyncio.sleep(wait)
else:
self._start = time.time()
self._timestamp = 0
frame = AudioFrame(format="s16", layout="mono", samples=samples)
for p in frame.planes:
p.update(bytes(p.buffer_size))
frame.pts = self._timestamp
frame.sample_rate = sample_rate
frame.time_base = fractions.Fraction(1, sample_rate)
return frame
class VideoStreamTrack(MediaStreamTrack):
"""
A dummy video track which reads green frames.
"""
kind = "video"
_start: float
_timestamp: int
async def next_timestamp(self) -> Tuple[int, fractions.Fraction]:
if self.readyState != "live":
raise MediaStreamError
if hasattr(self, "_timestamp"):
self._timestamp += int(VIDEO_PTIME * VIDEO_CLOCK_RATE)
wait = self._start + (self._timestamp / VIDEO_CLOCK_RATE) - time.time()
await asyncio.sleep(wait)
else:
self._start = time.time()
self._timestamp = 0
return self._timestamp, VIDEO_TIME_BASE
async def recv(self) -> Frame:
"""
Receive the next :class:`~av.video.frame.VideoFrame`.
The base implementation just reads a 640x480 green frame at 30fps,
subclass :class:`VideoStreamTrack` to provide a useful implementation.
"""
pts, time_base = await self.next_timestamp()
frame = VideoFrame(width=640, height=480)
for p in frame.planes:
p.update(bytes(p.buffer_size))
frame.pts = pts
frame.time_base = time_base
return frame
| 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/src/aiortc/utils.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/utils.py | import os
from struct import unpack
def random16() -> int:
return unpack("!H", os.urandom(2))[0]
def random32() -> int:
return unpack("!L", os.urandom(4))[0]
def uint16_add(a: int, b: int) -> int:
"""
Return a + b.
"""
return (a + b) & 0xFFFF
def uint16_gt(a: int, b: int) -> bool:
"""
Return a > b.
"""
half_mod = 0x8000
return ((a < b) and ((b - a) > half_mod)) or ((a > b) and ((a - b) < half_mod))
def uint16_gte(a: int, b: int) -> bool:
"""
Return a >= b.
"""
return (a == b) or uint16_gt(a, b)
def uint32_add(a: int, b: int) -> int:
"""
Return a + b.
"""
return (a + b) & 0xFFFFFFFF
def uint32_gt(a: int, b: int) -> bool:
"""
Return a > b.
"""
half_mod = 0x80000000
return ((a < b) and ((b - a) > half_mod)) or ((a > b) and ((a - b) < half_mod))
def uint32_gte(a: int, b: int) -> bool:
"""
Return a >= b.
"""
return (a == b) or uint32_gt(a, b)
| 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/src/aiortc/sdp.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/sdp.py | import enum
import ipaddress
import re
from dataclasses import dataclass
from typing import Any, Dict, List, Optional, Tuple, Union
from . import rtp
from .rtcdtlstransport import RTCDtlsFingerprint, RTCDtlsParameters
from .rtcicetransport import RTCIceCandidate, RTCIceParameters
from .rtcrtpparameters import (
ParametersDict,
RTCRtcpFeedback,
RTCRtpCodecParameters,
RTCRtpHeaderExtensionParameters,
RTCRtpParameters,
)
from .rtcsctptransport import RTCSctpCapabilities
DIRECTIONS = ["inactive", "sendonly", "recvonly", "sendrecv"]
DTLS_ROLE_SETUP = {"auto": "actpass", "client": "active", "server": "passive"}
DTLS_SETUP_ROLE = dict([(v, k) for (k, v) in DTLS_ROLE_SETUP.items()])
FMTP_INT_PARAMETERS = [
"apt",
"max-fr",
"max-fs",
"maxplaybackrate",
"minptime",
"stereo",
"useinbandfec",
]
class BitPattern:
def __init__(self, v: str) -> None:
self._mask = ~self._bytemaskstring("x", v)
self._masked_value = self._bytemaskstring("1", v)
def matches(self, v: int) -> bool:
return (v & self._mask) == self._masked_value
def _bytemaskstring(self, c: str, s: str) -> int:
return (
(s[0] == c) << 7
| (s[1] == c) << 6
| (s[2] == c) << 5
| (s[3] == c) << 4
| (s[4] == c) << 3
| (s[5] == c) << 2
| (s[6] == c) << 1
| (s[7] == c) << 0
)
class H264Profile(enum.Enum):
PROFILE_CONSTRAINED_BASELINE = 0
PROFILE_BASELINE = 1
PROFILE_MAIN = 2
PROFILE_CONSTRAINED_HIGH = 3
PROFILE_HIGH = 4
PROFILE_PREDICTIVE_HIGH_444 = 5
class H264Level(enum.IntEnum):
LEVEL1_B = -1
LEVEL1 = 10
LEVEL1_1 = 11
LEVEL1_2 = 12
LEVEL1_3 = 13
LEVEL2 = 20
LEVEL2_1 = 21
LEVEL2_2 = 22
LEVEL3 = 30
LEVEL3_1 = 31
LEVEL3_2 = 32
LEVEL4 = 40
LEVEL4_1 = 41
LEVEL4_2 = 42
LEVEL5 = 50
LEVEL5_1 = 51
LEVEL5_2 = 52
H264_PROFILE_PATTERNS = [
(0x42, BitPattern("x1xx0000"), H264Profile.PROFILE_CONSTRAINED_BASELINE),
(0x4D, BitPattern("1xxx0000"), H264Profile.PROFILE_CONSTRAINED_BASELINE),
(0x58, BitPattern("11xx0000"), H264Profile.PROFILE_CONSTRAINED_BASELINE),
(0x42, BitPattern("x0xx0000"), H264Profile.PROFILE_BASELINE),
(0x58, BitPattern("10xx0000"), H264Profile.PROFILE_BASELINE),
(0x4D, BitPattern("0x0x0000"), H264Profile.PROFILE_MAIN),
(0x64, BitPattern("00000000"), H264Profile.PROFILE_HIGH),
(0x64, BitPattern("00001100"), H264Profile.PROFILE_CONSTRAINED_HIGH),
(0xF4, BitPattern("00000000"), H264Profile.PROFILE_PREDICTIVE_HIGH_444),
]
def candidate_from_sdp(sdp: str) -> RTCIceCandidate:
bits = sdp.split()
assert len(bits) >= 8
candidate = RTCIceCandidate(
component=int(bits[1]),
foundation=bits[0],
ip=bits[4],
port=int(bits[5]),
priority=int(bits[3]),
protocol=bits[2],
type=bits[7],
)
for i in range(8, len(bits) - 1, 2):
if bits[i] == "raddr":
candidate.relatedAddress = bits[i + 1]
elif bits[i] == "rport":
candidate.relatedPort = int(bits[i + 1])
elif bits[i] == "tcptype":
candidate.tcpType = bits[i + 1]
return candidate
def candidate_to_sdp(candidate: RTCIceCandidate) -> str:
sdp = (
f"{candidate.foundation} {candidate.component} {candidate.protocol} "
f"{candidate.priority} {candidate.ip} {candidate.port} typ {candidate.type}"
)
if candidate.relatedAddress is not None:
sdp += f" raddr {candidate.relatedAddress}"
if candidate.relatedPort is not None:
sdp += f" rport {candidate.relatedPort}"
if candidate.tcpType is not None:
sdp += f" tcptype {candidate.tcpType}"
return sdp
def grouplines(sdp: str) -> Tuple[List[str], List[List[str]]]:
session = []
media = []
for line in sdp.splitlines():
if line.startswith("m="):
media.append([line])
elif len(media):
media[-1].append(line)
else:
session.append(line)
return session, media
def ipaddress_from_sdp(sdp: str) -> str:
m = re.match("^IN (IP4|IP6) ([^ ]+)$", sdp)
assert m
return m.group(2)
def ipaddress_to_sdp(addr: str) -> str:
version = ipaddress.ip_address(addr).version
return f"IN IP{version} {addr}"
def parameters_from_sdp(sdp: str) -> ParametersDict:
parameters: ParametersDict = {}
for param in sdp.split(";"):
if "=" in param:
k, v = param.split("=", 1)
if k in FMTP_INT_PARAMETERS:
parameters[k] = int(v)
else:
parameters[k] = v
else:
parameters[param] = None
return parameters
def parameters_to_sdp(parameters: ParametersDict) -> str:
params = []
for param_k, param_v in parameters.items():
if param_v is not None:
params.append(f"{param_k}={param_v}")
else:
params.append(param_k)
return ";".join(params)
def parse_attr(line: str) -> Tuple[str, Optional[str]]:
if ":" in line:
bits = line[2:].split(":", 1)
return bits[0], bits[1]
else:
return line[2:], None
def parse_h264_profile_level_id(profile_str: str) -> Tuple[H264Profile, H264Level]:
if not isinstance(profile_str, str) or not re.match(
"[0-9a-f]{6}", profile_str, re.I
):
raise ValueError("Expected a 6 character hexadecimal string")
level_idc = int(profile_str[4:6], 16)
profile_iop = int(profile_str[2:4], 16)
profile_idc = int(profile_str[0:2], 16)
level: H264Level
if level_idc == H264Level.LEVEL1_1:
level = H264Level.LEVEL1_B if (profile_iop & 0x10) else H264Level.LEVEL1_1
else:
level = H264Level(level_idc)
for idc, pattern, profile in H264_PROFILE_PATTERNS:
if idc == profile_idc and pattern.matches(profile_iop):
return profile, level
raise ValueError(
f"Unrecognized profile_iop = {profile_iop}, profile_idc = {profile_idc}"
)
@dataclass
class GroupDescription:
semantic: str
items: List[Union[int, str]]
def __str__(self) -> str:
return f"{self.semantic} {' '.join(map(str, self.items))}"
def parse_group(dest: List[GroupDescription], value: str, type=str) -> None:
bits = value.split()
if bits:
dest.append(GroupDescription(semantic=bits[0], items=list(map(type, bits[1:]))))
@dataclass
class SsrcDescription:
ssrc: int
cname: Optional[str] = None
msid: Optional[str] = None
mslabel: Optional[str] = None
label: Optional[str] = None
SSRC_INFO_ATTRS = ["cname", "msid", "mslabel", "label"]
class MediaDescription:
def __init__(self, kind: str, port: int, profile: str, fmt: List[Any]) -> None:
# rtp
self.kind = kind
self.port = port
self.host: Optional[str] = None
self.profile = profile
self.direction: Optional[str] = None
self.msid: Optional[str] = None
# rtcp
self.rtcp_port: Optional[int] = None
self.rtcp_host: Optional[str] = None
self.rtcp_mux = False
# ssrc
self.ssrc: List[SsrcDescription] = []
self.ssrc_group: List[GroupDescription] = []
# formats
self.fmt = fmt
self.rtp = RTCRtpParameters()
# SCTP
self.sctpCapabilities: Optional[RTCSctpCapabilities] = None
self.sctpmap: Dict[int, str] = {}
self.sctp_port: Optional[int] = None
# DTLS
self.dtls: Optional[RTCDtlsParameters] = None
# ICE
self.ice: Optional[RTCIceParameters] = None
self.ice_candidates: List[RTCIceCandidate] = []
self.ice_candidates_complete = False
self.ice_options: Optional[str] = None
def __str__(self) -> str:
lines = []
lines.append(
f"m={self.kind} {self.port} {self.profile} {' '.join(map(str, self.fmt))}"
)
if self.host is not None:
lines.append(f"c={ipaddress_to_sdp(self.host)}")
if self.direction is not None:
lines.append(f"a={self.direction}")
for header in self.rtp.headerExtensions:
lines.append(f"a=extmap:{header.id} {header.uri}")
if self.rtp.muxId:
lines.append(f"a=mid:{self.rtp.muxId}")
if self.msid:
lines.append(f"a=msid:{self.msid}")
if self.rtcp_port is not None and self.rtcp_host is not None:
lines.append(f"a=rtcp:{self.rtcp_port} {ipaddress_to_sdp(self.rtcp_host)}")
if self.rtcp_mux:
lines.append("a=rtcp-mux")
for group in self.ssrc_group:
lines.append(f"a=ssrc-group:{group}")
for ssrc_info in self.ssrc:
for ssrc_attr in SSRC_INFO_ATTRS:
ssrc_value = getattr(ssrc_info, ssrc_attr)
if ssrc_value is not None:
lines.append(f"a=ssrc:{ssrc_info.ssrc} {ssrc_attr}:{ssrc_value}")
for codec in self.rtp.codecs:
lines.append(f"a=rtpmap:{codec.payloadType} {codec}")
# RTCP feedback
for feedback in codec.rtcpFeedback:
value = feedback.type
if feedback.parameter:
value += f" {feedback.parameter}"
lines.append(f"a=rtcp-fb:{codec.payloadType} {value}")
# parameters
params = parameters_to_sdp(codec.parameters)
if params:
lines.append(f"a=fmtp:{codec.payloadType} {params}")
for k, v in self.sctpmap.items():
lines.append(f"a=sctpmap:{k} {v}")
if self.sctp_port is not None:
lines.append(f"a=sctp-port:{self.sctp_port}")
if self.sctpCapabilities is not None:
lines.append(f"a=max-message-size:{self.sctpCapabilities.maxMessageSize}")
# ice
for candidate in self.ice_candidates:
lines.append("a=candidate:" + candidate_to_sdp(candidate))
if self.ice_candidates_complete:
lines.append("a=end-of-candidates")
if self.ice.usernameFragment is not None:
lines.append(f"a=ice-ufrag:{self.ice.usernameFragment}")
if self.ice.password is not None:
lines.append(f"a=ice-pwd:{self.ice.password}")
if self.ice_options is not None:
lines.append(f"a=ice-options:{self.ice_options}")
# dtls
if self.dtls:
for fingerprint in self.dtls.fingerprints:
lines.append(
f"a=fingerprint:{fingerprint.algorithm} {fingerprint.value}"
)
lines.append(f"a=setup:{DTLS_ROLE_SETUP[self.dtls.role]}")
return "\r\n".join(lines) + "\r\n"
class SessionDescription:
def __init__(self) -> None:
self.version = 0
self.origin: Optional[str] = None
self.name = "-"
self.time = "0 0"
self.host: Optional[str] = None
self.group: List[GroupDescription] = []
self.msid_semantic: List[GroupDescription] = []
self.media: List[MediaDescription] = []
self.type: Optional[str] = None
@classmethod
def parse(cls, sdp: str):
current_media: Optional[MediaDescription] = None
dtls_fingerprints = []
dtls_role = None
ice_lite = False
ice_options = None
ice_password = None
ice_usernameFragment = None
def find_codec(pt: int) -> RTCRtpCodecParameters:
return next(filter(lambda x: x.payloadType == pt, current_media.rtp.codecs))
session_lines, media_groups = grouplines(sdp)
# parse session
session = cls()
for line in session_lines:
if line.startswith("v="):
session.version = int(line.strip()[2:])
elif line.startswith("o="):
session.origin = line.strip()[2:]
elif line.startswith("s="):
session.name = line.strip()[2:]
elif line.startswith("c="):
session.host = ipaddress_from_sdp(line[2:])
elif line.startswith("t="):
session.time = line.strip()[2:]
elif line.startswith("a="):
attr, value = parse_attr(line)
if attr == "fingerprint":
algorithm, fingerprint = value.split()
dtls_fingerprints.append(
RTCDtlsFingerprint(algorithm=algorithm, value=fingerprint)
)
elif attr == "ice-lite":
ice_lite = True
elif attr == "ice-options":
ice_options = value
elif attr == "ice-pwd":
ice_password = value
elif attr == "ice-ufrag":
ice_usernameFragment = value
elif attr == "group":
parse_group(session.group, value)
elif attr == "msid-semantic":
parse_group(session.msid_semantic, value)
elif attr == "setup":
dtls_role = DTLS_SETUP_ROLE[value]
# parse media
for media_lines in media_groups:
m = re.match("^m=([^ ]+) ([0-9]+) ([A-Z/]+) (.+)$", media_lines[0])
assert m
# check payload types are valid
kind = m.group(1)
fmt = m.group(4).split()
fmt_int: Optional[List[int]] = None
if kind in ["audio", "video"]:
fmt_int = [int(x) for x in fmt]
for pt in fmt_int:
assert pt >= 0 and pt < 256
assert pt not in rtp.FORBIDDEN_PAYLOAD_TYPES
current_media = MediaDescription(
kind=kind, port=int(m.group(2)), profile=m.group(3), fmt=fmt_int or fmt
)
current_media.dtls = RTCDtlsParameters(
fingerprints=dtls_fingerprints[:], role=dtls_role
)
current_media.ice = RTCIceParameters(
iceLite=ice_lite,
usernameFragment=ice_usernameFragment,
password=ice_password,
)
current_media.ice_options = ice_options
session.media.append(current_media)
for line in media_lines[1:]:
if line.startswith("c="):
current_media.host = ipaddress_from_sdp(line[2:])
elif line.startswith("a="):
attr, value = parse_attr(line)
if attr == "candidate":
current_media.ice_candidates.append(candidate_from_sdp(value))
elif attr == "end-of-candidates":
current_media.ice_candidates_complete = True
elif attr == "extmap":
ext_id, ext_uri = value.split()
if "/" in ext_id:
ext_id, ext_direction = ext_id.split("/")
extension = RTCRtpHeaderExtensionParameters(
id=int(ext_id), uri=ext_uri
)
current_media.rtp.headerExtensions.append(extension)
elif attr == "fingerprint":
algorithm, fingerprint = value.split()
current_media.dtls.fingerprints.append(
RTCDtlsFingerprint(algorithm=algorithm, value=fingerprint)
)
elif attr == "ice-options":
current_media.ice_options = value
elif attr == "ice-pwd":
current_media.ice.password = value
elif attr == "ice-ufrag":
current_media.ice.usernameFragment = value
elif attr == "max-message-size":
current_media.sctpCapabilities = RTCSctpCapabilities(
maxMessageSize=int(value)
)
elif attr == "mid":
current_media.rtp.muxId = value
elif attr == "msid":
current_media.msid = value
elif attr == "rtcp":
port, rest = value.split(" ", 1)
current_media.rtcp_port = int(port)
current_media.rtcp_host = ipaddress_from_sdp(rest)
elif attr == "rtcp-mux":
current_media.rtcp_mux = True
elif attr == "setup":
current_media.dtls.role = DTLS_SETUP_ROLE[value]
elif attr in DIRECTIONS:
current_media.direction = attr
elif attr == "rtpmap":
format_id, format_desc = value.split(" ", 1)
bits = format_desc.split("/")
if current_media.kind == "audio":
if len(bits) > 2:
channels = int(bits[2])
else:
channels = 1
else:
channels = None
codec = RTCRtpCodecParameters(
mimeType=current_media.kind + "/" + bits[0],
channels=channels,
clockRate=int(bits[1]),
payloadType=int(format_id),
)
current_media.rtp.codecs.append(codec)
elif attr == "sctpmap":
format_id, format_desc = value.split(" ", 1)
getattr(current_media, attr)[int(format_id)] = format_desc
elif attr == "sctp-port":
current_media.sctp_port = int(value)
elif attr == "ssrc-group":
parse_group(current_media.ssrc_group, value, type=int)
elif attr == "ssrc":
ssrc_str, ssrc_desc = value.split(" ", 1)
ssrc = int(ssrc_str)
ssrc_attr, ssrc_value = ssrc_desc.split(":", 1)
try:
ssrc_info = next(
(x for x in current_media.ssrc if x.ssrc == ssrc)
)
except StopIteration:
ssrc_info = SsrcDescription(ssrc=ssrc)
current_media.ssrc.append(ssrc_info)
if ssrc_attr in SSRC_INFO_ATTRS:
setattr(ssrc_info, ssrc_attr, ssrc_value)
if current_media.dtls.role is None:
current_media.dtls = None
# requires codecs to have been parsed
for line in media_lines[1:]:
if line.startswith("a="):
attr, value = parse_attr(line)
if attr == "fmtp":
format_id, format_desc = value.split(" ", 1)
codec = find_codec(int(format_id))
codec.parameters = parameters_from_sdp(format_desc)
elif attr == "rtcp-fb":
bits = value.split(" ", 2)
for codec in current_media.rtp.codecs:
if bits[0] in ["*", str(codec.payloadType)]:
codec.rtcpFeedback.append(
RTCRtcpFeedback(
type=bits[1],
parameter=bits[2] if len(bits) > 2 else None,
)
)
return session
def webrtc_track_id(self, media: MediaDescription) -> Optional[str]:
assert media in self.media
if media.msid is not None and " " in media.msid:
bits = media.msid.split()
for group in self.msid_semantic:
if group.semantic == "WMS" and (
bits[0] in group.items or "*" in group.items
):
return bits[1]
return None
def __str__(self) -> str:
lines = [f"v={self.version}", f"o={self.origin}", f"s={self.name}"]
if self.host is not None:
lines += [f"c={ipaddress_to_sdp(self.host)}"]
lines += [f"t={self.time}"]
if any(m.ice.iceLite for m in self.media):
lines += ["a=ice-lite"]
for group in self.group:
lines += [f"a=group:{group}"]
for group in self.msid_semantic:
lines += [f"a=msid-semantic:{group}"]
return "\r\n".join(lines) + "\r\n" + "".join([str(m) for m in self.media])
| 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/src/aiortc/rate.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rate.py | import math
from enum import Enum
from typing import Dict, List, Optional, Tuple
from aiortc.utils import uint32_add, uint32_gt
BURST_DELTA_THRESHOLD_MS = 5
# overuse detector
MAX_ADAPT_OFFSET_MS = 15
MIN_NUM_DELTAS = 60
# overuse estimator
DELTA_COUNTER_MAX = 1000
MIN_FRAME_PERIOD_HISTORY_LENGTH = 60
# abs-send-time estimator
INTER_ARRIVAL_SHIFT = 26
TIMESTAMP_GROUP_LENGTH_MS = 5
TIMESTAMP_TO_MS = 1000.0 / (1 << INTER_ARRIVAL_SHIFT)
class BandwidthUsage(Enum):
NORMAL = 0
UNDERUSING = 1
OVERUSING = 2
class RateControlState(Enum):
HOLD = 0
INCREASE = 1
DECREASE = 2
class AimdRateControl:
def __init__(self) -> None:
self.avg_max_bitrate_kbps = None
self.var_max_bitrate_kbps = 0.4
self.current_bitrate = 30000000
self.current_bitrate_initialized = False
self.first_estimated_throughput_time: Optional[int] = None
self.last_change_ms: Optional[int] = None
self.near_max = False
self.latest_estimated_throughput = 30000000
self.rtt = 200
self.state = RateControlState.HOLD
def feedback_interval(self) -> int:
return 500
def set_estimate(self, bitrate: int, now_ms: int) -> None:
"""
For testing purposes.
"""
self.current_bitrate = self._clamp_bitrate(bitrate, bitrate)
self.current_bitrate_initialized = True
self.last_change_ms = now_ms
def update(
self,
bandwidth_usage: BandwidthUsage,
estimated_throughput: Optional[int],
now_ms: int,
) -> Optional[int]:
if not self.current_bitrate_initialized and estimated_throughput is not None:
if self.first_estimated_throughput_time is None:
self.first_estimated_throughput_time = now_ms
elif now_ms - self.first_estimated_throughput_time > 3000:
self.current_bitrate = estimated_throughput
self.current_bitrate_initialized = True
# wait for initialisation or overuse
if (
not self.current_bitrate_initialized
and bandwidth_usage != BandwidthUsage.OVERUSING
):
return None
# update state
if (
bandwidth_usage == BandwidthUsage.NORMAL
and self.state == RateControlState.HOLD
):
self.last_change_ms = now_ms
self.state = RateControlState.INCREASE
elif bandwidth_usage == BandwidthUsage.OVERUSING:
self.state = RateControlState.DECREASE
elif bandwidth_usage == BandwidthUsage.UNDERUSING:
self.state = RateControlState.HOLD
# helper variables
new_bitrate = self.current_bitrate
if estimated_throughput is not None:
self.latest_estimated_throughput = estimated_throughput
else:
estimated_throughput = self.latest_estimated_throughput
estimated_throughput_kbps = estimated_throughput / 1000
# update bitrate
if self.state == RateControlState.INCREASE:
# if the estimated throughput increases significantly,
# clear estimated max throughput
if self.avg_max_bitrate_kbps is not None:
sigma_kbps = math.sqrt(
self.var_max_bitrate_kbps * self.avg_max_bitrate_kbps
)
if (
estimated_throughput_kbps
>= self.avg_max_bitrate_kbps + 3 * sigma_kbps
):
self.near_max = False
self.avg_max_bitrate_kbps = None
# we use additive or multiplicative rate increase depending on whether
# we are close to the maximum throughput
if self.near_max:
new_bitrate += self._additive_rate_increase(self.last_change_ms, now_ms)
else:
new_bitrate += self._multiplicative_rate_increase(
new_bitrate, self.last_change_ms, now_ms
)
self.last_change_ms = now_ms
elif self.state == RateControlState.DECREASE:
# if the estimated throughput drops significantly,
# clear estimated max throughput
if self.avg_max_bitrate_kbps is not None:
sigma_kbps = math.sqrt(
self.var_max_bitrate_kbps * self.avg_max_bitrate_kbps
)
if (
estimated_throughput_kbps
< self.avg_max_bitrate_kbps - 3 * sigma_kbps
):
self.avg_max_bitrate_kbps = None
self._update_max_throughput_estimate(estimated_throughput_kbps)
self.near_max = True
new_bitrate = round(0.85 * estimated_throughput)
self.last_change_ms = now_ms
self.state = RateControlState.HOLD
self.current_bitrate = self._clamp_bitrate(new_bitrate, estimated_throughput)
return self.current_bitrate
def _additive_rate_increase(self, last_ms: int, now_ms: int) -> int:
return int((now_ms - last_ms) * self._near_max_rate_increase() / 1000)
def _clamp_bitrate(self, new_bitrate: int, estimated_throughput: int) -> int:
max_bitrate = max(int(1.5 * estimated_throughput) + 10000, self.current_bitrate)
return min(new_bitrate, max_bitrate)
def _multiplicative_rate_increase(
self, new_bitrate: int, last_ms: int, now_ms: int
) -> int:
alpha = 1.08
if last_ms is not None:
elapsed_ms = min(now_ms - last_ms, 1000)
alpha = pow(alpha, elapsed_ms / 1000)
return int(max((alpha - 1) * new_bitrate, 1000))
def _near_max_rate_increase(self) -> int:
bits_per_frame = self.current_bitrate / 30
packets_per_frame = math.ceil(bits_per_frame / (8 * 1200))
avg_packet_size_bits = bits_per_frame / packets_per_frame
response_time = self.rtt + 100
return max(4000, int((avg_packet_size_bits * 1000) / response_time))
def _update_max_throughput_estimate(self, estimated_throughput_kbps) -> None:
alpha = 0.05
if self.avg_max_bitrate_kbps is None:
self.avg_max_bitrate_kbps = estimated_throughput_kbps
else:
self.avg_max_bitrate_kbps = (
1 - alpha
) * self.avg_max_bitrate_kbps + alpha * estimated_throughput_kbps
norm = max(1, self.avg_max_bitrate_kbps)
self.var_max_bitrate_kbps = (1 - alpha) * self.var_max_bitrate_kbps + alpha * (
(self.avg_max_bitrate_kbps - estimated_throughput_kbps) ** 2
) / norm
self.var_max_bitrate_kbps = max(0.4, min(self.var_max_bitrate_kbps, 2.5))
class TimestampGroup:
def __init__(self, timestamp: Optional[int] = None) -> None:
self.arrival_time: Optional[int] = None
self.first_timestamp = timestamp
self.last_timestamp = timestamp
self.size = 0
class InterArrivalDelta:
def __init__(self, timestamp: int, arrival_time: int, size: int) -> None:
self.timestamp = timestamp
self.arrival_time = arrival_time
self.size = size
class InterArrival:
"""
Inter-arrival time and size filter.
Adapted from the webrtc.org codebase.
"""
def __init__(self, group_length: int, timestamp_to_ms: float) -> None:
self.group_length = group_length
self.timestamp_to_ms = timestamp_to_ms
self.current_group: Optional[TimestampGroup] = None
self.previous_group: Optional[TimestampGroup] = None
def compute_deltas(
self, timestamp: int, arrival_time: int, packet_size: int
) -> Optional[InterArrivalDelta]:
deltas = None
if self.current_group is None:
self.current_group = TimestampGroup(timestamp)
elif self.packet_out_of_order(timestamp):
return deltas
elif self.new_timestamp_group(timestamp, arrival_time):
if self.previous_group is not None:
deltas = InterArrivalDelta(
timestamp=uint32_add(
self.current_group.last_timestamp,
-self.previous_group.last_timestamp,
),
arrival_time=(
self.current_group.arrival_time
- self.previous_group.arrival_time
),
size=self.current_group.size - self.previous_group.size,
)
# shift groups
self.previous_group = self.current_group
self.current_group = TimestampGroup(timestamp=timestamp)
elif uint32_gt(timestamp, self.current_group.last_timestamp):
self.current_group.last_timestamp = timestamp
self.current_group.size += packet_size
self.current_group.arrival_time = arrival_time
return deltas
def belongs_to_burst(self, timestamp: int, arrival_time: int) -> bool:
timestamp_delta = uint32_add(timestamp, -self.current_group.last_timestamp)
timestamp_delta_ms = round(self.timestamp_to_ms * timestamp_delta)
arrival_time_delta = arrival_time - self.current_group.arrival_time
return timestamp_delta_ms == 0 or (
(arrival_time_delta - timestamp_delta_ms) < 0
and arrival_time_delta <= BURST_DELTA_THRESHOLD_MS
)
def new_timestamp_group(self, timestamp: int, arrival_time: int) -> bool:
if self.belongs_to_burst(timestamp, arrival_time):
return False
else:
timestamp_delta = uint32_add(timestamp, -self.current_group.first_timestamp)
return timestamp_delta > self.group_length
def packet_out_of_order(self, timestamp: int) -> bool:
timestamp_delta = uint32_add(timestamp, -self.current_group.first_timestamp)
return timestamp_delta >= 0x80000000
class OveruseDetector:
"""
Bandwidth overuse detector.
Adapted from the webrtc.org codebase.
"""
def __init__(self) -> None:
self.hypothesis = BandwidthUsage.NORMAL
self.last_update_ms: Optional[int] = None
self.k_up = 0.0087
self.k_down = 0.039
self.overuse_counter = 0
self.overuse_time: Optional[float] = None
self.overuse_time_threshold = 10
self.previous_offset = 0.0
self.threshold = 12.5
def detect(
self, offset: float, timestamp_delta_ms: float, num_of_deltas: int, now_ms: int
) -> BandwidthUsage:
if num_of_deltas < 2:
return BandwidthUsage.NORMAL
T = min(num_of_deltas, MIN_NUM_DELTAS) * offset
if T > self.threshold:
if self.overuse_time is None:
self.overuse_time = timestamp_delta_ms / 2
else:
self.overuse_time += timestamp_delta_ms
self.overuse_counter += 1
if (
self.overuse_time > self.overuse_time_threshold
and self.overuse_counter > 1
and offset >= self.previous_offset
):
self.overuse_counter = 0
self.overuse_time = 0
self.hypothesis = BandwidthUsage.OVERUSING
elif T < -self.threshold:
self.overuse_counter = 0
self.overuse_time = None
self.hypothesis = BandwidthUsage.UNDERUSING
else:
self.overuse_counter = 0
self.overuse_time = None
self.hypothesis = BandwidthUsage.NORMAL
self.previous_offset = offset
self.update_threshold(T, now_ms)
return self.hypothesis
def state(self) -> BandwidthUsage:
return self.hypothesis
def update_threshold(self, modified_offset: float, now_ms: int) -> None:
if self.last_update_ms is None:
self.last_update_ms = now_ms
if abs(modified_offset) > self.threshold + MAX_ADAPT_OFFSET_MS:
self.last_update_ms = now_ms
return
k = self.k_down if abs(modified_offset) < self.threshold else self.k_up
time_delta_ms = min(now_ms - self.last_update_ms, 100)
self.threshold += k * (abs(modified_offset) - self.threshold) * time_delta_ms
self.threshold = max(6, min(self.threshold, 600))
self.last_update_ms = now_ms
class OveruseEstimator:
"""
Bandwidth overuse estimator.
Adapted from the webrtc.org codebase.
"""
def __init__(self) -> None:
self.E = [[100.0, 0.0], [0.0, 0.1]]
self._num_of_deltas = 0
self._offset = 0.0
self.previous_offset = 0.0
self.slope = 1 / 64
self.ts_delta_hist: List[float] = []
self.avg_noise = 0.0
self.var_noise = 50.0
self.process_noise = [1e-13, 1e-3]
def num_of_deltas(self) -> int:
return self._num_of_deltas
def offset(self) -> float:
return self._offset
def update(
self,
time_delta_ms: int,
timestamp_delta_ms: float,
size_delta: int,
current_hypothesis: BandwidthUsage,
now_ms: int,
):
min_frame_period = self.update_min_frame_period(timestamp_delta_ms)
t_ts_delta = time_delta_ms - timestamp_delta_ms
fs_delta = size_delta
self._num_of_deltas = min(self._num_of_deltas + 1, DELTA_COUNTER_MAX)
# update Kalman filter
self.E[0][0] += self.process_noise[0]
self.E[1][1] += self.process_noise[1]
if (
current_hypothesis == BandwidthUsage.OVERUSING
and self._offset < self.previous_offset
) or (
current_hypothesis == BandwidthUsage.UNDERUSING
and self._offset > self.previous_offset
):
self.E[1][1] += 10 * self.process_noise[1]
h = [fs_delta, 1.0]
Eh = [
self.E[0][0] * h[0] + self.E[0][1] * h[1],
self.E[1][0] * h[0] + self.E[1][1] * h[1],
]
# update noise estimate
residual = t_ts_delta - self.slope * h[0] - self._offset
if current_hypothesis == BandwidthUsage.NORMAL:
max_residual = 3.0 * math.sqrt(self.var_noise)
if abs(residual) < max_residual:
self.update_noise_estimate(residual, min_frame_period)
else:
self.update_noise_estimate(
-max_residual if residual < 0 else max_residual, min_frame_period
)
denom = self.var_noise + h[0] * Eh[0] + h[1] * Eh[1]
K = [Eh[0] / denom, Eh[1] / denom]
IKh = [[1.0 - K[0] * h[0], -K[0] * h[1]], [-K[1] * h[0], 1.0 - K[1] * h[1]]]
e00 = self.E[0][0]
e01 = self.E[0][1]
# update state
self.E[0][0] = e00 * IKh[0][0] + self.E[1][0] * IKh[0][1]
self.E[0][1] = e01 * IKh[0][0] + self.E[1][1] * IKh[0][1]
self.E[1][0] = e00 * IKh[1][0] + self.E[1][0] * IKh[1][1]
self.E[1][1] = e01 * IKh[1][0] + self.E[1][1] * IKh[1][1]
self.previous_offset = self._offset
self.slope += K[0] * residual
self._offset += K[1] * residual
def update_min_frame_period(self, ts_delta: float) -> float:
min_frame_period = ts_delta
if len(self.ts_delta_hist) >= MIN_FRAME_PERIOD_HISTORY_LENGTH:
self.ts_delta_hist.pop(0)
for old_ts_delta in self.ts_delta_hist:
min_frame_period = min(old_ts_delta, min_frame_period)
self.ts_delta_hist.append(ts_delta)
return min_frame_period
def update_noise_estimate(self, residual: float, ts_delta: float) -> None:
alpha = 0.01
if self._num_of_deltas > 10 * 30:
alpha = 0.002
beta = pow(1 - alpha, ts_delta * 30.0 / 1000.0)
self.avg_noise = beta * self.avg_noise + (1 - beta) * residual
self.var_noise = (
beta * self.var_noise + (1 - beta) * (self.avg_noise - residual) ** 2
)
if self.var_noise < 1:
self.var_noise = 1
class RateBucket:
def __init__(self, count: int = 0, value: int = 0) -> None:
self.count = count
self.value = value
def __eq__(self, other) -> bool:
return self.count == other.count and self.value == other.value
class RateCounter:
"""
Rate counter, which stores the amount received in 1ms buckets.
"""
def __init__(self, window_size: int, scale: int = 8000) -> None:
self._origin_index = 0
self._origin_ms: Optional[int] = None
self._scale = scale
self._window_size = window_size
self.reset()
def add(self, value: int, now_ms: int) -> None:
if self._origin_ms is None:
self._origin_ms = now_ms
else:
self._erase_old(now_ms)
index = (self._origin_index + now_ms - self._origin_ms) % self._window_size
self._buckets[index].count += 1
self._buckets[index].value += value
self._total.count += 1
self._total.value += value
def rate(self, now_ms: int) -> Optional[int]:
if self._origin_ms is not None:
self._erase_old(now_ms)
active_window_size = now_ms - self._origin_ms + 1
if self._total.count > 0 and active_window_size > 1:
return round(self._scale * self._total.value / active_window_size)
return None
def reset(self) -> None:
self._buckets = [RateBucket() for i in range(self._window_size)]
self._origin_index = 0
self._origin_ms = None
self._total = RateBucket()
def _erase_old(self, now_ms: int) -> None:
new_origin_ms = now_ms - self._window_size + 1
while self._origin_ms < new_origin_ms:
bucket = self._buckets[self._origin_index]
self._total.count -= bucket.count
self._total.value -= bucket.value
bucket.count = 0
bucket.value = 0
self._origin_index = (self._origin_index + 1) % self._window_size
self._origin_ms += 1
class RemoteBitrateEstimator:
def __init__(self) -> None:
self.incoming_bitrate = RateCounter(1000, 8000)
self.incoming_bitrate_initialized = True
self.inter_arrival = InterArrival(
(TIMESTAMP_GROUP_LENGTH_MS << INTER_ARRIVAL_SHIFT) // 1000, TIMESTAMP_TO_MS
)
self.estimator = OveruseEstimator()
self.detector = OveruseDetector()
self.rate_control = AimdRateControl()
self.last_update_ms: Optional[int] = None
self.ssrcs: Dict[int, int] = {}
def add(
self, arrival_time_ms: int, abs_send_time: int, payload_size: int, ssrc: int
) -> Optional[Tuple[int, List[int]]]:
timestamp = abs_send_time << 8
update_estimate = False
# make note of SSRC
self.ssrcs[ssrc] = arrival_time_ms
# update incoming bitrate
if self.incoming_bitrate.rate(arrival_time_ms) is not None:
self.incoming_bitrate_initialized = True
elif self.incoming_bitrate_initialized:
self.incoming_bitrate.reset()
self.incoming_bitrate_initialized = False
self.incoming_bitrate.add(payload_size, arrival_time_ms)
# calculate inter-arrival deltas
deltas = self.inter_arrival.compute_deltas(
timestamp, arrival_time_ms, payload_size
)
if deltas is not None:
timestamp_delta_ms = deltas.timestamp * TIMESTAMP_TO_MS
self.estimator.update(
deltas.arrival_time,
timestamp_delta_ms,
deltas.size,
self.detector.state(),
arrival_time_ms,
)
self.detector.detect(
self.estimator.offset(),
timestamp_delta_ms,
self.estimator.num_of_deltas(),
arrival_time_ms,
)
if not update_estimate:
if (
self.last_update_ms is None
or (arrival_time_ms - self.last_update_ms)
> self.rate_control.feedback_interval()
):
update_estimate = True
elif self.detector.state() == BandwidthUsage.OVERUSING:
update_estimate = True
if update_estimate:
target_bitrate = self.rate_control.update(
self.detector.state(),
self.incoming_bitrate.rate(arrival_time_ms),
arrival_time_ms,
)
if target_bitrate is not None:
self.last_update_ms = arrival_time_ms
return target_bitrate, list(self.ssrcs.keys())
return 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/src/aiortc/clock.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/clock.py | import datetime
NTP_EPOCH = datetime.datetime(1900, 1, 1, tzinfo=datetime.timezone.utc)
def current_datetime() -> datetime.datetime:
return datetime.datetime.now(datetime.timezone.utc)
def current_ms() -> int:
delta = current_datetime() - NTP_EPOCH
return int(delta.total_seconds() * 1000)
def current_ntp_time() -> int:
return datetime_to_ntp(current_datetime())
def datetime_from_ntp(ntp: int) -> datetime.datetime:
seconds = ntp >> 32
microseconds = ((ntp & 0xFFFFFFFF) * 1000000) / (1 << 32)
return NTP_EPOCH + datetime.timedelta(seconds=seconds, microseconds=microseconds)
def datetime_to_ntp(dt: datetime.datetime) -> int:
delta = dt - NTP_EPOCH
high = int(delta.total_seconds())
low = round((delta.microseconds * (1 << 32)) // 1000000)
return (high << 32) | low
| 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/src/aiortc/__init__.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/__init__.py | # flake8: noqa
import logging
import av.logging
from .about import __version__
from .exceptions import InvalidAccessError, InvalidStateError
from .mediastreams import MediaStreamTrack, VideoStreamTrack
from .rtcconfiguration import RTCConfiguration, RTCIceServer
from .rtcdatachannel import RTCDataChannel, RTCDataChannelParameters
from .rtcdtlstransport import (
RTCCertificate,
RTCDtlsFingerprint,
RTCDtlsParameters,
RTCDtlsTransport,
)
from .rtcicetransport import (
RTCIceCandidate,
RTCIceGatherer,
RTCIceParameters,
RTCIceTransport,
)
from .rtcpeerconnection import RTCPeerConnection
from .rtcrtpparameters import (
RTCRtcpParameters,
RTCRtpCapabilities,
RTCRtpCodecCapability,
RTCRtpCodecParameters,
RTCRtpHeaderExtensionCapability,
RTCRtpHeaderExtensionParameters,
RTCRtpParameters,
)
from .rtcrtpreceiver import (
RTCRtpContributingSource,
RTCRtpReceiver,
RTCRtpSynchronizationSource,
)
from .rtcrtpsender import RTCRtpSender
from .rtcrtptransceiver import RTCRtpTransceiver
from .rtcsctptransport import RTCSctpCapabilities, RTCSctpTransport
from .rtcsessiondescription import RTCSessionDescription
from .stats import (
RTCInboundRtpStreamStats,
RTCOutboundRtpStreamStats,
RTCRemoteInboundRtpStreamStats,
RTCRemoteOutboundRtpStreamStats,
RTCStatsReport,
RTCTransportStats,
)
# Disable PyAV's logging framework as it can lead to thread deadlocks.
av.logging.restore_default_callback()
# 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/aiortc/src/aiortc/rtcpeerconnection.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcpeerconnection.py | import asyncio
import copy
import logging
import uuid
from typing import Dict, List, Optional, Set, Union
from pyee.asyncio import AsyncIOEventEmitter
from . import clock, rtp, sdp
from .codecs import CODECS, HEADER_EXTENSIONS, is_rtx
from .events import RTCTrackEvent
from .exceptions import (
InternalError,
InvalidAccessError,
InvalidStateError,
OperationError,
)
from .mediastreams import MediaStreamTrack
from .rtcconfiguration import RTCConfiguration
from .rtcdatachannel import RTCDataChannel, RTCDataChannelParameters
from .rtcdtlstransport import RTCCertificate, RTCDtlsParameters, RTCDtlsTransport
from .rtcicetransport import (
RTCIceCandidate,
RTCIceGatherer,
RTCIceParameters,
RTCIceTransport,
)
from .rtcrtpparameters import (
RTCRtpCodecCapability,
RTCRtpCodecParameters,
RTCRtpDecodingParameters,
RTCRtpHeaderExtensionParameters,
RTCRtpParameters,
RTCRtpReceiveParameters,
RTCRtpRtxParameters,
RTCRtpSendParameters,
)
from .rtcrtpreceiver import RemoteStreamTrack, RTCRtpReceiver
from .rtcrtpsender import RTCRtpSender
from .rtcrtptransceiver import RTCRtpTransceiver
from .rtcsctptransport import RTCSctpTransport
from .rtcsessiondescription import RTCSessionDescription
from .stats import RTCStatsReport
DISCARD_HOST = "0.0.0.0"
DISCARD_PORT = 9
MEDIA_KINDS = ["audio", "video"]
logger = logging.getLogger(__name__)
def filter_preferred_codecs(
codecs: List[RTCRtpCodecParameters], preferred: List[RTCRtpCodecCapability]
) -> List[RTCRtpCodecParameters]:
if not preferred:
return codecs
rtx_codecs = list(filter(is_rtx, codecs))
rtx_enabled = next(filter(is_rtx, preferred), None) is not None
filtered = []
for pref in filter(lambda x: not is_rtx(x), preferred):
for codec in codecs:
if (
codec.mimeType.lower() == pref.mimeType.lower()
and codec.parameters == pref.parameters
):
filtered.append(codec)
# add corresponding RTX
if rtx_enabled:
for rtx in rtx_codecs:
if rtx.parameters["apt"] == codec.payloadType:
filtered.append(rtx)
break
break
return filtered
def find_common_codecs(
local_codecs: List[RTCRtpCodecParameters],
remote_codecs: List[RTCRtpCodecParameters],
) -> List[RTCRtpCodecParameters]:
common = []
common_base: Dict[int, RTCRtpCodecParameters] = {}
for c in remote_codecs:
# for RTX, check we accepted the base codec
if is_rtx(c):
if c.parameters.get("apt") in common_base:
base = common_base[c.parameters["apt"]]
if c.clockRate == base.clockRate:
common.append(copy.deepcopy(c))
continue
# handle other codecs
for codec in local_codecs:
if is_codec_compatible(codec, c):
codec = copy.deepcopy(codec)
if c.payloadType in rtp.DYNAMIC_PAYLOAD_TYPES:
codec.payloadType = c.payloadType
codec.rtcpFeedback = list(
filter(lambda x: x in c.rtcpFeedback, codec.rtcpFeedback)
)
common.append(codec)
common_base[codec.payloadType] = codec
break
return common
def find_common_header_extensions(
local_extensions: List[RTCRtpHeaderExtensionParameters],
remote_extensions: List[RTCRtpHeaderExtensionParameters],
) -> List[RTCRtpHeaderExtensionParameters]:
common = []
for rx in remote_extensions:
for lx in local_extensions:
if lx.uri == rx.uri:
common.append(rx)
return common
def is_codec_compatible(a: RTCRtpCodecParameters, b: RTCRtpCodecParameters) -> bool:
if a.mimeType.lower() != b.mimeType.lower() or a.clockRate != b.clockRate:
return False
if a.mimeType.lower() == "video/h264":
def packetization(c: RTCRtpCodecParameters):
return c.parameters.get("packetization-mode", "0")
def profile(c: RTCRtpCodecParameters):
# for backwards compatibility with older versions of WebRTC,
# consider the absence of a profile-level-id parameter to mean
# "constrained baseline level 3.1"
return sdp.parse_h264_profile_level_id(
c.parameters.get("profile-level-id", "42E01F")
)[0]
try:
return packetization(a) == packetization(b) and profile(a) == profile(b)
except ValueError:
return False
return True
def add_transport_description(
media: sdp.MediaDescription, dtlsTransport: RTCDtlsTransport
) -> None:
# ice
iceTransport = dtlsTransport.transport
iceGatherer = iceTransport.iceGatherer
media.ice_candidates = iceGatherer.getLocalCandidates()
media.ice_candidates_complete = iceGatherer.state == "completed"
media.ice = iceGatherer.getLocalParameters()
if media.ice_candidates:
media.host = media.ice_candidates[0].ip
media.port = media.ice_candidates[0].port
else:
media.host = DISCARD_HOST
media.port = DISCARD_PORT
# dtls
if media.dtls is None:
media.dtls = dtlsTransport.getLocalParameters()
else:
media.dtls.fingerprints = dtlsTransport.getLocalParameters().fingerprints
async def add_remote_candidates(
iceTransport: RTCIceTransport, media: sdp.MediaDescription
) -> None:
coros = map(iceTransport.addRemoteCandidate, media.ice_candidates)
await asyncio.gather(*coros)
if media.ice_candidates_complete:
await iceTransport.addRemoteCandidate(None)
def allocate_mid(mids: Set[str]) -> str:
"""
Allocate a MID which has not been used yet.
"""
i = 0
while True:
mid = str(i)
if mid not in mids:
mids.add(mid)
return mid
i += 1
def create_media_description_for_sctp(
sctp: RTCSctpTransport, legacy: bool, mid: str
) -> sdp.MediaDescription:
if legacy:
media = sdp.MediaDescription(
kind="application", port=DISCARD_PORT, profile="DTLS/SCTP", fmt=[sctp.port]
)
media.sctpmap[sctp.port] = f"webrtc-datachannel {sctp._outbound_streams_count}"
else:
media = sdp.MediaDescription(
kind="application",
port=DISCARD_PORT,
profile="UDP/DTLS/SCTP",
fmt=["webrtc-datachannel"],
)
media.sctp_port = sctp.port
media.rtp.muxId = mid
media.sctpCapabilities = sctp.getCapabilities()
add_transport_description(media, sctp.transport)
return media
def create_media_description_for_transceiver(
transceiver: RTCRtpTransceiver, cname: str, direction: str, mid: str
) -> sdp.MediaDescription:
media = sdp.MediaDescription(
kind=transceiver.kind,
port=DISCARD_PORT,
profile="UDP/TLS/RTP/SAVPF",
fmt=[c.payloadType for c in transceiver._codecs],
)
media.direction = direction
media.msid = f"{transceiver.sender._stream_id} {transceiver.sender._track_id}"
media.rtp = RTCRtpParameters(
codecs=transceiver._codecs,
headerExtensions=transceiver._headerExtensions,
muxId=mid,
)
media.rtcp_host = DISCARD_HOST
media.rtcp_port = DISCARD_PORT
media.rtcp_mux = True
media.ssrc = [sdp.SsrcDescription(ssrc=transceiver.sender._ssrc, cname=cname)]
# if RTX is enabled, add corresponding SSRC
if next(filter(is_rtx, media.rtp.codecs), None):
media.ssrc.append(
sdp.SsrcDescription(ssrc=transceiver.sender._rtx_ssrc, cname=cname)
)
media.ssrc_group = [
sdp.GroupDescription(
semantic="FID",
items=[transceiver.sender._ssrc, transceiver.sender._rtx_ssrc],
)
]
add_transport_description(media, transceiver._transport)
return media
def and_direction(a: str, b: str) -> str:
return sdp.DIRECTIONS[sdp.DIRECTIONS.index(a) & sdp.DIRECTIONS.index(b)]
def or_direction(a: str, b: str) -> str:
return sdp.DIRECTIONS[sdp.DIRECTIONS.index(a) | sdp.DIRECTIONS.index(b)]
def reverse_direction(direction: str) -> str:
if direction == "sendonly":
return "recvonly"
elif direction == "recvonly":
return "sendonly"
return direction
def wrap_session_description(
session_description: Optional[sdp.SessionDescription],
) -> Optional[RTCSessionDescription]:
if session_description is not None:
return RTCSessionDescription(
sdp=str(session_description), type=session_description.type
)
return None
class RTCPeerConnection(AsyncIOEventEmitter):
"""
The :class:`RTCPeerConnection` interface represents a WebRTC connection
between the local computer and a remote peer.
:param configuration: An optional :class:`RTCConfiguration`.
"""
def __init__(self, configuration: Optional[RTCConfiguration] = None) -> None:
super().__init__()
self.__certificates = [RTCCertificate.generateCertificate()]
self.__cname = f"{uuid.uuid4()}"
self.__configuration = configuration or RTCConfiguration()
self.__dtlsTransports: Set[RTCDtlsTransport] = set()
self.__iceTransports: Set[RTCIceTransport] = set()
self.__remoteDtls: Dict[
Union[RTCRtpTransceiver, RTCSctpTransport], RTCDtlsParameters
] = {}
self.__remoteIce: Dict[
Union[RTCRtpTransceiver, RTCSctpTransport], RTCIceParameters
] = {}
self.__seenMids: Set[str] = set()
self.__sctp: Optional[RTCSctpTransport] = None
self.__sctp_mline_index: Optional[int] = None
self._sctpLegacySdp = True
self.__sctpRemotePort: Optional[int] = None
self.__sctpRemoteCaps = None
self.__stream_id = str(uuid.uuid4())
self.__transceivers: List[RTCRtpTransceiver] = []
self.__connectionState = "new"
self.__iceConnectionState = "new"
self.__iceGatheringState = "new"
self.__isClosed = False
self.__signalingState = "stable"
self.__currentLocalDescription: Optional[sdp.SessionDescription] = None
self.__currentRemoteDescription: Optional[sdp.SessionDescription] = None
self.__pendingLocalDescription: Optional[sdp.SessionDescription] = None
self.__pendingRemoteDescription: Optional[sdp.SessionDescription] = None
@property
def connectionState(self) -> str:
"""
The current connection state.
Possible values: `"connected"`, `"connecting"`, `"closed"`, `"failed"`, `"new`".
When the state changes, the `"connectionstatechange"` event is fired.
"""
return self.__connectionState
@property
def iceConnectionState(self) -> str:
"""
The current ICE connection state.
Possible values: `"checking"`, `"completed"`, `"closed"`, `"failed"`, `"new`".
When the state changes, the `"iceconnectionstatechange"` event is fired.
"""
return self.__iceConnectionState
@property
def iceGatheringState(self) -> str:
"""
The current ICE gathering state.
Possible values: `"complete"`, `"gathering"`, `"new`".
When the state changes, the `"icegatheringstatechange"` event is fired.
"""
return self.__iceGatheringState
@property
def localDescription(self) -> RTCSessionDescription:
"""
An :class:`RTCSessionDescription` describing the session for
the local end of the connection.
"""
return wrap_session_description(self.__localDescription())
@property
def remoteDescription(self) -> RTCSessionDescription:
"""
An :class:`RTCSessionDescription` describing the session for
the remote end of the connection.
"""
return wrap_session_description(self.__remoteDescription())
@property
def sctp(self) -> Optional[RTCSctpTransport]:
"""
An :class:`RTCSctpTransport` describing the SCTP transport being used
for datachannels or `None`.
"""
return self.__sctp
@property
def signalingState(self):
"""
The current signaling state.
Possible values: `"closed"`, `"have-local-offer"`, `"have-remote-offer`", `"stable"`.
When the state changes, the `"signalingstatechange"` event is fired.
"""
return self.__signalingState
async def addIceCandidate(self, candidate: RTCIceCandidate) -> None:
"""
Add a new :class:`RTCIceCandidate` received from the remote peer.
The specified candidate must have a value for either `sdpMid` or `sdpMLineIndex`.
:param candidate: The new remote candidate.
"""
if candidate.sdpMid is None and candidate.sdpMLineIndex is None:
raise ValueError("Candidate must have either sdpMid or sdpMLineIndex")
for transceiver in self.__transceivers:
if candidate.sdpMid == transceiver.mid and not transceiver._bundled:
iceTransport = transceiver._transport.transport
await iceTransport.addRemoteCandidate(candidate)
return
if (
self.__sctp
and candidate.sdpMid == self.__sctp.mid
and not self.__sctp._bundled
):
iceTransport = self.__sctp.transport.transport
await iceTransport.addRemoteCandidate(candidate)
def addTrack(self, track: MediaStreamTrack) -> RTCRtpSender:
"""
Add a :class:`MediaStreamTrack` to the set of media tracks which
will be transmitted to the remote peer.
"""
# check state is valid
self.__assertNotClosed()
if track.kind not in ["audio", "video"]:
raise InternalError(f'Invalid track kind "{track.kind}"')
# don't add track twice
self.__assertTrackHasNoSender(track)
for transceiver in self.__transceivers:
if transceiver.kind == track.kind:
if transceiver.sender.track is None:
transceiver.sender.replaceTrack(track)
transceiver.direction = or_direction(
transceiver.direction, "sendonly"
)
return transceiver.sender
transceiver = self.__createTransceiver(
direction="sendrecv", kind=track.kind, sender_track=track
)
return transceiver.sender
def addTransceiver(
self, trackOrKind: Union[str, MediaStreamTrack], direction: str = "sendrecv"
) -> RTCRtpTransceiver:
"""
Add a new :class:`RTCRtpTransceiver`.
"""
self.__assertNotClosed()
# determine track or kind
if isinstance(trackOrKind, MediaStreamTrack):
kind = trackOrKind.kind
track = trackOrKind
else:
kind = trackOrKind
track = None
if kind not in ["audio", "video"]:
raise InternalError(f'Invalid track kind "{kind}"')
# check direction
if direction not in sdp.DIRECTIONS:
raise InternalError(f'Invalid direction "{direction}"')
# don't add track twice
if track:
self.__assertTrackHasNoSender(track)
return self.__createTransceiver(
direction=direction, kind=kind, sender_track=track
)
async def close(self):
"""
Terminate the ICE agent, ending ICE processing and streams.
"""
if self.__isClosed:
return
self.__isClosed = True
self.__setSignalingState("closed")
# stop senders / receivers
for transceiver in self.__transceivers:
await transceiver.stop()
if self.__sctp:
await self.__sctp.stop()
# stop transports
for transceiver in self.__transceivers:
await transceiver._transport.stop()
await transceiver._transport.transport.stop()
if self.__sctp:
await self.__sctp.transport.stop()
await self.__sctp.transport.transport.stop()
# update states
self.__updateIceGatheringState()
self.__updateIceConnectionState()
self.__updateConnectionState()
# no more events will be emitted, so remove all event listeners
# to facilitate garbage collection.
self.remove_all_listeners()
async def createAnswer(self):
"""
Create an SDP answer to an offer received from a remote peer during
the offer/answer negotiation of a WebRTC connection.
:rtype: :class:`RTCSessionDescription`
"""
# check state is valid
self.__assertNotClosed()
if self.signalingState not in ["have-remote-offer", "have-local-pranswer"]:
raise InvalidStateError(
f'Cannot create answer in signaling state "{self.signalingState}"'
)
# create description
ntp_seconds = clock.current_ntp_time() >> 32
description = sdp.SessionDescription()
description.origin = f"- {ntp_seconds} {ntp_seconds} IN IP4 0.0.0.0"
description.msid_semantic.append(
sdp.GroupDescription(semantic="WMS", items=["*"])
)
description.type = "answer"
for remote_m in self.__remoteDescription().media:
if remote_m.kind in ["audio", "video"]:
transceiver = self.__getTransceiverByMid(remote_m.rtp.muxId)
media = create_media_description_for_transceiver(
transceiver,
cname=self.__cname,
direction=and_direction(
transceiver.direction, transceiver._offerDirection
),
mid=transceiver.mid,
)
dtlsTransport = transceiver._transport
else:
media = create_media_description_for_sctp(
self.__sctp, legacy=self._sctpLegacySdp, mid=self.__sctp.mid
)
dtlsTransport = self.__sctp.transport
# determine DTLS role, or preserve the currently configured role
if dtlsTransport._role == "auto":
media.dtls.role = "client"
else:
media.dtls.role = dtlsTransport._role
description.media.append(media)
bundle = sdp.GroupDescription(semantic="BUNDLE", items=[])
for media in description.media:
bundle.items.append(media.rtp.muxId)
description.group.append(bundle)
return wrap_session_description(description)
def createDataChannel(
self,
label,
maxPacketLifeTime=None,
maxRetransmits=None,
ordered=True,
protocol="",
negotiated=False,
id=None,
):
"""
Create a data channel with the given label.
:rtype: :class:`RTCDataChannel`
"""
if maxPacketLifeTime is not None and maxRetransmits is not None:
raise ValueError("Cannot specify both maxPacketLifeTime and maxRetransmits")
if not self.__sctp:
self.__createSctpTransport()
parameters = RTCDataChannelParameters(
id=id,
label=label,
maxPacketLifeTime=maxPacketLifeTime,
maxRetransmits=maxRetransmits,
negotiated=negotiated,
ordered=ordered,
protocol=protocol,
)
return RTCDataChannel(self.__sctp, parameters)
async def createOffer(self) -> RTCSessionDescription:
"""
Create an SDP offer for the purpose of starting a new WebRTC
connection to a remote peer.
:rtype: :class:`RTCSessionDescription`
"""
# check state is valid
self.__assertNotClosed()
if not self.__sctp and not self.__transceivers:
raise InternalError(
"Cannot create an offer with no media and no data channels"
)
# offer codecs
for transceiver in self.__transceivers:
transceiver._codecs = filter_preferred_codecs(
CODECS[transceiver.kind][:], transceiver._preferred_codecs
)
transceiver._headerExtensions = HEADER_EXTENSIONS[transceiver.kind][:]
mids = self.__seenMids.copy()
# create description
ntp_seconds = clock.current_ntp_time() >> 32
description = sdp.SessionDescription()
description.origin = f"- {ntp_seconds} {ntp_seconds} IN IP4 0.0.0.0"
description.msid_semantic.append(
sdp.GroupDescription(semantic="WMS", items=["*"])
)
description.type = "offer"
def get_media(
description: sdp.SessionDescription,
) -> List[sdp.MediaDescription]:
return description.media if description else []
def get_media_section(
media: List[sdp.MediaDescription], i: int
) -> Optional[sdp.MediaDescription]:
return media[i] if i < len(media) else None
# handle existing transceivers / sctp
local_media = get_media(self.__localDescription())
remote_media = get_media(self.__remoteDescription())
for i in range(max(len(local_media), len(remote_media))):
local_m = get_media_section(local_media, i)
remote_m = get_media_section(remote_media, i)
media_kind = local_m.kind if local_m else remote_m.kind
mid = local_m.rtp.muxId if local_m else remote_m.rtp.muxId
if media_kind in ["audio", "video"]:
transceiver = self.__getTransceiverByMid(mid)
transceiver._set_mline_index(i)
description.media.append(
create_media_description_for_transceiver(
transceiver,
cname=self.__cname,
direction=transceiver.direction,
mid=mid,
)
)
elif media_kind == "application":
self.__sctp_mline_index = i
description.media.append(
create_media_description_for_sctp(
self.__sctp, legacy=self._sctpLegacySdp, mid=mid
)
)
# handle new transceivers / sctp
def next_mline_index() -> int:
return len(description.media)
for transceiver in filter(
lambda x: x.mid is None and not x.stopped, self.__transceivers
):
transceiver._set_mline_index(next_mline_index())
description.media.append(
create_media_description_for_transceiver(
transceiver,
cname=self.__cname,
direction=transceiver.direction,
mid=allocate_mid(mids),
)
)
if self.__sctp and self.__sctp.mid is None:
self.__sctp_mline_index = next_mline_index()
description.media.append(
create_media_description_for_sctp(
self.__sctp, legacy=self._sctpLegacySdp, mid=allocate_mid(mids)
)
)
bundle = sdp.GroupDescription(semantic="BUNDLE", items=[])
for media in description.media:
bundle.items.append(media.rtp.muxId)
description.group.append(bundle)
return wrap_session_description(description)
def getReceivers(self) -> List[RTCRtpReceiver]:
"""
Returns the list of :class:`RTCRtpReceiver` objects that are currently
attached to the connection.
"""
return list(map(lambda x: x.receiver, self.__transceivers))
def getSenders(self) -> List[RTCRtpSender]:
"""
Returns the list of :class:`RTCRtpSender` objects that are currently
attached to the connection.
"""
return list(map(lambda x: x.sender, self.__transceivers))
async def getStats(self) -> RTCStatsReport:
"""
Returns statistics for the connection.
:rtype: :class:`RTCStatsReport`
"""
merged = RTCStatsReport()
coros = [x.getStats() for x in self.getSenders()] + [
x.getStats() for x in self.getReceivers()
]
for report in await asyncio.gather(*coros):
merged.update(report)
return merged
def getTransceivers(self) -> List[RTCRtpTransceiver]:
"""
Returns the list of :class:`RTCRtpTransceiver` objects that are currently
attached to the connection.
"""
return list(self.__transceivers)
async def setLocalDescription(
self, sessionDescription: RTCSessionDescription
) -> None:
"""
Change the local description associated with the connection.
:param sessionDescription: An :class:`RTCSessionDescription` generated
by :meth:`createOffer` or :meth:`createAnswer()`.
"""
self.__log_debug(
"setLocalDescription(%s)\n%s",
sessionDescription.type,
sessionDescription.sdp,
)
# parse and validate description
description = sdp.SessionDescription.parse(sessionDescription.sdp)
description.type = sessionDescription.type
self.__validate_description(description, is_local=True)
# update signaling state
if description.type == "offer":
self.__setSignalingState("have-local-offer")
elif description.type == "answer":
self.__setSignalingState("stable")
# assign MID
for i, media in enumerate(description.media):
mid = media.rtp.muxId
self.__seenMids.add(mid)
if media.kind in ["audio", "video"]:
transceiver = self.__getTransceiverByMLineIndex(i)
transceiver._set_mid(mid)
elif media.kind == "application":
self.__sctp.mid = mid
# set ICE role
if description.type == "offer":
for iceTransport in self.__iceTransports:
if not iceTransport._role_set:
iceTransport._connection.ice_controlling = True
iceTransport._role_set = True
# set DTLS role
if description.type == "answer":
for i, media in enumerate(description.media):
if media.kind in ["audio", "video"]:
transceiver = self.__getTransceiverByMLineIndex(i)
transceiver._transport._set_role(media.dtls.role)
elif media.kind == "application":
self.__sctp.transport._set_role(media.dtls.role)
# configure direction
for t in self.__transceivers:
if description.type in ["answer", "pranswer"]:
t._currentDirection = and_direction(t.direction, t._offerDirection)
# gather candidates
await self.__gather()
for i, media in enumerate(description.media):
if media.kind in ["audio", "video"]:
transceiver = self.__getTransceiverByMLineIndex(i)
add_transport_description(media, transceiver._transport)
elif media.kind == "application":
add_transport_description(media, self.__sctp.transport)
# connect
asyncio.ensure_future(self.__connect())
# replace description
if description.type == "answer":
self.__currentLocalDescription = description
self.__pendingLocalDescription = None
else:
self.__pendingLocalDescription = description
async def setRemoteDescription(
self, sessionDescription: RTCSessionDescription
) -> None:
"""
Changes the remote description associated with the connection.
:param sessionDescription: An :class:`RTCSessionDescription` created from
information received over the signaling channel.
"""
self.__log_debug(
"setRemoteDescription(%s)\n%s",
sessionDescription.type,
sessionDescription.sdp,
)
# parse and validate description
description = sdp.SessionDescription.parse(sessionDescription.sdp)
description.type = sessionDescription.type
self.__validate_description(description, is_local=False)
# apply description
iceCandidates: Dict[RTCIceTransport, sdp.MediaDescription] = {}
trackEvents = []
for i, media in enumerate(description.media):
dtlsTransport: Optional[RTCDtlsTransport] = None
self.__seenMids.add(media.rtp.muxId)
if media.kind in ["audio", "video"]:
# find transceiver
transceiver = None
for t in self.__transceivers:
if t.kind == media.kind and t.mid in [None, media.rtp.muxId]:
transceiver = t
if transceiver is None:
transceiver = self.__createTransceiver(
direction="recvonly", kind=media.kind
)
if transceiver.mid is None:
transceiver._set_mid(media.rtp.muxId)
transceiver._set_mline_index(i)
# negotiate codecs
common = filter_preferred_codecs(
find_common_codecs(CODECS[media.kind], media.rtp.codecs),
transceiver._preferred_codecs,
)
if not len(common):
raise OperationError(
"Failed to set remote {} description send parameters".format(
media.kind
)
)
transceiver._codecs = common
transceiver._headerExtensions = find_common_header_extensions(
HEADER_EXTENSIONS[media.kind], media.rtp.headerExtensions
)
# configure direction
direction = reverse_direction(media.direction)
if description.type in ["answer", "pranswer"]:
transceiver._currentDirection = direction
else:
transceiver._offerDirection = direction
# create remote stream track
if (
direction in ["recvonly", "sendrecv"]
and not transceiver.receiver.track
):
transceiver.receiver._track = RemoteStreamTrack(
kind=media.kind, id=description.webrtc_track_id(media)
)
trackEvents.append(
RTCTrackEvent(
receiver=transceiver.receiver,
track=transceiver.receiver.track,
transceiver=transceiver,
)
)
# memorise transport parameters
dtlsTransport = transceiver._transport
self.__remoteDtls[transceiver] = media.dtls
self.__remoteIce[transceiver] = media.ice
elif media.kind == "application":
if not self.__sctp:
self.__createSctpTransport()
if self.__sctp.mid is None:
self.__sctp.mid = media.rtp.muxId
self.__sctp_mline_index = i
# configure sctp
if media.profile == "DTLS/SCTP":
self._sctpLegacySdp = True
self.__sctpRemotePort = int(media.fmt[0])
else:
self._sctpLegacySdp = False
self.__sctpRemotePort = media.sctp_port
self.__sctpRemoteCaps = media.sctpCapabilities
# memorise transport parameters
dtlsTransport = self.__sctp.transport
self.__remoteDtls[self.__sctp] = media.dtls
self.__remoteIce[self.__sctp] = media.ice
if dtlsTransport is not None:
# add ICE candidates
iceTransport = dtlsTransport.transport
iceCandidates[iceTransport] = media
# set ICE role
if description.type == "offer" and not iceTransport._role_set:
| 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/aiortc/src/aiortc/about.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/about.py | __author__ = "Jeremy Lainé"
__email__ = "jeremy.laine@m4x.org"
__license__ = "BSD"
__summary__ = "An implementation of WebRTC and ORTC"
__title__ = "aiortc"
__uri__ = "https://github.com/aiortc/aiortc"
__version__ = "1.4.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/aiortc/src/aiortc/stats.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/stats.py | import datetime
from dataclasses import dataclass
from typing import Optional
@dataclass
class RTCStats:
"""
Base class for statistics.
"""
timestamp: datetime.datetime
"The timestamp associated with this object."
type: str
id: str
@dataclass
class RTCRtpStreamStats(RTCStats):
ssrc: int
kind: str
transportId: str
@dataclass
class RTCReceivedRtpStreamStats(RTCRtpStreamStats):
packetsReceived: int
packetsLost: int
jitter: int
@dataclass
class RTCSentRtpStreamStats(RTCRtpStreamStats):
packetsSent: int
"Total number of RTP packets sent for this SSRC."
bytesSent: int
"Total number of bytes sent for this SSRC."
@dataclass
class RTCInboundRtpStreamStats(RTCReceivedRtpStreamStats):
"""
The :class:`RTCInboundRtpStreamStats` dictionary represents the measurement
metrics for the incoming RTP media stream.
"""
pass
@dataclass
class RTCRemoteInboundRtpStreamStats(RTCReceivedRtpStreamStats):
"""
The :class:`RTCRemoteInboundRtpStreamStats` dictionary represents the remote
endpoint's measurement metrics for a particular incoming RTP stream.
"""
roundTripTime: float
fractionLost: float
@dataclass
class RTCOutboundRtpStreamStats(RTCSentRtpStreamStats):
"""
The :class:`RTCOutboundRtpStreamStats` dictionary represents the measurement
metrics for the outgoing RTP stream.
"""
trackId: str
@dataclass
class RTCRemoteOutboundRtpStreamStats(RTCSentRtpStreamStats):
"""
The :class:`RTCRemoteOutboundRtpStreamStats` dictionary represents the remote
endpoint's measurement metrics for its outgoing RTP stream.
"""
remoteTimestamp: Optional[datetime.datetime] = None
@dataclass
class RTCTransportStats(RTCStats):
packetsSent: int
"Total number of packets sent over this transport."
packetsReceived: int
"Total number of packets received over this transport."
bytesSent: int
"Total number of bytes sent over this transport."
bytesReceived: int
"Total number of bytes received over this transport."
iceRole: str
"The current value of :attr:`RTCIceTransport.role`."
dtlsState: str
"The current value of :attr:`RTCDtlsTransport.state`."
class RTCStatsReport(dict):
"""
Provides statistics data about WebRTC connections as returned by the
:meth:`RTCPeerConnection.getStats()`, :meth:`RTCRtpReceiver.getStats()`
and :meth:`RTCRtpSender.getStats()` coroutines.
This object consists of a mapping of string identifiers to objects which
are instances of:
- :class:`RTCInboundRtpStreamStats`
- :class:`RTCOutboundRtpStreamStats`
- :class:`RTCRemoteInboundRtpStreamStats`
- :class:`RTCRemoteOutboundRtpStreamStats`
- :class:`RTCTransportStats`
"""
def add(self, stats: RTCStats) -> None:
self[stats.id] = stats
| 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/src/aiortc/rtcrtpsender.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcrtpsender.py | import asyncio
import logging
import random
import time
import traceback
import uuid
from typing import Callable, Dict, List, Optional, Union
from av import AudioFrame
from av.frame import Frame
from . import clock, rtp
from .codecs import get_capabilities, get_encoder, is_rtx
from .codecs.base import Encoder
from .exceptions import InvalidStateError
from .mediastreams import MediaStreamError, MediaStreamTrack
from .rtcrtpparameters import RTCRtpCodecParameters, RTCRtpSendParameters
from .rtp import (
RTCP_PSFB_APP,
RTCP_PSFB_PLI,
RTCP_RTPFB_NACK,
RTP_HISTORY_SIZE,
AnyRtcpPacket,
RtcpByePacket,
RtcpPsfbPacket,
RtcpRrPacket,
RtcpRtpfbPacket,
RtcpSdesPacket,
RtcpSenderInfo,
RtcpSourceInfo,
RtcpSrPacket,
RtpPacket,
unpack_remb_fci,
wrap_rtx,
)
from .stats import (
RTCOutboundRtpStreamStats,
RTCRemoteInboundRtpStreamStats,
RTCStatsReport,
)
from .utils import random16, random32, uint16_add, uint32_add
logger = logging.getLogger(__name__)
RTT_ALPHA = 0.85
class RTCEncodedFrame:
def __init__(self, payloads: List[bytes], timestamp: int, audio_level: int):
self.payloads = payloads
self.timestamp = timestamp
self.audio_level = audio_level
class RTCRtpSender:
"""
The :class:`RTCRtpSender` interface provides the ability to control and
obtain details about how a particular :class:`MediaStreamTrack` is encoded
and sent to a remote peer.
:param trackOrKind: Either a :class:`MediaStreamTrack` instance or a
media kind (`'audio'` or `'video'`).
:param transport: An :class:`RTCDtlsTransport`.
"""
def __init__(self, trackOrKind: Union[MediaStreamTrack, str], transport) -> None:
if transport.state == "closed":
raise InvalidStateError
if isinstance(trackOrKind, MediaStreamTrack):
self.__kind = trackOrKind.kind
self.replaceTrack(trackOrKind)
else:
self.__kind = trackOrKind
self.replaceTrack(None)
self.__cname: Optional[str] = None
self._ssrc = random32()
self._rtx_ssrc = random32()
# FIXME: how should this be initialised?
self._stream_id = str(uuid.uuid4())
self.__encoder: Optional[Encoder] = None
self.__force_keyframe = False
self.__loop = asyncio.get_event_loop()
self.__mid: Optional[str] = None
self.__rtp_exited = asyncio.Event()
self.__rtp_header_extensions_map = rtp.HeaderExtensionsMap()
self.__rtp_started = asyncio.Event()
self.__rtp_task: Optional[asyncio.Future[None]] = None
self.__rtp_history: Dict[int, RtpPacket] = {}
self.__rtcp_exited = asyncio.Event()
self.__rtcp_started = asyncio.Event()
self.__rtcp_task: Optional[asyncio.Future[None]] = None
self.__rtx_payload_type: Optional[int] = None
self.__rtx_sequence_number = random16()
self.__started = False
self.__stats = RTCStatsReport()
self.__transport = transport
# stats
self.__lsr: Optional[int] = None
self.__lsr_time: Optional[float] = None
self.__ntp_timestamp = 0
self.__rtp_timestamp = 0
self.__octet_count = 0
self.__packet_count = 0
self.__rtt = None
# logging
self.__log_debug: Callable[..., None] = lambda *args: None
if logger.isEnabledFor(logging.DEBUG):
self.__log_debug = lambda msg, *args: logger.debug(
f"RTCRtpSender(%s) {msg}", self.__kind, *args
)
@property
def kind(self):
return self.__kind
@property
def track(self) -> MediaStreamTrack:
"""
The :class:`MediaStreamTrack` which is being handled by the sender.
"""
return self.__track
@property
def transport(self):
"""
The :class:`RTCDtlsTransport` over which media data for the track is
transmitted.
"""
return self.__transport
@classmethod
def getCapabilities(self, kind):
"""
Returns the most optimistic view of the system's capabilities for
sending media of the given `kind`.
:rtype: :class:`RTCRtpCapabilities`
"""
return get_capabilities(kind)
async def getStats(self) -> RTCStatsReport:
"""
Returns statistics about the RTP sender.
:rtype: :class:`RTCStatsReport`
"""
self.__stats.add(
RTCOutboundRtpStreamStats(
# RTCStats
timestamp=clock.current_datetime(),
type="outbound-rtp",
id="outbound-rtp_" + str(id(self)),
# RTCStreamStats
ssrc=self._ssrc,
kind=self.__kind,
transportId=self.transport._stats_id,
# RTCSentRtpStreamStats
packetsSent=self.__packet_count,
bytesSent=self.__octet_count,
# RTCOutboundRtpStreamStats
trackId=str(id(self.track)),
)
)
self.__stats.update(self.transport._get_stats())
return self.__stats
def replaceTrack(self, track: Optional[MediaStreamTrack]) -> None:
self.__track = track
if track is not None:
self._track_id = track.id
else:
self._track_id = str(uuid.uuid4())
def setTransport(self, transport) -> None:
self.__transport = transport
async def send(self, parameters: RTCRtpSendParameters) -> None:
"""
Attempt to set the parameters controlling the sending of media.
:param parameters: The :class:`RTCRtpSendParameters` for the sender.
"""
if not self.__started:
self.__cname = parameters.rtcp.cname
self.__mid = parameters.muxId
# make note of the RTP header extension IDs
self.__transport._register_rtp_sender(self, parameters)
self.__rtp_header_extensions_map.configure(parameters)
# make note of RTX payload type
for codec in parameters.codecs:
if (
is_rtx(codec)
and codec.parameters["apt"] == parameters.codecs[0].payloadType
):
self.__rtx_payload_type = codec.payloadType
break
self.__rtp_task = asyncio.ensure_future(self._run_rtp(parameters.codecs[0]))
self.__rtcp_task = asyncio.ensure_future(self._run_rtcp())
self.__started = True
async def stop(self):
"""
Irreversibly stop the sender.
"""
if self.__started:
self.__transport._unregister_rtp_sender(self)
# shutdown RTP and RTCP tasks
await asyncio.gather(self.__rtp_started.wait(), self.__rtcp_started.wait())
self.__rtp_task.cancel()
self.__rtcp_task.cancel()
await asyncio.gather(self.__rtp_exited.wait(), self.__rtcp_exited.wait())
async def _handle_rtcp_packet(self, packet):
if isinstance(packet, (RtcpRrPacket, RtcpSrPacket)):
for report in filter(lambda x: x.ssrc == self._ssrc, packet.reports):
# estimate round-trip time
if self.__lsr == report.lsr and report.dlsr:
rtt = time.time() - self.__lsr_time - (report.dlsr / 65536)
if self.__rtt is None:
self.__rtt = rtt
else:
self.__rtt = RTT_ALPHA * self.__rtt + (1 - RTT_ALPHA) * rtt
self.__stats.add(
RTCRemoteInboundRtpStreamStats(
# RTCStats
timestamp=clock.current_datetime(),
type="remote-inbound-rtp",
id="remote-inbound-rtp_" + str(id(self)),
# RTCStreamStats
ssrc=packet.ssrc,
kind=self.__kind,
transportId=self.transport._stats_id,
# RTCReceivedRtpStreamStats
packetsReceived=self.__packet_count - report.packets_lost,
packetsLost=report.packets_lost,
jitter=report.jitter,
# RTCRemoteInboundRtpStreamStats
roundTripTime=self.__rtt,
fractionLost=report.fraction_lost,
)
)
elif isinstance(packet, RtcpRtpfbPacket) and packet.fmt == RTCP_RTPFB_NACK:
for seq in packet.lost:
await self._retransmit(seq)
elif isinstance(packet, RtcpPsfbPacket) and packet.fmt == RTCP_PSFB_PLI:
self._send_keyframe()
elif isinstance(packet, RtcpPsfbPacket) and packet.fmt == RTCP_PSFB_APP:
try:
bitrate, ssrcs = unpack_remb_fci(packet.fci)
if self._ssrc in ssrcs:
self.__log_debug(
"- receiver estimated maximum bitrate %d bps", bitrate
)
if self.__encoder and hasattr(self.__encoder, "target_bitrate"):
self.__encoder.target_bitrate = bitrate
except ValueError:
pass
async def _next_encoded_frame(self, codec: RTCRtpCodecParameters):
# get [Frame|Packet]
data = await self.__track.recv()
audio_level = None
if self.__encoder is None:
self.__encoder = get_encoder(codec)
if isinstance(data, Frame):
# encode frame
if isinstance(data, AudioFrame):
audio_level = rtp.compute_audio_level_dbov(data)
force_keyframe = self.__force_keyframe
self.__force_keyframe = False
payloads, timestamp = await self.__loop.run_in_executor(
None, self.__encoder.encode, data, force_keyframe
)
else:
payloads, timestamp = self.__encoder.pack(data)
return RTCEncodedFrame(payloads, timestamp, audio_level)
async def _retransmit(self, sequence_number: int) -> None:
"""
Retransmit an RTP packet which was reported as lost.
"""
packet = self.__rtp_history.get(sequence_number % RTP_HISTORY_SIZE)
if packet and packet.sequence_number == sequence_number:
if self.__rtx_payload_type is not None:
packet = wrap_rtx(
packet,
payload_type=self.__rtx_payload_type,
sequence_number=self.__rtx_sequence_number,
ssrc=self._rtx_ssrc,
)
self.__rtx_sequence_number = uint16_add(self.__rtx_sequence_number, 1)
self.__log_debug("> %s", packet)
packet_bytes = packet.serialize(self.__rtp_header_extensions_map)
await self.transport._send_rtp(packet_bytes)
def _send_keyframe(self) -> None:
"""
Request the next frame to be a keyframe.
"""
self.__force_keyframe = True
async def _run_rtp(self, codec: RTCRtpCodecParameters) -> None:
self.__log_debug("- RTP started")
self.__rtp_started.set()
sequence_number = random16()
timestamp_origin = random32()
try:
while True:
if not self.__track:
await asyncio.sleep(0.02)
continue
enc_frame = await self._next_encoded_frame(codec)
timestamp = uint32_add(timestamp_origin, enc_frame.timestamp)
for i, payload in enumerate(enc_frame.payloads):
packet = RtpPacket(
payload_type=codec.payloadType,
sequence_number=sequence_number,
timestamp=timestamp,
)
packet.ssrc = self._ssrc
packet.payload = payload
packet.marker = (i == len(enc_frame.payloads) - 1) and 1 or 0
# set header extensions
packet.extensions.abs_send_time = (
clock.current_ntp_time() >> 14
) & 0x00FFFFFF
packet.extensions.mid = self.__mid
if enc_frame.audio_level is not None:
packet.extensions.audio_level = (False, -enc_frame.audio_level)
# send packet
self.__log_debug("> %s", packet)
self.__rtp_history[
packet.sequence_number % RTP_HISTORY_SIZE
] = packet
packet_bytes = packet.serialize(self.__rtp_header_extensions_map)
await self.transport._send_rtp(packet_bytes)
self.__ntp_timestamp = clock.current_ntp_time()
self.__rtp_timestamp = packet.timestamp
self.__octet_count += len(payload)
self.__packet_count += 1
sequence_number = uint16_add(sequence_number, 1)
except (asyncio.CancelledError, ConnectionError, MediaStreamError):
pass
except Exception:
# we *need* to set __rtp_exited, otherwise RTCRtpSender.stop() will hang,
# so issue a warning if we hit an unexpected exception
self.__log_warning(traceback.format_exc())
# stop track
if self.__track:
self.__track.stop()
self.__track = None
self.__log_debug("- RTP finished")
self.__rtp_exited.set()
async def _run_rtcp(self) -> None:
self.__log_debug("- RTCP started")
self.__rtcp_started.set()
try:
while True:
# The interval between RTCP packets is varied randomly over the
# range [0.5, 1.5] times the calculated interval.
await asyncio.sleep(0.5 + random.random())
# RTCP SR
packets: List[AnyRtcpPacket] = [
RtcpSrPacket(
ssrc=self._ssrc,
sender_info=RtcpSenderInfo(
ntp_timestamp=self.__ntp_timestamp,
rtp_timestamp=self.__rtp_timestamp,
packet_count=self.__packet_count,
octet_count=self.__octet_count,
),
)
]
self.__lsr = ((self.__ntp_timestamp) >> 16) & 0xFFFFFFFF
self.__lsr_time = time.time()
# RTCP SDES
if self.__cname is not None:
packets.append(
RtcpSdesPacket(
chunks=[
RtcpSourceInfo(
ssrc=self._ssrc,
items=[(1, self.__cname.encode("utf8"))],
)
]
)
)
await self._send_rtcp(packets)
except asyncio.CancelledError:
pass
# RTCP BYE
packet = RtcpByePacket(sources=[self._ssrc])
await self._send_rtcp([packet])
self.__log_debug("- RTCP finished")
self.__rtcp_exited.set()
async def _send_rtcp(self, packets: List[AnyRtcpPacket]) -> None:
payload = b""
for packet in packets:
self.__log_debug("> %s", packet)
payload += bytes(packet)
try:
await self.transport._send_rtp(payload)
except ConnectionError:
pass
def __log_warning(self, msg: str, *args) -> None:
logger.warning(f"RTCRtpsender(%s) {msg}", self.__kind, *args)
| 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/src/aiortc/rtcconfiguration.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/rtcconfiguration.py | from dataclasses import dataclass
from typing import List, Optional, Iterable
@dataclass
class RTCIceServer:
"""
The :class:`RTCIceServer` dictionary defines how to connect to a single
STUN or TURN server. It includes both the URL and the necessary credentials,
if any, to connect to the server.
"""
urls: str
"""
This required property is either a single string or a list of strings,
each specifying a URL which can be used to connect to the server.
"""
username: Optional[str] = None
"The username to use during authentication (for TURN only)."
credential: Optional[str] = None
"The credential to use during authentication (for TURN only)."
credentialType: str = "password"
ephemeral_ports: Optional[Iterable[int]] = None
@dataclass
class RTCConfiguration:
"""
The :class:`RTCConfiguration` dictionary is used to provide configuration
options for an :class:`RTCPeerConnection`.
"""
iceServers: Optional[List[RTCIceServer]] = None
"A list of :class:`RTCIceServer` objects to configure STUN / TURN servers."
| 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/src/aiortc/contrib/signaling.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/contrib/signaling.py | import asyncio
import json
import logging
import os
import sys
from aiortc import RTCIceCandidate, RTCSessionDescription
from aiortc.sdp import candidate_from_sdp, candidate_to_sdp
logger = logging.getLogger(__name__)
BYE = object()
def object_from_string(message_str):
message = json.loads(message_str)
if message["type"] in ["answer", "offer"]:
return RTCSessionDescription(**message)
elif message["type"] == "candidate" and message["candidate"]:
candidate = candidate_from_sdp(message["candidate"].split(":", 1)[1])
candidate.sdpMid = message["id"]
candidate.sdpMLineIndex = message["label"]
return candidate
elif message["type"] == "bye":
return BYE
def object_to_string(obj):
if isinstance(obj, RTCSessionDescription):
message = {"sdp": obj.sdp, "type": obj.type}
elif isinstance(obj, RTCIceCandidate):
message = {
"candidate": "candidate:" + candidate_to_sdp(obj),
"id": obj.sdpMid,
"label": obj.sdpMLineIndex,
"type": "candidate",
}
else:
assert obj is BYE
message = {"type": "bye"}
return json.dumps(message, sort_keys=True)
class CopyAndPasteSignaling:
def __init__(self):
self._read_pipe = sys.stdin
self._read_transport = None
self._reader = None
self._write_pipe = sys.stdout
async def connect(self):
loop = asyncio.get_event_loop()
self._reader = asyncio.StreamReader(loop=loop)
self._read_transport, _ = await loop.connect_read_pipe(
lambda: asyncio.StreamReaderProtocol(self._reader), self._read_pipe
)
async def close(self):
if self._reader is not None:
await self.send(BYE)
self._read_transport.close()
self._reader = None
async def receive(self):
print("-- Please enter a message from remote party --")
data = await self._reader.readline()
print()
return object_from_string(data.decode(self._read_pipe.encoding))
async def send(self, descr):
print("-- Please send this message to the remote party --")
self._write_pipe.write(object_to_string(descr) + "\n")
self._write_pipe.flush()
print()
class TcpSocketSignaling:
def __init__(self, host, port):
self._host = host
self._port = port
self._server = None
self._reader = None
self._writer = None
async def connect(self):
pass
async def _connect(self, server):
if self._writer is not None:
return
if server:
connected = asyncio.Event()
def client_connected(reader, writer):
self._reader = reader
self._writer = writer
connected.set()
self._server = await asyncio.start_server(
client_connected, host=self._host, port=self._port
)
await connected.wait()
else:
self._reader, self._writer = await asyncio.open_connection(
host=self._host, port=self._port
)
async def close(self):
if self._writer is not None:
await self.send(BYE)
self._writer.close()
self._reader = None
self._writer = None
if self._server is not None:
self._server.close()
self._server = None
async def receive(self):
await self._connect(False)
try:
data = await self._reader.readuntil()
except asyncio.IncompleteReadError:
return
return object_from_string(data.decode("utf8"))
async def send(self, descr):
await self._connect(True)
data = object_to_string(descr).encode("utf8")
self._writer.write(data + b"\n")
class UnixSocketSignaling:
def __init__(self, path):
self._path = path
self._server = None
self._reader = None
self._writer = None
async def connect(self):
pass
async def _connect(self, server):
if self._writer is not None:
return
if server:
connected = asyncio.Event()
def client_connected(reader, writer):
self._reader = reader
self._writer = writer
connected.set()
self._server = await asyncio.start_unix_server(
client_connected, path=self._path
)
await connected.wait()
else:
self._reader, self._writer = await asyncio.open_unix_connection(self._path)
async def close(self):
if self._writer is not None:
await self.send(BYE)
self._writer.close()
self._reader = None
self._writer = None
if self._server is not None:
self._server.close()
self._server = None
os.unlink(self._path)
async def receive(self):
await self._connect(False)
try:
data = await self._reader.readuntil()
except asyncio.IncompleteReadError:
return
return object_from_string(data.decode("utf8"))
async def send(self, descr):
await self._connect(True)
data = object_to_string(descr).encode("utf8")
self._writer.write(data + b"\n")
def add_signaling_arguments(parser):
"""
Add signaling method arguments to an argparse.ArgumentParser.
"""
parser.add_argument(
"--signaling",
"-s",
choices=["copy-and-paste", "tcp-socket", "unix-socket"],
)
parser.add_argument(
"--signaling-host", default="127.0.0.1", help="Signaling host (tcp-socket only)"
)
parser.add_argument(
"--signaling-port", default=1234, help="Signaling port (tcp-socket only)"
)
parser.add_argument(
"--signaling-path",
default="aiortc.socket",
help="Signaling socket path (unix-socket only)",
)
def create_signaling(args):
"""
Create a signaling method based on command-line arguments.
"""
if args.signaling == "tcp-socket":
return TcpSocketSignaling(args.signaling_host, args.signaling_port)
elif args.signaling == "unix-socket":
return UnixSocketSignaling(args.signaling_path)
else:
return CopyAndPasteSignaling()
| 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/src/aiortc/contrib/__init__.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/contrib/__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/aiortc/src/aiortc/contrib/media.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/contrib/media.py | import asyncio
import errno
import fractions
import logging
import threading
import time
from typing import Dict, Optional, Set, Union
import av
from av import AudioFrame, VideoFrame
from av.audio import AudioStream
from av.frame import Frame
from av.packet import Packet
from av.video.stream import VideoStream
from ..mediastreams import AUDIO_PTIME, MediaStreamError, MediaStreamTrack
logger = logging.getLogger(__name__)
REAL_TIME_FORMATS = [
"alsa",
"android_camera",
"avfoundation",
"bktr",
"decklink",
"dshow",
"fbdev",
"gdigrab",
"iec61883",
"jack",
"kmsgrab",
"openal",
"oss",
"pulse",
"sndio",
"rtsp",
"v4l2",
"vfwcap",
"x11grab",
]
async def blackhole_consume(track):
while True:
try:
await track.recv()
except MediaStreamError:
return
class MediaBlackhole:
"""
A media sink that consumes and discards all media.
"""
def __init__(self):
self.__tracks = {}
def addTrack(self, track):
"""
Add a track whose media should be discarded.
:param track: A :class:`aiortc.MediaStreamTrack`.
"""
if track not in self.__tracks:
self.__tracks[track] = None
async def start(self):
"""
Start discarding media.
"""
for track, task in self.__tracks.items():
if task is None:
self.__tracks[track] = asyncio.ensure_future(blackhole_consume(track))
async def stop(self):
"""
Stop discarding media.
"""
for task in self.__tracks.values():
if task is not None:
task.cancel()
self.__tracks = {}
def player_worker_decode(
loop,
container,
streams,
audio_track,
video_track,
quit_event,
throttle_playback,
loop_playback,
):
audio_sample_rate = 48000
audio_samples = 0
audio_time_base = fractions.Fraction(1, audio_sample_rate)
audio_resampler = av.AudioResampler(
format="s16",
layout="stereo",
rate=audio_sample_rate,
frame_size=int(audio_sample_rate * AUDIO_PTIME),
)
video_first_pts = None
frame_time = None
start_time = time.time()
while not quit_event.is_set():
try:
frame = next(container.decode(*streams))
except Exception as exc:
if isinstance(exc, av.FFmpegError) and exc.errno == errno.EAGAIN:
time.sleep(0.01)
continue
if isinstance(exc, StopIteration) and loop_playback:
container.seek(0)
continue
if audio_track:
asyncio.run_coroutine_threadsafe(audio_track._queue.put(None), loop)
if video_track:
asyncio.run_coroutine_threadsafe(video_track._queue.put(None), loop)
break
# read up to 1 second ahead
if throttle_playback:
elapsed_time = time.time() - start_time
if frame_time and frame_time > elapsed_time + 1:
time.sleep(0.1)
if isinstance(frame, AudioFrame) and audio_track:
for frame in audio_resampler.resample(frame):
# fix timestamps
frame.pts = audio_samples
frame.time_base = audio_time_base
audio_samples += frame.samples
frame_time = frame.time
asyncio.run_coroutine_threadsafe(audio_track._queue.put(frame), loop)
elif isinstance(frame, VideoFrame) and video_track:
if frame.pts is None: # pragma: no cover
logger.warning(
"MediaPlayer(%s) Skipping video frame with no pts", container.name
)
continue
# video from a webcam doesn't start at pts 0, cancel out offset
if video_first_pts is None:
video_first_pts = frame.pts
frame.pts -= video_first_pts
frame_time = frame.time
asyncio.run_coroutine_threadsafe(video_track._queue.put(frame), loop)
def player_worker_demux(
loop,
container,
streams,
audio_track,
video_track,
quit_event,
throttle_playback,
loop_playback,
):
video_first_pts = None
frame_time = None
start_time = time.time()
while not quit_event.is_set():
try:
packet = next(container.demux(*streams))
if not packet.size:
raise StopIteration
except Exception as exc:
if isinstance(exc, av.FFmpegError) and exc.errno == errno.EAGAIN:
time.sleep(0.01)
continue
if isinstance(exc, StopIteration) and loop_playback:
container.seek(0)
continue
if audio_track:
asyncio.run_coroutine_threadsafe(audio_track._queue.put(None), loop)
if video_track:
asyncio.run_coroutine_threadsafe(video_track._queue.put(None), loop)
break
# read up to 1 second ahead
if throttle_playback:
elapsed_time = time.time() - start_time
if frame_time and frame_time > elapsed_time + 1:
time.sleep(0.1)
track = None
if isinstance(packet.stream, AudioStream) and audio_track:
track = audio_track
elif isinstance(packet.stream, VideoStream) and video_track:
if packet.pts is None: # pragma: no cover
logger.warning(
"MediaPlayer(%s) Skipping video packet with no pts", container.name
)
continue
track = video_track
# video from a webcam doesn't start at pts 0, cancel out offset
if video_first_pts is None:
video_first_pts = packet.pts
packet.pts -= video_first_pts
if (
track is not None
and packet.pts is not None
and packet.time_base is not None
):
frame_time = int(packet.pts * packet.time_base)
asyncio.run_coroutine_threadsafe(track._queue.put(packet), loop)
class PlayerStreamTrack(MediaStreamTrack):
def __init__(self, player, kind):
super().__init__()
self.kind = kind
self._player = player
self._queue = asyncio.Queue()
self._start = None
async def recv(self) -> Union[Frame, Packet]:
if self.readyState != "live":
raise MediaStreamError
self._player._start(self)
data = await self._queue.get()
if data is None:
self.stop()
raise MediaStreamError
if isinstance(data, Frame):
data_time = data.time
elif isinstance(data, Packet):
data_time = float(data.pts * data.time_base)
# control playback rate
if (
self._player is not None
and self._player._throttle_playback
and data_time is not None
):
if self._start is None:
self._start = time.time() - data_time
else:
wait = self._start + data_time - time.time()
await asyncio.sleep(wait)
return data
def stop(self):
super().stop()
if self._player is not None:
self._player._stop(self)
self._player = None
class MediaPlayer:
"""
A media source that reads audio and/or video from a file.
Examples:
.. code-block:: python
# Open a video file.
player = MediaPlayer('/path/to/some.mp4')
# Open an HTTP stream.
player = MediaPlayer(
'http://download.tsi.telecom-paristech.fr/'
'gpac/dataset/dash/uhd/mux_sources/hevcds_720p30_2M.mp4')
# Open webcam on Linux.
player = MediaPlayer('/dev/video0', format='v4l2', options={
'video_size': '640x480'
})
# Open webcam on OS X.
player = MediaPlayer('default:none', format='avfoundation', options={
'video_size': '640x480'
})
# Open webcam on Windows.
player = MediaPlayer('video=Integrated Camera', format='dshow', options={
'video_size': '640x480'
})
:param file: The path to a file, or a file-like object.
:param format: The format to use, defaults to autodect.
:param options: Additional options to pass to FFmpeg.
:param timeout: Open/read timeout to pass to FFmpeg.
:param loop: Whether to repeat playback indefinitely (requires a seekable file).
"""
def __init__(
self, file, format=None, options={}, timeout=None, loop=False, decode=True
):
self.__container = av.open(
file=file, format=format, mode="r", options=options, timeout=timeout
)
self.__thread: Optional[threading.Thread] = None
self.__thread_quit: Optional[threading.Event] = None
# examine streams
self.__started: Set[PlayerStreamTrack] = set()
self.__streams = []
self.__decode = decode
self.__audio: Optional[PlayerStreamTrack] = None
self.__video: Optional[PlayerStreamTrack] = None
for stream in self.__container.streams:
if stream.type == "audio" and not self.__audio:
if self.__decode:
self.__audio = PlayerStreamTrack(self, kind="audio")
self.__streams.append(stream)
elif stream.codec_context.name in ["opus", "pcm_alaw", "pcm_mulaw"]:
self.__audio = PlayerStreamTrack(self, kind="audio")
self.__streams.append(stream)
elif stream.type == "video" and not self.__video:
if self.__decode:
self.__video = PlayerStreamTrack(self, kind="video")
self.__streams.append(stream)
elif stream.codec_context.name in ["h264", "vp8"]:
self.__video = PlayerStreamTrack(self, kind="video")
self.__streams.append(stream)
# check whether we need to throttle playback
container_format = set(self.__container.format.name.split(","))
self._throttle_playback = not container_format.intersection(REAL_TIME_FORMATS)
# check whether the looping is supported
assert (
not loop or self.__container.duration is not None
), "The `loop` argument requires a seekable file"
self._loop_playback = loop
@property
def audio(self) -> MediaStreamTrack:
"""
A :class:`aiortc.MediaStreamTrack` instance if the file contains audio.
"""
return self.__audio
@property
def video(self) -> MediaStreamTrack:
"""
A :class:`aiortc.MediaStreamTrack` instance if the file contains video.
"""
return self.__video
def _start(self, track: PlayerStreamTrack) -> None:
self.__started.add(track)
if self.__thread is None:
self.__log_debug("Starting worker thread")
self.__thread_quit = threading.Event()
self.__thread = threading.Thread(
name="media-player",
target=player_worker_decode if self.__decode else player_worker_demux,
args=(
asyncio.get_event_loop(),
self.__container,
self.__streams,
self.__audio,
self.__video,
self.__thread_quit,
self._throttle_playback,
self._loop_playback,
),
)
self.__thread.start()
def _stop(self, track: PlayerStreamTrack) -> None:
self.__started.discard(track)
if not self.__started and self.__thread is not None:
self.__log_debug("Stopping worker thread")
self.__thread_quit.set()
self.__thread.join()
self.__thread = None
if not self.__started and self.__container is not None:
self.__container.close()
self.__container = None
def __log_debug(self, msg: str, *args) -> None:
logger.debug(f"MediaPlayer(%s) {msg}", self.__container.name, *args)
class MediaRecorderContext:
def __init__(self, stream):
self.started = False
self.stream = stream
self.task = None
class MediaRecorder:
"""
A media sink that writes audio and/or video to a file.
Examples:
.. code-block:: python
# Write to a video file.
player = MediaRecorder('/path/to/file.mp4')
# Write to a set of images.
player = MediaRecorder('/path/to/file-%3d.png')
:param file: The path to a file, or a file-like object.
:param format: The format to use, defaults to autodect.
:param options: Additional options to pass to FFmpeg.
"""
def __init__(self, file, format=None, options={}):
self.__container = av.open(file=file, format=format, mode="w", options=options)
self.__tracks = {}
def addTrack(self, track):
"""
Add a track to be recorded.
:param track: A :class:`aiortc.MediaStreamTrack`.
"""
if track.kind == "audio":
if self.__container.format.name in ("wav", "alsa"):
codec_name = "pcm_s16le"
elif self.__container.format.name == "mp3":
codec_name = "mp3"
else:
codec_name = "aac"
stream = self.__container.add_stream(codec_name)
else:
if self.__container.format.name == "image2":
stream = self.__container.add_stream("png", rate=30)
stream.pix_fmt = "rgb24"
else:
stream = self.__container.add_stream("libx264", rate=30)
stream.pix_fmt = "yuv420p"
self.__tracks[track] = MediaRecorderContext(stream)
async def start(self):
"""
Start recording.
"""
for track, context in self.__tracks.items():
if context.task is None:
context.task = asyncio.ensure_future(self.__run_track(track, context))
async def stop(self):
"""
Stop recording.
"""
if self.__container:
for track, context in self.__tracks.items():
if context.task is not None:
context.task.cancel()
context.task = None
for packet in context.stream.encode(None):
self.__container.mux(packet)
self.__tracks = {}
if self.__container:
self.__container.close()
self.__container = None
async def __run_track(self, track: MediaStreamTrack, context: MediaRecorderContext):
while True:
try:
frame = await track.recv()
except MediaStreamError:
return
if not context.started:
# adjust the output size to match the first frame
if isinstance(frame, VideoFrame):
context.stream.width = frame.width
context.stream.height = frame.height
context.started = True
for packet in context.stream.encode(frame):
self.__container.mux(packet)
class RelayStreamTrack(MediaStreamTrack):
def __init__(self, relay, source: MediaStreamTrack, buffered) -> None:
super().__init__()
self.kind = source.kind
self._relay = relay
self._source: Optional[MediaStreamTrack] = source
self._buffered = buffered
self._frame: Optional[Frame] = None
self._queue: Optional[asyncio.Queue[Optional[Frame]]] = None
self._new_frame_event: Optional[asyncio.Event] = None
if self._buffered:
self._queue = asyncio.Queue()
else:
self._new_frame_event = asyncio.Event()
async def recv(self):
if self.readyState != "live":
raise MediaStreamError
self._relay._start(self)
if self._buffered:
self._frame = await self._queue.get()
else:
await self._new_frame_event.wait()
self._new_frame_event.clear()
if self._frame is None:
self.stop()
raise MediaStreamError
return self._frame
def stop(self):
super().stop()
if self._relay is not None:
self._relay._stop(self)
self._relay = None
self._source = None
class MediaRelay:
"""
A media source that relays one or more tracks to multiple consumers.
This is especially useful for live tracks such as webcams or media received
over the network.
"""
def __init__(self) -> None:
self.__proxies: Dict[MediaStreamTrack, Set[RelayStreamTrack]] = {}
self.__tasks: Dict[MediaStreamTrack, asyncio.Future[None]] = {}
def subscribe(
self, track: MediaStreamTrack, buffered: bool = True
) -> MediaStreamTrack:
"""
Create a proxy around the given `track` for a new consumer.
:param track: Source :class:`MediaStreamTrack` which is relayed
:param buffered: Whether there need a buffer between the source track and relayed track
:rtype: :class: MediaStreamTrack
"""
proxy = RelayStreamTrack(self, track, buffered)
self.__log_debug("Create proxy %s for source %s", id(proxy), id(track))
if track not in self.__proxies:
self.__proxies[track] = set()
return proxy
def _start(self, proxy: RelayStreamTrack) -> None:
track = proxy._source
if track is not None and track in self.__proxies:
# register proxy
if proxy not in self.__proxies[track]:
self.__log_debug("Start proxy %s", id(proxy))
self.__proxies[track].add(proxy)
# start worker
if track not in self.__tasks:
self.__tasks[track] = asyncio.ensure_future(self.__run_track(track))
def _stop(self, proxy: RelayStreamTrack) -> None:
track = proxy._source
if track is not None and track in self.__proxies:
# unregister proxy
self.__log_debug("Stop proxy %s", id(proxy))
self.__proxies[track].discard(proxy)
def __log_debug(self, msg: str, *args) -> None:
logger.debug(f"MediaRelay(%s) {msg}", id(self), *args)
async def __run_track(self, track: MediaStreamTrack) -> None:
self.__log_debug("Start reading source %s" % id(track))
while True:
try:
frame = await track.recv()
except MediaStreamError:
frame = None
for proxy in self.__proxies[track]:
if proxy._buffered:
proxy._queue.put_nowait(frame)
else:
proxy._frame = frame
proxy._new_frame_event.set()
if frame is None:
break
self.__log_debug("Stop reading source %s", id(track))
del self.__proxies[track]
del self.__tasks[track]
| 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/src/aiortc/codecs/g711.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/codecs/g711.py | import audioop
import fractions
from abc import ABC, abstractmethod
from typing import List, Optional, Tuple
from av import AudioFrame
from av.frame import Frame
from av.packet import Packet
from ..jitterbuffer import JitterFrame
from ..mediastreams import convert_timebase
from .base import Decoder, Encoder
SAMPLE_RATE = 8000
SAMPLE_WIDTH = 2
SAMPLES_PER_FRAME = 160
TIME_BASE = fractions.Fraction(1, 8000)
class PcmDecoder(ABC, Decoder):
@staticmethod
@abstractmethod
def _convert(data: bytes, width: int) -> bytes:
pass # pragma: no cover
def decode(self, encoded_frame: JitterFrame) -> List[Frame]:
frame = AudioFrame(format="s16", layout="mono", samples=SAMPLES_PER_FRAME)
frame.planes[0].update(self._convert(encoded_frame.data, SAMPLE_WIDTH))
frame.pts = encoded_frame.timestamp
frame.sample_rate = SAMPLE_RATE
frame.time_base = TIME_BASE
return [frame]
class PcmEncoder(ABC, Encoder):
@staticmethod
@abstractmethod
def _convert(data: bytes, width: int) -> bytes:
pass # pragma: no cover
def __init__(self) -> None:
self.rate_state: Optional[Tuple[int, Tuple[Tuple[int, int], ...]]] = None
def encode(
self, frame: Frame, force_keyframe: bool = False
) -> Tuple[List[bytes], int]:
assert isinstance(frame, AudioFrame)
assert frame.format.name == "s16"
assert frame.layout.name in ["mono", "stereo"]
channels = len(frame.layout.channels)
data = bytes(frame.planes[0])
timestamp = frame.pts
# resample at 8 kHz
if frame.sample_rate != SAMPLE_RATE:
data, self.rate_state = audioop.ratecv(
data,
SAMPLE_WIDTH,
channels,
frame.sample_rate,
SAMPLE_RATE,
self.rate_state,
)
timestamp = (timestamp * SAMPLE_RATE) // frame.sample_rate
# convert to mono
if channels == 2:
data = audioop.tomono(data, SAMPLE_WIDTH, 1, 1)
data = self._convert(data, SAMPLE_WIDTH)
return [data], timestamp
def pack(self, packet: Packet) -> Tuple[List[bytes], int]:
timestamp = convert_timebase(packet.pts, packet.time_base, TIME_BASE)
return [bytes(packet)], timestamp
class PcmaDecoder(PcmDecoder):
@staticmethod
def _convert(data: bytes, width: int) -> bytes:
return audioop.alaw2lin(data, width)
class PcmaEncoder(PcmEncoder):
@staticmethod
def _convert(data: bytes, width: int) -> bytes:
return audioop.lin2alaw(data, width)
class PcmuDecoder(PcmDecoder):
@staticmethod
def _convert(data: bytes, width: int) -> bytes:
return audioop.ulaw2lin(data, width)
class PcmuEncoder(PcmEncoder):
@staticmethod
def _convert(data: bytes, width: int) -> bytes:
return audioop.lin2ulaw(data, width)
| 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/src/aiortc/codecs/opus.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/codecs/opus.py | import audioop
import fractions
from typing import List, Optional, Tuple
from av import AudioFrame
from av.frame import Frame
from av.packet import Packet
from ..jitterbuffer import JitterFrame
from ..mediastreams import convert_timebase
from ._opus import ffi, lib
from .base import Decoder, Encoder
CHANNELS = 2
SAMPLE_RATE = 48000
SAMPLE_WIDTH = 2
SAMPLES_PER_FRAME = 960
TIME_BASE = fractions.Fraction(1, SAMPLE_RATE)
class OpusDecoder(Decoder):
def __init__(self) -> None:
error = ffi.new("int *")
self.decoder = lib.opus_decoder_create(SAMPLE_RATE, CHANNELS, error)
assert error[0] == lib.OPUS_OK
def __del__(self) -> None:
lib.opus_decoder_destroy(self.decoder)
def decode(self, encoded_frame: JitterFrame) -> List[Frame]:
frame = AudioFrame(format="s16", layout="stereo", samples=SAMPLES_PER_FRAME)
frame.pts = encoded_frame.timestamp
frame.sample_rate = SAMPLE_RATE
frame.time_base = TIME_BASE
length = lib.opus_decode(
self.decoder,
encoded_frame.data,
len(encoded_frame.data),
ffi.cast("int16_t *", frame.planes[0].buffer_ptr),
SAMPLES_PER_FRAME,
0,
)
assert length == SAMPLES_PER_FRAME
return [frame]
class OpusEncoder(Encoder):
def __init__(self) -> None:
error = ffi.new("int *")
self.encoder = lib.opus_encoder_create(
SAMPLE_RATE, CHANNELS, lib.OPUS_APPLICATION_VOIP, error
)
assert error[0] == lib.OPUS_OK
self.cdata = ffi.new(
"unsigned char []", SAMPLES_PER_FRAME * CHANNELS * SAMPLE_WIDTH
)
self.buffer = ffi.buffer(self.cdata)
self.rate_state: Optional[Tuple[int, Tuple[Tuple[int, int], ...]]] = None
def __del__(self) -> None:
lib.opus_encoder_destroy(self.encoder)
def encode(
self, frame: Frame, force_keyframe: bool = False
) -> Tuple[List[bytes], int]:
assert isinstance(frame, AudioFrame)
assert frame.format.name == "s16"
assert frame.layout.name in ["mono", "stereo"]
channels = len(frame.layout.channels)
data = bytes(frame.planes[0])
timestamp = frame.pts
# resample at 48 kHz
if frame.sample_rate != SAMPLE_RATE:
data, self.rate_state = audioop.ratecv(
data,
SAMPLE_WIDTH,
channels,
frame.sample_rate,
SAMPLE_RATE,
self.rate_state,
)
timestamp = (timestamp * SAMPLE_RATE) // frame.sample_rate
# convert to stereo
if channels == 1:
data = audioop.tostereo(data, SAMPLE_WIDTH, 1, 1)
length = lib.opus_encode(
self.encoder,
ffi.cast("int16_t*", ffi.from_buffer(data)),
SAMPLES_PER_FRAME,
self.cdata,
len(self.cdata),
)
assert length > 0
return [self.buffer[0:length]], timestamp
def pack(self, packet: Packet) -> Tuple[List[bytes], int]:
timestamp = convert_timebase(packet.pts, packet.time_base, TIME_BASE)
return [bytes(packet)], timestamp
| 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/src/aiortc/codecs/vpx.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/codecs/vpx.py | import multiprocessing
import random
from struct import pack, unpack_from
from typing import List, Tuple, Type, TypeVar, cast
from av import VideoFrame
from av.frame import Frame
from av.packet import Packet
from ..jitterbuffer import JitterFrame
from ..mediastreams import VIDEO_CLOCK_RATE, VIDEO_TIME_BASE, convert_timebase
from ._vpx import ffi, lib
from .base import Decoder, Encoder
DEFAULT_BITRATE = 500000 # 500 kbps
MIN_BITRATE = 250000 # 250 kbps
MAX_BITRATE = 1500000 # 1.5 Mbps
MAX_FRAME_RATE = 30
PACKET_MAX = 1300
DESCRIPTOR_T = TypeVar("DESCRIPTOR_T", bound="VpxPayloadDescriptor")
def number_of_threads(pixels: int, cpus: int) -> int:
if pixels >= 1920 * 1080 and cpus > 8:
return 8
elif pixels > 1280 * 960 and cpus >= 6:
return 3
elif pixels > 640 * 480 and cpus >= 3:
return 2
else:
return 1
class VpxPayloadDescriptor:
def __init__(
self,
partition_start,
partition_id,
picture_id=None,
tl0picidx=None,
tid=None,
keyidx=None,
) -> None:
self.partition_start = partition_start
self.partition_id = partition_id
self.picture_id = picture_id
self.tl0picidx = tl0picidx
self.tid = tid
self.keyidx = keyidx
def __bytes__(self) -> bytes:
octet = (self.partition_start << 4) | self.partition_id
ext_octet = 0
if self.picture_id is not None:
ext_octet |= 1 << 7
if self.tl0picidx is not None:
ext_octet |= 1 << 6
if self.tid is not None:
ext_octet |= 1 << 5
if self.keyidx is not None:
ext_octet |= 1 << 4
if ext_octet:
data = pack("!BB", (1 << 7) | octet, ext_octet)
if self.picture_id is not None:
if self.picture_id < 128:
data += pack("!B", self.picture_id)
else:
data += pack("!H", (1 << 15) | self.picture_id)
if self.tl0picidx is not None:
data += pack("!B", self.tl0picidx)
if self.tid is not None or self.keyidx is not None:
t_k = 0
if self.tid is not None:
t_k |= (self.tid[0] << 6) | (self.tid[1] << 5)
if self.keyidx is not None:
t_k |= self.keyidx
data += pack("!B", t_k)
else:
data = pack("!B", octet)
return data
def __repr__(self) -> str:
return (
f"VpxPayloadDescriptor(S={self.partition_start}, "
f"PID={self.partition_id}, pic_id={self.picture_id})"
)
@classmethod
def parse(cls: Type[DESCRIPTOR_T], data: bytes) -> Tuple[DESCRIPTOR_T, bytes]:
if len(data) < 1:
raise ValueError("VPX descriptor is too short")
# first byte
octet = data[0]
extended = octet >> 7
partition_start = (octet >> 4) & 1
partition_id = octet & 0xF
picture_id = None
tl0picidx = None
tid = None
keyidx = None
pos = 1
# extended control bits
if extended:
if len(data) < pos + 1:
raise ValueError("VPX descriptor has truncated extended bits")
octet = data[pos]
ext_I = (octet >> 7) & 1
ext_L = (octet >> 6) & 1
ext_T = (octet >> 5) & 1
ext_K = (octet >> 4) & 1
pos += 1
# picture id
if ext_I:
if len(data) < pos + 1:
raise ValueError("VPX descriptor has truncated PictureID")
if data[pos] & 0x80:
if len(data) < pos + 2:
raise ValueError("VPX descriptor has truncated long PictureID")
picture_id = unpack_from("!H", data, pos)[0] & 0x7FFF
pos += 2
else:
picture_id = data[pos]
pos += 1
# unused
if ext_L:
if len(data) < pos + 1:
raise ValueError("VPX descriptor has truncated TL0PICIDX")
tl0picidx = data[pos]
pos += 1
if ext_T or ext_K:
if len(data) < pos + 1:
raise ValueError("VPX descriptor has truncated T/K")
t_k = data[pos]
if ext_T:
tid = ((t_k >> 6) & 3, (t_k >> 5) & 1)
if ext_K:
keyidx = t_k & 0x1F
pos += 1
obj = cls(
partition_start=partition_start,
partition_id=partition_id,
picture_id=picture_id,
tl0picidx=tl0picidx,
tid=tid,
keyidx=keyidx,
)
return obj, data[pos:]
def _vpx_assert(err: int) -> None:
if err != lib.VPX_CODEC_OK:
reason = ffi.string(lib.vpx_codec_err_to_string(err))
raise Exception("libvpx error: " + reason.decode("utf8"))
class Vp8Decoder(Decoder):
def __init__(self) -> None:
self.codec = ffi.new("vpx_codec_ctx_t *")
_vpx_assert(
lib.vpx_codec_dec_init(self.codec, lib.vpx_codec_vp8_dx(), ffi.NULL, 0)
)
ppcfg = ffi.new("vp8_postproc_cfg_t *")
ppcfg.post_proc_flag = lib.VP8_DEMACROBLOCK | lib.VP8_DEBLOCK
ppcfg.deblocking_level = 3
lib.vpx_codec_control_(self.codec, lib.VP8_SET_POSTPROC, ppcfg)
def __del__(self) -> None:
lib.vpx_codec_destroy(self.codec)
def decode(self, encoded_frame: JitterFrame) -> List[Frame]:
frames: List[Frame] = []
result = lib.vpx_codec_decode(
self.codec,
encoded_frame.data,
len(encoded_frame.data),
ffi.NULL,
lib.VPX_DL_REALTIME,
)
if result == lib.VPX_CODEC_OK:
it = ffi.new("vpx_codec_iter_t *")
while True:
img = lib.vpx_codec_get_frame(self.codec, it)
if not img:
break
assert img.fmt == lib.VPX_IMG_FMT_I420
frame = VideoFrame(width=img.d_w, height=img.d_h)
frame.pts = encoded_frame.timestamp
frame.time_base = VIDEO_TIME_BASE
for p in range(3):
i_stride = img.stride[p]
i_buf = ffi.buffer(img.planes[p], i_stride * img.d_h)
i_pos = 0
o_stride = frame.planes[p].line_size
o_buf = memoryview(cast(bytes, frame.planes[p]))
o_pos = 0
div = p and 2 or 1
for r in range(0, img.d_h // div):
o_buf[o_pos : o_pos + o_stride] = i_buf[
i_pos : i_pos + o_stride
]
i_pos += i_stride
o_pos += o_stride
frames.append(frame)
return frames
class Vp8Encoder(Encoder):
def __init__(self) -> None:
self.cx = lib.vpx_codec_vp8_cx()
self.cfg = ffi.new("vpx_codec_enc_cfg_t *")
lib.vpx_codec_enc_config_default(self.cx, self.cfg, 0)
self.buffer = bytearray(8000)
self.codec = None
self.picture_id = random.randint(0, (1 << 15) - 1)
self.timestamp_increment = VIDEO_CLOCK_RATE // MAX_FRAME_RATE
self.__target_bitrate = DEFAULT_BITRATE
self.__update_config_needed = False
def __del__(self) -> None:
if self.codec:
lib.vpx_codec_destroy(self.codec)
def encode(
self, frame: Frame, force_keyframe: bool = False
) -> Tuple[List[bytes], int]:
assert isinstance(frame, VideoFrame)
if frame.format.name != "yuv420p":
frame = frame.reformat(format="yuv420p")
if self.codec and (frame.width != self.cfg.g_w or frame.height != self.cfg.g_h):
lib.vpx_codec_destroy(self.codec)
self.codec = None
if not self.codec:
# create codec
self.codec = ffi.new("vpx_codec_ctx_t *")
self.cfg.g_timebase.num = 1
self.cfg.g_timebase.den = VIDEO_CLOCK_RATE
self.cfg.g_lag_in_frames = 0
self.cfg.g_threads = number_of_threads(
frame.width * frame.height, multiprocessing.cpu_count()
)
self.cfg.g_w = frame.width
self.cfg.g_h = frame.height
self.cfg.rc_resize_allowed = 0
self.cfg.rc_end_usage = lib.VPX_CBR
self.cfg.rc_min_quantizer = 2
self.cfg.rc_max_quantizer = 56
self.cfg.rc_undershoot_pct = 100
self.cfg.rc_overshoot_pct = 15
self.cfg.rc_buf_initial_sz = 500
self.cfg.rc_buf_optimal_sz = 600
self.cfg.rc_buf_sz = 1000
self.cfg.kf_mode = lib.VPX_KF_AUTO
self.cfg.kf_max_dist = 3000
self.__update_config()
_vpx_assert(lib.vpx_codec_enc_init(self.codec, self.cx, self.cfg, 0))
lib.vpx_codec_control_(
self.codec, lib.VP8E_SET_NOISE_SENSITIVITY, ffi.cast("int", 4)
)
lib.vpx_codec_control_(
self.codec, lib.VP8E_SET_STATIC_THRESHOLD, ffi.cast("int", 1)
)
lib.vpx_codec_control_(
self.codec, lib.VP8E_SET_CPUUSED, ffi.cast("int", -6)
)
lib.vpx_codec_control_(
self.codec,
lib.VP8E_SET_TOKEN_PARTITIONS,
ffi.cast("int", lib.VP8_ONE_TOKENPARTITION),
)
# create image on a dummy buffer, we will fill the pointers during encoding
self.image = ffi.new("vpx_image_t *")
lib.vpx_img_wrap(
self.image,
lib.VPX_IMG_FMT_I420,
frame.width,
frame.height,
1,
ffi.cast("void*", 1),
)
elif self.__update_config_needed:
self.__update_config()
_vpx_assert(lib.vpx_codec_enc_config_set(self.codec, self.cfg))
# setup image
for p in range(3):
self.image.planes[p] = ffi.cast("void*", frame.planes[p].buffer_ptr)
self.image.stride[p] = frame.planes[p].line_size
# encode frame
flags = 0
if force_keyframe:
flags |= lib.VPX_EFLAG_FORCE_KF
_vpx_assert(
lib.vpx_codec_encode(
self.codec,
self.image,
frame.pts,
self.timestamp_increment,
flags,
lib.VPX_DL_REALTIME,
)
)
it = ffi.new("vpx_codec_iter_t *")
length = 0
while True:
pkt = lib.vpx_codec_get_cx_data(self.codec, it)
if not pkt:
break
elif pkt.kind == lib.VPX_CODEC_CX_FRAME_PKT:
# resize buffer if needed
if length + pkt.data.frame.sz > len(self.buffer):
new_buffer = bytearray(length + pkt.data.frame.sz)
new_buffer[0:length] = self.buffer[0:length]
self.buffer = new_buffer
# append new data
self.buffer[length : length + pkt.data.frame.sz] = ffi.buffer(
pkt.data.frame.buf, pkt.data.frame.sz
)
length += pkt.data.frame.sz
# packetize
payloads = self._packetize(self.buffer[:length], self.picture_id)
timestamp = convert_timebase(frame.pts, frame.time_base, VIDEO_TIME_BASE)
self.picture_id = (self.picture_id + 1) % (1 << 15)
return payloads, timestamp
def pack(self, packet: Packet) -> Tuple[List[bytes], int]:
payloads = self._packetize(bytes(packet), self.picture_id)
timestamp = convert_timebase(packet.pts, packet.time_base, VIDEO_TIME_BASE)
self.picture_id = (self.picture_id + 1) % (1 << 15)
return payloads, timestamp
@property
def target_bitrate(self) -> int:
"""
Target bitrate in bits per second.
"""
return self.__target_bitrate
@target_bitrate.setter
def target_bitrate(self, bitrate: int) -> None:
bitrate = max(MIN_BITRATE, min(bitrate, MAX_BITRATE))
if bitrate != self.__target_bitrate:
self.__target_bitrate = bitrate
self.__update_config_needed = True
@classmethod
def _packetize(cls, buffer: bytes, picture_id: int) -> List[bytes]:
payloads = []
descr = VpxPayloadDescriptor(
partition_start=1, partition_id=0, picture_id=picture_id
)
length = len(buffer)
pos = 0
while pos < length:
descr_bytes = bytes(descr)
size = min(length - pos, PACKET_MAX - len(descr_bytes))
payloads.append(descr_bytes + buffer[pos : pos + size])
descr.partition_start = 0
pos += size
return payloads
def __update_config(self) -> None:
self.cfg.rc_target_bitrate = self.__target_bitrate // 1000
self.__update_config_needed = False
def vp8_depayload(payload: bytes) -> bytes:
descriptor, data = VpxPayloadDescriptor.parse(payload)
return data
| 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/src/aiortc/codecs/h264.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/codecs/h264.py | import fractions
import logging
import math
from itertools import tee
from struct import pack, unpack_from
from typing import Iterator, List, Optional, Sequence, Tuple, Type, TypeVar
import av
from av.frame import Frame
from av.packet import Packet
from ..jitterbuffer import JitterFrame
from ..mediastreams import VIDEO_TIME_BASE, convert_timebase
from .base import Decoder, Encoder
logger = logging.getLogger(__name__)
DEFAULT_BITRATE = 1000000 # 1 Mbps
MIN_BITRATE = 500000 # 500 kbps
MAX_BITRATE = 3000000 # 3 Mbps
MAX_FRAME_RATE = 30
PACKET_MAX = 1300
NAL_TYPE_FU_A = 28
NAL_TYPE_STAP_A = 24
NAL_HEADER_SIZE = 1
FU_A_HEADER_SIZE = 2
LENGTH_FIELD_SIZE = 2
STAP_A_HEADER_SIZE = NAL_HEADER_SIZE + LENGTH_FIELD_SIZE
DESCRIPTOR_T = TypeVar("DESCRIPTOR_T", bound="H264PayloadDescriptor")
T = TypeVar("T")
def pairwise(iterable: Sequence[T]) -> Iterator[Tuple[T, T]]:
a, b = tee(iterable)
next(b, None)
return zip(a, b)
class H264PayloadDescriptor:
def __init__(self, first_fragment):
self.first_fragment = first_fragment
def __repr__(self):
return f"H264PayloadDescriptor(FF={self.first_fragment})"
@classmethod
def parse(cls: Type[DESCRIPTOR_T], data: bytes) -> Tuple[DESCRIPTOR_T, bytes]:
output = bytes()
# NAL unit header
if len(data) < 2:
raise ValueError("NAL unit is too short")
nal_type = data[0] & 0x1F
f_nri = data[0] & (0x80 | 0x60)
pos = NAL_HEADER_SIZE
if nal_type in range(1, 24):
# single NAL unit
output = bytes([0, 0, 0, 1]) + data
obj = cls(first_fragment=True)
elif nal_type == NAL_TYPE_FU_A:
# fragmentation unit
original_nal_type = data[pos] & 0x1F
first_fragment = bool(data[pos] & 0x80)
pos += 1
if first_fragment:
original_nal_header = bytes([f_nri | original_nal_type])
output += bytes([0, 0, 0, 1])
output += original_nal_header
output += data[pos:]
obj = cls(first_fragment=first_fragment)
elif nal_type == NAL_TYPE_STAP_A:
# single time aggregation packet
offsets = []
while pos < len(data):
if len(data) < pos + LENGTH_FIELD_SIZE:
raise ValueError("STAP-A length field is truncated")
nalu_size = unpack_from("!H", data, pos)[0]
pos += LENGTH_FIELD_SIZE
offsets.append(pos)
pos += nalu_size
if len(data) < pos:
raise ValueError("STAP-A data is truncated")
offsets.append(len(data) + LENGTH_FIELD_SIZE)
for start, end in pairwise(offsets):
end -= LENGTH_FIELD_SIZE
output += bytes([0, 0, 0, 1])
output += data[start:end]
obj = cls(first_fragment=True)
else:
raise ValueError(f"NAL unit type {nal_type} is not supported")
return obj, output
class H264Decoder(Decoder):
def __init__(self) -> None:
self.codec = av.CodecContext.create("h264", "r")
def decode(self, encoded_frame: JitterFrame) -> List[Frame]:
try:
packet = av.Packet(encoded_frame.data)
packet.pts = encoded_frame.timestamp
packet.time_base = VIDEO_TIME_BASE
frames = self.codec.decode(packet)
except av.AVError as e:
logger.warning(
"H264Decoder() failed to decode, skipping package: " + str(e)
)
return []
return frames
def create_encoder_context(
codec_name: str, width: int, height: int, bitrate: int
) -> Tuple[av.CodecContext, bool]:
codec = av.CodecContext.create(codec_name, "w")
codec.width = width
codec.height = height
codec.bit_rate = bitrate
codec.pix_fmt = "yuv420p"
codec.framerate = fractions.Fraction(MAX_FRAME_RATE, 1)
codec.time_base = fractions.Fraction(1, MAX_FRAME_RATE)
codec.options = {
"profile": "baseline",
"level": "31",
"tune": "zerolatency", # does nothing using h264_omx
}
codec.open()
return codec, codec_name == "h264_omx"
class H264Encoder(Encoder):
def __init__(self) -> None:
self.buffer_data = b""
self.buffer_pts: Optional[int] = None
self.codec: Optional[av.CodecContext] = None
self.codec_buffering = False
self.__target_bitrate = DEFAULT_BITRATE
@staticmethod
def _packetize_fu_a(data: bytes) -> List[bytes]:
available_size = PACKET_MAX - FU_A_HEADER_SIZE
payload_size = len(data) - NAL_HEADER_SIZE
num_packets = math.ceil(payload_size / available_size)
num_larger_packets = payload_size % num_packets
package_size = payload_size // num_packets
f_nri = data[0] & (0x80 | 0x60) # fni of original header
nal = data[0] & 0x1F
fu_indicator = f_nri | NAL_TYPE_FU_A
fu_header_end = bytes([fu_indicator, nal | 0x40])
fu_header_middle = bytes([fu_indicator, nal])
fu_header_start = bytes([fu_indicator, nal | 0x80])
fu_header = fu_header_start
packages = []
offset = NAL_HEADER_SIZE
while offset < len(data):
if num_larger_packets > 0:
num_larger_packets -= 1
payload = data[offset : offset + package_size + 1]
offset += package_size + 1
else:
payload = data[offset : offset + package_size]
offset += package_size
if offset == len(data):
fu_header = fu_header_end
packages.append(fu_header + payload)
fu_header = fu_header_middle
assert offset == len(data), "incorrect fragment data"
return packages
@staticmethod
def _packetize_stap_a(
data: bytes, packages_iterator: Iterator[bytes]
) -> Tuple[bytes, bytes]:
counter = 0
available_size = PACKET_MAX - STAP_A_HEADER_SIZE
stap_header = NAL_TYPE_STAP_A | (data[0] & 0xE0)
payload = bytes()
try:
nalu = data # with header
while len(nalu) <= available_size and counter < 9:
stap_header |= nalu[0] & 0x80
nri = nalu[0] & 0x60
if stap_header & 0x60 < nri:
stap_header = stap_header & 0x9F | nri
available_size -= LENGTH_FIELD_SIZE + len(nalu)
counter += 1
payload += pack("!H", len(nalu)) + nalu
nalu = next(packages_iterator)
if counter == 0:
nalu = next(packages_iterator)
except StopIteration:
nalu = None
if counter <= 1:
return data, nalu
else:
return bytes([stap_header]) + payload, nalu
@staticmethod
def _split_bitstream(buf: bytes) -> Iterator[bytes]:
# Translated from: https://github.com/aizvorski/h264bitstream/blob/master/h264_nal.c#L134
i = 0
while True:
# Find the start of the NAL unit
# NAL Units start with a 3-byte or 4 byte start code of 0x000001 or 0x00000001
# while buf[i:i+3] != b'\x00\x00\x01':
i = buf.find(b"\x00\x00\x01", i)
if i == -1:
return
# Jump past the start code
i += 3
nal_start = i
# Find the end of the NAL unit (end of buffer OR next start code)
i = buf.find(b"\x00\x00\x01", i)
if i == -1:
yield buf[nal_start : len(buf)]
return
elif buf[i - 1] == 0:
# 4-byte start code case, jump back one byte
yield buf[nal_start : i - 1]
else:
yield buf[nal_start:i]
@classmethod
def _packetize(cls, packages: Iterator[bytes]) -> List[bytes]:
packetized_packages = []
packages_iterator = iter(packages)
package = next(packages_iterator, None)
while package is not None:
if len(package) > PACKET_MAX:
packetized_packages.extend(cls._packetize_fu_a(package))
package = next(packages_iterator, None)
else:
packetized, package = cls._packetize_stap_a(package, packages_iterator)
packetized_packages.append(packetized)
return packetized_packages
def _encode_frame(
self, frame: av.VideoFrame, force_keyframe: bool
) -> Iterator[bytes]:
if self.codec and (
frame.width != self.codec.width
or frame.height != self.codec.height
# we only adjust bitrate if it changes by over 10%
or abs(self.target_bitrate - self.codec.bit_rate) / self.codec.bit_rate
> 0.1
):
self.buffer_data = b""
self.buffer_pts = None
self.codec = None
# reset the picture type, otherwise no B-frames are produced
frame.pict_type = av.video.frame.PictureType.NONE
if self.codec is None:
try:
self.codec, self.codec_buffering = create_encoder_context(
"h264_omx", frame.width, frame.height, bitrate=self.target_bitrate
)
except Exception:
self.codec, self.codec_buffering = create_encoder_context(
"libx264",
frame.width,
frame.height,
bitrate=self.target_bitrate,
)
data_to_send = b""
for package in self.codec.encode(frame):
package_bytes = bytes(package)
if self.codec_buffering:
# delay sending to ensure we accumulate all packages
# for a given PTS
if package.pts == self.buffer_pts:
self.buffer_data += package_bytes
else:
data_to_send += self.buffer_data
self.buffer_data = package_bytes
self.buffer_pts = package.pts
else:
data_to_send += package_bytes
if data_to_send:
yield from self._split_bitstream(data_to_send)
def encode(
self, frame: Frame, force_keyframe: bool = False
) -> Tuple[List[bytes], int]:
assert isinstance(frame, av.VideoFrame)
packages = self._encode_frame(frame, force_keyframe)
timestamp = convert_timebase(frame.pts, frame.time_base, VIDEO_TIME_BASE)
return self._packetize(packages), timestamp
def pack(self, packet: Packet) -> Tuple[List[bytes], int]:
assert isinstance(packet, av.Packet)
packages = self._split_bitstream(bytes(packet))
timestamp = convert_timebase(packet.pts, packet.time_base, VIDEO_TIME_BASE)
return self._packetize(packages), timestamp
@property
def target_bitrate(self) -> int:
"""
Target bitrate in bits per second.
"""
return self.__target_bitrate
@target_bitrate.setter
def target_bitrate(self, bitrate: int) -> None:
bitrate = max(MIN_BITRATE, min(bitrate, MAX_BITRATE))
self.__target_bitrate = bitrate
def h264_depayload(payload: bytes) -> bytes:
descriptor, data = H264PayloadDescriptor.parse(payload)
return data
| 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/src/aiortc/codecs/__init__.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/codecs/__init__.py | from typing import Dict, List, Optional, Union
from ..rtcrtpparameters import (
ParametersDict,
RTCRtcpFeedback,
RTCRtpCapabilities,
RTCRtpCodecCapability,
RTCRtpCodecParameters,
RTCRtpHeaderExtensionCapability,
RTCRtpHeaderExtensionParameters,
)
from .base import Decoder, Encoder
from .g711 import PcmaDecoder, PcmaEncoder, PcmuDecoder, PcmuEncoder
from .h264 import H264Decoder, H264Encoder, h264_depayload
from .opus import OpusDecoder, OpusEncoder
from .vpx import Vp8Decoder, Vp8Encoder, vp8_depayload
PCMU_CODEC = RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, channels=1, payloadType=0
)
PCMA_CODEC = RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
)
CODECS: Dict[str, List[RTCRtpCodecParameters]] = {
"audio": [
RTCRtpCodecParameters(
mimeType="audio/opus", clockRate=48000, channels=2, payloadType=96
),
PCMU_CODEC,
PCMA_CODEC,
],
"video": [],
}
HEADER_EXTENSIONS: Dict[str, List[RTCRtpHeaderExtensionParameters]] = {
"audio": [
RTCRtpHeaderExtensionParameters(
id=1, uri="urn:ietf:params:rtp-hdrext:sdes:mid"
),
RTCRtpHeaderExtensionParameters(
id=2, uri="urn:ietf:params:rtp-hdrext:ssrc-audio-level"
),
],
"video": [
RTCRtpHeaderExtensionParameters(
id=1, uri="urn:ietf:params:rtp-hdrext:sdes:mid"
),
RTCRtpHeaderExtensionParameters(
id=2, uri="http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time"
),
],
}
def init_codecs() -> None:
dynamic_pt = 97
def add_video_codec(
mimeType: str, parameters: Optional[ParametersDict] = None
) -> None:
nonlocal dynamic_pt
clockRate = 90000
CODECS["video"] += [
RTCRtpCodecParameters(
mimeType=mimeType,
clockRate=clockRate,
payloadType=dynamic_pt,
rtcpFeedback=[
RTCRtcpFeedback(type="nack"),
RTCRtcpFeedback(type="nack", parameter="pli"),
RTCRtcpFeedback(type="goog-remb"),
],
parameters=parameters or {},
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=clockRate,
payloadType=dynamic_pt + 1,
parameters={"apt": dynamic_pt},
),
]
dynamic_pt += 2
add_video_codec("video/VP8")
for profile_level_id in ("42001f", "42e01f"):
add_video_codec(
"video/H264",
{
"level-asymmetry-allowed": "1",
"packetization-mode": "1",
"profile-level-id": profile_level_id,
},
)
def depayload(codec: RTCRtpCodecParameters, payload: bytes) -> bytes:
if codec.name == "VP8":
return vp8_depayload(payload)
elif codec.name == "H264":
return h264_depayload(payload)
else:
return payload
def get_capabilities(kind: str) -> RTCRtpCapabilities:
if kind not in CODECS:
raise ValueError(f"cannot get capabilities for unknown media {kind}")
codecs = []
rtx_added = False
for params in CODECS[kind]:
if not is_rtx(params):
codecs.append(
RTCRtpCodecCapability(
mimeType=params.mimeType,
clockRate=params.clockRate,
channels=params.channels,
parameters=params.parameters,
)
)
elif not rtx_added:
# There will only be a single entry in codecs[] for retransmission
# via RTX, with sdpFmtpLine not present.
codecs.append(
RTCRtpCodecCapability(
mimeType=params.mimeType, clockRate=params.clockRate
)
)
rtx_added = True
headerExtensions = []
for extension in HEADER_EXTENSIONS[kind]:
headerExtensions.append(RTCRtpHeaderExtensionCapability(uri=extension.uri))
return RTCRtpCapabilities(codecs=codecs, headerExtensions=headerExtensions)
def get_decoder(codec: RTCRtpCodecParameters) -> Decoder:
mimeType = codec.mimeType.lower()
if mimeType == "audio/opus":
return OpusDecoder()
elif mimeType == "audio/pcma":
return PcmaDecoder()
elif mimeType == "audio/pcmu":
return PcmuDecoder()
elif mimeType == "video/h264":
return H264Decoder()
elif mimeType == "video/vp8":
return Vp8Decoder()
else:
raise ValueError(f"No decoder found for MIME type `{mimeType}`")
def get_encoder(codec: RTCRtpCodecParameters) -> Encoder:
mimeType = codec.mimeType.lower()
if mimeType == "audio/opus":
return OpusEncoder()
elif mimeType == "audio/pcma":
return PcmaEncoder()
elif mimeType == "audio/pcmu":
return PcmuEncoder()
elif mimeType == "video/h264":
return H264Encoder()
elif mimeType == "video/vp8":
return Vp8Encoder()
else:
raise ValueError(f"No encoder found for MIME type `{mimeType}`")
def is_rtx(codec: Union[RTCRtpCodecCapability, RTCRtpCodecParameters]) -> bool:
return codec.name.lower() == "rtx"
init_codecs()
| 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/src/aiortc/codecs/base.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/aiortc/codecs/base.py | from abc import ABCMeta, abstractmethod
from typing import List, Tuple
from av.frame import Frame
from av.packet import Packet
from ..jitterbuffer import JitterFrame
class Decoder(metaclass=ABCMeta):
@abstractmethod
def decode(self, encoded_frame: JitterFrame) -> List[Frame]:
pass # pragma: no cover
class Encoder(metaclass=ABCMeta):
@abstractmethod
def encode(
self, frame: Frame, force_keyframe: bool = False
) -> Tuple[List[bytes], int]:
pass # pragma: no cover
@abstractmethod
def pack(self, packet: Packet) -> Tuple[List[bytes], int]:
pass # pragma: no cover
| 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/src/_cffi_src/build_vpx.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/_cffi_src/build_vpx.py | from cffi import FFI
ffibuilder = FFI()
ffibuilder.set_source(
"aiortc.codecs._vpx",
"""
#include <vpx/vpx_decoder.h>
#include <vpx/vpx_encoder.h>
#include <vpx/vp8cx.h>
#include <vpx/vp8dx.h>
#undef vpx_codec_dec_init
#undef vpx_codec_enc_init
vpx_codec_err_t vpx_codec_dec_init(vpx_codec_ctx_t *ctx,
vpx_codec_iface_t *iface,
const vpx_codec_dec_cfg_t *cfg,
vpx_codec_flags_t flags)
{
return vpx_codec_dec_init_ver(ctx, iface, cfg, flags, VPX_DECODER_ABI_VERSION);
}
vpx_codec_err_t vpx_codec_enc_init(vpx_codec_ctx_t *ctx,
vpx_codec_iface_t *iface,
const vpx_codec_enc_cfg_t *cfg,
vpx_codec_flags_t flags)
{
return vpx_codec_enc_init_ver(ctx, iface, cfg, flags, VPX_ENCODER_ABI_VERSION);
}
""",
libraries=["vpx"],
)
ffibuilder.cdef(
"""
#define VPX_CODEC_USE_OUTPUT_PARTITION 0x20000
#define VPX_DL_REALTIME 1
#define VPX_EFLAG_FORCE_KF 1
#define VPX_FRAME_IS_KEY 0x1
#define VPX_FRAME_IS_DROPPABLE 0x2
#define VPX_FRAME_IS_INVISIBLE 0x4
#define VPX_FRAME_IS_FRAGMENT 0x8
#define VPX_PLANE_PACKED 0
#define VPX_PLANE_Y 0
#define VPX_PLANE_U 1
#define VPX_PLANE_V 2
#define VPX_PLANE_ALPHA 3
#define VP8_SET_POSTPROC 3
#define VP8E_SET_CPUUSED 13
#define VP8E_SET_NOISE_SENSITIVITY 15
#define VP8E_SET_STATIC_THRESHOLD 17
#define VP8E_SET_TOKEN_PARTITIONS 18
typedef enum {
VPX_CODEC_OK,
VPX_CODEC_ERROR,
VPX_CODEC_MEM_ERROR,
VPX_CODEC_ABI_MISMATCH,
VPX_CODEC_INCAPABLE,
VPX_CODEC_UNSUP_BITSTREAM,
VPX_CODEC_UNSUP_FEATURE,
VPX_CODEC_CORRUPT_FRAME,
VPX_CODEC_INVALID_PARAM,
VPX_CODEC_LIST_END
} vpx_codec_err_t;
enum vpx_codec_cx_pkt_kind {
VPX_CODEC_CX_FRAME_PKT,
...
};
typedef enum vpx_img_fmt {
VPX_IMG_FMT_I420,
...
} vpx_img_fmt_t;
typedef long vpx_codec_flags_t;
typedef uint32_t vpx_codec_frame_flags_t;
typedef long vpx_enc_frame_flags_t;
typedef const void *vpx_codec_iter_t;
typedef int64_t vpx_codec_pts_t;
typedef const struct vpx_codec_iface vpx_codec_iface_t;
typedef struct vpx_rational {
int num;
int den;
} vpx_rational_t;
enum vpx_rc_mode {
VPX_VBR,
VPX_CBR,
VPX_CQ,
VPX_Q,
};
enum vpx_kf_mode {
VPX_KF_FIXED,
VPX_KF_AUTO,
VPX_KF_DISABLED = 0
};
typedef struct vpx_codec_dec_cfg {
unsigned int threads;
unsigned int w;
unsigned int h;
} vpx_codec_dec_cfg_t;
typedef struct vpx_codec_enc_cfg {
unsigned int g_usage;
unsigned int g_threads;
unsigned int g_profile;
unsigned int g_w;
unsigned int g_h;
struct vpx_rational g_timebase;
unsigned int g_lag_in_frames;
unsigned int rc_resize_allowed;
enum vpx_rc_mode rc_end_usage;
unsigned int rc_target_bitrate;
unsigned int rc_min_quantizer;
unsigned int rc_max_quantizer;
unsigned int rc_undershoot_pct;
unsigned int rc_overshoot_pct;
unsigned int rc_buf_sz;
unsigned int rc_buf_initial_sz;
unsigned int rc_buf_optimal_sz;
enum vpx_kf_mode kf_mode;
unsigned int kf_max_dist;
...;
} vpx_codec_enc_cfg_t;
typedef struct vpx_codec_ctx {
...;
} vpx_codec_ctx_t;
typedef struct vpx_fixed_buf {
void *buf;
size_t sz;
} vpx_fixed_buf_t;
typedef struct vpx_codec_cx_pkt {
enum vpx_codec_cx_pkt_kind kind;
union {
struct {
void *buf;
size_t sz;
vpx_codec_pts_t pts;
unsigned long duration;
vpx_codec_frame_flags_t flags;
int partition_id;
} frame;
vpx_fixed_buf_t twopass_stats;
vpx_fixed_buf_t firstpass_mb_stats;
struct vpx_psnr_pkt {
unsigned int samples[4];
uint64_t sse[4];
double psnr[4];
} psnr;
vpx_fixed_buf_t raw;
char pad[124];
} data;
...;
} vpx_codec_cx_pkt_t;
typedef struct vpx_image {
vpx_img_fmt_t fmt;
unsigned int w;
unsigned int h;
unsigned int d_w;
unsigned int d_h;
unsigned char *planes[4];
int stride[4];
...;
} vpx_image_t;
enum vp8_postproc_level {
VP8_NOFILTERING = 0,
VP8_DEBLOCK = 1,
VP8_DEMACROBLOCK = 2
};
typedef enum {
VP8_ONE_TOKENPARTITION = 0,
VP8_TWO_TOKENPARTITION = 1,
VP8_FOUR_TOKENPARTITION = 2,
VP8_EIGHT_TOKENPARTITION = 3
} vp8e_token_partitions;
typedef struct vp8_postproc_cfg {
int post_proc_flag;
int deblocking_level;
int noise_level;
} vp8_postproc_cfg_t;
extern vpx_codec_iface_t *vpx_codec_vp8_cx(void);
extern vpx_codec_iface_t *vpx_codec_vp8_dx(void);
extern vpx_codec_iface_t *vpx_codec_vp9_cx(void);
extern vpx_codec_iface_t *vpx_codec_vp9_dx(void);
vpx_codec_err_t vpx_codec_control_(vpx_codec_ctx_t *ctx, int ctrl_id, ...);
vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx);
vpx_codec_err_t vpx_codec_dec_init(vpx_codec_ctx_t *ctx,
vpx_codec_iface_t *iface,
const vpx_codec_dec_cfg_t *cfg,
vpx_codec_flags_t flags);
vpx_image_t *vpx_codec_get_frame(vpx_codec_ctx_t *ctx, vpx_codec_iter_t *iter);
vpx_codec_err_t vpx_codec_decode(vpx_codec_ctx_t *ctx, const uint8_t *data,
unsigned int data_sz, void *user_priv,
long deadline);
vpx_codec_err_t vpx_codec_enc_config_default(vpx_codec_iface_t *iface,
vpx_codec_enc_cfg_t *cfg,
unsigned int reserved);
vpx_codec_err_t vpx_codec_enc_config_set(vpx_codec_ctx_t *ctx,
const vpx_codec_enc_cfg_t *cfg);
vpx_codec_err_t vpx_codec_enc_init(vpx_codec_ctx_t *ctx,
vpx_codec_iface_t *iface,
const vpx_codec_enc_cfg_t *cfg,
vpx_codec_flags_t flags);
vpx_codec_err_t vpx_codec_encode(vpx_codec_ctx_t *ctx, const vpx_image_t *img,
vpx_codec_pts_t pts, unsigned long duration,
vpx_enc_frame_flags_t flags,
unsigned long deadline);
const char *vpx_codec_err_to_string (vpx_codec_err_t err);
const vpx_codec_cx_pkt_t *vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx,
vpx_codec_iter_t *iter);
vpx_image_t *vpx_img_alloc(vpx_image_t *img, vpx_img_fmt_t fmt,
unsigned int d_w, unsigned int d_h,
unsigned int align);
void vpx_img_free(vpx_image_t *img);
vpx_image_t *vpx_img_wrap(vpx_image_t *img, vpx_img_fmt_t fmt, unsigned int d_w,
unsigned int d_h, unsigned int align,
unsigned char *img_data);
"""
)
if __name__ == "__main__":
ffibuilder.compile(verbose=True)
| 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/src/_cffi_src/build_opus.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/src/_cffi_src/build_opus.py | from cffi import FFI
ffibuilder = FFI()
ffibuilder.set_source(
"aiortc.codecs._opus",
"""
#include <opus/opus.h>
""",
libraries=["opus"],
)
ffibuilder.cdef(
"""
#define OPUS_APPLICATION_VOIP 2048
#define OPUS_OK 0
typedef struct OpusDecoder OpusDecoder;
typedef struct OpusEncoder OpusEncoder;
typedef int16_t opus_int16;
typedef int32_t opus_int32;
OpusDecoder *opus_decoder_create(
opus_int32 Fs,
int channels,
int *error
);
int opus_decode(
OpusDecoder *st,
const unsigned char *data,
opus_int32 len,
opus_int16 *pcm,
int frame_size,
int decode_fec
);
void opus_decoder_destroy(OpusDecoder *st);
OpusEncoder *opus_encoder_create(
opus_int32 Fs,
int channels,
int application,
int *error
);
opus_int32 opus_encode(
OpusEncoder *st,
const opus_int16 *pcm,
int frame_size,
unsigned char *data,
opus_int32 max_data_bytes
);
void opus_encoder_destroy(OpusEncoder *st);
"""
)
if __name__ == "__main__":
ffibuilder.compile(verbose=True)
| 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_rate.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rate.py | from unittest import TestCase
from numpy import random
from aiortc.rate import (
AimdRateControl,
BandwidthUsage,
InterArrival,
OveruseDetector,
OveruseEstimator,
RateBucket,
RateControlState,
RateCounter,
RemoteBitrateEstimator,
)
TIMESTAMP_GROUP_LENGTH_US = 5000
MIN_STEP_US = 20
TRIGGER_NEW_GROUP_US = TIMESTAMP_GROUP_LENGTH_US + MIN_STEP_US
BURST_THRESHOLD_MS = 5
START_RTP_TIMESTAMP_WRAP_US = 47721858827
START_ABS_SEND_TIME_WRAP_US = 63999995
def abs_send_time(us):
absolute_send_time = (((us << 18) + 500000) // 1000000) & 0xFFFFFF
return absolute_send_time << 8
def rtp_timestamp(us):
return ((us * 90 + 500) // 1000) & 0xFFFFFFFF
class AimdRateControlTest(TestCase):
def setUp(self):
self.rate_control = AimdRateControl()
def test_update_normal(self):
bitrate = 300000
now_ms = 0
self.rate_control.set_estimate(bitrate, now_ms)
estimate = self.rate_control.update(BandwidthUsage.NORMAL, bitrate, now_ms)
self.assertEqual(estimate, 301000)
self.assertEqual(self.rate_control.state, RateControlState.INCREASE)
self.assertEqual(self.rate_control.avg_max_bitrate_kbps, None)
self.assertEqual(self.rate_control.var_max_bitrate_kbps, 0.4)
def test_update_normal_no_estimated_throughput(self):
bitrate = 300000
now_ms = 0
self.rate_control.set_estimate(bitrate, now_ms)
estimate = self.rate_control.update(BandwidthUsage.NORMAL, None, now_ms)
self.assertEqual(estimate, 301000)
def test_update_overuse(self):
bitrate = 300000
now_ms = 0
self.rate_control.set_estimate(bitrate, now_ms)
estimate = self.rate_control.update(BandwidthUsage.OVERUSING, bitrate, now_ms)
self.assertEqual(estimate, 255000)
self.assertEqual(self.rate_control.state, RateControlState.HOLD)
self.assertEqual(self.rate_control.avg_max_bitrate_kbps, 300.0)
self.assertEqual(self.rate_control.var_max_bitrate_kbps, 0.4)
def test_update_underuse(self):
bitrate = 300000
now_ms = 0
self.rate_control.set_estimate(bitrate, now_ms)
estimate = self.rate_control.update(BandwidthUsage.UNDERUSING, bitrate, now_ms)
self.assertEqual(estimate, 300000)
self.assertEqual(self.rate_control.state, RateControlState.HOLD)
self.assertEqual(self.rate_control.avg_max_bitrate_kbps, None)
self.assertEqual(self.rate_control.var_max_bitrate_kbps, 0.4)
def test_additive_rate_increase(self):
acked_bitrate = 100000
self.rate_control.set_estimate(acked_bitrate, 0)
for now_ms in range(0, 20000, 100):
estimate = self.rate_control.update(
BandwidthUsage.NORMAL, acked_bitrate, now_ms
)
self.assertEqual(estimate, 160000)
self.assertEqual(self.rate_control.near_max, False)
# overuse -> hold
estimate = self.rate_control.update(
BandwidthUsage.OVERUSING, acked_bitrate, now_ms
)
self.assertEqual(estimate, 85000)
self.assertEqual(self.rate_control.near_max, True)
now_ms += 1000
# back to normal -> hold
estimate = self.rate_control.update(
BandwidthUsage.NORMAL, acked_bitrate, now_ms
)
self.assertEqual(estimate, 85000)
self.assertEqual(self.rate_control.near_max, True)
now_ms += 1000
# still normal -> additive increase
estimate = self.rate_control.update(
BandwidthUsage.NORMAL, acked_bitrate, now_ms
)
self.assertEqual(estimate, 94444)
self.assertEqual(self.rate_control.near_max, True)
now_ms += 1000
# overuse -> hold
estimate = self.rate_control.update(
BandwidthUsage.OVERUSING, acked_bitrate, now_ms
)
self.assertEqual(estimate, 85000)
self.assertEqual(self.rate_control.near_max, True)
now_ms += 1000
def test_clear_max_throughput(self):
normal_bitrate = 100000
high_bitrate = 150000
now_ms = 0
self.rate_control.set_estimate(normal_bitrate, now_ms)
self.rate_control.update(BandwidthUsage.NORMAL, normal_bitrate, now_ms)
now_ms += 1000
# overuse
self.rate_control.update(BandwidthUsage.OVERUSING, normal_bitrate, now_ms)
self.assertEqual(self.rate_control.avg_max_bitrate_kbps, 100.0)
now_ms += 1000
# stable
self.rate_control.update(BandwidthUsage.NORMAL, normal_bitrate, now_ms)
self.assertEqual(self.rate_control.avg_max_bitrate_kbps, 100.0)
now_ms += 1000
# large increase in throughput
self.rate_control.update(BandwidthUsage.NORMAL, high_bitrate, now_ms)
self.assertEqual(self.rate_control.avg_max_bitrate_kbps, None)
now_ms += 1000
# overuse
self.rate_control.update(BandwidthUsage.OVERUSING, high_bitrate, now_ms)
self.assertEqual(self.rate_control.avg_max_bitrate_kbps, 150.0)
now_ms += 1000
# overuse and large decrease in throughput
self.rate_control.update(BandwidthUsage.OVERUSING, normal_bitrate, now_ms)
self.assertEqual(self.rate_control.avg_max_bitrate_kbps, 100.0)
now_ms += 1000
def test_bwe_limited_by_acked_bitrate(self):
acked_bitrate = 10000
self.rate_control.set_estimate(acked_bitrate, 0)
for now_ms in range(0, 20000, 100):
estimate = self.rate_control.update(
BandwidthUsage.NORMAL, acked_bitrate, now_ms
)
self.assertEqual(estimate, 25000)
def test_bwe_not_limited_by_decreasing_acked_bitrate(self):
acked_bitrate = 100000
self.rate_control.set_estimate(acked_bitrate, 0)
for now_ms in range(0, 20000, 100):
estimate = self.rate_control.update(
BandwidthUsage.NORMAL, acked_bitrate, now_ms
)
self.assertEqual(estimate, 160000)
# estimate doesn't change
estimate = self.rate_control.update(
BandwidthUsage.NORMAL, acked_bitrate // 2, now_ms
)
self.assertEqual(estimate, 160000)
class InterArrivalTest(TestCase):
def setUp(self):
self.inter_arrival_ast = InterArrival(
abs_send_time(TIMESTAMP_GROUP_LENGTH_US), 1000 / (1 << 26)
)
self.inter_arrival_rtp = InterArrival(
rtp_timestamp(TIMESTAMP_GROUP_LENGTH_US), 1 / 9
)
def assertComputed(
self,
timestamp_us,
arrival_time_ms,
packet_size,
timestamp_delta_us,
arrival_time_delta_ms,
packet_size_delta,
timestamp_near=0,
):
# AbsSendTime
deltas = self.inter_arrival_ast.compute_deltas(
abs_send_time(timestamp_us), arrival_time_ms, packet_size
)
self.assertIsNotNone(deltas)
self.assertAlmostEqual(
deltas.timestamp,
abs_send_time(timestamp_delta_us),
delta=timestamp_near << 8,
)
self.assertEqual(deltas.arrival_time, arrival_time_delta_ms)
self.assertEqual(deltas.size, packet_size_delta)
# RtpTimestamp
deltas = self.inter_arrival_rtp.compute_deltas(
rtp_timestamp(timestamp_us), arrival_time_ms, packet_size
)
self.assertIsNotNone(deltas)
self.assertAlmostEqual(
deltas.timestamp, rtp_timestamp(timestamp_delta_us), delta=timestamp_near
)
self.assertEqual(deltas.arrival_time, arrival_time_delta_ms)
self.assertEqual(deltas.size, packet_size_delta)
def assertNotComputed(self, timestamp_us, arrival_time_ms, packet_size):
self.assertIsNone(
self.inter_arrival_ast.compute_deltas(
abs_send_time(timestamp_us), arrival_time_ms, packet_size
)
)
self.assertIsNone(
self.inter_arrival_rtp.compute_deltas(
rtp_timestamp(timestamp_us), arrival_time_ms, packet_size
)
)
def wrapTest(self, wrap_start_us, unorderly_within_group):
timestamp_near = 1
# G1
arrival_time = 17
self.assertNotComputed(0, arrival_time, 1)
# G2
arrival_time += BURST_THRESHOLD_MS + 1
self.assertNotComputed(wrap_start_us // 4, arrival_time, 1)
# G3
arrival_time += BURST_THRESHOLD_MS + 1
self.assertComputed(
wrap_start_us // 2, arrival_time, 1, wrap_start_us // 4, 6, 0
)
# G4
arrival_time += BURST_THRESHOLD_MS + 1
self.assertComputed(
wrap_start_us // 2 + wrap_start_us // 4,
arrival_time,
1,
wrap_start_us // 4,
6,
0,
timestamp_near,
)
g4_arrival_time = arrival_time
# G5
arrival_time += BURST_THRESHOLD_MS + 1
self.assertComputed(
wrap_start_us, arrival_time, 2, wrap_start_us // 4, 6, 0, timestamp_near
)
for i in range(10):
arrival_time += BURST_THRESHOLD_MS + 1
if unorderly_within_group:
self.assertNotComputed(
wrap_start_us + (9 - i) * MIN_STEP_US, arrival_time, 1
)
else:
self.assertNotComputed(wrap_start_us + i * MIN_STEP_US, arrival_time, 1)
g5_arrival_time = arrival_time
# out of order
arrival_time += BURST_THRESHOLD_MS + 1
self.assertNotComputed(wrap_start_us - 100, arrival_time, 100)
# G6
arrival_time += BURST_THRESHOLD_MS + 1
self.assertComputed(
wrap_start_us + TRIGGER_NEW_GROUP_US,
arrival_time,
10,
wrap_start_us // 4 + 9 * MIN_STEP_US,
g5_arrival_time - g4_arrival_time,
11,
timestamp_near,
)
g6_arrival_time = arrival_time
# out of order
arrival_time += BURST_THRESHOLD_MS + 1
self.assertNotComputed(
wrap_start_us + TIMESTAMP_GROUP_LENGTH_US, arrival_time, 100
)
# G7
arrival_time += BURST_THRESHOLD_MS + 1
self.assertComputed(
wrap_start_us + 2 * TRIGGER_NEW_GROUP_US,
arrival_time,
10,
TRIGGER_NEW_GROUP_US - 9 * MIN_STEP_US,
g6_arrival_time - g5_arrival_time,
-2,
timestamp_near,
)
def test_first_packet(self):
self.assertNotComputed(0, 17, 1)
def test_first_group(self):
# G1
timestamp = 0
arrival_time = 17
self.assertNotComputed(timestamp, arrival_time, 1)
g1_arrival_time = arrival_time
# G2
timestamp += TRIGGER_NEW_GROUP_US
arrival_time += BURST_THRESHOLD_MS + 1
self.assertNotComputed(timestamp, arrival_time, 2)
g2_arrival_time = arrival_time
# G3
timestamp += TRIGGER_NEW_GROUP_US
arrival_time += BURST_THRESHOLD_MS + 1
self.assertComputed(
timestamp,
arrival_time,
1,
TRIGGER_NEW_GROUP_US,
g2_arrival_time - g1_arrival_time,
1,
)
def test_second_group(self):
# G1
timestamp = 0
arrival_time = 17
self.assertNotComputed(timestamp, arrival_time, 1)
g1_arrival_time = arrival_time
# G2
timestamp += TRIGGER_NEW_GROUP_US
arrival_time += BURST_THRESHOLD_MS + 1
self.assertNotComputed(timestamp, arrival_time, 2)
g2_arrival_time = arrival_time
# G3
timestamp += TRIGGER_NEW_GROUP_US
arrival_time += BURST_THRESHOLD_MS + 1
self.assertComputed(
timestamp,
arrival_time,
1,
TRIGGER_NEW_GROUP_US,
g2_arrival_time - g1_arrival_time,
1,
)
g3_arrival_time = arrival_time
# G4
timestamp += TRIGGER_NEW_GROUP_US
arrival_time += BURST_THRESHOLD_MS + 1
self.assertComputed(
timestamp,
arrival_time,
2,
TRIGGER_NEW_GROUP_US,
g3_arrival_time - g2_arrival_time,
-1,
)
def test_accumulated_group(self):
# G1
timestamp = 0
arrival_time = 17
self.assertNotComputed(timestamp, arrival_time, 1)
g1_timestamp = timestamp
g1_arrival_time = arrival_time
# G2
timestamp += TRIGGER_NEW_GROUP_US
arrival_time += BURST_THRESHOLD_MS + 1
self.assertNotComputed(timestamp, 28, 2)
for i in range(10):
timestamp += MIN_STEP_US
arrival_time += BURST_THRESHOLD_MS + 1
self.assertNotComputed(timestamp, arrival_time, 1)
g2_timestamp = timestamp
g2_arrival_time = arrival_time
# G3
timestamp = 2 * TRIGGER_NEW_GROUP_US
arrival_time = 500
self.assertComputed(
timestamp,
arrival_time,
100,
g2_timestamp - g1_timestamp,
g2_arrival_time - g1_arrival_time,
11,
)
def test_out_of_order_packet(self):
# G1
timestamp = 0
arrival_time = 17
self.assertNotComputed(timestamp, arrival_time, 1)
g1_timestamp = timestamp
g1_arrival_time = arrival_time
# G2
timestamp += TRIGGER_NEW_GROUP_US
arrival_time += 11
self.assertNotComputed(timestamp, 28, 2)
for i in range(10):
timestamp += MIN_STEP_US
arrival_time += BURST_THRESHOLD_MS + 1
self.assertNotComputed(timestamp, arrival_time, 1)
g2_timestamp = timestamp
g2_arrival_time = arrival_time
# out of order packet
arrival_time = 281
self.assertNotComputed(g1_timestamp, arrival_time, 1)
# G3
timestamp = 2 * TRIGGER_NEW_GROUP_US
arrival_time = 500
self.assertComputed(
timestamp,
arrival_time,
100,
g2_timestamp - g1_timestamp,
g2_arrival_time - g1_arrival_time,
11,
)
def test_out_of_order_within_group(self):
# G1
timestamp = 0
arrival_time = 17
self.assertNotComputed(timestamp, arrival_time, 1)
g1_timestamp = timestamp
g1_arrival_time = arrival_time
# G2
timestamp += TRIGGER_NEW_GROUP_US
arrival_time += 11
self.assertNotComputed(timestamp, 28, 2)
timestamp += 10 * MIN_STEP_US
g2_timestamp = timestamp
for i in range(10):
arrival_time += BURST_THRESHOLD_MS + 1
self.assertNotComputed(timestamp, arrival_time, 1)
timestamp -= MIN_STEP_US
g2_arrival_time = arrival_time
# out of order packet
arrival_time = 281
self.assertNotComputed(g1_timestamp, arrival_time, 1)
# G3
timestamp = 2 * TRIGGER_NEW_GROUP_US
arrival_time = 500
self.assertComputed(
timestamp,
arrival_time,
100,
g2_timestamp - g1_timestamp,
g2_arrival_time - g1_arrival_time,
11,
)
def test_two_bursts(self):
# G1
timestamp = 0
arrival_time = 17
self.assertNotComputed(timestamp, arrival_time, 1)
g1_timestamp = timestamp
g1_arrival_time = arrival_time
# G2
timestamp += TRIGGER_NEW_GROUP_US
arrival_time = 100
for i in range(10):
timestamp += 30000
arrival_time += BURST_THRESHOLD_MS
self.assertNotComputed(timestamp, arrival_time, 1)
g2_timestamp = timestamp
g2_arrival_time = arrival_time
# G3
timestamp += 30000
arrival_time += BURST_THRESHOLD_MS + 1
self.assertComputed(
timestamp,
arrival_time,
100,
g2_timestamp - g1_timestamp,
g2_arrival_time - g1_arrival_time,
9,
)
def test_no_bursts(self):
# G1
timestamp = 0
arrival_time = 17
self.assertNotComputed(timestamp, arrival_time, 1)
g1_timestamp = timestamp
g1_arrival_time = arrival_time
# G2
timestamp += TRIGGER_NEW_GROUP_US
arrival_time = 28
self.assertNotComputed(timestamp, arrival_time, 2)
g2_timestamp = timestamp
g2_arrival_time = arrival_time
# G3
timestamp += 30000
arrival_time += BURST_THRESHOLD_MS + 1
self.assertComputed(
timestamp,
arrival_time,
100,
g2_timestamp - g1_timestamp,
g2_arrival_time - g1_arrival_time,
1,
)
def test_wrap_abs_send_time(self):
self.wrapTest(START_ABS_SEND_TIME_WRAP_US, False)
def test_wrap_abs_send_time_out_of_order_within_group(self):
self.wrapTest(START_ABS_SEND_TIME_WRAP_US, True)
def test_wrap_rtp_timestamp(self):
self.wrapTest(START_RTP_TIMESTAMP_WRAP_US, False)
def test_wrap_rtp_timestamp_out_of_order_within_group(self):
self.wrapTest(START_RTP_TIMESTAMP_WRAP_US, True)
class OveruseDetectorTest(TestCase):
def setUp(self):
self.timestamp_to_ms = 1 / 90
self.detector = OveruseDetector()
self.estimator = OveruseEstimator()
self.inter_arrival = InterArrival(5 * 90, 1 / 9)
self.packet_size = 1200
self.now_ms = 0
self.receive_time_ms = 0
self.rtp_timestamp = 900
random.seed(21)
def test_simple_non_overuse_30fps(self):
frame_duration_ms = 33
for i in range(1000):
self.update_detector(self.rtp_timestamp, self.now_ms)
self.now_ms += frame_duration_ms
self.rtp_timestamp += frame_duration_ms * 90
self.assertEqual(self.detector.state(), BandwidthUsage.NORMAL)
def test_simple_non_overuse_with_receive_variance(self):
frame_duration_ms = 10
for i in range(1000):
self.update_detector(self.rtp_timestamp, self.now_ms)
self.rtp_timestamp += frame_duration_ms * 90
if i % 2:
self.now_ms += frame_duration_ms - 5
else:
self.now_ms += frame_duration_ms + 5
self.assertEqual(self.detector.state(), BandwidthUsage.NORMAL)
def test_simple_non_overuse_with_rtp_timestamp_variance(self):
frame_duration_ms = 10
for i in range(1000):
self.update_detector(self.rtp_timestamp, self.now_ms)
self.now_ms += frame_duration_ms
if i % 2:
self.rtp_timestamp += (frame_duration_ms - 5) * 90
else:
self.rtp_timestamp += (frame_duration_ms + 5) * 90
self.assertEqual(self.detector.state(), BandwidthUsage.NORMAL)
def test_simple_overuse_2000Kbit_30fps(self):
packets_per_frame = 6
frame_duration_ms = 33
drift_per_frame_ms = 1
sigma_ms = 0
unique_overuse = self.run_100000_samples(
packets_per_frame, frame_duration_ms, sigma_ms
)
self.assertEqual(unique_overuse, 0)
frames_until_overuse = self.run_until_overuse(
packets_per_frame, frame_duration_ms, sigma_ms, drift_per_frame_ms
)
self.assertEqual(frames_until_overuse, 7)
def test_simple_overuse_100Kbit_10fps(self):
packets_per_frame = 1
frame_duration_ms = 100
drift_per_frame_ms = 1
sigma_ms = 0
unique_overuse = self.run_100000_samples(
packets_per_frame, frame_duration_ms, sigma_ms
)
self.assertEqual(unique_overuse, 0)
frames_until_overuse = self.run_until_overuse(
packets_per_frame, frame_duration_ms, sigma_ms, drift_per_frame_ms
)
self.assertEqual(frames_until_overuse, 7)
def test_overuse_with_low_variance_2000Kbit_30fps(self):
frame_duration_ms = 33
drift_per_frame_ms = 1
self.rtp_timestamp = frame_duration_ms * 90
offset = 0
# run 1000 samples to reach steady state
for i in range(1000):
for j in range(6):
self.update_detector(self.rtp_timestamp, self.now_ms)
self.rtp_timestamp += frame_duration_ms * 90
if i % 2:
offset = random.randint(0, 1)
self.now_ms += frame_duration_ms - offset
else:
self.now_ms += frame_duration_ms + offset
self.assertEqual(self.detector.state(), BandwidthUsage.NORMAL)
# simulate a higher send pace, that is too high.
for i in range(3):
for j in range(6):
self.update_detector(self.rtp_timestamp, self.now_ms)
self.now_ms += frame_duration_ms + drift_per_frame_ms * 6
self.rtp_timestamp += frame_duration_ms * 90
self.assertEqual(self.detector.state(), BandwidthUsage.NORMAL)
self.update_detector(self.rtp_timestamp, self.now_ms)
self.assertEqual(self.detector.state(), BandwidthUsage.OVERUSING)
def test_low_gaussian_variance_fast_drift_30Kbit_3fps(self):
packets_per_frame = 1
frame_duration_ms = 333
drift_per_frame_ms = 100
sigma_ms = 3
unique_overuse = self.run_100000_samples(
packets_per_frame, frame_duration_ms, sigma_ms
)
self.assertEqual(unique_overuse, 0)
frames_until_overuse = self.run_until_overuse(
packets_per_frame, frame_duration_ms, sigma_ms, drift_per_frame_ms
)
self.assertEqual(frames_until_overuse, 4)
def test_high_haussian_variance_30Kbit_3fps(self):
packets_per_frame = 1
frame_duration_ms = 333
drift_per_frame_ms = 1
sigma_ms = 10
unique_overuse = self.run_100000_samples(
packets_per_frame, frame_duration_ms, sigma_ms
)
self.assertEqual(unique_overuse, 0)
frames_until_overuse = self.run_until_overuse(
packets_per_frame, frame_duration_ms, sigma_ms, drift_per_frame_ms
)
self.assertEqual(frames_until_overuse, 44)
def run_100000_samples(self, packets_per_frame, mean_ms, standard_deviation_ms):
unique_overuse = 0
last_overuse = -1
for i in range(100000):
for j in range(packets_per_frame):
self.update_detector(self.rtp_timestamp, self.receive_time_ms)
self.rtp_timestamp += mean_ms * 90
self.now_ms += mean_ms
self.receive_time_ms = max(
self.receive_time_ms,
int(self.now_ms + random.normal(0, standard_deviation_ms) + 0.5),
)
if self.detector.state() == BandwidthUsage.OVERUSING:
if last_overuse + 1 != i:
unique_overuse += 1
last_overuse = i
return unique_overuse
def run_until_overuse(
self, packets_per_frame, mean_ms, standard_deviation_ms, drift_per_frame_ms
):
for i in range(100000):
for j in range(packets_per_frame):
self.update_detector(self.rtp_timestamp, self.receive_time_ms)
self.rtp_timestamp += mean_ms * 90
self.now_ms += mean_ms + drift_per_frame_ms
self.receive_time_ms = max(
self.receive_time_ms,
int(self.now_ms + random.normal(0, standard_deviation_ms) + 0.5),
)
if self.detector.state() == BandwidthUsage.OVERUSING:
return i + 1
return -1
def update_detector(self, timestamp, receive_time_ms):
deltas = self.inter_arrival.compute_deltas(
timestamp, receive_time_ms, self.packet_size
)
if deltas is not None:
timestamp_delta_ms = deltas.timestamp / 90
self.estimator.update(
deltas.arrival_time,
timestamp_delta_ms,
deltas.size,
self.detector.state(),
receive_time_ms,
)
self.detector.detect(
self.estimator.offset(),
timestamp_delta_ms,
self.estimator.num_of_deltas(),
receive_time_ms,
)
class RateCounterTest(TestCase):
def test_constructor(self):
counter = RateCounter(10)
self.assertEqual(
counter._buckets,
[
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
],
)
self.assertIsNone(counter._origin_ms)
self.assertEqual(counter._origin_index, 0)
self.assertEqual(counter._total, RateBucket())
self.assertIsNone(counter.rate(0))
def test_add(self):
counter = RateCounter(10)
counter.add(500, 123)
self.assertEqual(
counter._buckets,
[
RateBucket(1, 500),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
],
)
self.assertEqual(counter._origin_index, 0)
self.assertEqual(counter._origin_ms, 123)
self.assertEqual(counter._total, RateBucket(1, 500))
self.assertIsNone(counter.rate(123))
counter.add(501, 123)
self.assertEqual(
counter._buckets,
[
RateBucket(2, 1001),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
],
)
self.assertEqual(counter._origin_index, 0)
self.assertEqual(counter._origin_ms, 123)
self.assertEqual(counter._total, RateBucket(2, 1001))
self.assertIsNone(counter.rate(123))
counter.add(502, 125)
self.assertEqual(
counter._buckets,
[
RateBucket(2, 1001),
RateBucket(),
RateBucket(1, 502),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
],
)
self.assertEqual(counter._origin_index, 0)
self.assertEqual(counter._origin_ms, 123)
self.assertEqual(counter._total, RateBucket(3, 1503))
self.assertEqual(counter.rate(125), 4008000)
counter.add(503, 128)
self.assertEqual(
counter._buckets,
[
RateBucket(2, 1001),
RateBucket(),
RateBucket(1, 502),
RateBucket(),
RateBucket(),
RateBucket(1, 503),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(),
],
)
self.assertEqual(counter._origin_index, 0)
self.assertEqual(counter._origin_ms, 123)
self.assertEqual(counter._total, RateBucket(4, 2006))
self.assertEqual(counter.rate(128), 2674667)
counter.add(504, 132)
self.assertEqual(
counter._buckets,
[
RateBucket(2, 1001),
RateBucket(),
RateBucket(1, 502),
RateBucket(),
RateBucket(),
RateBucket(1, 503),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(1, 504),
],
)
self.assertEqual(counter._origin_index, 0)
self.assertEqual(counter._origin_ms, 123)
self.assertEqual(counter._total, RateBucket(5, 2510))
self.assertEqual(counter.rate(132), 2008000)
counter.add(505, 134)
self.assertEqual(
counter._buckets,
[
RateBucket(),
RateBucket(1, 505),
RateBucket(1, 502),
RateBucket(),
RateBucket(),
RateBucket(1, 503),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(1, 504),
],
)
self.assertEqual(counter._origin_index, 2)
self.assertEqual(counter._origin_ms, 125)
self.assertEqual(counter._total, RateBucket(4, 2014))
self.assertEqual(counter.rate(134), 1611200)
counter.add(506, 135)
self.assertEqual(
counter._buckets,
[
RateBucket(),
RateBucket(1, 505),
RateBucket(1, 506),
RateBucket(),
RateBucket(),
RateBucket(1, 503),
RateBucket(),
RateBucket(),
RateBucket(),
RateBucket(1, 504),
],
)
self.assertEqual(counter._origin_index, 3)
self.assertEqual(counter._origin_ms, 126)
self.assertEqual(counter._total, RateBucket(4, 2018))
self.assertEqual(counter.rate(135), 1614400)
class Stream:
def __init__(self, capacity):
self.capacity = capacity
self.framerate = 30
self.payload_size = 1500
self.send_time_us = 0
self.arrival_time_us = 0
def generate_frames(self, count):
for i in range(count):
abs_send_time = self.send_time_us * (1 << 18) // 1000000
self.arrival_time_us = max(self.arrival_time_us, self.send_time_us) + round(
(self.payload_size * 8000000) / self.capacity
)
self.send_time_us += 1000000 // self.framerate
yield abs_send_time, self.arrival_time_us // 1000, self.payload_size
class RemoteBitrateEstimatorTest(TestCase):
def test_capacity_drop(self):
estimator = RemoteBitrateEstimator()
stream = Stream(capacity=500000)
target_bitrate = None
for abs_send_time, arrival_time_ms, payload_size in stream.generate_frames(
1000
):
res = estimator.add(
abs_send_time=abs_send_time,
arrival_time_ms=arrival_time_ms,
payload_size=payload_size,
ssrc=1234,
)
if res is not None:
target_bitrate = res[0]
self.assertEqual(target_bitrate, 550000)
# reduce capacity
stream.capacity = 250000
for abs_send_time, arrival_time_ms, payload_size in stream.generate_frames(
1000
):
res = estimator.add(
abs_send_time=abs_send_time,
arrival_time_ms=arrival_time_ms,
payload_size=payload_size,
ssrc=1234,
)
if res is not None:
target_bitrate = res[0]
self.assertEqual(target_bitrate, 214200)
| 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_opus.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_opus.py | import fractions
from aiortc.codecs import get_decoder, get_encoder
from aiortc.codecs.opus import OpusDecoder, OpusEncoder
from aiortc.jitterbuffer import JitterFrame
from aiortc.rtcrtpparameters import RTCRtpCodecParameters
from .codecs import CodecTestCase
OPUS_CODEC = RTCRtpCodecParameters(
mimeType="audio/opus", clockRate=48000, channels=2, payloadType=100
)
OPUS_PAYLOAD = b"\xfc\xff\xfe"
class OpusTest(CodecTestCase):
def test_decoder(self):
decoder = get_decoder(OPUS_CODEC)
self.assertIsInstance(decoder, OpusDecoder)
frames = decoder.decode(JitterFrame(data=OPUS_PAYLOAD, timestamp=0))
self.assertEqual(len(frames), 1)
frame = frames[0]
self.assertEqual(frame.format.name, "s16")
self.assertEqual(frame.layout.name, "stereo")
self.assertEqual(bytes(frame.planes[0]), b"\x00" * 4 * 960)
self.assertEqual(frame.sample_rate, 48000)
self.assertEqual(frame.pts, 0)
self.assertEqual(frame.time_base, fractions.Fraction(1, 48000))
def test_encoder_mono_8khz(self):
encoder = get_encoder(OPUS_CODEC)
self.assertIsInstance(encoder, OpusEncoder)
frames = self.create_audio_frames(layout="mono", sample_rate=8000, count=2)
# first frame
payloads, timestamp = encoder.encode(frames[0])
self.assertEqual(payloads, [OPUS_PAYLOAD])
self.assertEqual(timestamp, 0)
# second frame
payloads, timestamp = encoder.encode(frames[1])
self.assertEqual(timestamp, 960)
def test_encoder_stereo_8khz(self):
encoder = get_encoder(OPUS_CODEC)
self.assertIsInstance(encoder, OpusEncoder)
frames = self.create_audio_frames(layout="stereo", sample_rate=8000, count=2)
# first frame
payloads, timestamp = encoder.encode(frames[0])
self.assertEqual(payloads, [OPUS_PAYLOAD])
self.assertEqual(timestamp, 0)
# second frame
payloads, timestamp = encoder.encode(frames[1])
self.assertEqual(timestamp, 960)
def test_encoder_stereo_48khz(self):
encoder = get_encoder(OPUS_CODEC)
self.assertIsInstance(encoder, OpusEncoder)
frames = self.create_audio_frames(layout="stereo", sample_rate=48000, count=2)
# first frame
payloads, timestamp = encoder.encode(frames[0])
self.assertEqual(payloads, [OPUS_PAYLOAD])
self.assertEqual(timestamp, 0)
# second frame
payloads, timestamp = encoder.encode(frames[1])
self.assertEqual(timestamp, 960)
def test_encoder_pack(self):
encoder = get_encoder(OPUS_CODEC)
self.assertTrue(isinstance(encoder, OpusEncoder))
packet = self.create_packet(payload=OPUS_PAYLOAD, pts=1)
payloads, timestamp = encoder.pack(packet)
self.assertEqual(payloads, [OPUS_PAYLOAD])
self.assertEqual(timestamp, 48)
def test_roundtrip(self):
self.roundtrip_audio(
OPUS_CODEC, output_layout="stereo", output_sample_rate=48000
)
def test_roundtrip_with_loss(self):
self.roundtrip_audio(
OPUS_CODEC, output_layout="stereo", output_sample_rate=48000, drop=[1]
)
| 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_rtcpeerconnection.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtcpeerconnection.py | import asyncio
import re
from unittest import TestCase
import aioice.ice
import aioice.stun
from aiortc import (
RTCConfiguration,
RTCIceCandidate,
RTCPeerConnection,
RTCSessionDescription,
)
from aiortc.contrib.media import MediaPlayer
from aiortc.exceptions import (
InternalError,
InvalidAccessError,
InvalidStateError,
OperationError,
)
from aiortc.mediastreams import AudioStreamTrack, VideoStreamTrack
from aiortc.rtcpeerconnection import (
filter_preferred_codecs,
find_common_codecs,
is_codec_compatible,
)
from aiortc.rtcrtpparameters import (
RTCRtcpFeedback,
RTCRtpCodecCapability,
RTCRtpCodecParameters,
)
from aiortc.rtcrtpsender import RTCRtpSender
from aiortc.sdp import SessionDescription
from aiortc.stats import RTCStatsReport
from .test_contrib_media import MediaTestCase
from .utils import asynctest, lf2crlf
LONG_DATA = b"\xff" * 2000
STRIP_CANDIDATES_RE = re.compile("^a=(candidate:.*|end-of-candidates)\r\n", re.M)
H264_SDP = lf2crlf(
"""a=rtpmap:99 H264/90000
a=rtcp-fb:99 nack
a=rtcp-fb:99 nack pli
a=rtcp-fb:99 goog-remb
a=fmtp:99 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f
a=rtpmap:100 rtx/90000
a=fmtp:100 apt=99
a=rtpmap:101 H264/90000
a=rtcp-fb:101 nack
a=rtcp-fb:101 nack pli
a=rtcp-fb:101 goog-remb
a=fmtp:101 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f
a=rtpmap:102 rtx/90000
a=fmtp:102 apt=101
"""
)
VP8_SDP = lf2crlf(
"""a=rtpmap:97 VP8/90000
a=rtcp-fb:97 nack
a=rtcp-fb:97 nack pli
a=rtcp-fb:97 goog-remb
a=rtpmap:98 rtx/90000
a=fmtp:98 apt=97
"""
)
class BogusStreamTrack(AudioStreamTrack):
kind = "bogus"
def mids(pc):
mids = [x.mid for x in pc.getTransceivers()]
if pc.sctp:
mids.append(pc.sctp.mid)
return sorted(mids)
def strip_ice_candidates(description):
return RTCSessionDescription(
sdp=STRIP_CANDIDATES_RE.sub("", description.sdp), type=description.type
)
def track_states(pc):
states = {
"connectionState": [pc.connectionState],
"iceConnectionState": [pc.iceConnectionState],
"iceGatheringState": [pc.iceGatheringState],
"signalingState": [pc.signalingState],
}
@pc.on("connectionstatechange")
def connectionstatechange():
states["connectionState"].append(pc.connectionState)
@pc.on("iceconnectionstatechange")
def iceconnectionstatechange():
states["iceConnectionState"].append(pc.iceConnectionState)
@pc.on("icegatheringstatechange")
def icegatheringstatechange():
states["iceGatheringState"].append(pc.iceGatheringState)
@pc.on("signalingstatechange")
def signalingstatechange():
states["signalingState"].append(pc.signalingState)
return states
def track_remote_tracks(pc):
tracks = []
@pc.on("track")
def track(track):
tracks.append(track)
return tracks
class RTCRtpCodecParametersTest(TestCase):
def test_find_common_codecs_static(self):
local_codecs = [
RTCRtpCodecParameters(
mimeType="audio/opus", clockRate=48000, channels=2, payloadType=96
),
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, channels=1, payloadType=0
),
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
]
remote_codecs = [
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, channels=1, payloadType=0
),
]
common = find_common_codecs(local_codecs, remote_codecs)
self.assertEqual(
common,
[
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, channels=1, payloadType=0
),
],
)
def find_common_codecs_dynamic(self):
local_codecs = [
RTCRtpCodecParameters(
mimeType="audio/opus", clockRate=48000, channels=2, payloadType=96
),
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, channels=1, payloadType=0
),
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
]
remote_codecs = [
RTCRtpCodecParameters(
mimeType="audio/opus", clockRate=48000, channels=2, payloadType=100
),
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
]
common = find_common_codecs(local_codecs, remote_codecs)
self.assertEqual(
common,
[
RTCRtpCodecParameters(
mimeType="audio/opus", clockRate=48000, channels=2, payloadType=100
),
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
],
)
def find_common_codecs_feedback(self):
local_codecs = [
RTCRtpCodecParameters(
mimeType="video/VP8",
clockRate=90000,
payloadType=100,
rtcpFeedback=[
RTCRtcpFeedback(type="nack"),
RTCRtcpFeedback(type="nack", parameter="pli"),
],
)
]
remote_codecs = [
RTCRtpCodecParameters(
mimeType="video/VP8",
clockRate=90000,
payloadType=120,
rtcpFeedback=[
RTCRtcpFeedback(type="nack"),
RTCRtcpFeedback(type="nack", parameter="sli"),
],
)
]
common = find_common_codecs(local_codecs, remote_codecs)
self.assertEqual(len(common), 1)
self.assertEqual(common[0].clockRate, 90000)
self.assertEqual(common[0].name, "VP8")
self.assertEqual(common[0].payloadType, 120)
self.assertEqual(common[0].rtcpFeedback, [RTCRtcpFeedback(type="nack")])
def test_find_common_codecs_rtx(self):
local_codecs = [
RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=100
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=101,
parameters={"apt": 100},
),
]
remote_codecs = [
RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=96
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=97,
parameters={"apt": 96},
),
RTCRtpCodecParameters(
mimeType="video/VP9", clockRate=90000, payloadType=98
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=99,
parameters={"apt": 98},
),
]
common = find_common_codecs(local_codecs, remote_codecs)
self.assertEqual(
common,
[
RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=96
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=97,
parameters={"apt": 96},
),
],
)
def test_filter_preferred_codecs(self):
codecs = [
RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=100
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=101,
parameters={"apt": 100},
),
RTCRtpCodecParameters(
mimeType="video/H264", clockRate=90000, payloadType=102
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=103,
parameters={"apt": 102},
),
]
# no preferences
self.assertEqual(filter_preferred_codecs(codecs, []), codecs)
# with RTX, prefer VP8
self.assertEqual(
filter_preferred_codecs(
codecs,
[
RTCRtpCodecCapability(mimeType="video/VP8", clockRate=90000),
RTCRtpCodecCapability(mimeType="video/rtx", clockRate=90000),
RTCRtpCodecCapability(mimeType="video/H264", clockRate=90000),
],
),
[
RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=100
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=101,
parameters={"apt": 100},
),
RTCRtpCodecParameters(
mimeType="video/H264", clockRate=90000, payloadType=102
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=103,
parameters={"apt": 102},
),
],
)
# with RTX, prefer H264
self.assertEqual(
filter_preferred_codecs(
codecs,
[
RTCRtpCodecCapability(mimeType="video/H264", clockRate=90000),
RTCRtpCodecCapability(mimeType="video/rtx", clockRate=90000),
RTCRtpCodecCapability(mimeType="video/VP8", clockRate=90000),
],
),
[
RTCRtpCodecParameters(
mimeType="video/H264", clockRate=90000, payloadType=102
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=103,
parameters={"apt": 102},
),
RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=100
),
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=101,
parameters={"apt": 100},
),
],
)
# no RTX, same order
self.assertEqual(
filter_preferred_codecs(
codecs,
[
RTCRtpCodecCapability(mimeType="video/VP8", clockRate=90000),
RTCRtpCodecCapability(mimeType="video/H264", clockRate=90000),
],
),
[
RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=100
),
RTCRtpCodecParameters(
mimeType="video/H264", clockRate=90000, payloadType=102
),
],
)
def test_is_codec_compatible(self):
# compatible: identical
self.assertTrue(
is_codec_compatible(
RTCRtpCodecParameters(
mimeType="video/H264", clockRate=90000, payloadType=102
),
RTCRtpCodecParameters(
mimeType="video/H264", clockRate=90000, payloadType=102
),
)
)
self.assertTrue(
is_codec_compatible(
RTCRtpCodecParameters(
mimeType="video/H264",
clockRate=90000,
payloadType=102,
parameters={
"packetization-mode": "0",
"profile-level-id": "42E01F",
},
),
RTCRtpCodecParameters(
mimeType="video/H264",
clockRate=90000,
payloadType=102,
),
)
)
# incompatible: different clockRate
self.assertFalse(
is_codec_compatible(
RTCRtpCodecParameters(
mimeType="video/H264", clockRate=90000, payloadType=102
),
RTCRtpCodecParameters(
mimeType="video/H264", clockRate=12345, payloadType=102
),
)
)
# incompatible: different mimeType
self.assertFalse(
is_codec_compatible(
RTCRtpCodecParameters(
mimeType="video/H264", clockRate=90000, payloadType=102
),
RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=102
),
)
)
# incompatible: different H.264 profile
self.assertFalse(
is_codec_compatible(
RTCRtpCodecParameters(
mimeType="video/H264",
clockRate=90000,
payloadType=102,
parameters={
"packetization-mode": "1",
"profile-level-id": "42001f",
},
),
RTCRtpCodecParameters(
mimeType="video/H264",
clockRate=90000,
payloadType=102,
parameters={
"packetization-mode": "1",
"profile-level-id": "42e01f",
},
),
)
)
# incompatible: different H.264 packetization mode
self.assertFalse(
is_codec_compatible(
RTCRtpCodecParameters(
mimeType="video/H264",
clockRate=90000,
payloadType=102,
parameters={
"packetization-mode": "0",
"profile-level-id": "42001f",
},
),
RTCRtpCodecParameters(
mimeType="video/H264",
clockRate=90000,
payloadType=102,
parameters={
"packetization-mode": "1",
"profile-level-id": "42001f",
},
),
)
)
# incompatible: cannot parse H.264 profile
self.assertFalse(
is_codec_compatible(
RTCRtpCodecParameters(
mimeType="video/H264",
clockRate=90000,
payloadType=102,
parameters={
"profile-level-id": "42001f",
},
),
RTCRtpCodecParameters(
mimeType="video/H264",
clockRate=90000,
payloadType=102,
parameters={
"profile-level-id": "blah",
},
),
)
)
class RTCPeerConnectionTest(TestCase):
def assertBundled(self, pc):
transceivers = pc.getTransceivers()
self.assertEqual(
transceivers[0].receiver.transport, transceivers[0].sender.transport
)
transport = transceivers[0].receiver.transport
for i in range(1, len(transceivers)):
self.assertEqual(transceivers[i].receiver.transport, transport)
self.assertEqual(transceivers[i].sender.transport, transport)
if pc.sctp:
self.assertEqual(pc.sctp.transport, transport)
async def assertDataChannelOpen(self, dc):
await self.sleepWhile(lambda: dc.readyState == "connecting")
self.assertEqual(dc.readyState, "open")
async def assertIceChecking(self, pc):
await self.sleepWhile(lambda: pc.iceConnectionState == "new")
self.assertEqual(pc.iceConnectionState, "checking")
self.assertEqual(pc.iceGatheringState, "complete")
async def assertIceCompleted(self, pc1, pc2):
await self.sleepWhile(
lambda: pc1.iceConnectionState == "checking"
or pc2.iceConnectionState == "checking"
)
self.assertEqual(pc1.iceConnectionState, "completed")
self.assertEqual(pc2.iceConnectionState, "completed")
def assertHasIceCandidates(self, description):
self.assertTrue("a=candidate:" in description.sdp)
self.assertTrue("a=end-of-candidates" in description.sdp)
def assertHasDtls(self, description, setup):
self.assertTrue("a=fingerprint:sha-256" in description.sdp)
self.assertEqual(
set(re.findall("a=setup:(.*)\r$", description.sdp)), set([setup])
)
async def closeDataChannel(self, dc):
dc.close()
await self.sleepWhile(lambda: dc.readyState == "closing")
self.assertEqual(dc.readyState, "closed")
async def sleepWhile(self, f, max_sleep=1.0):
sleep = 0.1
total = 0.0
while f() and total < max_sleep:
await asyncio.sleep(sleep)
total += sleep
def setUp(self):
# save timers
self.consent_failures = aioice.ice.CONSENT_FAILURES
self.consent_interval = aioice.ice.CONSENT_INTERVAL
self.retry_max = aioice.stun.RETRY_MAX
self.retry_rto = aioice.stun.RETRY_RTO
# shorten timers to run tests faster
aioice.ice.CONSENT_FAILURES = 1
aioice.ice.CONSENT_INTERVAL = 1
aioice.stun.RETRY_MAX = 1
aioice.stun.RETRY_RTO = 0.1
def tearDown(self):
# restore timers
aioice.ice.CONSENT_FAILURES = self.consent_failures
aioice.ice.CONSENT_INTERVAL = self.consent_interval
aioice.stun.RETRY_MAX = self.retry_max
aioice.stun.RETRY_RTO = self.retry_rto
@asynctest
async def test_addIceCandidate_no_sdpMid_or_sdpMLineIndex(self):
pc = RTCPeerConnection()
with self.assertRaises(ValueError) as cm:
await pc.addIceCandidate(
RTCIceCandidate(
component=1,
foundation="0",
ip="192.168.99.7",
port=33543,
priority=2122252543,
protocol="UDP",
type="host",
)
)
self.assertEqual(
str(cm.exception), "Candidate must have either sdpMid or sdpMLineIndex"
)
@asynctest
async def test_addTrack_audio(self):
pc = RTCPeerConnection()
# add audio track
track1 = AudioStreamTrack()
sender1 = pc.addTrack(track1)
self.assertIsNotNone(sender1)
self.assertEqual(sender1.track, track1)
self.assertEqual(pc.getSenders(), [sender1])
self.assertEqual(len(pc.getTransceivers()), 1)
# try to add same track again
with self.assertRaises(InvalidAccessError) as cm:
pc.addTrack(track1)
self.assertEqual(str(cm.exception), "Track already has a sender")
# add another audio track
track2 = AudioStreamTrack()
sender2 = pc.addTrack(track2)
self.assertIsNotNone(sender2)
self.assertEqual(sender2.track, track2)
self.assertEqual(pc.getSenders(), [sender1, sender2])
self.assertEqual(len(pc.getTransceivers()), 2)
@asynctest
async def test_addTrack_bogus(self):
pc = RTCPeerConnection()
# try adding a bogus track
with self.assertRaises(InternalError) as cm:
pc.addTrack(BogusStreamTrack())
self.assertEqual(str(cm.exception), 'Invalid track kind "bogus"')
@asynctest
async def test_addTrack_video(self):
pc = RTCPeerConnection()
# add video track
video_track1 = VideoStreamTrack()
video_sender1 = pc.addTrack(video_track1)
self.assertIsNotNone(video_sender1)
self.assertEqual(video_sender1.track, video_track1)
self.assertEqual(pc.getSenders(), [video_sender1])
self.assertEqual(len(pc.getTransceivers()), 1)
# try to add same track again
with self.assertRaises(InvalidAccessError) as cm:
pc.addTrack(video_track1)
self.assertEqual(str(cm.exception), "Track already has a sender")
# add another video track
video_track2 = VideoStreamTrack()
video_sender2 = pc.addTrack(video_track2)
self.assertIsNotNone(video_sender2)
self.assertEqual(video_sender2.track, video_track2)
self.assertEqual(pc.getSenders(), [video_sender1, video_sender2])
self.assertEqual(len(pc.getTransceivers()), 2)
# add audio track
audio_track = AudioStreamTrack()
audio_sender = pc.addTrack(audio_track)
self.assertIsNotNone(audio_sender)
self.assertEqual(audio_sender.track, audio_track)
self.assertEqual(pc.getSenders(), [video_sender1, video_sender2, audio_sender])
self.assertEqual(len(pc.getTransceivers()), 3)
@asynctest
async def test_addTrack_closed(self):
pc = RTCPeerConnection()
await pc.close()
with self.assertRaises(InvalidStateError) as cm:
pc.addTrack(AudioStreamTrack())
self.assertEqual(str(cm.exception), "RTCPeerConnection is closed")
@asynctest
async def test_addTransceiver_audio_inactive(self):
pc = RTCPeerConnection()
# add transceiver
transceiver = pc.addTransceiver("audio", direction="inactive")
self.assertIsNotNone(transceiver)
self.assertEqual(transceiver.currentDirection, None)
self.assertEqual(transceiver.direction, "inactive")
self.assertEqual(transceiver.sender.track, None)
self.assertEqual(transceiver.stopped, False)
self.assertEqual(pc.getSenders(), [transceiver.sender])
self.assertEqual(len(pc.getTransceivers()), 1)
# add track
track = AudioStreamTrack()
pc.addTrack(track)
self.assertEqual(transceiver.currentDirection, None)
self.assertEqual(transceiver.direction, "sendonly")
self.assertEqual(transceiver.sender.track, track)
self.assertEqual(transceiver.stopped, False)
self.assertEqual(len(pc.getTransceivers()), 1)
# stop transceiver
await transceiver.stop()
self.assertEqual(transceiver.currentDirection, None)
self.assertEqual(transceiver.direction, "sendonly")
self.assertEqual(transceiver.sender.track, track)
self.assertEqual(transceiver.stopped, True)
@asynctest
async def test_addTransceiver_audio_sendrecv(self):
pc = RTCPeerConnection()
# add transceiver
transceiver = pc.addTransceiver("audio")
self.assertIsNotNone(transceiver)
self.assertEqual(transceiver.currentDirection, None)
self.assertEqual(transceiver.direction, "sendrecv")
self.assertEqual(transceiver.sender.track, None)
self.assertEqual(transceiver.stopped, False)
self.assertEqual(pc.getSenders(), [transceiver.sender])
self.assertEqual(len(pc.getTransceivers()), 1)
# add track
track = AudioStreamTrack()
pc.addTrack(track)
self.assertEqual(transceiver.currentDirection, None)
self.assertEqual(transceiver.direction, "sendrecv")
self.assertEqual(transceiver.sender.track, track)
self.assertEqual(transceiver.stopped, False)
self.assertEqual(len(pc.getTransceivers()), 1)
@asynctest
async def test_addTransceiver_audio_track(self):
pc = RTCPeerConnection()
# add audio track
track1 = AudioStreamTrack()
transceiver1 = pc.addTransceiver(track1)
self.assertIsNotNone(transceiver1)
self.assertEqual(transceiver1.currentDirection, None)
self.assertEqual(transceiver1.direction, "sendrecv")
self.assertEqual(transceiver1.sender.track, track1)
self.assertEqual(transceiver1.stopped, False)
self.assertEqual(pc.getSenders(), [transceiver1.sender])
self.assertEqual(len(pc.getTransceivers()), 1)
# try to add same track again
with self.assertRaises(InvalidAccessError) as cm:
pc.addTransceiver(track1)
self.assertEqual(str(cm.exception), "Track already has a sender")
# add another audio track
track2 = AudioStreamTrack()
transceiver2 = pc.addTransceiver(track2)
self.assertIsNotNone(transceiver2)
self.assertEqual(transceiver2.currentDirection, None)
self.assertEqual(transceiver2.direction, "sendrecv")
self.assertEqual(transceiver2.sender.track, track2)
self.assertEqual(transceiver2.stopped, False)
self.assertEqual(pc.getSenders(), [transceiver1.sender, transceiver2.sender])
self.assertEqual(len(pc.getTransceivers()), 2)
def test_addTransceiver_bogus_direction(self):
pc = RTCPeerConnection()
# try adding a bogus kind
with self.assertRaises(InternalError) as cm:
pc.addTransceiver("audio", direction="bogus")
self.assertEqual(str(cm.exception), 'Invalid direction "bogus"')
def test_addTransceiver_bogus_kind(self):
pc = RTCPeerConnection()
# try adding a bogus kind
with self.assertRaises(InternalError) as cm:
pc.addTransceiver("bogus")
self.assertEqual(str(cm.exception), 'Invalid track kind "bogus"')
def test_addTransceiver_bogus_track(self):
pc = RTCPeerConnection()
# try adding a bogus track
with self.assertRaises(InternalError) as cm:
pc.addTransceiver(BogusStreamTrack())
self.assertEqual(str(cm.exception), 'Invalid track kind "bogus"')
@asynctest
async def test_close(self):
pc = RTCPeerConnection()
pc_states = track_states(pc)
# close once
await pc.close()
# close twice
await pc.close()
self.assertEqual(pc_states["signalingState"], ["stable", "closed"])
async def _test_connect_audio_bidirectional(self, pc1, pc2):
pc1_states = track_states(pc1)
pc1_tracks = track_remote_tracks(pc1)
pc2_states = track_states(pc2)
pc2_tracks = track_remote_tracks(pc2)
self.assertEqual(pc1.iceConnectionState, "new")
self.assertEqual(pc1.iceGatheringState, "new")
self.assertIsNone(pc1.localDescription)
self.assertIsNone(pc1.remoteDescription)
self.assertEqual(pc2.iceConnectionState, "new")
self.assertEqual(pc2.iceGatheringState, "new")
self.assertIsNone(pc2.localDescription)
self.assertIsNone(pc2.remoteDescription)
# create offer
track1 = AudioStreamTrack()
pc1.addTrack(track1)
offer = await pc1.createOffer()
self.assertEqual(offer.type, "offer")
self.assertTrue("m=audio " in offer.sdp)
self.assertFalse("a=candidate:" in offer.sdp)
self.assertFalse("a=end-of-candidates" in offer.sdp)
await pc1.setLocalDescription(offer)
self.assertEqual(pc1.iceConnectionState, "new")
self.assertEqual(pc1.iceGatheringState, "complete")
self.assertEqual(mids(pc1), ["0"])
self.assertTrue("m=audio " in pc1.localDescription.sdp)
self.assertTrue(
lf2crlf(
"""a=rtpmap:96 opus/48000/2
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000
"""
)
in pc1.localDescription.sdp
)
self.assertTrue("a=sendrecv" in pc1.localDescription.sdp)
self.assertHasIceCandidates(pc1.localDescription)
self.assertHasDtls(pc1.localDescription, "actpass")
# handle offer
await pc2.setRemoteDescription(pc1.localDescription)
self.assertEqual(pc2.remoteDescription, pc1.localDescription)
self.assertEqual(len(pc2.getReceivers()), 1)
self.assertEqual(len(pc2.getSenders()), 1)
self.assertEqual(len(pc2.getTransceivers()), 1)
self.assertEqual(mids(pc2), ["0"])
# the RemoteStreamTrack should have the same ID as the source track
self.assertEqual(len(pc2_tracks), 1)
self.assertEqual(pc2_tracks[0].id, track1.id)
# create answer
track2 = AudioStreamTrack()
pc2.addTrack(track2)
answer = await pc2.createAnswer()
self.assertEqual(answer.type, "answer")
self.assertTrue("m=audio " in answer.sdp)
self.assertFalse("a=candidate:" in answer.sdp)
self.assertFalse("a=end-of-candidates" in answer.sdp)
await pc2.setLocalDescription(answer)
await self.assertIceChecking(pc2)
self.assertEqual(mids(pc2), ["0"])
self.assertTrue("m=audio " in pc2.localDescription.sdp)
self.assertTrue(
lf2crlf(
"""a=rtpmap:96 opus/48000/2
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000
"""
)
in pc2.localDescription.sdp
)
self.assertTrue("a=sendrecv" in pc2.localDescription.sdp)
self.assertHasIceCandidates(pc2.localDescription)
self.assertHasDtls(pc2.localDescription, "active")
self.assertEqual(pc2.getTransceivers()[0].currentDirection, "sendrecv")
self.assertEqual(pc2.getTransceivers()[0].direction, "sendrecv")
# handle answer
await pc1.setRemoteDescription(pc2.localDescription)
self.assertEqual(pc1.remoteDescription, pc2.localDescription)
self.assertEqual(pc1.getTransceivers()[0].currentDirection, "sendrecv")
self.assertEqual(pc1.getTransceivers()[0].direction, "sendrecv")
# the RemoteStreamTrack should have the same ID as the source track
self.assertEqual(len(pc1_tracks), 1)
self.assertEqual(pc1_tracks[0].id, track2.id)
# check outcome
await self.assertIceCompleted(pc1, pc2)
# allow media to flow long enough to collect stats
await asyncio.sleep(2)
# check stats
report = await pc1.getStats()
self.assertIsInstance(report, RTCStatsReport)
self.assertEqual(
sorted([s.type for s in report.values()]),
[
"inbound-rtp",
"outbound-rtp",
"remote-inbound-rtp",
"remote-outbound-rtp",
"transport",
],
)
# close
await pc1.close()
await pc2.close()
self.assertEqual(pc1.iceConnectionState, "closed")
self.assertEqual(pc2.iceConnectionState, "closed")
# check state changes
self.assertEqual(
pc1_states["connectionState"], ["new", "connecting", "connected", "closed"]
)
self.assertEqual(
pc1_states["iceConnectionState"], ["new", "checking", "completed", "closed"]
)
self.assertEqual(
pc1_states["iceGatheringState"], ["new", "gathering", "complete"]
)
self.assertEqual(
pc1_states["signalingState"],
["stable", "have-local-offer", "stable", "closed"],
)
self.assertEqual(
pc2_states["connectionState"], ["new", "connecting", "connected", "closed"]
)
self.assertEqual(
pc2_states["iceConnectionState"], ["new", "checking", "completed", "closed"]
)
self.assertEqual(
pc2_states["iceGatheringState"], ["new", "gathering", "complete"]
)
self.assertEqual(
pc2_states["signalingState"],
["stable", "have-remote-offer", "stable", "closed"],
)
@asynctest
async def test_connect_audio_bidirectional(self):
pc1 = RTCPeerConnection()
pc2 = RTCPeerConnection()
await self._test_connect_audio_bidirectional(pc1, pc2)
@asynctest
| 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/aiortc/tests/test_h264.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_h264.py | import fractions
import io
from contextlib import redirect_stderr
from unittest import TestCase
from av import Packet
from aiortc.codecs import get_decoder, get_encoder, h264
from aiortc.codecs.h264 import H264Decoder, H264Encoder, H264PayloadDescriptor
from aiortc.jitterbuffer import JitterFrame
from aiortc.rtcrtpparameters import RTCRtpCodecParameters
from .codecs import CodecTestCase
from .utils import load
H264_CODEC = RTCRtpCodecParameters(
mimeType="video/H264", clockRate=90000, payloadType=100
)
class FragmentedCodecContext:
def __init__(self, orig):
self.__orig = orig
def encode(self, frame):
packages = self.__orig.encode(frame)
dummy = Packet()
dummy.pts = packages[0].pts
packages.append(dummy)
return packages
def __getattr__(self, name):
return getattr(self.__orig, name)
class H264PayloadDescriptorTest(TestCase):
def test_parse_empty(self):
with self.assertRaises(ValueError) as cm:
H264PayloadDescriptor.parse(b"")
self.assertEqual(str(cm.exception), "NAL unit is too short")
def test_parse_stap_a(self):
payload = load("h264_0000.bin")
descr, rest = H264PayloadDescriptor.parse(payload)
self.assertEqual(descr.first_fragment, True)
self.assertEqual(repr(descr), "H264PayloadDescriptor(FF=True)")
self.assertEqual(rest[:4], b"\00\00\00\01")
self.assertEqual(len(rest), 26)
def test_parse_stap_a_truncated(self):
payload = load("h264_0000.bin")
with self.assertRaises(ValueError) as cm:
H264PayloadDescriptor.parse(payload[0:1])
self.assertEqual(str(cm.exception), "NAL unit is too short")
with self.assertRaises(ValueError) as cm:
H264PayloadDescriptor.parse(payload[0:2])
self.assertEqual(str(cm.exception), "STAP-A length field is truncated")
with self.assertRaises(ValueError) as cm:
H264PayloadDescriptor.parse(payload[0:3])
self.assertEqual(str(cm.exception), "STAP-A data is truncated")
def test_parse_stap_b(self):
with self.assertRaises(ValueError) as cm:
H264PayloadDescriptor.parse(b"\x19\x00")
self.assertEqual(str(cm.exception), "NAL unit type 25 is not supported")
def test_parse_fu_a_1(self):
payload = load("h264_0001.bin")
descr, rest = H264PayloadDescriptor.parse(payload)
self.assertEqual(descr.first_fragment, True)
self.assertEqual(repr(descr), "H264PayloadDescriptor(FF=True)")
self.assertEqual(rest[:4], b"\00\00\00\01")
self.assertEqual(len(rest), 916)
def test_parse_fu_a_2(self):
payload = load("h264_0002.bin")
descr, rest = H264PayloadDescriptor.parse(payload)
self.assertEqual(descr.first_fragment, False)
self.assertEqual(repr(descr), "H264PayloadDescriptor(FF=False)")
self.assertNotEqual(rest[:4], b"\00\00\00\01")
self.assertEqual(len(rest), 912)
def test_parse_fu_a_truncated(self):
with self.assertRaises(ValueError) as cm:
H264PayloadDescriptor.parse(b"\x7c")
self.assertEqual(str(cm.exception), "NAL unit is too short")
def test_parse_nalu(self):
payload = load("h264_0003.bin")
descr, rest = H264PayloadDescriptor.parse(payload)
self.assertEqual(descr.first_fragment, True)
self.assertEqual(repr(descr), "H264PayloadDescriptor(FF=True)")
self.assertEqual(rest[:4], b"\00\00\00\01")
self.assertEqual(rest[4:], payload)
self.assertEqual(len(rest), 564)
class H264Test(CodecTestCase):
def test_decoder(self):
decoder = get_decoder(H264_CODEC)
self.assertIsInstance(decoder, H264Decoder)
# decode junk
with redirect_stderr(io.StringIO()):
frames = decoder.decode(JitterFrame(data=b"123", timestamp=0))
self.assertEqual(frames, [])
def test_encoder(self):
encoder = get_encoder(H264_CODEC)
self.assertIsInstance(encoder, H264Encoder)
frame = self.create_video_frame(width=640, height=480, pts=0)
packages, timestamp = encoder.encode(frame)
self.assertGreaterEqual(len(packages), 1)
def test_encoder_pack(self):
encoder = get_encoder(H264_CODEC)
self.assertTrue(isinstance(encoder, H264Encoder))
packet = self.create_packet(payload=bytes([0, 0, 1, 0]), pts=1)
payloads, timestamp = encoder.pack(packet)
self.assertEqual(payloads, [b"\x00"])
self.assertEqual(timestamp, 90)
def test_encoder_buffering(self):
create_encoder_context = h264.create_encoder_context
def mock_create_encoder_context(*args, **kwargs):
codec, _ = create_encoder_context(*args, **kwargs)
return FragmentedCodecContext(codec), True
h264.create_encoder_context = mock_create_encoder_context
try:
encoder = get_encoder(H264_CODEC)
self.assertIsInstance(encoder, H264Encoder)
frame = self.create_video_frame(width=640, height=480, pts=0)
packages, timestamp = encoder.encode(frame)
self.assertEqual(len(packages), 0)
frame = self.create_video_frame(width=640, height=480, pts=3000)
packages, timestamp = encoder.encode(frame)
self.assertGreaterEqual(len(packages), 1)
finally:
h264.create_encoder_context = create_encoder_context
def test_encoder_target_bitrate(self):
encoder = get_encoder(H264_CODEC)
self.assertIsInstance(encoder, H264Encoder)
self.assertEqual(encoder.target_bitrate, 1000000)
frame = self.create_video_frame(width=640, height=480, pts=0)
packages, timestamp = encoder.encode(frame)
self.assertGreaterEqual(len(packages), 1)
self.assertTrue(len(packages[0]) < 1300)
self.assertEqual(timestamp, 0)
# change target bitrate
encoder.target_bitrate = 1200000
self.assertEqual(encoder.target_bitrate, 1200000)
frame = self.create_video_frame(width=640, height=480, pts=3000)
packages, timestamp = encoder.encode(frame)
self.assertGreaterEqual(len(packages), 1)
self.assertTrue(len(packages[0]) < 1300)
self.assertEqual(timestamp, 3000)
def test_roundtrip_1280_720(self):
self.roundtrip_video(H264_CODEC, 1280, 720)
def test_roundtrip_960_540(self):
self.roundtrip_video(H264_CODEC, 960, 540)
def test_roundtrip_640_480(self):
self.roundtrip_video(H264_CODEC, 640, 480)
def test_roundtrip_640_480_time_base(self):
self.roundtrip_video(
H264_CODEC, 640, 480, time_base=fractions.Fraction(1, 9000)
)
def test_roundtrip_320_240(self):
self.roundtrip_video(H264_CODEC, 320, 240)
def test_split_bitstream(self):
# No start code
packages = list(H264Encoder._split_bitstream(b"\x00\x00\x00\x00"))
self.assertEqual(packages, [])
# 3-byte start code
packages = list(
H264Encoder._split_bitstream(b"\x00\x00\x01\xFF\x00\x00\x01\xFB")
)
self.assertEqual(packages, [b"\xFF", b"\xFB"])
# 4-byte start code
packages = list(
H264Encoder._split_bitstream(b"\x00\x00\x00\x01\xFF\x00\x00\x00\x01\xFB")
)
self.assertEqual(packages, [b"\xFF", b"\xFB"])
# Multiple bytes in a packet
packages = list(
H264Encoder._split_bitstream(
b"\x00\x00\x00\x01\xFF\xAB\xCD\x00\x00\x00\x01\xFB"
)
)
self.assertEqual(packages, [b"\xFF\xAB\xCD", b"\xFB"])
# Skip leading 0s
packages = list(H264Encoder._split_bitstream(b"\x00\x00\x00\x01\xFF"))
self.assertEqual(packages, [b"\xFF"])
# Both leading and trailing 0s
packages = list(
H264Encoder._split_bitstream(
b"\x00\x00\x00\x00\x00\x00\x01\xFF\x00\x00\x00\x00\x00"
)
)
self.assertEqual(packages, [b"\xFF\x00\x00\x00\x00\x00"])
def test_packetize_one_small(self):
packages = [bytes([0xFF, 0xFF])]
packetize_packages = H264Encoder._packetize(packages)
self.assertListEqual(packages, packetize_packages)
packages = [bytes([0xFF]) * 1300]
packetize_packages = H264Encoder._packetize(packages)
self.assertListEqual(packages, packetize_packages)
def test_packetize_one_big(self):
packages = [bytes([0xFF, 0xFF] * 1000)]
packetize_packages = H264Encoder._packetize(packages)
self.assertEqual(len(packetize_packages), 2)
self.assertEqual(packetize_packages[0][0] & 0x1F, 28)
self.assertEqual(packetize_packages[1][0] & 0x1F, 28)
def test_packetize_two_small(self):
packages = [bytes([0x01, 0xFF]), bytes([0xFF, 0xFF])]
packetize_packages = H264Encoder._packetize(packages)
self.assertEqual(len(packetize_packages), 1)
self.assertEqual(packetize_packages[0][0] & 0x1F, 24)
def test_packetize_multiple_small(self):
packages = [bytes([0x01, 0xFF])] * 9
packetize_packages = H264Encoder._packetize(packages)
self.assertEqual(len(packetize_packages), 1)
self.assertEqual(packetize_packages[0][0] & 0x1F, 24)
packages = [bytes([0x01, 0xFF])] * 10
packetize_packages = H264Encoder._packetize(packages)
self.assertEqual(len(packetize_packages), 2)
self.assertEqual(packetize_packages[0][0] & 0x1F, 24)
self.assertEqual(packetize_packages[1], packages[-1])
def test_frame_encoder(self):
encoder = get_encoder(H264_CODEC)
frame = self.create_video_frame(width=640, height=480, pts=0)
packages = list(encoder._encode_frame(frame, False))
self.assertGreaterEqual(len(packages), 3)
# first frame must have at least
set(p[0] & 0x1F for p in packages).issuperset(
{
8, # PPS (picture parameter set)
7, # SPS (session parameter set)
5, # IDR (aka key frame)
}
)
frame = self.create_video_frame(width=640, height=480, pts=3000)
packages = list(encoder._encode_frame(frame, False))
self.assertGreaterEqual(len(packages), 1)
# change resolution
frame = self.create_video_frame(width=320, height=240, pts=6000)
packages = list(encoder._encode_frame(frame, False))
self.assertGreaterEqual(len(packages), 1)
| 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_sdp.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_sdp.py | from unittest import TestCase
from aiortc.rtcrtpparameters import (
RTCRtcpFeedback,
RTCRtpCodecParameters,
RTCRtpHeaderExtensionParameters,
)
from aiortc.sdp import (
GroupDescription,
H264Level,
H264Profile,
SessionDescription,
SsrcDescription,
parse_h264_profile_level_id,
)
from .utils import lf2crlf
class SdpTest(TestCase):
maxDiff = None
def test_audio_chrome(self):
d = SessionDescription.parse(
lf2crlf(
"""v=0
o=- 863426017819471768 2 IN IP4 127.0.0.1
s=-
t=0 0
a=group:BUNDLE audio
a=msid-semantic: WMS TF6VRif1dxuAfe5uefrV2953LhUZt1keYvxU
m=audio 45076 UDP/TLS/RTP/SAVPF 111 103 104 9 0 8 106 105 13 110 112 113 126
c=IN IP4 192.168.99.58
a=rtcp:9 IN IP4 0.0.0.0
a=candidate:2665802302 1 udp 2122262783 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 38475 typ host generation 0 network-id 2 network-cost 10
a=candidate:1039001212 1 udp 2122194687 192.168.99.58 45076 typ host generation 0 network-id 1 network-cost 10
a=candidate:3496416974 1 tcp 1518283007 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 9 typ host tcptype active generation 0 network-id 2 network-cost 10
a=candidate:1936595596 1 tcp 1518214911 192.168.99.58 9 typ host tcptype active generation 0 network-id 1 network-cost 10
a=ice-ufrag:5+Ix
a=ice-pwd:uK8IlylxzDMUhrkVzdmj0M+v
a=ice-options:trickle
a=fingerprint:sha-256 6B:8B:5D:EA:59:04:20:23:29:C8:87:1C:CC:87:32:BE:DD:8C:66:A5:8E:50:55:EA:8C:D3:B6:5C:09:5E:D6:BC
a=setup:actpass
a=mid:audio
a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level
a=sendrecv
a=rtcp-mux
a=rtpmap:111 opus/48000/2
a=rtcp-fb:111 transport-cc
a=fmtp:111 minptime=10;useinbandfec=1
a=rtpmap:103 ISAC/16000
a=rtpmap:104 ISAC/32000
a=rtpmap:9 G722/8000
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000
a=rtpmap:106 CN/32000
a=rtpmap:105 CN/16000
a=rtpmap:13 CN/8000
a=rtpmap:110 telephone-event/48000
a=rtpmap:112 telephone-event/32000
a=rtpmap:113 telephone-event/16000
a=rtpmap:126 telephone-event/8000
a=ssrc:1944796561 cname:/vC4ULAr8vHNjXmq
a=ssrc:1944796561 msid:TF6VRif1dxuAfe5uefrV2953LhUZt1keYvxU ec1eb8de-8df8-4956-ae81-879e5d062d12
a=ssrc:1944796561 mslabel:TF6VRif1dxuAfe5uefrV2953LhUZt1keYvxU
a=ssrc:1944796561 label:ec1eb8de-8df8-4956-ae81-879e5d062d12"""
)
)
self.assertEqual(
d.group, [GroupDescription(semantic="BUNDLE", items=["audio"])]
)
self.assertEqual(
d.msid_semantic,
[
GroupDescription(
semantic="WMS", items=["TF6VRif1dxuAfe5uefrV2953LhUZt1keYvxU"]
)
],
)
self.assertEqual(d.host, None)
self.assertEqual(d.name, "-")
self.assertEqual(d.origin, "- 863426017819471768 2 IN IP4 127.0.0.1")
self.assertEqual(d.time, "0 0")
self.assertEqual(d.version, 0)
self.assertEqual(len(d.media), 1)
self.assertEqual(d.media[0].kind, "audio")
self.assertEqual(d.media[0].host, "192.168.99.58")
self.assertEqual(d.media[0].port, 45076)
self.assertEqual(d.media[0].profile, "UDP/TLS/RTP/SAVPF")
self.assertEqual(d.media[0].direction, "sendrecv")
self.assertEqual(d.media[0].msid, None)
self.assertEqual(
d.media[0].rtp.codecs,
[
RTCRtpCodecParameters(
mimeType="audio/opus",
clockRate=48000,
channels=2,
payloadType=111,
rtcpFeedback=[RTCRtcpFeedback(type="transport-cc")],
parameters={"minptime": 10, "useinbandfec": 1},
),
RTCRtpCodecParameters(
mimeType="audio/ISAC", clockRate=16000, channels=1, payloadType=103
),
RTCRtpCodecParameters(
mimeType="audio/ISAC", clockRate=32000, channels=1, payloadType=104
),
RTCRtpCodecParameters(
mimeType="audio/G722", clockRate=8000, channels=1, payloadType=9
),
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, channels=1, payloadType=0
),
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
RTCRtpCodecParameters(
mimeType="audio/CN", clockRate=32000, channels=1, payloadType=106
),
RTCRtpCodecParameters(
mimeType="audio/CN", clockRate=16000, channels=1, payloadType=105
),
RTCRtpCodecParameters(
mimeType="audio/CN", clockRate=8000, channels=1, payloadType=13
),
RTCRtpCodecParameters(
mimeType="audio/telephone-event",
clockRate=48000,
channels=1,
payloadType=110,
),
RTCRtpCodecParameters(
mimeType="audio/telephone-event",
clockRate=32000,
channels=1,
payloadType=112,
),
RTCRtpCodecParameters(
mimeType="audio/telephone-event",
clockRate=16000,
channels=1,
payloadType=113,
),
RTCRtpCodecParameters(
mimeType="audio/telephone-event",
clockRate=8000,
channels=1,
payloadType=126,
),
],
)
self.assertEqual(
d.media[0].rtp.headerExtensions,
[
RTCRtpHeaderExtensionParameters(
id=1, uri="urn:ietf:params:rtp-hdrext:ssrc-audio-level"
)
],
)
self.assertEqual(d.media[0].rtp.muxId, "audio")
self.assertEqual(d.media[0].rtcp_host, "0.0.0.0")
self.assertEqual(d.media[0].rtcp_port, 9)
self.assertEqual(d.media[0].rtcp_mux, True)
# ssrc
self.assertEqual(
d.media[0].ssrc,
[
SsrcDescription(
ssrc=1944796561,
cname="/vC4ULAr8vHNjXmq",
msid="TF6VRif1dxuAfe5uefrV2953LhUZt1keYvxU ec1eb8de-8df8-4956-ae81-879e5d062d12",
mslabel="TF6VRif1dxuAfe5uefrV2953LhUZt1keYvxU",
label="ec1eb8de-8df8-4956-ae81-879e5d062d12",
)
],
)
self.assertEqual(d.media[0].ssrc_group, [])
# formats
self.assertEqual(
d.media[0].fmt, [111, 103, 104, 9, 0, 8, 106, 105, 13, 110, 112, 113, 126]
)
self.assertEqual(d.media[0].sctpmap, {})
self.assertEqual(d.media[0].sctp_port, None)
# ice
self.assertEqual(len(d.media[0].ice_candidates), 4)
self.assertEqual(d.media[0].ice_candidates_complete, False)
self.assertEqual(d.media[0].ice_options, "trickle")
self.assertEqual(d.media[0].ice.iceLite, False)
self.assertEqual(d.media[0].ice.usernameFragment, "5+Ix")
self.assertEqual(d.media[0].ice.password, "uK8IlylxzDMUhrkVzdmj0M+v")
# dtls
self.assertEqual(len(d.media[0].dtls.fingerprints), 1)
self.assertEqual(d.media[0].dtls.fingerprints[0].algorithm, "sha-256")
self.assertEqual(
d.media[0].dtls.fingerprints[0].value,
"6B:8B:5D:EA:59:04:20:23:29:C8:87:1C:CC:87:32:BE:DD:8C:66:A5:8E:50:55:EA:8C:D3:B6:5C:09:5E:D6:BC",
)
self.assertEqual(d.media[0].dtls.role, "auto")
self.assertEqual(
str(d),
lf2crlf(
"""v=0
o=- 863426017819471768 2 IN IP4 127.0.0.1
s=-
t=0 0
a=group:BUNDLE audio
a=msid-semantic:WMS TF6VRif1dxuAfe5uefrV2953LhUZt1keYvxU
m=audio 45076 UDP/TLS/RTP/SAVPF 111 103 104 9 0 8 106 105 13 110 112 113 126
c=IN IP4 192.168.99.58
a=sendrecv
a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level
a=mid:audio
a=rtcp:9 IN IP4 0.0.0.0
a=rtcp-mux
a=ssrc:1944796561 cname:/vC4ULAr8vHNjXmq
a=ssrc:1944796561 msid:TF6VRif1dxuAfe5uefrV2953LhUZt1keYvxU ec1eb8de-8df8-4956-ae81-879e5d062d12
a=ssrc:1944796561 mslabel:TF6VRif1dxuAfe5uefrV2953LhUZt1keYvxU
a=ssrc:1944796561 label:ec1eb8de-8df8-4956-ae81-879e5d062d12
a=rtpmap:111 opus/48000/2
a=rtcp-fb:111 transport-cc
a=fmtp:111 minptime=10;useinbandfec=1
a=rtpmap:103 ISAC/16000
a=rtpmap:104 ISAC/32000
a=rtpmap:9 G722/8000
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000
a=rtpmap:106 CN/32000
a=rtpmap:105 CN/16000
a=rtpmap:13 CN/8000
a=rtpmap:110 telephone-event/48000
a=rtpmap:112 telephone-event/32000
a=rtpmap:113 telephone-event/16000
a=rtpmap:126 telephone-event/8000
a=candidate:2665802302 1 udp 2122262783 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 38475 typ host
a=candidate:1039001212 1 udp 2122194687 192.168.99.58 45076 typ host
a=candidate:3496416974 1 tcp 1518283007 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 9 typ host tcptype active
a=candidate:1936595596 1 tcp 1518214911 192.168.99.58 9 typ host tcptype active
a=ice-ufrag:5+Ix
a=ice-pwd:uK8IlylxzDMUhrkVzdmj0M+v
a=ice-options:trickle
a=fingerprint:sha-256 6B:8B:5D:EA:59:04:20:23:29:C8:87:1C:CC:87:32:BE:DD:8C:66:A5:8E:50:55:EA:8C:D3:B6:5C:09:5E:D6:BC
a=setup:actpass
"""
),
)
def test_audio_firefox(self):
d = SessionDescription.parse(
lf2crlf(
"""v=0
o=mozilla...THIS_IS_SDPARTA-58.0.1 4934139885953732403 1 IN IP4 0.0.0.0
s=-
t=0 0
a=sendrecv
a=fingerprint:sha-256 EB:A9:3E:50:D7:E3:B3:86:0F:7B:01:C1:EB:D6:AF:E4:97:DE:15:05:A8:DE:7B:83:56:C7:4B:6E:9D:75:D4:17
a=group:BUNDLE sdparta_0
a=ice-options:trickle
a=msid-semantic:WMS *
m=audio 45274 UDP/TLS/RTP/SAVPF 109 9 0 8 101
c=IN IP4 192.168.99.58
a=candidate:0 1 UDP 2122187007 192.168.99.58 45274 typ host
a=candidate:2 1 UDP 2122252543 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 47387 typ host
a=candidate:3 1 TCP 2105458943 192.168.99.58 9 typ host tcptype active
a=candidate:4 1 TCP 2105524479 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 9 typ host tcptype active
a=candidate:0 2 UDP 2122187006 192.168.99.58 38612 typ host
a=candidate:2 2 UDP 2122252542 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 54301 typ host
a=candidate:3 2 TCP 2105458942 192.168.99.58 9 typ host tcptype active
a=candidate:4 2 TCP 2105524478 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 9 typ host tcptype active
a=candidate:1 1 UDP 1685921791 1.2.3.4 37264 typ srflx raddr 192.168.99.58 rport 37264
a=candidate:1 2 UDP 1685921790 1.2.3.4 52902 typ srflx raddr 192.168.99.58 rport 52902
a=sendrecv
a=end-of-candidates
a=extmap:1/sendonly urn:ietf:params:rtp-hdrext:ssrc-audio-level
a=extmap:2 urn:ietf:params:rtp-hdrext:sdes:mid
a=fmtp:109 maxplaybackrate=48000;stereo=1;useinbandfec=1
a=fmtp:101 0-15
a=ice-pwd:f9b83487285016f7492197a5790ceee5
a=ice-ufrag:403a81e1
a=ice-options:trickle
a=mid:sdparta_0
a=msid:{dee771c7-671a-451e-b847-f86f8e87c7d8} {12692dea-686c-47ca-b3e9-48f38fc92b78}
a=rtcp:38612 IN IP4 192.168.99.58
a=rtcp-mux
a=rtpmap:109 opus/48000/2
a=rtpmap:9 G722/8000/1
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000
a=rtpmap:101 telephone-event/8000
a=setup:actpass
a=ssrc:882128807 cname:{ed463ac5-dabf-44d4-8b9f-e14318427b2b}
"""
)
)
self.assertEqual(
d.group, [GroupDescription(semantic="BUNDLE", items=["sdparta_0"])]
)
self.assertEqual(
d.msid_semantic, [GroupDescription(semantic="WMS", items=["*"])]
)
self.assertEqual(d.host, None)
self.assertEqual(d.name, "-")
self.assertEqual(
d.origin,
"mozilla...THIS_IS_SDPARTA-58.0.1 4934139885953732403 1 IN IP4 0.0.0.0",
)
self.assertEqual(d.time, "0 0")
self.assertEqual(d.version, 0)
self.assertEqual(len(d.media), 1)
self.assertEqual(d.media[0].kind, "audio")
self.assertEqual(d.media[0].host, "192.168.99.58")
self.assertEqual(d.media[0].port, 45274)
self.assertEqual(d.media[0].profile, "UDP/TLS/RTP/SAVPF")
self.assertEqual(d.media[0].direction, "sendrecv")
self.assertEqual(
d.media[0].msid,
"{dee771c7-671a-451e-b847-f86f8e87c7d8} "
"{12692dea-686c-47ca-b3e9-48f38fc92b78}",
)
self.assertEqual(
d.media[0].rtp.codecs,
[
RTCRtpCodecParameters(
mimeType="audio/opus",
clockRate=48000,
channels=2,
payloadType=109,
parameters={
"maxplaybackrate": 48000,
"stereo": 1,
"useinbandfec": 1,
},
),
RTCRtpCodecParameters(
mimeType="audio/G722", clockRate=8000, channels=1, payloadType=9
),
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, channels=1, payloadType=0
),
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
RTCRtpCodecParameters(
mimeType="audio/telephone-event",
clockRate=8000,
channels=1,
payloadType=101,
parameters={"0-15": None},
),
],
)
self.assertEqual(
d.media[0].rtp.headerExtensions,
[
RTCRtpHeaderExtensionParameters(
id=1, uri="urn:ietf:params:rtp-hdrext:ssrc-audio-level"
),
RTCRtpHeaderExtensionParameters(
id=2, uri="urn:ietf:params:rtp-hdrext:sdes:mid"
),
],
)
self.assertEqual(d.media[0].rtp.muxId, "sdparta_0")
self.assertEqual(d.media[0].rtcp_host, "192.168.99.58")
self.assertEqual(d.media[0].rtcp_port, 38612)
self.assertEqual(d.media[0].rtcp_mux, True)
self.assertEqual(
d.webrtc_track_id(d.media[0]), "{12692dea-686c-47ca-b3e9-48f38fc92b78}"
)
# ssrc
self.assertEqual(
d.media[0].ssrc,
[
SsrcDescription(
ssrc=882128807, cname="{ed463ac5-dabf-44d4-8b9f-e14318427b2b}"
)
],
)
self.assertEqual(d.media[0].ssrc_group, [])
# formats
self.assertEqual(d.media[0].fmt, [109, 9, 0, 8, 101])
self.assertEqual(d.media[0].sctpmap, {})
self.assertEqual(d.media[0].sctp_port, None)
# ice
self.assertEqual(len(d.media[0].ice_candidates), 10)
self.assertEqual(d.media[0].ice_candidates_complete, True)
self.assertEqual(d.media[0].ice_options, "trickle")
self.assertEqual(d.media[0].ice.iceLite, False)
self.assertEqual(d.media[0].ice.usernameFragment, "403a81e1")
self.assertEqual(d.media[0].ice.password, "f9b83487285016f7492197a5790ceee5")
# dtls
self.assertEqual(len(d.media[0].dtls.fingerprints), 1)
self.assertEqual(d.media[0].dtls.fingerprints[0].algorithm, "sha-256")
self.assertEqual(
d.media[0].dtls.fingerprints[0].value,
"EB:A9:3E:50:D7:E3:B3:86:0F:7B:01:C1:EB:D6:AF:E4:97:DE:15:05:A8:DE:7B:83:56:C7:4B:6E:9D:75:D4:17",
)
self.assertEqual(d.media[0].dtls.role, "auto")
self.assertEqual(
str(d),
lf2crlf(
"""v=0
o=mozilla...THIS_IS_SDPARTA-58.0.1 4934139885953732403 1 IN IP4 0.0.0.0
s=-
t=0 0
a=group:BUNDLE sdparta_0
a=msid-semantic:WMS *
m=audio 45274 UDP/TLS/RTP/SAVPF 109 9 0 8 101
c=IN IP4 192.168.99.58
a=sendrecv
a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level
a=extmap:2 urn:ietf:params:rtp-hdrext:sdes:mid
a=mid:sdparta_0
a=msid:{dee771c7-671a-451e-b847-f86f8e87c7d8} {12692dea-686c-47ca-b3e9-48f38fc92b78}
a=rtcp:38612 IN IP4 192.168.99.58
a=rtcp-mux
a=ssrc:882128807 cname:{ed463ac5-dabf-44d4-8b9f-e14318427b2b}
a=rtpmap:109 opus/48000/2
a=fmtp:109 maxplaybackrate=48000;stereo=1;useinbandfec=1
a=rtpmap:9 G722/8000
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000
a=rtpmap:101 telephone-event/8000
a=fmtp:101 0-15
a=candidate:0 1 UDP 2122187007 192.168.99.58 45274 typ host
a=candidate:2 1 UDP 2122252543 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 47387 typ host
a=candidate:3 1 TCP 2105458943 192.168.99.58 9 typ host tcptype active
a=candidate:4 1 TCP 2105524479 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 9 typ host tcptype active
a=candidate:0 2 UDP 2122187006 192.168.99.58 38612 typ host
a=candidate:2 2 UDP 2122252542 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 54301 typ host
a=candidate:3 2 TCP 2105458942 192.168.99.58 9 typ host tcptype active
a=candidate:4 2 TCP 2105524478 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 9 typ host tcptype active
a=candidate:1 1 UDP 1685921791 1.2.3.4 37264 typ srflx raddr 192.168.99.58 rport 37264
a=candidate:1 2 UDP 1685921790 1.2.3.4 52902 typ srflx raddr 192.168.99.58 rport 52902
a=end-of-candidates
a=ice-ufrag:403a81e1
a=ice-pwd:f9b83487285016f7492197a5790ceee5
a=ice-options:trickle
a=fingerprint:sha-256 EB:A9:3E:50:D7:E3:B3:86:0F:7B:01:C1:EB:D6:AF:E4:97:DE:15:05:A8:DE:7B:83:56:C7:4B:6E:9D:75:D4:17
a=setup:actpass
"""
),
)
def test_audio_freeswitch(self):
d = SessionDescription.parse(
lf2crlf(
"""v=0
o=FreeSWITCH 1538380016 1538380017 IN IP4 1.2.3.4
s=FreeSWITCH
c=IN IP4 1.2.3.4
t=0 0
a=msid-semantic: WMS lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys
m=audio 16628 UDP/TLS/RTP/SAVPF 8 101
a=rtpmap:8 PCMA/8000
a=rtpmap:101 telephone-event/8000
a=ptime:20
a=fingerprint:sha-256 35:5A:BC:8E:CD:F8:CD:EB:36:00:BB:C4:C3:33:54:B5:9B:70:3C:E9:C4:33:8F:39:3C:4B:5B:5C:AD:88:12:2B
a=setup:active
a=rtcp-mux
a=rtcp:16628 IN IP4 1.2.3.4
a=ice-ufrag:75EDuLTEOkEUd3cu
a=ice-pwd:5dvb9SbfooWc49814CupdeTS
a=candidate:0560693492 1 udp 659136 1.2.3.4 16628 typ host generation 0
a=end-of-candidates
a=ssrc:2690029308 cname:rbaag6w9fGmRXQm6
a=ssrc:2690029308 msid:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys a0
a=ssrc:2690029308 mslabel:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys
a=ssrc:2690029308 label:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ysa0"""
)
)
self.assertEqual(d.group, [])
self.assertEqual(
d.msid_semantic,
[
GroupDescription(
semantic="WMS", items=["lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys"]
)
],
)
self.assertEqual(d.host, "1.2.3.4")
self.assertEqual(d.name, "FreeSWITCH")
self.assertEqual(d.origin, "FreeSWITCH 1538380016 1538380017 IN IP4 1.2.3.4")
self.assertEqual(d.time, "0 0")
self.assertEqual(d.version, 0)
self.assertEqual(len(d.media), 1)
self.assertEqual(d.media[0].kind, "audio")
self.assertEqual(d.media[0].host, None)
self.assertEqual(d.media[0].port, 16628)
self.assertEqual(d.media[0].profile, "UDP/TLS/RTP/SAVPF")
self.assertEqual(d.media[0].direction, None)
self.assertEqual(
d.media[0].rtp.codecs,
[
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
RTCRtpCodecParameters(
mimeType="audio/telephone-event",
clockRate=8000,
channels=1,
payloadType=101,
),
],
)
self.assertEqual(d.media[0].rtp.headerExtensions, [])
self.assertEqual(d.media[0].rtp.muxId, "")
self.assertEqual(d.media[0].rtcp_host, "1.2.3.4")
self.assertEqual(d.media[0].rtcp_port, 16628)
self.assertEqual(d.media[0].rtcp_mux, True)
# ssrc
self.assertEqual(
d.media[0].ssrc,
[
SsrcDescription(
ssrc=2690029308,
cname="rbaag6w9fGmRXQm6",
msid="lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys a0",
mslabel="lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys",
label="lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ysa0",
)
],
)
self.assertEqual(d.media[0].ssrc_group, [])
# formats
self.assertEqual(d.media[0].fmt, [8, 101])
self.assertEqual(d.media[0].sctpmap, {})
self.assertEqual(d.media[0].sctp_port, None)
# ice
self.assertEqual(len(d.media[0].ice_candidates), 1)
self.assertEqual(d.media[0].ice_candidates_complete, True)
self.assertEqual(d.media[0].ice_options, None)
self.assertEqual(d.media[0].ice.iceLite, False)
self.assertEqual(d.media[0].ice.usernameFragment, "75EDuLTEOkEUd3cu")
self.assertEqual(d.media[0].ice.password, "5dvb9SbfooWc49814CupdeTS")
# dtls
self.assertEqual(len(d.media[0].dtls.fingerprints), 1)
self.assertEqual(d.media[0].dtls.fingerprints[0].algorithm, "sha-256")
self.assertEqual(
d.media[0].dtls.fingerprints[0].value,
"35:5A:BC:8E:CD:F8:CD:EB:36:00:BB:C4:C3:33:54:B5:9B:70:3C:E9:C4:33:8F:39:3C:4B:5B:5C:AD:88:12:2B",
)
self.assertEqual(d.media[0].dtls.role, "client")
self.assertEqual(
str(d),
lf2crlf(
"""v=0
o=FreeSWITCH 1538380016 1538380017 IN IP4 1.2.3.4
s=FreeSWITCH
c=IN IP4 1.2.3.4
t=0 0
a=msid-semantic:WMS lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys
m=audio 16628 UDP/TLS/RTP/SAVPF 8 101
a=rtcp:16628 IN IP4 1.2.3.4
a=rtcp-mux
a=ssrc:2690029308 cname:rbaag6w9fGmRXQm6
a=ssrc:2690029308 msid:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys a0
a=ssrc:2690029308 mslabel:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys
a=ssrc:2690029308 label:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ysa0
a=rtpmap:8 PCMA/8000
a=rtpmap:101 telephone-event/8000
a=candidate:0560693492 1 udp 659136 1.2.3.4 16628 typ host
a=end-of-candidates
a=ice-ufrag:75EDuLTEOkEUd3cu
a=ice-pwd:5dvb9SbfooWc49814CupdeTS
a=fingerprint:sha-256 35:5A:BC:8E:CD:F8:CD:EB:36:00:BB:C4:C3:33:54:B5:9B:70:3C:E9:C4:33:8F:39:3C:4B:5B:5C:AD:88:12:2B
a=setup:active
"""
),
)
def test_audio_freeswitch_no_dtls(self):
d = SessionDescription.parse(
lf2crlf(
"""v=0
o=FreeSWITCH 1538380016 1538380017 IN IP4 1.2.3.4
s=FreeSWITCH
c=IN IP4 1.2.3.4
t=0 0
a=msid-semantic: WMS lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys
m=audio 16628 UDP/TLS/RTP/SAVPF 8 101
a=rtpmap:8 PCMA/8000
a=rtpmap:101 telephone-event/8000
a=ptime:20
a=rtcp-mux
a=rtcp:16628 IN IP4 1.2.3.4
a=ice-ufrag:75EDuLTEOkEUd3cu
a=ice-pwd:5dvb9SbfooWc49814CupdeTS
a=candidate:0560693492 1 udp 659136 1.2.3.4 16628 typ host generation 0
a=end-of-candidates
a=ssrc:2690029308 cname:rbaag6w9fGmRXQm6
a=ssrc:2690029308 msid:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys a0
a=ssrc:2690029308 mslabel:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys
a=ssrc:2690029308 label:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ysa0"""
)
)
self.assertEqual(d.group, [])
self.assertEqual(
d.msid_semantic,
[
GroupDescription(
semantic="WMS", items=["lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys"]
)
],
)
self.assertEqual(d.host, "1.2.3.4")
self.assertEqual(d.name, "FreeSWITCH")
self.assertEqual(d.origin, "FreeSWITCH 1538380016 1538380017 IN IP4 1.2.3.4")
self.assertEqual(d.time, "0 0")
self.assertEqual(d.version, 0)
self.assertEqual(len(d.media), 1)
self.assertEqual(d.media[0].kind, "audio")
self.assertEqual(d.media[0].host, None)
self.assertEqual(d.media[0].port, 16628)
self.assertEqual(d.media[0].profile, "UDP/TLS/RTP/SAVPF")
self.assertEqual(d.media[0].direction, None)
self.assertEqual(
d.media[0].rtp.codecs,
[
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
RTCRtpCodecParameters(
mimeType="audio/telephone-event",
clockRate=8000,
channels=1,
payloadType=101,
),
],
)
self.assertEqual(d.media[0].rtp.headerExtensions, [])
self.assertEqual(d.media[0].rtp.muxId, "")
self.assertEqual(d.media[0].rtcp_host, "1.2.3.4")
self.assertEqual(d.media[0].rtcp_port, 16628)
self.assertEqual(d.media[0].rtcp_mux, True)
# ssrc
self.assertEqual(
d.media[0].ssrc,
[
SsrcDescription(
ssrc=2690029308,
cname="rbaag6w9fGmRXQm6",
msid="lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys a0",
mslabel="lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys",
label="lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ysa0",
)
],
)
self.assertEqual(d.media[0].ssrc_group, [])
# formats
self.assertEqual(d.media[0].fmt, [8, 101])
self.assertEqual(d.media[0].sctpmap, {})
self.assertEqual(d.media[0].sctp_port, None)
# ice
self.assertEqual(len(d.media[0].ice_candidates), 1)
self.assertEqual(d.media[0].ice_candidates_complete, True)
self.assertEqual(d.media[0].ice_options, None)
self.assertEqual(d.media[0].ice.iceLite, False)
self.assertEqual(d.media[0].ice.usernameFragment, "75EDuLTEOkEUd3cu")
self.assertEqual(d.media[0].ice.password, "5dvb9SbfooWc49814CupdeTS")
# dtls
self.assertEqual(d.media[0].dtls, None)
self.assertEqual(
str(d),
lf2crlf(
"""v=0
o=FreeSWITCH 1538380016 1538380017 IN IP4 1.2.3.4
s=FreeSWITCH
c=IN IP4 1.2.3.4
t=0 0
a=msid-semantic:WMS lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys
m=audio 16628 UDP/TLS/RTP/SAVPF 8 101
a=rtcp:16628 IN IP4 1.2.3.4
a=rtcp-mux
a=ssrc:2690029308 cname:rbaag6w9fGmRXQm6
a=ssrc:2690029308 msid:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys a0
a=ssrc:2690029308 mslabel:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ys
a=ssrc:2690029308 label:lyNSTe6w2ijnMrDEiqTHFyhqjdAag3ysa0
a=rtpmap:8 PCMA/8000
a=rtpmap:101 telephone-event/8000
a=candidate:0560693492 1 udp 659136 1.2.3.4 16628 typ host
a=end-of-candidates
a=ice-ufrag:75EDuLTEOkEUd3cu
a=ice-pwd:5dvb9SbfooWc49814CupdeTS
"""
),
)
def test_audio_dtls_session_level(self):
d = SessionDescription.parse(
lf2crlf(
"""v=0
o=- 863426017819471768 2 IN IP4 127.0.0.1
s=-
t=0 0
a=fingerprint:sha-256 6B:8B:5D:EA:59:04:20:23:29:C8:87:1C:CC:87:32:BE:DD:8C:66:A5:8E:50:55:EA:8C:D3:B6:5C:09:5E:D6:BC
a=setup:actpass
m=audio 45076 UDP/TLS/RTP/SAVPF 0 8
c=IN IP4 192.168.99.58
a=rtcp:9 IN IP4 0.0.0.0
a=candidate:2665802302 1 udp 2122262783 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 38475 typ host generation 0 network-id 2 network-cost 10
a=candidate:1039001212 1 udp 2122194687 192.168.99.58 45076 typ host generation 0 network-id 1 network-cost 10
a=ice-ufrag:5+Ix
a=ice-pwd:uK8IlylxzDMUhrkVzdmj0M+v
a=mid:audio
a=sendrecv
a=rtcp-mux
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000"""
)
)
self.assertEqual(d.group, [])
self.assertEqual(d.msid_semantic, [])
self.assertEqual(d.host, None)
self.assertEqual(d.name, "-")
self.assertEqual(d.origin, "- 863426017819471768 2 IN IP4 127.0.0.1")
self.assertEqual(d.time, "0 0")
self.assertEqual(d.version, 0)
self.assertEqual(len(d.media), 1)
self.assertEqual(d.media[0].kind, "audio")
self.assertEqual(d.media[0].host, "192.168.99.58")
self.assertEqual(d.media[0].port, 45076)
self.assertEqual(d.media[0].profile, "UDP/TLS/RTP/SAVPF")
self.assertEqual(d.media[0].direction, "sendrecv")
self.assertEqual(d.media[0].msid, None)
self.assertEqual(
d.media[0].rtp.codecs,
[
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, channels=1, payloadType=0
),
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
],
)
self.assertEqual(d.media[0].rtp.headerExtensions, [])
self.assertEqual(d.media[0].rtp.muxId, "audio")
self.assertEqual(d.media[0].rtcp_host, "0.0.0.0")
self.assertEqual(d.media[0].rtcp_port, 9)
self.assertEqual(d.media[0].rtcp_mux, True)
# ssrc
self.assertEqual(d.media[0].ssrc, [])
self.assertEqual(d.media[0].ssrc_group, [])
# formats
self.assertEqual(d.media[0].fmt, [0, 8])
self.assertEqual(d.media[0].sctpmap, {})
self.assertEqual(d.media[0].sctp_port, None)
# ice
self.assertEqual(len(d.media[0].ice_candidates), 2)
self.assertEqual(d.media[0].ice_candidates_complete, False)
self.assertEqual(d.media[0].ice_options, None)
self.assertEqual(d.media[0].ice.iceLite, False)
self.assertEqual(d.media[0].ice.usernameFragment, "5+Ix")
self.assertEqual(d.media[0].ice.password, "uK8IlylxzDMUhrkVzdmj0M+v")
# dtls
self.assertEqual(len(d.media[0].dtls.fingerprints), 1)
self.assertEqual(d.media[0].dtls.fingerprints[0].algorithm, "sha-256")
self.assertEqual(
d.media[0].dtls.fingerprints[0].value,
"6B:8B:5D:EA:59:04:20:23:29:C8:87:1C:CC:87:32:BE:DD:8C:66:A5:8E:50:55:EA:8C:D3:B6:5C:09:5E:D6:BC",
)
self.assertEqual(d.media[0].dtls.role, "auto")
self.assertEqual(
str(d),
lf2crlf(
"""v=0
o=- 863426017819471768 2 IN IP4 127.0.0.1
s=-
t=0 0
m=audio 45076 UDP/TLS/RTP/SAVPF 0 8
c=IN IP4 192.168.99.58
a=sendrecv
a=mid:audio
a=rtcp:9 IN IP4 0.0.0.0
a=rtcp-mux
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000
a=candidate:2665802302 1 udp 2122262783 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 38475 typ host
a=candidate:1039001212 1 udp 2122194687 192.168.99.58 45076 typ host
a=ice-ufrag:5+Ix
a=ice-pwd:uK8IlylxzDMUhrkVzdmj0M+v
a=fingerprint:sha-256 6B:8B:5D:EA:59:04:20:23:29:C8:87:1C:CC:87:32:BE:DD:8C:66:A5:8E:50:55:EA:8C:D3:B6:5C:09:5E:D6:BC
a=setup:actpass
"""
),
)
def test_audio_ice_lite(self):
d = SessionDescription.parse(
lf2crlf(
"""v=0
o=- 863426017819471768 2 IN IP4 127.0.0.1
s=-
t=0 0
a=ice-lite
m=audio 45076 UDP/TLS/RTP/SAVPF 0 8
c=IN IP4 192.168.99.58
a=rtcp:9 IN IP4 0.0.0.0
a=candidate:2665802302 1 udp 2122262783 2a02:a03f:3eb0:e000:b0aa:d60a:cff2:933c 38475 typ host generation 0 network-id 2 network-cost 10
a=candidate:1039001212 1 udp 2122194687 192.168.99.58 45076 typ host generation 0 network-id 1 network-cost 10
a=ice-ufrag:5+Ix
a=ice-pwd:uK8IlylxzDMUhrkVzdmj0M+v
a=fingerprint:sha-256 6B:8B:5D:EA:59:04:20:23:29:C8:87:1C:CC:87:32:BE:DD:8C:66:A5:8E:50:55:EA:8C:D3:B6:5C:09:5E:D6:BC
a=setup:actpass
a=mid:audio
a=sendrecv
a=rtcp-mux
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000"""
)
)
self.assertEqual(d.group, [])
self.assertEqual(d.msid_semantic, [])
self.assertEqual(d.host, None)
self.assertEqual(d.name, "-")
self.assertEqual(d.origin, "- 863426017819471768 2 IN IP4 127.0.0.1")
self.assertEqual(d.time, "0 0")
self.assertEqual(d.version, 0)
self.assertEqual(len(d.media), 1)
self.assertEqual(d.media[0].kind, "audio")
self.assertEqual(d.media[0].host, "192.168.99.58")
self.assertEqual(d.media[0].port, 45076)
self.assertEqual(d.media[0].profile, "UDP/TLS/RTP/SAVPF")
self.assertEqual(d.media[0].direction, "sendrecv")
self.assertEqual(d.media[0].msid, None)
self.assertEqual(
d.media[0].rtp.codecs,
[
RTCRtpCodecParameters(
mimeType="audio/PCMU", clockRate=8000, channels=1, payloadType=0
),
RTCRtpCodecParameters(
mimeType="audio/PCMA", clockRate=8000, channels=1, payloadType=8
),
],
)
self.assertEqual(d.media[0].rtp.headerExtensions, [])
self.assertEqual(d.media[0].rtp.muxId, "audio")
self.assertEqual(d.media[0].rtcp_host, "0.0.0.0")
self.assertEqual(d.media[0].rtcp_port, 9)
self.assertEqual(d.media[0].rtcp_mux, True)
# ssrc
| 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/aiortc/tests/test_rtcrtpsender.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtcrtpsender.py | import asyncio
from struct import pack
from unittest import TestCase
from unittest.mock import patch
from aiortc import MediaStreamTrack
from aiortc.codecs import PCMU_CODEC
from aiortc.exceptions import InvalidStateError
from aiortc.mediastreams import AudioStreamTrack, VideoStreamTrack
from aiortc.rtcrtpparameters import (
RTCRtpCapabilities,
RTCRtpCodecCapability,
RTCRtpCodecParameters,
RTCRtpHeaderExtensionCapability,
RTCRtpParameters,
)
from aiortc.rtcrtpsender import RTCRtpSender
from aiortc.rtp import (
RTCP_PSFB_APP,
RTCP_PSFB_PLI,
RTCP_RTPFB_NACK,
RtcpPsfbPacket,
RtcpReceiverInfo,
RtcpRrPacket,
RtcpRtpfbPacket,
RtpPacket,
is_rtcp,
pack_remb_fci,
)
from aiortc.stats import RTCStatsReport
from tests.test_mediastreams import VideoPacketStreamTrack
from .utils import ClosedDtlsTransport, asynctest, dummy_dtls_transport_pair
VP8_CODEC = RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=100
)
H264_CODEC = RTCRtpCodecParameters(
mimeType="video/H264", clockRate=90000, payloadType=98
)
class BuggyStreamTrack(MediaStreamTrack):
kind = "audio"
async def recv(self):
raise Exception("I'm a buggy track!")
class RTCRtpSenderTest(TestCase):
def test_capabilities(self):
# audio
capabilities = RTCRtpSender.getCapabilities("audio")
self.assertIsInstance(capabilities, RTCRtpCapabilities)
self.assertEqual(
capabilities.codecs,
[
RTCRtpCodecCapability(
mimeType="audio/opus", clockRate=48000, channels=2
),
RTCRtpCodecCapability(
mimeType="audio/PCMU", clockRate=8000, channels=1
),
RTCRtpCodecCapability(
mimeType="audio/PCMA", clockRate=8000, channels=1
),
],
)
self.assertEqual(
capabilities.headerExtensions,
[
RTCRtpHeaderExtensionCapability(
uri="urn:ietf:params:rtp-hdrext:sdes:mid"
),
RTCRtpHeaderExtensionCapability(
uri="urn:ietf:params:rtp-hdrext:ssrc-audio-level"
),
],
)
# video
capabilities = RTCRtpSender.getCapabilities("video")
self.assertIsInstance(capabilities, RTCRtpCapabilities)
self.assertEqual(
capabilities.codecs,
[
RTCRtpCodecCapability(mimeType="video/VP8", clockRate=90000),
RTCRtpCodecCapability(mimeType="video/rtx", clockRate=90000),
RTCRtpCodecCapability(
mimeType="video/H264",
clockRate=90000,
parameters={
"level-asymmetry-allowed": "1",
"packetization-mode": "1",
"profile-level-id": "42001f",
},
),
RTCRtpCodecCapability(
mimeType="video/H264",
clockRate=90000,
parameters={
"level-asymmetry-allowed": "1",
"packetization-mode": "1",
"profile-level-id": "42e01f",
},
),
],
)
self.assertEqual(
capabilities.headerExtensions,
[
RTCRtpHeaderExtensionCapability(
uri="urn:ietf:params:rtp-hdrext:sdes:mid"
),
RTCRtpHeaderExtensionCapability(
uri="http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time"
),
],
)
# bogus
with self.assertRaises(ValueError):
RTCRtpSender.getCapabilities("bogus")
@asynctest
async def test_construct(self):
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender("audio", local_transport)
self.assertEqual(sender.kind, "audio")
self.assertEqual(sender.transport, local_transport)
def test_construct_invalid_dtls_transport_state(self):
dtlsTransport = ClosedDtlsTransport()
with self.assertRaises(InvalidStateError):
RTCRtpSender("audio", dtlsTransport)
@asynctest
async def test_connection_error(self):
"""
Close the underlying transport before the sender.
"""
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender(AudioStreamTrack(), local_transport)
self.assertEqual(sender.kind, "audio")
await sender.send(RTCRtpParameters(codecs=[PCMU_CODEC]))
await local_transport.stop()
@asynctest
async def test_handle_rtcp_nack(self):
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender(VideoStreamTrack(), local_transport)
self.assertEqual(sender.kind, "video")
await sender.send(RTCRtpParameters(codecs=[VP8_CODEC]))
# receive RTCP feedback NACK
packet = RtcpRtpfbPacket(
fmt=RTCP_RTPFB_NACK, ssrc=1234, media_ssrc=sender._ssrc
)
packet.lost.append(7654)
await sender._handle_rtcp_packet(packet)
# clean shutdown
await sender.stop()
@asynctest
async def test_handle_rtcp_pli(self):
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender(VideoStreamTrack(), local_transport)
self.assertEqual(sender.kind, "video")
await sender.send(RTCRtpParameters(codecs=[VP8_CODEC]))
# receive RTCP feedback NACK
packet = RtcpPsfbPacket(
fmt=RTCP_PSFB_PLI, ssrc=1234, media_ssrc=sender._ssrc
)
await sender._handle_rtcp_packet(packet)
# clean shutdown
await sender.stop()
@asynctest
async def test_handle_rtcp_remb(self):
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender(VideoStreamTrack(), local_transport)
self.assertEqual(sender.kind, "video")
await sender.send(RTCRtpParameters(codecs=[VP8_CODEC]))
# receive RTCP feedback REMB
packet = RtcpPsfbPacket(
fmt=RTCP_PSFB_APP,
ssrc=1234,
media_ssrc=0,
fci=pack_remb_fci(4160000, [sender._ssrc]),
)
await sender._handle_rtcp_packet(packet)
# receive RTCP feedback REMB (malformed)
packet = RtcpPsfbPacket(
fmt=RTCP_PSFB_APP, ssrc=1234, media_ssrc=0, fci=b"JUNK"
)
await sender._handle_rtcp_packet(packet)
# clean shutdown
await sender.stop()
@asynctest
async def test_handle_rtcp_rr(self):
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender(VideoStreamTrack(), local_transport)
self.assertEqual(sender.kind, "video")
await sender.send(RTCRtpParameters(codecs=[VP8_CODEC]))
# receive RTCP RR
packet = RtcpRrPacket(
ssrc=1234,
reports=[
RtcpReceiverInfo(
ssrc=sender._ssrc,
fraction_lost=0,
packets_lost=0,
highest_sequence=630,
jitter=1906,
lsr=0,
dlsr=0,
)
],
)
await sender._handle_rtcp_packet(packet)
# check stats
report = await sender.getStats()
self.assertIsInstance(report, RTCStatsReport)
self.assertEqual(
sorted([s.type for s in report.values()]),
["outbound-rtp", "remote-inbound-rtp", "transport"],
)
# clean shutdown
await sender.stop()
@patch("aiortc.rtcrtpsender.logger.isEnabledFor")
@asynctest
async def test_log_debug(self, mock_is_enabled_for):
mock_is_enabled_for.return_value = True
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender(VideoStreamTrack(), local_transport)
await sender.send(RTCRtpParameters(codecs=[VP8_CODEC]))
# clean shutdown
await sender.stop()
@asynctest
async def test_send_keyframe(self):
"""
Ask for a keyframe.
"""
queue = asyncio.Queue()
async def mock_send_rtp(data):
if not is_rtcp(data):
await queue.put(RtpPacket.parse(data))
async with dummy_dtls_transport_pair() as (local_transport, _):
local_transport._send_rtp = mock_send_rtp
sender = RTCRtpSender(VideoStreamTrack(), local_transport)
self.assertEqual(sender.kind, "video")
await sender.send(RTCRtpParameters(codecs=[VP8_CODEC]))
# wait for one packet to be transmitted, and ask for keyframe
await queue.get()
sender._send_keyframe()
# wait for packet to be transmitted, then shutdown
await asyncio.sleep(0.1)
await sender.stop()
@asynctest
async def test_handle_encoded_packet(self):
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender(VideoPacketStreamTrack(), local_transport)
self.assertEqual(sender.kind, "video")
await sender.send(RTCRtpParameters(codecs=[H264_CODEC]))
# wait for cleanup
await asyncio.sleep(0.1)
await sender.stop()
@asynctest
async def test_retransmit(self):
"""
Ask for an RTP packet retransmission.
"""
queue = asyncio.Queue()
async def mock_send_rtp(data):
if not is_rtcp(data):
await queue.put(RtpPacket.parse(data))
async with dummy_dtls_transport_pair() as (local_transport, _):
local_transport._send_rtp = mock_send_rtp
sender = RTCRtpSender(VideoStreamTrack(), local_transport)
sender._ssrc = 1234
self.assertEqual(sender.kind, "video")
await sender.send(RTCRtpParameters(codecs=[VP8_CODEC]))
# wait for one packet to be transmitted, and ask to retransmit
packet = await queue.get()
await sender._retransmit(packet.sequence_number)
# wait for packet to be retransmitted, then shutdown
await asyncio.sleep(0.1)
await sender.stop()
# check packet was retransmitted
found_rtx = None
while not queue.empty():
queue_packet = queue.get_nowait()
if queue_packet.sequence_number == packet.sequence_number:
found_rtx = queue_packet
break
self.assertIsNotNone(found_rtx)
self.assertEqual(found_rtx.payload_type, 100)
self.assertEqual(found_rtx.ssrc, 1234)
@asynctest
async def test_retransmit_with_rtx(self):
"""
Ask for an RTP packet retransmission.
"""
queue = asyncio.Queue()
async def mock_send_rtp(data):
if not is_rtcp(data):
await queue.put(RtpPacket.parse(data))
async with dummy_dtls_transport_pair() as (local_transport, _):
local_transport._send_rtp = mock_send_rtp
sender = RTCRtpSender(VideoStreamTrack(), local_transport)
sender._ssrc = 1234
sender._rtx_ssrc = 2345
self.assertEqual(sender.kind, "video")
await sender.send(
RTCRtpParameters(
codecs=[
VP8_CODEC,
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=101,
parameters={"apt": 100},
),
]
)
)
# wait for one packet to be transmitted, and ask to retransmit
packet = await queue.get()
await sender._retransmit(packet.sequence_number)
# wait for packet to be retransmitted, then shutdown
await asyncio.sleep(0.1)
await sender.stop()
# check packet was retransmitted
found_rtx = None
while not queue.empty():
queue_packet = queue.get_nowait()
if queue_packet.payload_type == 101:
found_rtx = queue_packet
break
self.assertIsNotNone(found_rtx)
self.assertEqual(found_rtx.payload_type, 101)
self.assertEqual(found_rtx.ssrc, 2345)
self.assertEqual(found_rtx.payload[0:2], pack("!H", packet.sequence_number))
@asynctest
async def test_stop(self):
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender(AudioStreamTrack(), local_transport)
self.assertEqual(sender.kind, "audio")
await sender.send(RTCRtpParameters(codecs=[PCMU_CODEC]))
# clean shutdown
await sender.stop()
@asynctest
async def test_stop_before_send(self):
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender(AudioStreamTrack(), local_transport)
await sender.stop()
@asynctest
async def test_stop_on_exception(self):
async with dummy_dtls_transport_pair() as (local_transport, _):
sender = RTCRtpSender(BuggyStreamTrack(), local_transport)
self.assertEqual(sender.kind, "audio")
await sender.send(RTCRtpParameters(codecs=[PCMU_CODEC]))
# clean shutdown
await sender.stop()
@asynctest
async def test_track_ended(self):
async with dummy_dtls_transport_pair() as (local_transport, _):
track = AudioStreamTrack()
sender = RTCRtpSender(track, local_transport)
await sender.send(RTCRtpParameters(codecs=[PCMU_CODEC]))
# stop track and wait for RTP loop to exit
track.stop()
await asyncio.sleep(0.1)
| 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_codecs.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_codecs.py | from unittest import TestCase
from aiortc.codecs import get_decoder, get_encoder
from aiortc.rtcrtpparameters import RTCRtpCodecParameters
BOGUS_CODEC = RTCRtpCodecParameters(
mimeType="audio/bogus", clockRate=8000, channels=1, payloadType=0
)
class CodecsTest(TestCase):
def test_get_decoder(self):
with self.assertRaises(ValueError):
get_decoder(BOGUS_CODEC)
def test_get_encoder(self):
with self.assertRaises(ValueError):
get_encoder(BOGUS_CODEC)
| 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_utils.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_utils.py | from unittest import TestCase
from aiortc.utils import (
uint16_add,
uint16_gt,
uint16_gte,
uint32_add,
uint32_gt,
uint32_gte,
)
class UtilsTest(TestCase):
def test_uint16_add(self):
self.assertEqual(uint16_add(0, 1), 1)
self.assertEqual(uint16_add(1, 1), 2)
self.assertEqual(uint16_add(1, 2), 3)
self.assertEqual(uint16_add(65534, 1), 65535)
self.assertEqual(uint16_add(65535, 1), 0)
self.assertEqual(uint16_add(65535, 3), 2)
def test_uint16_gt(self):
self.assertFalse(uint16_gt(0, 1))
self.assertFalse(uint16_gt(1, 1))
self.assertTrue(uint16_gt(2, 1))
self.assertTrue(uint16_gt(32768, 1))
self.assertFalse(uint16_gt(32769, 1))
self.assertFalse(uint16_gt(65535, 1))
def test_uint16_gte(self):
self.assertFalse(uint16_gte(0, 1))
self.assertTrue(uint16_gte(1, 1))
self.assertTrue(uint16_gte(2, 1))
self.assertTrue(uint16_gte(32768, 1))
self.assertFalse(uint16_gte(32769, 1))
self.assertFalse(uint16_gte(65535, 1))
def test_uint32_add(self):
self.assertEqual(uint32_add(0, 1), 1)
self.assertEqual(uint32_add(1, 1), 2)
self.assertEqual(uint32_add(1, 2), 3)
self.assertEqual(uint32_add(4294967294, 1), 4294967295)
self.assertEqual(uint32_add(4294967295, 1), 0)
self.assertEqual(uint32_add(4294967295, 3), 2)
def test_uint32_gt(self):
self.assertFalse(uint32_gt(0, 1))
self.assertFalse(uint32_gt(1, 1))
self.assertTrue(uint32_gt(2, 1))
self.assertTrue(uint32_gt(2147483648, 1))
self.assertFalse(uint32_gt(2147483649, 1))
self.assertFalse(uint32_gt(4294967295, 1))
def test_uint32_gte(self):
self.assertFalse(uint32_gte(0, 1))
self.assertTrue(uint32_gte(1, 1))
self.assertTrue(uint32_gte(2, 1))
self.assertTrue(uint32_gte(2147483648, 1))
self.assertFalse(uint32_gte(2147483649, 1))
self.assertFalse(uint32_gte(4294967295, 1))
| 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_contrib_media.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_contrib_media.py | import asyncio
import errno
import os
import tempfile
import time
import wave
from unittest import TestCase
from unittest.mock import patch
import av
from aiortc.contrib.media import MediaBlackhole, MediaPlayer, MediaRecorder, MediaRelay
from aiortc.mediastreams import AudioStreamTrack, MediaStreamError, VideoStreamTrack
from .codecs import CodecTestCase
from .utils import asynctest
class VideoStreamTrackUhd(VideoStreamTrack):
async def recv(self):
pts, time_base = await self.next_timestamp()
frame = av.VideoFrame(width=3840, height=2160)
for p in frame.planes:
p.update(bytes(p.buffer_size))
frame.pts = pts
frame.time_base = time_base
return frame
class MediaTestCase(CodecTestCase):
def setUp(self):
self.directory = tempfile.TemporaryDirectory()
def tearDown(self):
self.directory.cleanup()
def create_audio_file(self, name, channels=1, sample_rate=8000, sample_width=2):
path = self.temporary_path(name)
writer = wave.open(path, "wb")
writer.setnchannels(channels)
writer.setframerate(sample_rate)
writer.setsampwidth(sample_width)
writer.writeframes(b"\x00" * sample_rate * sample_width * channels)
writer.close()
return path
def create_audio_and_video_file(
self, name, width=640, height=480, video_rate=30, duration=1
):
path = self.temporary_path(name)
audio_pts = 0
audio_rate = 48000
audio_samples = audio_rate // video_rate
container = av.open(path, "w")
audio_stream = container.add_stream("libopus", rate=audio_rate)
video_stream = container.add_stream("h264", rate=video_rate)
for video_frame in self.create_video_frames(
width=width, height=height, count=duration * video_rate
):
audio_frame = self.create_audio_frame(
samples=audio_samples, pts=audio_pts, sample_rate=audio_rate
)
audio_pts += audio_samples
for packet in audio_stream.encode(audio_frame):
container.mux(packet)
for packet in video_stream.encode(video_frame):
container.mux(packet)
for packet in audio_stream.encode(None):
container.mux(packet)
for packet in video_stream.encode(None):
container.mux(packet)
container.close()
return path
def create_video_file(self, name, width=640, height=480, rate=30, duration=1):
path = self.temporary_path(name)
container = av.open(path, "w")
if name.endswith(".png"):
stream = container.add_stream("png", rate=rate)
stream.pix_fmt = "rgb24"
elif name.endswith(".ts"):
stream = container.add_stream("h264", rate=rate)
else:
assert name.endswith(".mp4")
stream = container.add_stream("mpeg4", rate=rate)
for frame in self.create_video_frames(
width=width, height=height, count=duration * rate
):
for packet in stream.encode(frame):
container.mux(packet)
for packet in stream.encode(None):
container.mux(packet)
container.close()
return path
def temporary_path(self, name):
return os.path.join(self.directory.name, name)
class MediaBlackholeTest(TestCase):
@asynctest
async def test_audio(self):
recorder = MediaBlackhole()
recorder.addTrack(AudioStreamTrack())
await recorder.start()
await asyncio.sleep(1)
await recorder.stop()
@asynctest
async def test_audio_ended(self):
track = AudioStreamTrack()
recorder = MediaBlackhole()
recorder.addTrack(track)
await recorder.start()
await asyncio.sleep(1)
track.stop()
await asyncio.sleep(1)
await recorder.stop()
@asynctest
async def test_audio_and_video(self):
recorder = MediaBlackhole()
recorder.addTrack(AudioStreamTrack())
recorder.addTrack(VideoStreamTrack())
await recorder.start()
await asyncio.sleep(2)
await recorder.stop()
@asynctest
async def test_video(self):
recorder = MediaBlackhole()
recorder.addTrack(VideoStreamTrack())
await recorder.start()
await asyncio.sleep(2)
await recorder.stop()
@asynctest
async def test_video_ended(self):
track = VideoStreamTrack()
recorder = MediaBlackhole()
recorder.addTrack(track)
await recorder.start()
await asyncio.sleep(1)
track.stop()
await asyncio.sleep(1)
await recorder.stop()
class MediaRelayTest(MediaTestCase):
@asynctest
async def test_audio_stop_consumer(self):
source = AudioStreamTrack()
relay = MediaRelay()
proxy1 = relay.subscribe(source)
proxy2 = relay.subscribe(source)
# read some frames
samples_per_frame = 160
for pts in range(0, 2 * samples_per_frame, samples_per_frame):
frame1, frame2 = await asyncio.gather(proxy1.recv(), proxy2.recv())
self.assertEqual(frame1.format.name, "s16")
self.assertEqual(frame1.layout.name, "mono")
self.assertEqual(frame1.pts, pts)
self.assertEqual(frame1.samples, samples_per_frame)
self.assertEqual(frame2.format.name, "s16")
self.assertEqual(frame2.layout.name, "mono")
self.assertEqual(frame2.pts, pts)
self.assertEqual(frame2.samples, samples_per_frame)
# stop a consumer
proxy1.stop()
# continue reading
for i in range(2):
exc1, frame2 = await asyncio.gather(
proxy1.recv(), proxy2.recv(), return_exceptions=True
)
self.assertIsInstance(exc1, MediaStreamError)
self.assertIsInstance(frame2, av.AudioFrame)
# stop source track
source.stop()
@asynctest
async def test_audio_stop_consumer_unbuffered(self):
source = AudioStreamTrack()
relay = MediaRelay()
proxy1 = relay.subscribe(source, buffered=False)
proxy2 = relay.subscribe(source, buffered=False)
# read some frames
samples_per_frame = 160
for pts in range(0, 2 * samples_per_frame, samples_per_frame):
frame1, frame2 = await asyncio.gather(proxy1.recv(), proxy2.recv())
self.assertEqual(frame1.format.name, "s16")
self.assertEqual(frame1.layout.name, "mono")
self.assertEqual(frame1.pts, pts)
self.assertEqual(frame1.samples, samples_per_frame)
self.assertEqual(frame2.format.name, "s16")
self.assertEqual(frame2.layout.name, "mono")
self.assertEqual(frame2.pts, pts)
self.assertEqual(frame2.samples, samples_per_frame)
# stop a consumer
proxy1.stop()
# continue reading
for i in range(2):
exc1, frame2 = await asyncio.gather(
proxy1.recv(), proxy2.recv(), return_exceptions=True
)
self.assertIsInstance(exc1, MediaStreamError)
self.assertIsInstance(frame2, av.AudioFrame)
# stop source track
source.stop()
@asynctest
async def test_audio_stop_source(self):
source = AudioStreamTrack()
relay = MediaRelay()
proxy1 = relay.subscribe(source)
proxy2 = relay.subscribe(source)
# read some frames
samples_per_frame = 160
for pts in range(0, 2 * samples_per_frame, samples_per_frame):
frame1, frame2 = await asyncio.gather(proxy1.recv(), proxy2.recv())
self.assertEqual(frame1.format.name, "s16")
self.assertEqual(frame1.layout.name, "mono")
self.assertEqual(frame1.pts, pts)
self.assertEqual(frame1.samples, samples_per_frame)
self.assertEqual(frame2.format.name, "s16")
self.assertEqual(frame2.layout.name, "mono")
self.assertEqual(frame2.pts, pts)
self.assertEqual(frame2.samples, samples_per_frame)
# stop source track
source.stop()
# continue reading
await asyncio.gather(proxy1.recv(), proxy2.recv())
for i in range(2):
exc1, exc2 = await asyncio.gather(
proxy1.recv(), proxy2.recv(), return_exceptions=True
)
self.assertIsInstance(exc1, MediaStreamError)
self.assertIsInstance(exc2, MediaStreamError)
@asynctest
async def test_audio_stop_source_unbuffered(self):
source = AudioStreamTrack()
relay = MediaRelay()
proxy1 = relay.subscribe(source, buffered=False)
proxy2 = relay.subscribe(source, buffered=False)
# read some frames
samples_per_frame = 160
for pts in range(0, 2 * samples_per_frame, samples_per_frame):
frame1, frame2 = await asyncio.gather(proxy1.recv(), proxy2.recv())
self.assertEqual(frame1.format.name, "s16")
self.assertEqual(frame1.layout.name, "mono")
self.assertEqual(frame1.pts, pts)
self.assertEqual(frame1.samples, samples_per_frame)
self.assertEqual(frame2.format.name, "s16")
self.assertEqual(frame2.layout.name, "mono")
self.assertEqual(frame2.pts, pts)
self.assertEqual(frame2.samples, samples_per_frame)
# stop source track
source.stop()
# continue reading
for i in range(2):
exc1, exc2 = await asyncio.gather(
proxy1.recv(), proxy2.recv(), return_exceptions=True
)
self.assertIsInstance(exc1, MediaStreamError)
self.assertIsInstance(exc2, MediaStreamError)
@asynctest
async def test_audio_slow_consumer(self):
source = AudioStreamTrack()
relay = MediaRelay()
proxy1 = relay.subscribe(source, buffered=False)
proxy2 = relay.subscribe(source, buffered=False)
# read some frames
samples_per_frame = 160
for pts in range(0, 2 * samples_per_frame, samples_per_frame):
frame1, frame2 = await asyncio.gather(proxy1.recv(), proxy2.recv())
self.assertEqual(frame1.format.name, "s16")
self.assertEqual(frame1.layout.name, "mono")
self.assertEqual(frame1.pts, pts)
self.assertEqual(frame1.samples, samples_per_frame)
self.assertEqual(frame2.format.name, "s16")
self.assertEqual(frame2.layout.name, "mono")
self.assertEqual(frame2.pts, pts)
self.assertEqual(frame2.samples, samples_per_frame)
# skip some frames
timestamp = 5 * samples_per_frame
await asyncio.sleep(source._start + (timestamp / 8000) - time.time())
frame1, frame2 = await asyncio.gather(proxy1.recv(), proxy2.recv())
self.assertEqual(frame1.format.name, "s16")
self.assertEqual(frame1.layout.name, "mono")
self.assertEqual(frame1.pts, 5 * samples_per_frame)
self.assertEqual(frame1.samples, samples_per_frame)
self.assertEqual(frame2.format.name, "s16")
self.assertEqual(frame2.layout.name, "mono")
self.assertEqual(frame2.pts, 5 * samples_per_frame)
self.assertEqual(frame2.samples, samples_per_frame)
# stop a consumer
proxy1.stop()
# continue reading
for i in range(2):
exc1, frame2 = await asyncio.gather(
proxy1.recv(), proxy2.recv(), return_exceptions=True
)
self.assertIsInstance(exc1, MediaStreamError)
self.assertIsInstance(frame2, av.AudioFrame)
# stop source track
source.stop()
class BufferingInputContainer:
def __init__(self, real):
self.__failed = False
self.__real = real
def decode(self, *args, **kwargs):
# fail with EAGAIN once
if not self.__failed:
self.__failed = True
raise av.AVError(errno.EAGAIN, "EAGAIN")
return self.__real.decode(*args, **kwargs)
def demux(self, *args, **kwargs):
# fail with EAGAIN once
if not self.__failed:
self.__failed = True
raise av.AVError(errno.EAGAIN, "EAGAIN")
return self.__real.demux(*args, **kwargs)
def __getattr__(self, name):
return getattr(self.__real, name)
class MediaPlayerTest(MediaTestCase):
def assertAudio(self, frame):
self.assertEqual(frame.format.name, "s16")
self.assertEqual(frame.layout.name, "stereo")
self.assertEqual(frame.samples, 960)
self.assertEqual(frame.sample_rate, 48000)
def assertVideo(self, frame):
self.assertEqual(frame.width, 640)
self.assertEqual(frame.height, 480)
def createMediaPlayer(self, path, **kwargs):
return MediaPlayer(path, **kwargs)
def endTime(self, frame):
return frame.time + frame.samples / frame.sample_rate
@asynctest
async def test_audio_file_8kHz(self):
path = self.create_audio_file("test.wav")
player = self.createMediaPlayer(path)
if isinstance(self, MediaPlayerNoDecodeTest):
self.assertIsNone(player.audio)
self.assertIsNone(player.video)
else:
# check tracks
self.assertIsNotNone(player.audio)
self.assertIsNone(player.video)
# read all frames
self.assertEqual(player.audio.readyState, "live")
while True:
frame = await player.audio.recv()
self.assertAudio(frame)
if self.endTime(frame) >= 0.98:
break
with self.assertRaises(MediaStreamError):
await player.audio.recv()
self.assertEqual(player.audio.readyState, "ended")
# try reading again
with self.assertRaises(MediaStreamError):
await player.audio.recv()
@asynctest
async def test_audio_file_48kHz(self):
path = self.create_audio_file("test.wav", sample_rate=48000)
player = self.createMediaPlayer(path)
if isinstance(self, MediaPlayerNoDecodeTest):
self.assertIsNone(player.audio)
self.assertIsNone(player.video)
else:
# check tracks
self.assertIsNotNone(player.audio)
self.assertIsNone(player.video)
# read all frames
self.assertEqual(player.audio.readyState, "live")
while True:
frame = await player.audio.recv()
if self.endTime(frame) >= 1.0:
break
self.assertAudio(frame)
with self.assertRaises(MediaStreamError):
await player.audio.recv()
self.assertEqual(player.audio.readyState, "ended")
@asynctest
async def test_audio_file_looping(self):
path = self.create_audio_file("test.wav", sample_rate=48000)
player = self.createMediaPlayer(path, loop=True)
if isinstance(self, MediaPlayerNoDecodeTest):
self.assertIsNone(player.audio)
else:
# read all frames, then loop and re-read all frames
self.assertEqual(player.audio.readyState, "live")
for i in range(100):
frame = await player.audio.recv()
self.assertAudio(frame)
# read one more time, forcing a second loop
await player.audio.recv()
self.assertEqual(player.audio.readyState, "live")
# stop the player
player.audio.stop()
@asynctest
async def test_audio_and_video_file(self):
path = self.create_audio_and_video_file(name="test.ts", duration=5)
player = self.createMediaPlayer(path)
# check tracks
self.assertIsNotNone(player.audio)
self.assertIsNotNone(player.video)
# read some frames
self.assertEqual(player.audio.readyState, "live")
self.assertEqual(player.video.readyState, "live")
for i in range(10):
await asyncio.gather(player.audio.recv(), player.video.recv())
# stop audio track
player.audio.stop()
# continue reading
for i in range(10):
with self.assertRaises(MediaStreamError):
await player.audio.recv()
await player.video.recv()
# stop video track
player.video.stop()
# continue reading
with self.assertRaises(MediaStreamError):
await player.audio.recv()
with self.assertRaises(MediaStreamError):
await player.video.recv()
@asynctest
async def test_video_file_mp4(self):
path = self.create_video_file("test.mp4", duration=3)
player = self.createMediaPlayer(path)
if isinstance(self, MediaPlayerNoDecodeTest):
self.assertIsNone(player.audio)
self.assertIsNone(player.video)
else:
# check tracks
self.assertIsNone(player.audio)
self.assertIsNotNone(player.video)
# read all frames
self.assertEqual(player.video.readyState, "live")
for i in range(90):
frame = await player.video.recv()
self.assertVideo(frame)
with self.assertRaises(MediaStreamError):
await player.video.recv()
self.assertEqual(player.video.readyState, "ended")
@asynctest
async def test_audio_and_video_file_mpegts_eagain(self):
path = self.create_audio_and_video_file("test.ts", duration=3)
container = BufferingInputContainer(av.open(path, "r"))
with patch("av.open") as mock_open:
mock_open.return_value = container
player = self.createMediaPlayer(path)
# check tracks
self.assertIsNotNone(player.audio)
self.assertIsNotNone(player.video)
# read all frames
self.assertEqual(player.video.readyState, "live")
error_count = 0
received_count = 0
for i in range(100):
try:
frame = await player.video.recv()
self.assertVideo(frame)
received_count += 1
except MediaStreamError:
error_count += 1
break
self.assertEqual(error_count, 1)
self.assertGreaterEqual(received_count, 89)
self.assertEqual(player.video.readyState, "ended")
@asynctest
async def test_video_file_mpegts_looping(self):
path = self.create_video_file("test.ts", duration=5)
player = self.createMediaPlayer(path, loop=True)
# read all frames, then loop and re-read all frames
self.assertEqual(player.video.readyState, "live")
for i in range(100):
frame = await player.video.recv()
self.assertVideo(frame)
# read one more time, forcing a second loop
await player.video.recv()
self.assertEqual(player.video.readyState, "live")
# stop the player
player.video.stop()
@asynctest
async def test_video_file_png(self):
path = self.create_video_file("test-%3d.png", duration=3)
player = self.createMediaPlayer(path)
if isinstance(self, MediaPlayerNoDecodeTest):
self.assertIsNone(player.audio)
self.assertIsNone(player.video)
else:
# check tracks
self.assertIsNone(player.audio)
self.assertIsNotNone(player.video)
# read all frames
self.assertEqual(player.video.readyState, "live")
for i in range(90):
frame = await player.video.recv()
self.assertVideo(frame)
with self.assertRaises(MediaStreamError):
await player.video.recv()
self.assertEqual(player.video.readyState, "ended")
class MediaPlayerNoDecodeTest(MediaPlayerTest):
def assertAudio(self, packet):
self.assertIsInstance(packet, av.Packet)
def assertVideo(self, packet):
self.assertIsInstance(packet, av.Packet)
def createMediaPlayer(self, path, **kwargs):
return MediaPlayer(path, decode=False, **kwargs)
def endTime(self, packet):
return float((packet.pts + packet.duration) * packet.time_base)
class MediaRecorderTest(MediaTestCase):
@asynctest
async def test_audio_mp3(self):
path = self.temporary_path("test.mp3")
recorder = MediaRecorder(path)
recorder.addTrack(AudioStreamTrack())
await recorder.start()
await asyncio.sleep(2)
await recorder.stop()
# check output media
container = av.open(path, "r")
self.assertEqual(len(container.streams), 1)
self.assertIn(container.streams[0].codec.name, ("mp3", "mp3float"))
self.assertGreater(
float(container.streams[0].duration * container.streams[0].time_base), 0
)
@asynctest
async def test_audio_wav(self):
path = self.temporary_path("test.wav")
recorder = MediaRecorder(path)
recorder.addTrack(AudioStreamTrack())
await recorder.start()
await asyncio.sleep(2)
await recorder.stop()
# check output media
container = av.open(path, "r")
self.assertEqual(len(container.streams), 1)
self.assertEqual(container.streams[0].codec.name, "pcm_s16le")
self.assertGreater(
float(container.streams[0].duration * container.streams[0].time_base), 0
)
@asynctest
async def test_audio_wav_ended(self):
track = AudioStreamTrack()
recorder = MediaRecorder(self.temporary_path("test.wav"))
recorder.addTrack(track)
await recorder.start()
await asyncio.sleep(1)
track.stop()
await asyncio.sleep(1)
await recorder.stop()
@asynctest
async def test_audio_and_video(self):
path = self.temporary_path("test.mp4")
recorder = MediaRecorder(path)
recorder.addTrack(AudioStreamTrack())
recorder.addTrack(VideoStreamTrack())
await recorder.start()
await asyncio.sleep(2)
await recorder.stop()
# check output media
container = av.open(path, "r")
self.assertEqual(len(container.streams), 2)
self.assertEqual(container.streams[0].codec.name, "aac")
self.assertGreater(
float(container.streams[0].duration * container.streams[0].time_base), 0
)
self.assertEqual(container.streams[1].codec.name, "h264")
self.assertEqual(container.streams[1].width, 640)
self.assertEqual(container.streams[1].height, 480)
self.assertGreater(
float(container.streams[1].duration * container.streams[1].time_base), 0
)
@asynctest
async def test_video_png(self):
path = self.temporary_path("test-%3d.png")
recorder = MediaRecorder(path)
recorder.addTrack(VideoStreamTrack())
await recorder.start()
await asyncio.sleep(2)
await recorder.stop()
# check output media
container = av.open(path, "r")
self.assertEqual(len(container.streams), 1)
self.assertEqual(container.streams[0].codec.name, "png")
self.assertGreater(
float(container.streams[0].duration * container.streams[0].time_base), 0
)
self.assertEqual(container.streams[0].width, 640)
self.assertEqual(container.streams[0].height, 480)
@asynctest
async def test_video_mp4(self):
path = self.temporary_path("test.mp4")
recorder = MediaRecorder(path)
recorder.addTrack(VideoStreamTrack())
await recorder.start()
await asyncio.sleep(2)
await recorder.stop()
# check output media
container = av.open(path, "r")
self.assertEqual(len(container.streams), 1)
self.assertEqual(container.streams[0].codec.name, "h264")
self.assertGreater(
float(container.streams[0].duration * container.streams[0].time_base), 0
)
self.assertEqual(container.streams[0].width, 640)
self.assertEqual(container.streams[0].height, 480)
@asynctest
async def test_video_mp4_uhd(self):
path = self.temporary_path("test.mp4")
recorder = MediaRecorder(path)
recorder.addTrack(VideoStreamTrackUhd())
await recorder.start()
await asyncio.sleep(2)
await recorder.stop()
# check output media
container = av.open(path, "r")
self.assertEqual(len(container.streams), 1)
self.assertEqual(container.streams[0].codec.name, "h264")
self.assertGreater(
float(container.streams[0].duration * container.streams[0].time_base), 0
)
self.assertEqual(container.streams[0].width, 3840)
self.assertEqual(container.streams[0].height, 2160)
| 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_rtcicetransport.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtcicetransport.py | import asyncio
from unittest import TestCase
import aioice.stun
from aioice import ConnectionClosed
from aiortc.exceptions import InvalidStateError
from aiortc.rtcconfiguration import RTCIceServer
from aiortc.rtcicetransport import (
RTCIceCandidate,
RTCIceGatherer,
RTCIceParameters,
RTCIceTransport,
connection_kwargs,
parse_stun_turn_uri,
)
from .utils import asynctest
async def mock_connect():
pass
async def mock_get_event():
await asyncio.sleep(0.5)
return ConnectionClosed()
class ConnectionKwargsTest(TestCase):
def test_empty(self):
self.assertEqual(connection_kwargs([]), {})
def test_stun(self):
self.assertEqual(
connection_kwargs([RTCIceServer("stun:stun.l.google.com:19302")]),
{"stun_server": ("stun.l.google.com", 19302)},
)
def test_stun_with_suffix(self):
self.assertEqual(
connection_kwargs(
[RTCIceServer("stun:global.stun.twilio.com:3478?transport=udp")]
),
{"stun_server": ("global.stun.twilio.com", 3478)},
)
def test_stun_multiple_servers(self):
self.assertEqual(
connection_kwargs(
[
RTCIceServer("stun:stun.l.google.com:19302"),
RTCIceServer("stun:stun.example.com"),
]
),
{"stun_server": ("stun.l.google.com", 19302)},
)
def test_stun_multiple_urls(self):
self.assertEqual(
connection_kwargs(
[
RTCIceServer(
[
"stun:stun1.l.google.com:19302",
"stun:stun2.l.google.com:19302",
]
)
]
),
{"stun_server": ("stun1.l.google.com", 19302)},
)
def test_turn(self):
self.assertEqual(
connection_kwargs([RTCIceServer("turn:turn.example.com")]),
{
"turn_password": None,
"turn_server": ("turn.example.com", 3478),
"turn_ssl": False,
"turn_transport": "udp",
"turn_username": None,
},
)
def test_turn_multiple_servers(self):
self.assertEqual(
connection_kwargs(
[
RTCIceServer("turn:turn.example.com"),
RTCIceServer("turn:turn.example.net"),
]
),
{
"turn_password": None,
"turn_server": ("turn.example.com", 3478),
"turn_ssl": False,
"turn_transport": "udp",
"turn_username": None,
},
)
def test_turn_multiple_urls(self):
self.assertEqual(
connection_kwargs(
[RTCIceServer(["turn:turn1.example.com", "turn:turn2.example.com"])]
),
{
"turn_password": None,
"turn_server": ("turn1.example.com", 3478),
"turn_ssl": False,
"turn_transport": "udp",
"turn_username": None,
},
)
def test_turn_over_bogus(self):
self.assertEqual(
connection_kwargs([RTCIceServer("turn:turn.example.com?transport=bogus")]),
{},
)
def test_turn_over_tcp(self):
self.assertEqual(
connection_kwargs([RTCIceServer("turn:turn.example.com?transport=tcp")]),
{
"turn_password": None,
"turn_server": ("turn.example.com", 3478),
"turn_ssl": False,
"turn_transport": "tcp",
"turn_username": None,
},
)
def test_turn_with_password(self):
self.assertEqual(
connection_kwargs(
[
RTCIceServer(
urls="turn:turn.example.com", username="foo", credential="bar"
)
]
),
{
"turn_password": "bar",
"turn_server": ("turn.example.com", 3478),
"turn_ssl": False,
"turn_transport": "udp",
"turn_username": "foo",
},
)
def test_turn_with_token(self):
self.assertEqual(
connection_kwargs(
[
RTCIceServer(
urls="turn:turn.example.com",
username="foo",
credential="bar",
credentialType="token",
)
]
),
{},
)
def test_turns(self):
self.assertEqual(
connection_kwargs([RTCIceServer("turns:turn.example.com")]),
{
"turn_password": None,
"turn_server": ("turn.example.com", 5349),
"turn_ssl": True,
"turn_transport": "tcp",
"turn_username": None,
},
)
def test_turns_over_udp(self):
self.assertEqual(
connection_kwargs([RTCIceServer("turns:turn.example.com?transport=udp")]),
{},
)
class ParseStunTurnUriTest(TestCase):
def test_invalid_scheme(self):
with self.assertRaises(ValueError) as cm:
parse_stun_turn_uri("foo")
self.assertEqual(str(cm.exception), "malformed uri: invalid scheme")
def test_invalid_uri(self):
with self.assertRaises(ValueError) as cm:
parse_stun_turn_uri("stun")
self.assertEqual(str(cm.exception), "malformed uri")
def test_stun(self):
uri = parse_stun_turn_uri("stun:stun.services.mozilla.com")
self.assertEqual(
uri, {"host": "stun.services.mozilla.com", "port": 3478, "scheme": "stun"}
)
def test_stuns(self):
uri = parse_stun_turn_uri("stuns:stun.services.mozilla.com")
self.assertEqual(
uri, {"host": "stun.services.mozilla.com", "port": 5349, "scheme": "stuns"}
)
def test_stun_with_port(self):
uri = parse_stun_turn_uri("stun:stun.l.google.com:19302")
self.assertEqual(
uri, {"host": "stun.l.google.com", "port": 19302, "scheme": "stun"}
)
def test_turn(self):
uri = parse_stun_turn_uri("turn:1.2.3.4")
self.assertEqual(
uri, {"host": "1.2.3.4", "port": 3478, "scheme": "turn", "transport": "udp"}
)
def test_turn_with_port_and_transport(self):
uri = parse_stun_turn_uri("turn:1.2.3.4:3478?transport=tcp")
self.assertEqual(
uri, {"host": "1.2.3.4", "port": 3478, "scheme": "turn", "transport": "tcp"}
)
def test_turns(self):
uri = parse_stun_turn_uri("turns:1.2.3.4")
self.assertEqual(
uri,
{"host": "1.2.3.4", "port": 5349, "scheme": "turns", "transport": "tcp"},
)
def test_turns_with_port_and_transport(self):
uri = parse_stun_turn_uri("turns:1.2.3.4:1234?transport=tcp")
self.assertEqual(
uri,
{"host": "1.2.3.4", "port": 1234, "scheme": "turns", "transport": "tcp"},
)
class RTCIceGathererTest(TestCase):
@asynctest
async def test_gather(self):
gatherer = RTCIceGatherer()
self.assertEqual(gatherer.state, "new")
self.assertEqual(gatherer.getLocalCandidates(), [])
await gatherer.gather()
self.assertEqual(gatherer.state, "completed")
self.assertTrue(len(gatherer.getLocalCandidates()) > 0)
# close
await gatherer._connection.close()
def test_default_ice_servers(self):
self.assertEqual(
RTCIceGatherer.getDefaultIceServers(),
[RTCIceServer(urls="stun:stun.l.google.com:19302")],
)
class RTCIceTransportTest(TestCase):
def setUp(self):
# save timers
self.retry_max = aioice.stun.RETRY_MAX
self.retry_rto = aioice.stun.RETRY_RTO
# shorten timers to run tests faster
aioice.stun.RETRY_MAX = 1
aioice.stun.RETRY_RTO = 0.1
def tearDown(self):
# restore timers
aioice.stun.RETRY_MAX = self.retry_max
aioice.stun.RETRY_RTO = self.retry_rto
@asynctest
async def test_construct(self):
gatherer = RTCIceGatherer()
connection = RTCIceTransport(gatherer)
self.assertEqual(connection.state, "new")
self.assertEqual(connection.getRemoteCandidates(), [])
candidate = RTCIceCandidate(
component=1,
foundation="0",
ip="192.168.99.7",
port=33543,
priority=2122252543,
protocol="UDP",
type="host",
)
# add candidate
await connection.addRemoteCandidate(candidate)
self.assertEqual(connection.getRemoteCandidates(), [candidate])
# end-of-candidates
await connection.addRemoteCandidate(None)
self.assertEqual(connection.getRemoteCandidates(), [candidate])
@asynctest
async def test_connect(self):
gatherer_1 = RTCIceGatherer()
transport_1 = RTCIceTransport(gatherer_1)
gatherer_2 = RTCIceGatherer()
transport_2 = RTCIceTransport(gatherer_2)
# gather candidates
await asyncio.gather(gatherer_1.gather(), gatherer_2.gather())
for candidate in gatherer_2.getLocalCandidates():
await transport_1.addRemoteCandidate(candidate)
for candidate in gatherer_1.getLocalCandidates():
await transport_2.addRemoteCandidate(candidate)
self.assertEqual(transport_1.state, "new")
self.assertEqual(transport_2.state, "new")
# connect
await asyncio.gather(
transport_1.start(gatherer_2.getLocalParameters()),
transport_2.start(gatherer_1.getLocalParameters()),
)
self.assertEqual(transport_1.state, "completed")
self.assertEqual(transport_2.state, "completed")
# cleanup
await asyncio.gather(transport_1.stop(), transport_2.stop())
self.assertEqual(transport_1.state, "closed")
self.assertEqual(transport_2.state, "closed")
@asynctest
async def test_connect_fail(self):
gatherer_1 = RTCIceGatherer()
transport_1 = RTCIceTransport(gatherer_1)
gatherer_2 = RTCIceGatherer()
transport_2 = RTCIceTransport(gatherer_2)
# gather candidates
await asyncio.gather(gatherer_1.gather(), gatherer_2.gather())
for candidate in gatherer_2.getLocalCandidates():
await transport_1.addRemoteCandidate(candidate)
for candidate in gatherer_1.getLocalCandidates():
await transport_2.addRemoteCandidate(candidate)
self.assertEqual(transport_1.state, "new")
self.assertEqual(transport_2.state, "new")
# connect
await transport_2.stop()
await transport_1.start(gatherer_2.getLocalParameters())
self.assertEqual(transport_1.state, "failed")
self.assertEqual(transport_2.state, "closed")
# cleanup
await asyncio.gather(transport_1.stop(), transport_2.stop())
self.assertEqual(transport_1.state, "closed")
self.assertEqual(transport_2.state, "closed")
@asynctest
async def test_connect_when_closed(self):
gatherer = RTCIceGatherer()
transport = RTCIceTransport(gatherer)
# stop transport
await transport.stop()
self.assertEqual(transport.state, "closed")
# try to start it
with self.assertRaises(InvalidStateError) as cm:
await transport.start(
RTCIceParameters(usernameFragment="foo", password="bar")
)
self.assertEqual(str(cm.exception), "RTCIceTransport is closed")
@asynctest
async def test_connection_closed(self):
gatherer = RTCIceGatherer()
# mock out methods
gatherer._connection.connect = mock_connect
gatherer._connection.get_event = mock_get_event
transport = RTCIceTransport(gatherer)
self.assertEqual(transport.state, "new")
await transport.start(RTCIceParameters(usernameFragment="foo", password="bar"))
self.assertEqual(transport.state, "completed")
await asyncio.sleep(1)
self.assertEqual(transport.state, "failed")
await transport.stop()
self.assertEqual(transport.state, "closed")
| 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_ortc.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_ortc.py | import asyncio
from unittest import TestCase
from aiortc import (
RTCCertificate,
RTCDtlsTransport,
RTCIceGatherer,
RTCIceTransport,
RTCSctpTransport,
)
from .utils import asynctest
async def start_dtls_pair(ice_a, ice_b):
dtls_a = RTCDtlsTransport(ice_a, [RTCCertificate.generateCertificate()])
dtls_b = RTCDtlsTransport(ice_b, [RTCCertificate.generateCertificate()])
await asyncio.gather(
dtls_a.start(dtls_b.getLocalParameters()),
dtls_b.start(dtls_a.getLocalParameters()),
)
return dtls_a, dtls_b
async def start_ice_pair():
ice_a = RTCIceTransport(gatherer=RTCIceGatherer())
ice_b = RTCIceTransport(gatherer=RTCIceGatherer())
await asyncio.gather(ice_a.iceGatherer.gather(), ice_b.iceGatherer.gather())
for candidate in ice_b.iceGatherer.getLocalCandidates():
await ice_a.addRemoteCandidate(candidate)
for candidate in ice_a.iceGatherer.getLocalCandidates():
await ice_b.addRemoteCandidate(candidate)
await asyncio.gather(
ice_a.start(ice_b.iceGatherer.getLocalParameters()),
ice_b.start(ice_a.iceGatherer.getLocalParameters()),
)
return ice_a, ice_b
async def start_sctp_pair(dtls_a, dtls_b):
sctp_a = RTCSctpTransport(dtls_a)
sctp_b = RTCSctpTransport(dtls_b)
await asyncio.gather(
sctp_a.start(sctp_b.getCapabilities(), sctp_b.port),
sctp_b.start(sctp_a.getCapabilities(), sctp_a.port),
)
return sctp_a, sctp_b
class OrtcTest(TestCase):
@asynctest
async def test_sctp(self):
# start ICE transports
ice_a, ice_b = await start_ice_pair()
# start DTLS transports
dtls_a, dtls_b = await start_dtls_pair(ice_a, ice_b)
# start SCTP transports
sctp_a, sctp_b = await start_sctp_pair(dtls_a, dtls_b)
# stop SCTP transports
await asyncio.gather(sctp_a.stop(), sctp_b.stop())
# stop DTLS transports
await asyncio.gather(dtls_a.stop(), dtls_b.stop())
# stop ICE transports
await asyncio.gather(ice_a.stop(), ice_b.stop())
| 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_rtcsessiondescription.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtcsessiondescription.py | from unittest import TestCase
from aiortc import RTCSessionDescription
class RTCSessionDescriptionTest(TestCase):
def test_bad_type(self):
with self.assertRaises(ValueError) as cm:
RTCSessionDescription(sdp="v=0\r\n", type="bogus")
self.assertEqual(
str(cm.exception),
"'type' must be in ['offer', 'pranswer', 'answer', 'rollback'] (got 'bogus')",
)
def test_good_type(self):
desc = RTCSessionDescription(sdp="v=0\r\n", type="answer")
self.assertEqual(desc.sdp, "v=0\r\n")
self.assertEqual(desc.type, "answer")
| 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/utils.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/utils.py | import asyncio
import contextlib
import functools
import logging
import os
from aiortc.rtcdtlstransport import RTCCertificate, RTCDtlsTransport
def lf2crlf(x):
return x.replace("\n", "\r\n")
class ClosedDtlsTransport:
state = "closed"
class DummyConnection:
def __init__(self, rx_queue, tx_queue):
self.closed = False
self.loss_cursor = 0
self.loss_pattern = None
self.rx_queue = rx_queue
self.tx_queue = tx_queue
async def close(self):
if not self.closed:
await self.rx_queue.put(None)
self.closed = True
async def recv(self):
if self.closed:
raise ConnectionError
data = await self.rx_queue.get()
if data is None:
raise ConnectionError
return data
async def send(self, data):
if self.closed:
raise ConnectionError
if self.loss_pattern is not None:
lost = self.loss_pattern[self.loss_cursor]
self.loss_cursor = (self.loss_cursor + 1) % len(self.loss_pattern)
if lost:
return
await self.tx_queue.put(data)
class DummyIceTransport:
def __init__(self, connection, role):
self._connection = connection
self.role = role
async def stop(self):
await self._connection.close()
async def _recv(self):
return await self._connection.recv()
async def _send(self, data):
await self._connection.send(data)
def asynctest(coro):
@functools.wraps(coro)
def wrap(*args, **kwargs):
asyncio.run(coro(*args, **kwargs))
return wrap
def dummy_connection_pair():
queue_a = asyncio.Queue()
queue_b = asyncio.Queue()
return (
DummyConnection(rx_queue=queue_a, tx_queue=queue_b),
DummyConnection(rx_queue=queue_b, tx_queue=queue_a),
)
def dummy_ice_transport_pair():
connection_a, connection_b = dummy_connection_pair()
return (
DummyIceTransport(connection_a, "controlling"),
DummyIceTransport(connection_b, "controlled"),
)
@contextlib.asynccontextmanager
async def dummy_dtls_transport_pair():
ice_a, ice_b = dummy_ice_transport_pair()
dtls_a = RTCDtlsTransport(ice_a, [RTCCertificate.generateCertificate()])
dtls_b = RTCDtlsTransport(ice_b, [RTCCertificate.generateCertificate()])
await asyncio.gather(
dtls_b.start(dtls_a.getLocalParameters()),
dtls_a.start(dtls_b.getLocalParameters()),
)
try:
yield (dtls_a, dtls_b)
finally:
await dtls_a.stop()
await dtls_b.stop()
def load(name: str) -> bytes:
path = os.path.join(os.path.dirname(__file__), name)
with open(path, "rb") as fp:
return fp.read()
if os.environ.get("AIORTC_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/aiortc/tests/test_g711.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_g711.py | import fractions
import sys
from aiortc.codecs import PCMA_CODEC, PCMU_CODEC, get_decoder, get_encoder
from aiortc.codecs.g711 import PcmaDecoder, PcmaEncoder, PcmuDecoder, PcmuEncoder
from aiortc.jitterbuffer import JitterFrame
from .codecs import CodecTestCase
# silence
PCMA_PAYLOAD = b"\xd5" * 160
PCMU_PAYLOAD = b"\xff" * 160
class PcmaTest(CodecTestCase):
def test_decoder(self):
decoder = get_decoder(PCMA_CODEC)
self.assertIsInstance(decoder, PcmaDecoder)
frames = decoder.decode(JitterFrame(data=PCMA_PAYLOAD, timestamp=0))
self.assertEqual(len(frames), 1)
frame = frames[0]
self.assertEqual(frame.format.name, "s16")
self.assertEqual(frame.layout.name, "mono")
self.assertEqual(
bytes(frame.planes[0]),
(b"\x08\x00" if sys.byteorder == "little" else b"\x00\x08") * 160,
)
self.assertEqual(frame.pts, 0)
self.assertEqual(frame.samples, 160)
self.assertEqual(frame.sample_rate, 8000)
self.assertEqual(frame.time_base, fractions.Fraction(1, 8000))
def test_encoder_mono_8hz(self):
encoder = get_encoder(PCMA_CODEC)
self.assertIsInstance(encoder, PcmaEncoder)
for frame in self.create_audio_frames(
layout="mono", sample_rate=8000, count=10
):
payloads, timestamp = encoder.encode(frame)
self.assertEqual(payloads, [PCMA_PAYLOAD])
self.assertEqual(timestamp, frame.pts)
def test_encoder_stereo_8khz(self):
encoder = get_encoder(PCMA_CODEC)
self.assertIsInstance(encoder, PcmaEncoder)
for frame in self.create_audio_frames(
layout="stereo", sample_rate=8000, count=10
):
payloads, timestamp = encoder.encode(frame)
self.assertEqual(payloads, [PCMA_PAYLOAD])
self.assertEqual(timestamp, frame.pts)
def test_encoder_stereo_48khz(self):
encoder = get_encoder(PCMA_CODEC)
self.assertIsInstance(encoder, PcmaEncoder)
for frame in self.create_audio_frames(
layout="stereo", sample_rate=48000, count=10
):
payloads, timestamp = encoder.encode(frame)
self.assertEqual(payloads, [PCMA_PAYLOAD])
self.assertEqual(timestamp, frame.pts // 6)
def test_encoder_pack(self):
encoder = get_encoder(PCMA_CODEC)
self.assertTrue(isinstance(encoder, PcmaEncoder))
packet = self.create_packet(payload=PCMA_PAYLOAD, pts=1)
payloads, timestamp = encoder.pack(packet)
self.assertEqual(payloads, [PCMA_PAYLOAD])
self.assertEqual(timestamp, 8)
def test_roundtrip(self):
self.roundtrip_audio(PCMA_CODEC, output_layout="mono", output_sample_rate=8000)
def test_roundtrip_with_loss(self):
self.roundtrip_audio(
PCMA_CODEC, output_layout="mono", output_sample_rate=8000, drop=[1]
)
class PcmuTest(CodecTestCase):
def test_decoder(self):
decoder = get_decoder(PCMU_CODEC)
self.assertIsInstance(decoder, PcmuDecoder)
frames = decoder.decode(JitterFrame(data=PCMU_PAYLOAD, timestamp=0))
self.assertEqual(len(frames), 1)
frame = frames[0]
self.assertEqual(frame.format.name, "s16")
self.assertEqual(frame.layout.name, "mono")
self.assertEqual(bytes(frame.planes[0]), b"\x00\x00" * 160)
self.assertEqual(frame.pts, 0)
self.assertEqual(frame.samples, 160)
self.assertEqual(frame.sample_rate, 8000)
self.assertEqual(frame.time_base, fractions.Fraction(1, 8000))
def test_encoder_mono_8hz(self):
encoder = get_encoder(PCMU_CODEC)
self.assertIsInstance(encoder, PcmuEncoder)
for frame in self.create_audio_frames(
layout="mono", sample_rate=8000, count=10
):
payloads, timestamp = encoder.encode(frame)
self.assertEqual(payloads, [PCMU_PAYLOAD])
self.assertEqual(timestamp, frame.pts)
def test_encoder_stereo_8khz(self):
encoder = get_encoder(PCMU_CODEC)
self.assertIsInstance(encoder, PcmuEncoder)
for frame in self.create_audio_frames(
layout="stereo", sample_rate=8000, count=10
):
payloads, timestamp = encoder.encode(frame)
self.assertEqual(payloads, [PCMU_PAYLOAD])
self.assertEqual(timestamp, frame.pts)
def test_encoder_stereo_48khz(self):
encoder = get_encoder(PCMU_CODEC)
self.assertIsInstance(encoder, PcmuEncoder)
for frame in self.create_audio_frames(
layout="stereo", sample_rate=48000, count=10
):
payloads, timestamp = encoder.encode(frame)
self.assertEqual(payloads, [PCMU_PAYLOAD])
self.assertEqual(timestamp, frame.pts // 6)
def test_roundtrip(self):
self.roundtrip_audio(PCMU_CODEC, output_layout="mono", output_sample_rate=8000)
def test_roundtrip_with_loss(self):
self.roundtrip_audio(
PCMU_CODEC, output_layout="mono", output_sample_rate=8000, drop=[1]
)
| 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_vpx.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_vpx.py | import fractions
from unittest import TestCase
from aiortc.codecs import get_decoder, get_encoder
from aiortc.codecs.vpx import (
Vp8Decoder,
Vp8Encoder,
VpxPayloadDescriptor,
_vpx_assert,
number_of_threads,
)
from aiortc.rtcrtpparameters import RTCRtpCodecParameters
from .codecs import CodecTestCase
VP8_CODEC = RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=100
)
class VpxPayloadDescriptorTest(TestCase):
def test_no_picture_id(self):
descr, rest = VpxPayloadDescriptor.parse(b"\x10")
self.assertEqual(descr.partition_start, 1)
self.assertEqual(descr.partition_id, 0)
self.assertEqual(descr.picture_id, None)
self.assertEqual(descr.tl0picidx, None)
self.assertEqual(descr.tid, None)
self.assertEqual(descr.keyidx, None)
self.assertEqual(bytes(descr), b"\x10")
self.assertEqual(repr(descr), "VpxPayloadDescriptor(S=1, PID=0, pic_id=None)")
self.assertEqual(rest, b"")
def test_short_picture_id_17(self):
"""
From RFC 7741 - 4.6.3
"""
descr, rest = VpxPayloadDescriptor.parse(b"\x90\x80\x11")
self.assertEqual(descr.partition_start, 1)
self.assertEqual(descr.partition_id, 0)
self.assertEqual(descr.picture_id, 17)
self.assertEqual(descr.tl0picidx, None)
self.assertEqual(descr.tid, None)
self.assertEqual(descr.keyidx, None)
self.assertEqual(bytes(descr), b"\x90\x80\x11")
self.assertEqual(repr(descr), "VpxPayloadDescriptor(S=1, PID=0, pic_id=17)")
self.assertEqual(rest, b"")
def test_short_picture_id_127(self):
descr, rest = VpxPayloadDescriptor.parse(b"\x90\x80\x7f")
self.assertEqual(descr.partition_start, 1)
self.assertEqual(descr.partition_id, 0)
self.assertEqual(descr.picture_id, 127)
self.assertEqual(descr.tl0picidx, None)
self.assertEqual(descr.tid, None)
self.assertEqual(descr.keyidx, None)
self.assertEqual(bytes(descr), b"\x90\x80\x7f")
self.assertEqual(rest, b"")
def test_long_picture_id_128(self):
descr, rest = VpxPayloadDescriptor.parse(b"\x90\x80\x80\x80")
self.assertEqual(descr.partition_start, 1)
self.assertEqual(descr.partition_id, 0)
self.assertEqual(descr.picture_id, 128)
self.assertEqual(descr.tl0picidx, None)
self.assertEqual(descr.tid, None)
self.assertEqual(descr.keyidx, None)
self.assertEqual(bytes(descr), b"\x90\x80\x80\x80")
self.assertEqual(rest, b"")
def test_long_picture_id_4711(self):
"""
From RFC 7741 - 4.6.5
"""
descr, rest = VpxPayloadDescriptor.parse(b"\x90\x80\x92\x67")
self.assertEqual(descr.partition_start, 1)
self.assertEqual(descr.partition_id, 0)
self.assertEqual(descr.picture_id, 4711)
self.assertEqual(descr.tl0picidx, None)
self.assertEqual(descr.tid, None)
self.assertEqual(descr.keyidx, None)
self.assertEqual(bytes(descr), b"\x90\x80\x92\x67")
self.assertEqual(rest, b"")
def test_tl0picidx(self):
descr, rest = VpxPayloadDescriptor.parse(b"\x90\xc0\x92\x67\x81")
self.assertEqual(descr.partition_start, 1)
self.assertEqual(descr.partition_id, 0)
self.assertEqual(descr.picture_id, 4711)
self.assertEqual(descr.tl0picidx, 129)
self.assertEqual(descr.tid, None)
self.assertEqual(descr.keyidx, None)
self.assertEqual(bytes(descr), b"\x90\xc0\x92\x67\x81")
self.assertEqual(rest, b"")
def test_tid(self):
descr, rest = VpxPayloadDescriptor.parse(b"\x90\x20\xe0")
self.assertEqual(descr.partition_start, 1)
self.assertEqual(descr.partition_id, 0)
self.assertEqual(descr.picture_id, None)
self.assertEqual(descr.tl0picidx, None)
self.assertEqual(descr.tid, (3, 1))
self.assertEqual(descr.keyidx, None)
self.assertEqual(bytes(descr), b"\x90\x20\xe0")
self.assertEqual(rest, b"")
def test_keyidx(self):
descr, rest = VpxPayloadDescriptor.parse(b"\x90\x10\x1f")
self.assertEqual(descr.partition_start, 1)
self.assertEqual(descr.partition_id, 0)
self.assertEqual(descr.picture_id, None)
self.assertEqual(descr.tl0picidx, None)
self.assertEqual(descr.tid, None)
self.assertEqual(descr.keyidx, 31)
self.assertEqual(bytes(descr), b"\x90\x10\x1f")
self.assertEqual(rest, b"")
def test_truncated(self):
with self.assertRaises(ValueError) as cm:
VpxPayloadDescriptor.parse(b"")
self.assertEqual(str(cm.exception), "VPX descriptor is too short")
with self.assertRaises(ValueError) as cm:
VpxPayloadDescriptor.parse(b"\x80")
self.assertEqual(
str(cm.exception), "VPX descriptor has truncated extended bits"
)
with self.assertRaises(ValueError) as cm:
VpxPayloadDescriptor.parse(b"\x80\x80")
self.assertEqual(str(cm.exception), "VPX descriptor has truncated PictureID")
with self.assertRaises(ValueError) as cm:
VpxPayloadDescriptor.parse(b"\x80\x80\x80")
self.assertEqual(
str(cm.exception), "VPX descriptor has truncated long PictureID"
)
with self.assertRaises(ValueError) as cm:
VpxPayloadDescriptor.parse(b"\x80\x40")
self.assertEqual(str(cm.exception), "VPX descriptor has truncated TL0PICIDX")
with self.assertRaises(ValueError) as cm:
VpxPayloadDescriptor.parse(b"\x80\x20")
self.assertEqual(str(cm.exception), "VPX descriptor has truncated T/K")
with self.assertRaises(ValueError) as cm:
VpxPayloadDescriptor.parse(b"\x80\x10")
self.assertEqual(str(cm.exception), "VPX descriptor has truncated T/K")
class Vp8Test(CodecTestCase):
def test_assert(self):
with self.assertRaises(Exception) as cm:
_vpx_assert(1)
self.assertEqual(str(cm.exception), "libvpx error: Unspecified internal error")
def test_decoder(self):
decoder = get_decoder(VP8_CODEC)
self.assertIsInstance(decoder, Vp8Decoder)
def test_encoder(self):
encoder = get_encoder(VP8_CODEC)
self.assertIsInstance(encoder, Vp8Encoder)
frame = self.create_video_frame(width=640, height=480, pts=0)
payloads, timestamp = encoder.encode(frame)
self.assertEqual(len(payloads), 1)
self.assertTrue(len(payloads[0]) < 1300)
self.assertEqual(timestamp, 0)
# change resolution
frame = self.create_video_frame(width=320, height=240, pts=3000)
payloads, timestamp = encoder.encode(frame)
self.assertEqual(len(payloads), 1)
self.assertTrue(len(payloads[0]) < 1300)
self.assertEqual(timestamp, 3000)
def test_encoder_rgb(self):
encoder = get_encoder(VP8_CODEC)
self.assertIsInstance(encoder, Vp8Encoder)
frame = self.create_video_frame(width=640, height=480, pts=0, format="rgb24")
payloads, timestamp = encoder.encode(frame)
self.assertEqual(len(payloads), 1)
self.assertTrue(len(payloads[0]) < 1300)
self.assertEqual(timestamp, 0)
def test_encoder_pack(self):
encoder = get_encoder(VP8_CODEC)
self.assertTrue(isinstance(encoder, Vp8Encoder))
encoder.picture_id = 0
packet = self.create_packet(payload=b"\x00", pts=1)
payloads, timestamp = encoder.pack(packet)
self.assertEqual(payloads, [b"\x90\x80\x00\x00"])
self.assertEqual(timestamp, 90)
def test_encoder_large(self):
encoder = get_encoder(VP8_CODEC)
self.assertIsInstance(encoder, Vp8Encoder)
# first keyframe
frame = self.create_video_frame(width=2560, height=1920, pts=0)
payloads, timestamp = encoder.encode(frame)
self.assertEqual(len(payloads), 7)
self.assertEqual(len(payloads[0]), 1300)
self.assertEqual(timestamp, 0)
# delta frame
frame = self.create_video_frame(width=2560, height=1920, pts=3000)
payloads, timestamp = encoder.encode(frame)
self.assertEqual(len(payloads), 1)
self.assertTrue(len(payloads[0]) < 1300)
self.assertEqual(timestamp, 3000)
# force keyframe
frame = self.create_video_frame(width=2560, height=1920, pts=6000)
payloads, timestamp = encoder.encode(frame, force_keyframe=True)
self.assertEqual(len(payloads), 7)
self.assertEqual(len(payloads[0]), 1300)
self.assertEqual(timestamp, 6000)
def test_encoder_target_bitrate(self):
encoder = get_encoder(VP8_CODEC)
self.assertIsInstance(encoder, Vp8Encoder)
self.assertEqual(encoder.target_bitrate, 500000)
frame = self.create_video_frame(width=640, height=480, pts=0)
payloads, timestamp = encoder.encode(frame)
self.assertEqual(len(payloads), 1)
self.assertTrue(len(payloads[0]) < 1300)
self.assertEqual(timestamp, 0)
# change target bitrate
encoder.target_bitrate = 600000
self.assertEqual(encoder.target_bitrate, 600000)
frame = self.create_video_frame(width=640, height=480, pts=3000)
payloads, timestamp = encoder.encode(frame)
self.assertEqual(len(payloads), 1)
self.assertTrue(len(payloads[0]) < 1300)
self.assertEqual(timestamp, 3000)
def test_number_of_threads(self):
self.assertEqual(number_of_threads(1920 * 1080, 16), 8)
self.assertEqual(number_of_threads(1920 * 1080, 8), 3)
self.assertEqual(number_of_threads(1920 * 1080, 4), 2)
self.assertEqual(number_of_threads(1920 * 1080, 2), 1)
def test_roundtrip_1280_720(self):
self.roundtrip_video(VP8_CODEC, 1280, 720)
def test_roundtrip_960_540(self):
self.roundtrip_video(VP8_CODEC, 960, 540)
def test_roundtrip_640_480(self):
self.roundtrip_video(VP8_CODEC, 640, 480)
def test_roundtrip_640_480_time_base(self):
self.roundtrip_video(VP8_CODEC, 640, 480, time_base=fractions.Fraction(1, 9000))
def test_roundtrip_320_240(self):
self.roundtrip_video(VP8_CODEC, 320, 240)
| 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_rtcrtpreceiver.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtcrtpreceiver.py | import asyncio
import contextlib
import fractions
from unittest import TestCase
from unittest.mock import patch
from aiortc.codecs import PCMU_CODEC, get_encoder
from aiortc.exceptions import InvalidStateError
from aiortc.mediastreams import MediaStreamError
from aiortc.rtcrtpparameters import (
RTCRtpCapabilities,
RTCRtpCodecCapability,
RTCRtpCodecParameters,
RTCRtpEncodingParameters,
RTCRtpHeaderExtensionCapability,
RTCRtpReceiveParameters,
RTCRtpRtxParameters,
)
from aiortc.rtcrtpreceiver import (
NackGenerator,
RemoteStreamTrack,
RTCRtpReceiver,
RTCRtpSynchronizationSource,
StreamStatistics,
TimestampMapper,
)
from aiortc.rtp import RtcpPacket, RtpPacket
from aiortc.stats import RTCStatsReport
from aiortc.utils import uint16_add
from .codecs import CodecTestCase
from .utils import ClosedDtlsTransport, asynctest, dummy_dtls_transport_pair, load
VP8_CODEC = RTCRtpCodecParameters(
mimeType="video/VP8", clockRate=90000, payloadType=100
)
@contextlib.asynccontextmanager
async def create_receiver(kind):
async with dummy_dtls_transport_pair() as (local_transport, _):
receiver = RTCRtpReceiver(kind, local_transport)
assert receiver.transport == local_transport
try:
yield receiver
finally:
await receiver.stop()
def create_rtp_packets(count, seq=0):
packets = []
for i in range(count):
packets.append(
RtpPacket(
payload_type=0,
sequence_number=uint16_add(seq, i),
ssrc=1234,
timestamp=i * 160,
)
)
return packets
def create_rtp_video_packets(self, codec, frames, seq=0):
encoder = get_encoder(codec)
packets = []
for frame in self.create_video_frames(width=640, height=480, count=frames):
payloads, timestamp = encoder.encode(frame)
self.assertEqual(len(payloads), 1)
packet = RtpPacket(
payload_type=codec.payloadType,
sequence_number=seq,
ssrc=1234,
timestamp=timestamp,
)
packet.payload = payloads[0]
packet.marker = 1
packets.append(packet)
seq = uint16_add(seq, 1)
return packets
class NackGeneratorTest(TestCase):
def test_no_loss(self):
generator = NackGenerator()
for packet in create_rtp_packets(20, 0):
missed = generator.add(packet)
self.assertEqual(missed, False)
self.assertEqual(generator.missing, set())
def test_with_loss(self):
generator = NackGenerator()
# receive packets: 0, <1 missing>, 2
packets = create_rtp_packets(3, 0)
missing = packets.pop(1)
for packet in packets:
missed = generator.add(packet)
self.assertEqual(missed, packet.sequence_number == 2)
self.assertEqual(generator.missing, set([1]))
# late arrival
missed = generator.add(missing)
self.assertEqual(missed, False)
self.assertEqual(generator.missing, set())
def test_with_loss_truncate(self):
generator = NackGenerator()
packets = create_rtp_packets(259, 0)
generator.add(packets[0])
generator.add(packets[129])
self.assertEqual(generator.missing, set(range(1, 129)))
generator.add(packets[258])
self.assertEqual(generator.missing, set(range(130, 258)))
class StreamStatisticsTest(TestCase):
def create_counter(self):
return StreamStatistics(clockrate=8000)
def test_no_loss(self):
counter = self.create_counter()
packets = create_rtp_packets(20, 0)
# receive 10 packets
for packet in packets[0:10]:
counter.add(packet)
self.assertEqual(counter.max_seq, 9)
self.assertEqual(counter.packets_received, 10)
self.assertEqual(counter.packets_lost, 0)
self.assertEqual(counter.fraction_lost, 0)
# receive 10 more packets
for packet in packets[10:20]:
counter.add(packet)
self.assertEqual(counter.max_seq, 19)
self.assertEqual(counter.packets_received, 20)
self.assertEqual(counter.packets_lost, 0)
self.assertEqual(counter.fraction_lost, 0)
def test_no_loss_cycle(self):
counter = self.create_counter()
# receive 10 packets (with sequence cycle)
for packet in create_rtp_packets(10, 65530):
counter.add(packet)
self.assertEqual(counter.max_seq, 3)
self.assertEqual(counter.packets_received, 10)
self.assertEqual(counter.packets_lost, 0)
self.assertEqual(counter.fraction_lost, 0)
def test_with_loss(self):
counter = self.create_counter()
packets = create_rtp_packets(20, 0)
packets.pop(1)
# receive 9 packets (one missing)
for packet in packets[0:9]:
counter.add(packet)
self.assertEqual(counter.max_seq, 9)
self.assertEqual(counter.packets_received, 9)
self.assertEqual(counter.packets_lost, 1)
self.assertEqual(counter.fraction_lost, 25)
# receive 10 more packets
for packet in packets[9:19]:
counter.add(packet)
self.assertEqual(counter.max_seq, 19)
self.assertEqual(counter.packets_received, 19)
self.assertEqual(counter.packets_lost, 1)
self.assertEqual(counter.fraction_lost, 0)
@patch("time.time")
def test_no_jitter(self, mock_time):
counter = self.create_counter()
packets = create_rtp_packets(3, 0)
mock_time.return_value = 1531562330.00
counter.add(packets[0])
self.assertEqual(counter._jitter_q4, 0)
self.assertEqual(counter.jitter, 0)
mock_time.return_value = 1531562330.02
counter.add(packets[1])
self.assertEqual(counter._jitter_q4, 0)
self.assertEqual(counter.jitter, 0)
mock_time.return_value = 1531562330.04
counter.add(packets[2])
self.assertEqual(counter._jitter_q4, 0)
self.assertEqual(counter.jitter, 0)
@patch("time.time")
def test_with_jitter(self, mock_time):
counter = self.create_counter()
packets = create_rtp_packets(3, 0)
mock_time.return_value = 1531562330.00
counter.add(packets[0])
self.assertEqual(counter._jitter_q4, 0)
self.assertEqual(counter.jitter, 0)
mock_time.return_value = 1531562330.03
counter.add(packets[1])
self.assertEqual(counter._jitter_q4, 80)
self.assertEqual(counter.jitter, 5)
mock_time.return_value = 1531562330.05
counter.add(packets[2])
self.assertEqual(counter._jitter_q4, 75)
self.assertEqual(counter.jitter, 4)
class RTCRtpReceiverTest(CodecTestCase):
def test_capabilities(self):
# audio
capabilities = RTCRtpReceiver.getCapabilities("audio")
self.assertIsInstance(capabilities, RTCRtpCapabilities)
self.assertEqual(
capabilities.codecs,
[
RTCRtpCodecCapability(
mimeType="audio/opus", clockRate=48000, channels=2
),
RTCRtpCodecCapability(
mimeType="audio/PCMU", clockRate=8000, channels=1
),
RTCRtpCodecCapability(
mimeType="audio/PCMA", clockRate=8000, channels=1
),
],
)
self.assertEqual(
capabilities.headerExtensions,
[
RTCRtpHeaderExtensionCapability(
uri="urn:ietf:params:rtp-hdrext:sdes:mid"
),
RTCRtpHeaderExtensionCapability(
uri="urn:ietf:params:rtp-hdrext:ssrc-audio-level"
),
],
)
# video
capabilities = RTCRtpReceiver.getCapabilities("video")
self.assertIsInstance(capabilities, RTCRtpCapabilities)
self.assertEqual(
capabilities.codecs,
[
RTCRtpCodecCapability(mimeType="video/VP8", clockRate=90000),
RTCRtpCodecCapability(mimeType="video/rtx", clockRate=90000),
RTCRtpCodecCapability(
mimeType="video/H264",
clockRate=90000,
parameters={
"level-asymmetry-allowed": "1",
"packetization-mode": "1",
"profile-level-id": "42001f",
},
),
RTCRtpCodecCapability(
mimeType="video/H264",
clockRate=90000,
parameters={
"level-asymmetry-allowed": "1",
"packetization-mode": "1",
"profile-level-id": "42e01f",
},
),
],
)
self.assertEqual(
capabilities.headerExtensions,
[
RTCRtpHeaderExtensionCapability(
uri="urn:ietf:params:rtp-hdrext:sdes:mid"
),
RTCRtpHeaderExtensionCapability(
uri="http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time"
),
],
)
# bogus
with self.assertRaises(ValueError):
RTCRtpReceiver.getCapabilities("bogus")
@asynctest
async def test_connection_error(self):
"""
Close the underlying transport before the receiver.
"""
async with create_receiver("audio") as receiver:
receiver._track = RemoteStreamTrack(kind="audio")
receiver._set_rtcp_ssrc(1234)
await receiver.receive(RTCRtpReceiveParameters(codecs=[PCMU_CODEC]))
# receive a packet to prime RTCP
packet = RtpPacket.parse(load("rtp.bin"))
await receiver._handle_rtp_packet(packet, arrival_time_ms=0)
# break connection
await receiver.transport.stop()
# give RTCP time to send a report
await asyncio.sleep(2)
@patch("aiortc.rtcrtpreceiver.logger.isEnabledFor")
@asynctest
async def test_log_debug(self, mock_is_enabled_for):
mock_is_enabled_for.return_value = True
async with create_receiver("audio"):
pass
@asynctest
async def test_rtp_and_rtcp(self):
async with create_receiver("audio") as receiver:
receiver._track = RemoteStreamTrack(kind="audio")
self.assertEqual(receiver.track.readyState, "live")
await receiver.receive(RTCRtpReceiveParameters(codecs=[PCMU_CODEC]))
# receive RTP
for i in range(10):
packet = RtpPacket.parse(load("rtp.bin"))
packet.sequence_number += i
packet.timestamp += i * 160
await receiver._handle_rtp_packet(packet, arrival_time_ms=i * 20)
# receive RTCP SR
for packet in RtcpPacket.parse(load("rtcp_sr.bin")):
await receiver._handle_rtcp_packet(packet)
# check stats
report = await receiver.getStats()
self.assertIsInstance(report, RTCStatsReport)
self.assertEqual(
sorted([s.type for s in report.values()]),
["inbound-rtp", "remote-outbound-rtp", "transport"],
)
# check sources
sources = receiver.getSynchronizationSources()
self.assertEqual(len(sources), 1)
self.assertIsInstance(sources[0], RTCRtpSynchronizationSource)
self.assertEqual(sources[0].source, 4028317929)
# check remote track
frame = await receiver.track.recv()
self.assertEqual(frame.pts, 0)
self.assertEqual(frame.sample_rate, 8000)
self.assertEqual(frame.time_base, fractions.Fraction(1, 8000))
frame = await receiver.track.recv()
self.assertEqual(frame.pts, 160)
self.assertEqual(frame.sample_rate, 8000)
self.assertEqual(frame.time_base, fractions.Fraction(1, 8000))
# shutdown
await receiver.stop()
# read until end
with self.assertRaises(MediaStreamError):
while True:
await receiver.track.recv()
self.assertEqual(receiver.track.readyState, "ended")
# try reading again
with self.assertRaises(MediaStreamError):
await receiver.track.recv()
@asynctest
async def test_rtp_missing_video_packet(self):
nacks = []
pli = []
async def mock_send_rtcp_nack(*args):
nacks.append(args)
async def mock_send_rtcp_pli(*args):
pli.append(args[0])
async with create_receiver("video") as receiver:
receiver._send_rtcp_nack = mock_send_rtcp_nack
receiver._send_rtcp_pli = mock_send_rtcp_pli
receiver._track = RemoteStreamTrack(kind="video")
await receiver.receive(RTCRtpReceiveParameters(codecs=[VP8_CODEC]))
# generate some packets
packets = create_rtp_video_packets(self, codec=VP8_CODEC, frames=129)
# receive RTP with a with a gap
await receiver._handle_rtp_packet(packets[0], arrival_time_ms=0)
await receiver._handle_rtp_packet(packets[128], arrival_time_ms=0)
# check NACK was triggered
lost_packets = list(range(1, 128))
self.assertEqual(nacks[0], (1234, lost_packets))
# check PLI was triggered
self.assertEqual(pli, [1234])
@asynctest
async def test_rtp_empty_video_packet(self):
async with create_receiver("video") as receiver:
receiver._track = RemoteStreamTrack(kind="video")
await receiver.receive(RTCRtpReceiveParameters(codecs=[VP8_CODEC]))
# receive RTP with empty payload
packet = RtpPacket(payload_type=100)
await receiver._handle_rtp_packet(packet, arrival_time_ms=0)
@asynctest
async def test_rtp_invalid_payload(self):
async with create_receiver("video") as receiver:
receiver._track = RemoteStreamTrack(kind="video")
await receiver.receive(RTCRtpReceiveParameters(codecs=[VP8_CODEC]))
# receive RTP with unknown payload type
packet = RtpPacket(payload_type=100, payload=b"\x80")
await receiver._handle_rtp_packet(packet, arrival_time_ms=0)
@asynctest
async def test_rtp_unknown_payload_type(self):
async with create_receiver("video") as receiver:
receiver._track = RemoteStreamTrack(kind="video")
await receiver.receive(RTCRtpReceiveParameters(codecs=[VP8_CODEC]))
# receive RTP with unknown payload type
packet = RtpPacket(payload_type=123)
await receiver._handle_rtp_packet(packet, arrival_time_ms=0)
@asynctest
async def test_rtp_rtx(self):
async with create_receiver("video") as receiver:
receiver._track = RemoteStreamTrack(kind="video")
await receiver.receive(
RTCRtpReceiveParameters(
codecs=[
VP8_CODEC,
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=101,
parameters={"apt": 100},
),
],
encodings=[
RTCRtpEncodingParameters(
ssrc=1234,
payloadType=100,
rtx=RTCRtpRtxParameters(ssrc=2345),
)
],
)
)
# receive RTX with payload
packet = RtpPacket(payload_type=101, ssrc=2345, payload=b"\x00\x00")
await receiver._handle_rtp_packet(packet, arrival_time_ms=0)
# receive RTX without payload
packet = RtpPacket(payload_type=101, ssrc=2345)
await receiver._handle_rtp_packet(packet, arrival_time_ms=0)
@asynctest
async def test_rtp_rtx_unknown_ssrc(self):
async with create_receiver("video") as receiver:
receiver._track = RemoteStreamTrack(kind="video")
await receiver.receive(
RTCRtpReceiveParameters(
codecs=[
VP8_CODEC,
RTCRtpCodecParameters(
mimeType="video/rtx",
clockRate=90000,
payloadType=101,
parameters={"apt": 100},
),
]
)
)
# receive RTX with unknown SSRC
packet = RtpPacket(payload_type=101, ssrc=1234)
await receiver._handle_rtp_packet(packet, arrival_time_ms=0)
@asynctest
async def test_send_rtcp_nack(self):
async with create_receiver("video") as receiver:
receiver._set_rtcp_ssrc(1234)
receiver._track = RemoteStreamTrack(kind="video")
await receiver.receive(RTCRtpReceiveParameters(codecs=[VP8_CODEC]))
# send RTCP feedback NACK
await receiver._send_rtcp_nack(5678, [7654])
@asynctest
async def test_send_rtcp_pli(self):
async with create_receiver("video") as receiver:
receiver._set_rtcp_ssrc(1234)
receiver._track = RemoteStreamTrack(kind="video")
await receiver.receive(RTCRtpReceiveParameters(codecs=[VP8_CODEC]))
# send RTCP feedback PLI
await receiver._send_rtcp_pli(5678)
def test_invalid_dtls_transport_state(self):
dtlsTransport = ClosedDtlsTransport()
with self.assertRaises(InvalidStateError):
RTCRtpReceiver("audio", dtlsTransport)
class TimestampMapperTest(TestCase):
def test_simple(self):
mapper = TimestampMapper()
self.assertEqual(mapper.map(1000), 0)
self.assertEqual(mapper.map(1001), 1)
self.assertEqual(mapper.map(1003), 3)
self.assertEqual(mapper.map(1004), 4)
self.assertEqual(mapper.map(1010), 10)
def test_wrap(self):
mapper = TimestampMapper()
self.assertEqual(mapper.map(4294967293), 0)
self.assertEqual(mapper.map(4294967294), 1)
self.assertEqual(mapper.map(4294967295), 2)
self.assertEqual(mapper.map(0), 3)
self.assertEqual(mapper.map(1), 4)
| 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_mediastreams.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_mediastreams.py | import asyncio
import fractions
import time
from typing import Tuple
from unittest import TestCase
from av.packet import Packet
from aiortc.mediastreams import (
VIDEO_CLOCK_RATE,
VIDEO_PTIME,
VIDEO_TIME_BASE,
AudioStreamTrack,
MediaStreamTrack,
VideoStreamTrack,
)
class VideoPacketStreamTrack(MediaStreamTrack):
"""
A dummy video native track which reads green frames.
"""
kind = "video"
_start: float
_timestamp: int
async def next_timestamp(self) -> Tuple[int, fractions.Fraction]:
if hasattr(self, "_timestamp"):
self._timestamp += int(VIDEO_PTIME * VIDEO_CLOCK_RATE)
wait = self._start + (self._timestamp / VIDEO_CLOCK_RATE) - time.time()
await asyncio.sleep(wait)
else:
self._start = time.time()
self._timestamp = 0
return self._timestamp, VIDEO_TIME_BASE
async def recv(self) -> Packet:
"""
Receive the next :class:`~av.packet.Packet`.
The base implementation dummy packet h264 for tests
"""
pts, time_base = await self.next_timestamp()
header = [0, 0, 0, 1]
buffer = header + [0] * 1020
packet = Packet(len(buffer))
packet.update(bytes(buffer))
packet.pts = pts
packet.time_base = time_base
return packet
class MediaStreamTrackTest(TestCase):
def test_audio(self):
track = AudioStreamTrack()
self.assertEqual(track.kind, "audio")
self.assertEqual(len(track.id), 36)
def test_video(self):
track = VideoStreamTrack()
self.assertEqual(track.kind, "video")
self.assertEqual(len(track.id), 36)
def test_native_video(self):
track = VideoPacketStreamTrack()
self.assertEqual(track.kind, "video")
self.assertEqual(len(track.id), 36)
| 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/__init__.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/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/aiortc/tests/test_rtcsctptransport.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_rtcsctptransport.py | import asyncio
import contextlib
from unittest import TestCase
from unittest.mock import patch
from aiortc.exceptions import InvalidStateError
from aiortc.rtcdatachannel import RTCDataChannel, RTCDataChannelParameters
from aiortc.rtcsctptransport import (
SCTP_DATA_FIRST_FRAG,
SCTP_DATA_LAST_FRAG,
SCTP_DATA_UNORDERED,
USERDATA_MAX_LENGTH,
AbortChunk,
CookieEchoChunk,
DataChunk,
ErrorChunk,
ForwardTsnChunk,
HeartbeatAckChunk,
HeartbeatChunk,
InboundStream,
InitChunk,
ReconfigChunk,
RTCSctpCapabilities,
RTCSctpTransport,
SackChunk,
ShutdownAckChunk,
ShutdownChunk,
ShutdownCompleteChunk,
StreamAddOutgoingParam,
StreamResetOutgoingParam,
StreamResetResponseParam,
parse_packet,
serialize_packet,
tsn_minus_one,
tsn_plus_one,
)
from .utils import ClosedDtlsTransport, asynctest, dummy_dtls_transport_pair, load
@contextlib.asynccontextmanager
async def client_and_server():
async with dummy_dtls_transport_pair() as (client_transport, server_transport):
client = RTCSctpTransport(client_transport)
server = RTCSctpTransport(server_transport)
assert client.is_server is False
assert server.is_server is True
try:
yield client, server
finally:
await client.stop()
await server.stop()
assert client._association_state == RTCSctpTransport.State.CLOSED
assert client.state == "closed"
assert server._association_state == RTCSctpTransport.State.CLOSED
assert server.state == "closed"
@contextlib.asynccontextmanager
async def client_standalone():
async with dummy_dtls_transport_pair() as (client_transport, server_transport):
client = RTCSctpTransport(client_transport)
assert client.is_server is False
try:
yield client
finally:
await client.stop()
def outstanding_tsns(client):
return [chunk.tsn for chunk in client._sent_queue]
def queued_tsns(client):
return [chunk.tsn for chunk in client._outbound_queue]
def track_channels(transport):
channels = []
@transport.on("datachannel")
def on_datachannel(channel):
channels.append(channel)
return channels
async def wait_for_outcome(client, server):
final = [RTCSctpTransport.State.ESTABLISHED, RTCSctpTransport.State.CLOSED]
for i in range(100):
if client._association_state in final and server._association_state in final:
break
await asyncio.sleep(0.1)
class SctpPacketTest(TestCase):
def roundtrip_packet(self, data):
source_port, destination_port, verification_tag, chunks = parse_packet(data)
self.assertEqual(source_port, 5000)
self.assertEqual(destination_port, 5000)
self.assertEqual(len(chunks), 1)
output = serialize_packet(
source_port, destination_port, verification_tag, chunks[0]
)
self.assertEqual(output, data)
return chunks[0]
def test_parse_init(self):
data = load("sctp_init.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, InitChunk)
self.assertEqual(chunk.type, 1)
self.assertEqual(chunk.flags, 0)
self.assertEqual(len(chunk.body), 82)
self.assertEqual(repr(chunk), "InitChunk(flags=0)")
def test_parse_init_invalid_checksum(self):
data = load("sctp_init.bin")
data = data[0:8] + b"\x01\x02\x03\x04" + data[12:]
with self.assertRaises(ValueError) as cm:
self.roundtrip_packet(data)
self.assertEqual(str(cm.exception), "SCTP packet has invalid checksum")
def test_parse_init_truncated_packet_header(self):
data = load("sctp_init.bin")[0:10]
with self.assertRaises(ValueError) as cm:
self.roundtrip_packet(data)
self.assertEqual(str(cm.exception), "SCTP packet length is less than 12 bytes")
def test_parse_cookie_echo(self):
data = load("sctp_cookie_echo.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, CookieEchoChunk)
self.assertEqual(chunk.type, 10)
self.assertEqual(chunk.flags, 0)
self.assertEqual(len(chunk.body), 8)
def test_parse_abort(self):
data = load("sctp_abort.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, AbortChunk)
self.assertEqual(chunk.type, 6)
self.assertEqual(chunk.flags, 0)
self.assertEqual(
chunk.params, [(13, b"Expected B-bit for TSN=4ce1f17f, SID=0001, SSN=0000")]
)
def test_parse_data(self):
data = load("sctp_data.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, DataChunk)
self.assertEqual(chunk.type, 0)
self.assertEqual(chunk.flags, 3)
self.assertEqual(chunk.tsn, 2584679421)
self.assertEqual(chunk.stream_id, 1)
self.assertEqual(chunk.stream_seq, 1)
self.assertEqual(chunk.protocol, 51)
self.assertEqual(chunk.user_data, b"ping")
self.assertEqual(
repr(chunk), "DataChunk(flags=3, tsn=2584679421, stream_id=1, stream_seq=1)"
)
def test_parse_data_padding(self):
data = load("sctp_data_padding.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, DataChunk)
self.assertEqual(chunk.type, 0)
self.assertEqual(chunk.flags, 3)
self.assertEqual(chunk.tsn, 2584679421)
self.assertEqual(chunk.stream_id, 1)
self.assertEqual(chunk.stream_seq, 1)
self.assertEqual(chunk.protocol, 51)
self.assertEqual(chunk.user_data, b"M")
self.assertEqual(
repr(chunk), "DataChunk(flags=3, tsn=2584679421, stream_id=1, stream_seq=1)"
)
def test_parse_error(self):
data = load("sctp_error.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, ErrorChunk)
self.assertEqual(chunk.type, 9)
self.assertEqual(chunk.flags, 0)
self.assertEqual(chunk.params, [(1, b"\x30\x39\x00\x00")])
def test_parse_forward_tsn(self):
data = load("sctp_forward_tsn.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, ForwardTsnChunk)
self.assertEqual(chunk.type, 192)
self.assertEqual(chunk.flags, 0)
self.assertEqual(chunk.cumulative_tsn, 1234)
self.assertEqual(chunk.streams, [(12, 34)])
self.assertEqual(
repr(chunk), "ForwardTsnChunk(cumulative_tsn=1234, streams=[(12, 34)])"
)
def test_parse_heartbeat(self):
data = load("sctp_heartbeat.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, HeartbeatChunk)
self.assertEqual(chunk.type, 4)
self.assertEqual(chunk.flags, 0)
self.assertEqual(
chunk.params,
[
(
1,
b"\xb5o\xaaZvZ\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00{\x10\x00\x00"
b"\x004\xeb\x07F\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
)
],
)
def test_parse_reconfig_reset_out(self):
data = load("sctp_reconfig_reset_out.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, ReconfigChunk)
self.assertEqual(chunk.type, 130)
self.assertEqual(chunk.flags, 0)
self.assertEqual(
chunk.params, [(13, b"\x8b\xd8\n[\xe4\x8b\xecs\x8b\xd8\n^\x00\x01")]
)
# Outgoing SSN Reset Request Parameter
param_data = chunk.params[0][1]
param = StreamResetOutgoingParam.parse(param_data)
self.assertEqual(param.request_sequence, 2346191451)
self.assertEqual(param.response_sequence, 3834375283)
self.assertEqual(param.last_tsn, 2346191454)
self.assertEqual(param.streams, [1])
self.assertEqual(bytes(param), param_data)
def test_parse_reconfig_add_out(self):
data = load("sctp_reconfig_add_out.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, ReconfigChunk)
self.assertEqual(chunk.type, 130)
self.assertEqual(chunk.flags, 0)
self.assertEqual(chunk.params, [(17, b"\xca\x02\xf60\x00\x10\x00\x00")])
# Add Outgoing Streams Request Parameter
param_data = chunk.params[0][1]
param = StreamAddOutgoingParam.parse(param_data)
self.assertEqual(param.request_sequence, 3389191728)
self.assertEqual(param.new_streams, 16)
self.assertEqual(bytes(param), param_data)
def test_parse_reconfig_response(self):
data = load("sctp_reconfig_response.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, ReconfigChunk)
self.assertEqual(chunk.type, 130)
self.assertEqual(chunk.flags, 0)
self.assertEqual(chunk.params, [(16, b"\x91S\x1fT\x00\x00\x00\x01")])
# Re-configuration Response Parameter
param_data = chunk.params[0][1]
param = StreamResetResponseParam.parse(param_data)
self.assertEqual(param.response_sequence, 2438143828)
self.assertEqual(param.result, 1)
self.assertEqual(bytes(param), param_data)
def test_parse_sack(self):
data = load("sctp_sack.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, SackChunk)
self.assertEqual(chunk.type, 3)
self.assertEqual(chunk.flags, 0)
self.assertEqual(chunk.cumulative_tsn, 2222939037)
self.assertEqual(chunk.gaps, [(2, 2), (4, 4)])
self.assertEqual(chunk.duplicates, [2222939041])
self.assertEqual(
repr(chunk),
"SackChunk(flags=0, advertised_rwnd=128160, cumulative_tsn=2222939037, "
"gaps=[(2, 2), (4, 4)])",
)
def test_parse_shutdown(self):
data = load("sctp_shutdown.bin")
chunk = self.roundtrip_packet(data)
self.assertIsInstance(chunk, ShutdownChunk)
self.assertEqual(
repr(chunk), "ShutdownChunk(flags=0, cumulative_tsn=2696426712)"
)
self.assertEqual(chunk.type, 7)
self.assertEqual(chunk.flags, 0)
self.assertEqual(chunk.cumulative_tsn, 2696426712)
class ChunkFactory:
def __init__(self, tsn=1):
self.tsn = tsn
self.stream_seq = 0
def create(self, frags, ordered=True):
chunks = []
for i, frag in enumerate(frags):
flags = 0
if not ordered:
flags |= SCTP_DATA_UNORDERED
if i == 0:
flags |= SCTP_DATA_FIRST_FRAG
if i == len(frags) - 1:
flags |= SCTP_DATA_LAST_FRAG
chunk = DataChunk(flags=flags)
chunk.protocol = 123
chunk.stream_id = 456
if ordered:
chunk.stream_seq = self.stream_seq
chunk.tsn = self.tsn
chunk.user_data = frag
chunks.append(chunk)
self.tsn += 1
if ordered:
self.stream_seq += 1
return chunks
class SctpStreamTest(TestCase):
def setUp(self):
self.factory = ChunkFactory()
def test_duplicate(self):
stream = InboundStream()
chunks = self.factory.create([b"foo", b"bar", b"baz"])
# feed first chunk
stream.add_chunk(chunks[0])
self.assertEqual(stream.reassembly, [chunks[0]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[0]])
self.assertEqual(stream.sequence_number, 0)
# feed first chunk again
with self.assertRaises(AssertionError) as cm:
stream.add_chunk(chunks[0])
self.assertEqual(str(cm.exception), "duplicate chunk in reassembly")
def test_whole_in_order(self):
stream = InboundStream()
chunks = self.factory.create([b"foo"]) + self.factory.create([b"bar"])
# feed first unfragmented
stream.add_chunk(chunks[0])
self.assertEqual(stream.reassembly, [chunks[0]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [(456, 123, b"foo")])
self.assertEqual(stream.reassembly, [])
self.assertEqual(stream.sequence_number, 1)
# feed second unfragmented
stream.add_chunk(chunks[1])
self.assertEqual(stream.reassembly, [chunks[1]])
self.assertEqual(stream.sequence_number, 1)
self.assertEqual(list(stream.pop_messages()), [(456, 123, b"bar")])
self.assertEqual(stream.reassembly, [])
self.assertEqual(stream.sequence_number, 2)
def test_whole_out_of_order(self):
stream = InboundStream()
chunks = (
self.factory.create([b"foo"])
+ self.factory.create([b"bar"])
+ self.factory.create([b"baz", b"qux"])
)
# feed second unfragmented
stream.add_chunk(chunks[1])
self.assertEqual(stream.reassembly, [chunks[1]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[1]])
self.assertEqual(stream.sequence_number, 0)
# feed third partial
stream.add_chunk(chunks[2])
self.assertEqual(stream.reassembly, [chunks[1], chunks[2]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[1], chunks[2]])
self.assertEqual(stream.sequence_number, 0)
# feed first unfragmented
stream.add_chunk(chunks[0])
self.assertEqual(stream.reassembly, [chunks[0], chunks[1], chunks[2]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(
list(stream.pop_messages()), [(456, 123, b"foo"), (456, 123, b"bar")]
)
self.assertEqual(stream.reassembly, [chunks[2]])
self.assertEqual(stream.sequence_number, 2)
def test_fragments_in_order(self):
stream = InboundStream()
chunks = self.factory.create([b"foo", b"bar", b"baz"])
# feed first chunk
stream.add_chunk(chunks[0])
self.assertEqual(stream.reassembly, [chunks[0]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[0]])
self.assertEqual(stream.sequence_number, 0)
# feed second chunk
stream.add_chunk(chunks[1])
self.assertEqual(stream.reassembly, [chunks[0], chunks[1]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[0], chunks[1]])
self.assertEqual(stream.sequence_number, 0)
# feed third chunk
stream.add_chunk(chunks[2])
self.assertEqual(stream.reassembly, [chunks[0], chunks[1], chunks[2]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [(456, 123, b"foobarbaz")])
self.assertEqual(stream.reassembly, [])
self.assertEqual(stream.sequence_number, 1)
def test_fragments_out_of_order(self):
stream = InboundStream()
chunks = self.factory.create([b"foo", b"bar", b"baz"])
# feed third chunk
stream.add_chunk(chunks[2])
self.assertEqual(stream.reassembly, [chunks[2]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[2]])
self.assertEqual(stream.sequence_number, 0)
# feed first chunk
stream.add_chunk(chunks[0])
self.assertEqual(stream.reassembly, [chunks[0], chunks[2]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[0], chunks[2]])
self.assertEqual(stream.sequence_number, 0)
# feed second chunk
stream.add_chunk(chunks[1])
self.assertEqual(stream.reassembly, [chunks[0], chunks[1], chunks[2]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [(456, 123, b"foobarbaz")])
self.assertEqual(stream.reassembly, [])
self.assertEqual(stream.sequence_number, 1)
def test_unordered_no_fragments(self):
stream = InboundStream()
chunks = (
self.factory.create([b"foo"], ordered=False)
+ self.factory.create([b"bar"], ordered=False)
+ self.factory.create([b"baz"], ordered=False)
)
# feed second unfragmented
stream.add_chunk(chunks[1])
self.assertEqual(stream.reassembly, [chunks[1]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [(456, 123, b"bar")])
self.assertEqual(stream.reassembly, [])
self.assertEqual(stream.sequence_number, 0)
# feed third unfragmented
stream.add_chunk(chunks[2])
self.assertEqual(stream.reassembly, [chunks[2]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [(456, 123, b"baz")])
self.assertEqual(stream.reassembly, [])
self.assertEqual(stream.sequence_number, 0)
# feed first unfragmented
stream.add_chunk(chunks[0])
self.assertEqual(stream.reassembly, [chunks[0]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [(456, 123, b"foo")])
self.assertEqual(stream.reassembly, [])
self.assertEqual(stream.sequence_number, 0)
def test_unordered_with_fragments(self):
stream = InboundStream()
chunks = (
self.factory.create([b"foo", b"bar"], ordered=False)
+ self.factory.create([b"baz"], ordered=False)
+ self.factory.create([b"qux", b"quux", b"corge"], ordered=False)
)
# feed second fragment of first message
stream.add_chunk(chunks[1])
self.assertEqual(stream.reassembly, [chunks[1]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[1]])
self.assertEqual(stream.sequence_number, 0)
# feed second message
stream.add_chunk(chunks[2])
self.assertEqual(stream.reassembly, [chunks[1], chunks[2]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [(456, 123, b"baz")])
self.assertEqual(stream.reassembly, [chunks[1]])
self.assertEqual(stream.sequence_number, 0)
# feed first fragment of third message
stream.add_chunk(chunks[3])
self.assertEqual(stream.reassembly, [chunks[1], chunks[3]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[1], chunks[3]])
self.assertEqual(stream.sequence_number, 0)
# feed third fragment of third message
stream.add_chunk(chunks[5])
self.assertEqual(stream.reassembly, [chunks[1], chunks[3], chunks[5]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[1], chunks[3], chunks[5]])
self.assertEqual(stream.sequence_number, 0)
# feed second fragment of third message
stream.add_chunk(chunks[4])
self.assertEqual(
stream.reassembly, [chunks[1], chunks[3], chunks[4], chunks[5]]
)
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [(456, 123, b"quxquuxcorge")])
self.assertEqual(stream.reassembly, [chunks[1]])
self.assertEqual(stream.sequence_number, 0)
# feed first fragment of first message
stream.add_chunk(chunks[0])
self.assertEqual(stream.reassembly, [chunks[0], chunks[1]])
self.assertEqual(stream.sequence_number, 0)
self.assertEqual(list(stream.pop_messages()), [(456, 123, b"foobar")])
self.assertEqual(stream.reassembly, [])
self.assertEqual(stream.sequence_number, 0)
def test_prune_chunks(self):
stream = InboundStream()
factory = ChunkFactory(tsn=100)
chunks = factory.create([b"foo", b"bar"]) + factory.create([b"baz", b"qux"])
for i in [1, 2]:
stream.add_chunk(chunks[i])
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[1], chunks[2]])
self.assertEqual(stream.sequence_number, 0)
stream.sequence_number = 2
self.assertEqual(list(stream.pop_messages()), [])
self.assertEqual(stream.reassembly, [chunks[1], chunks[2]])
self.assertEqual(stream.sequence_number, 2)
self.assertEqual(stream.prune_chunks(101), 3)
self.assertEqual(stream.reassembly, [chunks[2]])
self.assertEqual(stream.sequence_number, 2)
class SctpUtilTest(TestCase):
def test_tsn_minus_one(self):
self.assertEqual(tsn_minus_one(0), 4294967295)
self.assertEqual(tsn_minus_one(1), 0)
self.assertEqual(tsn_minus_one(4294967294), 4294967293)
self.assertEqual(tsn_minus_one(4294967295), 4294967294)
def test_tsn_plus_one(self):
self.assertEqual(tsn_plus_one(0), 1)
self.assertEqual(tsn_plus_one(1), 2)
self.assertEqual(tsn_plus_one(4294967294), 4294967295)
self.assertEqual(tsn_plus_one(4294967295), 0)
class RTCSctpTransportTest(TestCase):
def assertTimerPreserved(self, client):
test = self
class Ctx:
def __enter__(self):
self.previous_timer = client._t3_handle
def __exit__(self, exc_type, exc_value, traceback):
test.assertIsNotNone(client._t3_handle)
test.assertEqual(client._t3_handle, self.previous_timer)
return Ctx()
def assertTimerRestarted(self, client):
test = self
class Ctx:
def __enter__(self):
self.previous_timer = client._t3_handle
def __exit__(self, exc_type, exc_value, traceback):
test.assertIsNotNone(client._t3_handle)
test.assertNotEqual(client._t3_handle, self.previous_timer)
return Ctx()
def assertTimerStopped(self, client):
test = self
class Ctx:
def __enter__(self):
pass
def __exit__(self, exc_type, exc_value, traceback):
test.assertIsNone(client._t3_handle)
return Ctx()
@asynctest
async def test_construct(self):
async with dummy_dtls_transport_pair() as (client_transport, _):
sctpTransport = RTCSctpTransport(client_transport)
self.assertEqual(sctpTransport.transport, client_transport)
self.assertEqual(sctpTransport.port, 5000)
@asynctest
async def test_construct_invalid_dtls_transport_state(self):
dtlsTransport = ClosedDtlsTransport()
with self.assertRaises(InvalidStateError):
RTCSctpTransport(dtlsTransport)
@asynctest
async def test_connect_broken_transport(self):
"""
Transport with 100% loss never connects.
"""
loss_pattern = [True]
async with client_and_server() as (client, server):
client._rto = 0.1
client.transport.transport._connection.loss_pattern = loss_pattern
server._rto = 0.1
server.transport.transport._connection.loss_pattern = loss_pattern
# connect
await server.start(client.getCapabilities(), client.port)
await client.start(server.getCapabilities(), server.port)
# check outcome
await wait_for_outcome(client, server)
self.assertEqual(client._association_state, RTCSctpTransport.State.CLOSED)
self.assertEqual(client.state, "closed")
self.assertEqual(server._association_state, RTCSctpTransport.State.CLOSED)
self.assertEqual(server.state, "connecting")
@asynctest
async def test_connect_lossy_transport(self):
"""
Transport with 25% loss eventually connects.
"""
loss_pattern = [True, False, False, False]
async with client_and_server() as (client, server):
client._rto = 0.1
client.transport.transport._connection.loss_pattern = loss_pattern
server._rto = 0.1
server.transport.transport._connection.loss_pattern = loss_pattern
# connect
await server.start(client.getCapabilities(), client.port)
await client.start(server.getCapabilities(), server.port)
# check outcome
await wait_for_outcome(client, server)
self.assertEqual(
client._association_state, RTCSctpTransport.State.ESTABLISHED
)
self.assertEqual(client.state, "connected")
self.assertEqual(
server._association_state, RTCSctpTransport.State.ESTABLISHED
)
self.assertEqual(server.state, "connected")
# transmit data
server_queue = asyncio.Queue()
async def server_fake_receive(*args):
await server_queue.put(args)
server._receive = server_fake_receive
for i in range(20):
message = (123, i, b"ping")
await client._send(*message)
received = await server_queue.get()
self.assertEqual(received, message)
@asynctest
async def test_connect_client_limits_streams(self):
async with client_and_server() as (client, server):
client._inbound_streams_max = 2048
client._outbound_streams_count = 256
self.assertEqual(client.maxChannels, None)
self.assertEqual(server.maxChannels, None)
# connect
await server.start(client.getCapabilities(), client.port)
await client.start(server.getCapabilities(), server.port)
# check outcome
await wait_for_outcome(client, server)
self.assertEqual(client.maxChannels, 256)
self.assertEqual(
client._association_state, RTCSctpTransport.State.ESTABLISHED
)
self.assertEqual(client._inbound_streams_count, 2048)
self.assertEqual(client._outbound_streams_count, 256)
self.assertEqual(client._remote_extensions, [192, 130])
self.assertEqual(server.maxChannels, 256)
self.assertEqual(
server._association_state, RTCSctpTransport.State.ESTABLISHED
)
self.assertEqual(server._inbound_streams_count, 256)
self.assertEqual(server._outbound_streams_count, 2048)
self.assertEqual(server._remote_extensions, [192, 130])
# client requests additional outbound streams
param = StreamAddOutgoingParam(
request_sequence=client._reconfig_request_seq, new_streams=16
)
await client._send_reconfig_param(param)
await asyncio.sleep(0.1)
self.assertEqual(server.maxChannels, 272)
self.assertEqual(server._inbound_streams_count, 272)
self.assertEqual(server._outbound_streams_count, 2048)
@asynctest
async def test_connect_server_limits_streams(self):
async with client_and_server() as (client, server):
server._inbound_streams_max = 2048
server._outbound_streams_count = 256
# connect
await server.start(client.getCapabilities(), client.port)
await client.start(server.getCapabilities(), server.port)
# check outcome
await wait_for_outcome(client, server)
self.assertEqual(client.maxChannels, 256)
self.assertEqual(
client._association_state, RTCSctpTransport.State.ESTABLISHED
)
self.assertEqual(client._inbound_streams_count, 256)
self.assertEqual(client._outbound_streams_count, 2048)
self.assertEqual(client._remote_extensions, [192, 130])
self.assertEqual(server.maxChannels, 256)
self.assertEqual(
server._association_state, RTCSctpTransport.State.ESTABLISHED
)
self.assertEqual(server._inbound_streams_count, 2048)
self.assertEqual(server._outbound_streams_count, 256)
self.assertEqual(server._remote_extensions, [192, 130])
await asyncio.sleep(0.1)
@asynctest
async def test_connect_then_client_creates_data_channel(self):
async with client_and_server() as (client, server):
self.assertFalse(client.is_server)
self.assertEqual(client.maxChannels, None)
self.assertTrue(server.is_server)
self.assertEqual(server.maxChannels, None)
client_channels = track_channels(client)
server_channels = track_channels(server)
# connect
await server.start(client.getCapabilities(), client.port)
await client.start(server.getCapabilities(), server.port)
# check outcome
await wait_for_outcome(client, server)
self.assertEqual(client.maxChannels, 65535)
self.assertEqual(
client._association_state, RTCSctpTransport.State.ESTABLISHED
)
self.assertEqual(client._inbound_streams_count, 65535)
self.assertEqual(client._outbound_streams_count, 65535)
self.assertEqual(client._remote_extensions, [192, 130])
self.assertEqual(server.maxChannels, 65535)
self.assertEqual(
server._association_state, RTCSctpTransport.State.ESTABLISHED
)
self.assertEqual(server._inbound_streams_count, 65535)
self.assertEqual(server._outbound_streams_count, 65535)
self.assertEqual(server._remote_extensions, [192, 130])
# create data channel
channel = RTCDataChannel(client, RTCDataChannelParameters(label="chat"))
self.assertEqual(channel.id, None)
self.assertEqual(channel.label, "chat")
await asyncio.sleep(0.1)
self.assertEqual(channel.id, 1)
self.assertEqual(channel.label, "chat")
self.assertEqual(len(client_channels), 0)
self.assertEqual(len(server_channels), 1)
self.assertEqual(server_channels[0].id, 1)
self.assertEqual(server_channels[0].label, "chat")
@asynctest
async def test_connect_then_client_creates_data_channel_with_custom_id(self):
async with client_and_server() as (client, server):
client_channels = track_channels(client)
server_channels = track_channels(server)
# connect
await server.start(client.getCapabilities(), client.port)
await client.start(server.getCapabilities(), server.port)
# check outcome
await wait_for_outcome(client, server)
self.assertEqual(
client._association_state, RTCSctpTransport.State.ESTABLISHED
)
self.assertEqual(client._inbound_streams_count, 65535)
self.assertEqual(client._outbound_streams_count, 65535)
self.assertEqual(client._remote_extensions, [192, 130])
self.assertEqual(
server._association_state, RTCSctpTransport.State.ESTABLISHED
)
self.assertEqual(server._inbound_streams_count, 65535)
self.assertEqual(server._outbound_streams_count, 65535)
self.assertEqual(server._remote_extensions, [192, 130])
# create data channel
channel = RTCDataChannel(
client, RTCDataChannelParameters(label="chat", id=100)
)
self.assertEqual(channel.id, 100)
self.assertEqual(channel.label, "chat")
| 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/aiortc/tests/codecs.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/codecs.py | import fractions
from unittest import TestCase
from av import AudioFrame, VideoFrame
from av.packet import Packet
from aiortc.codecs import depayload, get_decoder, get_encoder
from aiortc.jitterbuffer import JitterFrame
from aiortc.mediastreams import AUDIO_PTIME, VIDEO_TIME_BASE
class CodecTestCase(TestCase):
def create_audio_frame(self, samples, pts, layout="mono", sample_rate=48000):
frame = AudioFrame(format="s16", layout=layout, samples=samples)
for p in frame.planes:
p.update(bytes(p.buffer_size))
frame.pts = pts
frame.sample_rate = sample_rate
frame.time_base = fractions.Fraction(1, sample_rate)
return frame
def create_audio_frames(self, layout, sample_rate, count):
frames = []
timestamp = 0
samples_per_frame = int(AUDIO_PTIME * sample_rate)
for i in range(count):
frames.append(
self.create_audio_frame(
samples=samples_per_frame,
pts=timestamp,
layout=layout,
sample_rate=sample_rate,
)
)
timestamp += samples_per_frame
return frames
def create_packet(self, payload: bytes, pts: int) -> Packet:
"""
Create a packet.
"""
packet = Packet(len(payload))
packet.update(payload)
packet.pts = pts
packet.time_base = fractions.Fraction(1, 1000)
return packet
def create_video_frame(
self, width, height, pts, format="yuv420p", time_base=VIDEO_TIME_BASE
):
"""
Create a single blank video frame.
"""
frame = VideoFrame(width=width, height=height, format=format)
for p in frame.planes:
p.update(bytes(p.buffer_size))
frame.pts = pts
frame.time_base = time_base
return frame
def create_video_frames(self, width, height, count, time_base=VIDEO_TIME_BASE):
"""
Create consecutive blank video frames.
"""
frames = []
for i in range(count):
frames.append(
self.create_video_frame(
width=width,
height=height,
pts=int(i / time_base / 30),
time_base=time_base,
)
)
return frames
def roundtrip_audio(self, codec, output_layout, output_sample_rate, drop=[]):
"""
Round-trip an AudioFrame through encoder then decoder.
"""
encoder = get_encoder(codec)
decoder = get_decoder(codec)
input_frames = self.create_audio_frames(
layout="mono", sample_rate=8000, count=10
)
output_sample_count = int(output_sample_rate * AUDIO_PTIME)
for i, frame in enumerate(input_frames):
# encode
packages, timestamp = encoder.encode(frame)
if i not in drop:
# depacketize
data = b""
for package in packages:
data += depayload(codec, package)
# decode
frames = decoder.decode(JitterFrame(data=data, timestamp=timestamp))
self.assertEqual(len(frames), 1)
self.assertEqual(frames[0].format.name, "s16")
self.assertEqual(frames[0].layout.name, output_layout)
self.assertEqual(frames[0].samples, output_sample_rate * AUDIO_PTIME)
self.assertEqual(frames[0].sample_rate, output_sample_rate)
self.assertEqual(frames[0].pts, i * output_sample_count)
self.assertEqual(
frames[0].time_base, fractions.Fraction(1, output_sample_rate)
)
def roundtrip_video(self, codec, width, height, time_base=VIDEO_TIME_BASE):
"""
Round-trip a VideoFrame through encoder then decoder.
"""
encoder = get_encoder(codec)
decoder = get_decoder(codec)
input_frames = self.create_video_frames(
width=width, height=height, count=30, time_base=time_base
)
for i, frame in enumerate(input_frames):
# encode
packages, timestamp = encoder.encode(frame)
# depacketize
data = b""
for package in packages:
data += depayload(codec, package)
# decode
frames = decoder.decode(JitterFrame(data=data, timestamp=timestamp))
self.assertEqual(len(frames), 1)
self.assertEqual(frames[0].width, frame.width)
self.assertEqual(frames[0].height, frame.height)
self.assertEqual(frames[0].pts, i * 3000)
self.assertEqual(frames[0].time_base, VIDEO_TIME_BASE)
| 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_contrib_signaling.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_contrib_signaling.py | import argparse
import asyncio
import os
from unittest import TestCase
from aiortc import RTCIceCandidate, RTCSessionDescription
from aiortc.contrib.signaling import (
BYE,
add_signaling_arguments,
create_signaling,
object_from_string,
object_to_string,
)
from .utils import asynctest
async def delay(coro):
await asyncio.sleep(0.1)
return await coro()
offer = RTCSessionDescription(sdp="some-offer", type="offer")
answer = RTCSessionDescription(sdp="some-answer", type="answer")
class SignalingTest(TestCase):
def setUp(self):
def mock_print(*args, **kwargs):
pass
# hijack print()
self.original_print = __builtins__["print"]
__builtins__["print"] = mock_print
def tearDown(self):
# restore print()
__builtins__["print"] = self.original_print
@asynctest
async def test_copy_and_paste(self):
parser = argparse.ArgumentParser()
add_signaling_arguments(parser)
args = parser.parse_args(["-s", "copy-and-paste"])
sig_server = create_signaling(args)
sig_client = create_signaling(args)
def make_pipes():
r, w = os.pipe()
return os.fdopen(r, "r"), os.fdopen(w, "w")
# mock out read / write pipes
sig_server._read_pipe, sig_client._write_pipe = make_pipes()
sig_client._read_pipe, sig_server._write_pipe = make_pipes()
# connect
await sig_server.connect()
await sig_client.connect()
res = await asyncio.gather(sig_server.send(offer), delay(sig_client.receive))
self.assertEqual(res[1], offer)
res = await asyncio.gather(sig_client.send(answer), delay(sig_server.receive))
self.assertEqual(res[1], answer)
await asyncio.gather(sig_server.close(), sig_client.close())
# cleanup mocks
sig_client._write_pipe.close()
sig_server._write_pipe.close()
@asynctest
async def test_tcp_socket(self):
parser = argparse.ArgumentParser()
add_signaling_arguments(parser)
args = parser.parse_args(["-s", "tcp-socket"])
sig_server = create_signaling(args)
sig_client = create_signaling(args)
# connect
await sig_server.connect()
await sig_client.connect()
res = await asyncio.gather(sig_server.send(offer), delay(sig_client.receive))
self.assertEqual(res[1], offer)
res = await asyncio.gather(sig_client.send(answer), delay(sig_server.receive))
self.assertEqual(res[1], answer)
await asyncio.gather(sig_server.close(), sig_client.close())
@asynctest
async def test_tcp_socket_abrupt_disconnect(self):
parser = argparse.ArgumentParser()
add_signaling_arguments(parser)
args = parser.parse_args(["-s", "tcp-socket"])
sig_server = create_signaling(args)
sig_client = create_signaling(args)
# connect
await sig_server.connect()
await sig_client.connect()
res = await asyncio.gather(sig_server.send(offer), delay(sig_client.receive))
self.assertEqual(res[1], offer)
# break connection
sig_client._writer.close()
sig_server._writer.close()
res = await sig_server.receive()
self.assertIsNone(res)
res = await sig_client.receive()
self.assertIsNone(res)
await asyncio.gather(sig_server.close(), sig_client.close())
@asynctest
async def test_unix_socket(self):
parser = argparse.ArgumentParser()
add_signaling_arguments(parser)
args = parser.parse_args(["-s", "unix-socket"])
sig_server = create_signaling(args)
sig_client = create_signaling(args)
# connect
await sig_server.connect()
await sig_client.connect()
res = await asyncio.gather(sig_server.send(offer), delay(sig_client.receive))
self.assertEqual(res[1], offer)
res = await asyncio.gather(sig_client.send(answer), delay(sig_server.receive))
self.assertEqual(res[1], answer)
await asyncio.gather(sig_server.close(), sig_client.close())
@asynctest
async def test_unix_socket_abrupt_disconnect(self):
parser = argparse.ArgumentParser()
add_signaling_arguments(parser)
args = parser.parse_args(["-s", "unix-socket"])
sig_server = create_signaling(args)
sig_client = create_signaling(args)
# connect
await sig_server.connect()
await sig_client.connect()
res = await asyncio.gather(sig_server.send(offer), delay(sig_client.receive))
self.assertEqual(res[1], offer)
# break connection
sig_client._writer.close()
sig_server._writer.close()
res = await sig_server.receive()
self.assertIsNone(res)
res = await sig_client.receive()
self.assertIsNone(res)
await asyncio.gather(sig_server.close(), sig_client.close())
class SignalingUtilsTest(TestCase):
def test_bye_from_string(self):
self.assertEqual(object_from_string('{"type": "bye"}'), BYE)
def test_bye_to_string(self):
self.assertEqual(object_to_string(BYE), '{"type": "bye"}')
def test_candidate_from_string(self):
candidate = object_from_string(
'{"candidate": "candidate:0 1 UDP 2122252543 192.168.99.7 33543 typ host", "id": "audio", "label": 0, "type": "candidate"}'
)
self.assertEqual(candidate.component, 1)
self.assertEqual(candidate.foundation, "0")
self.assertEqual(candidate.ip, "192.168.99.7")
self.assertEqual(candidate.port, 33543)
self.assertEqual(candidate.priority, 2122252543)
self.assertEqual(candidate.protocol, "UDP")
self.assertEqual(candidate.sdpMid, "audio")
self.assertEqual(candidate.sdpMLineIndex, 0)
self.assertEqual(candidate.type, "host")
def test_candidate_to_string(self):
candidate = RTCIceCandidate(
component=1,
foundation="0",
ip="192.168.99.7",
port=33543,
priority=2122252543,
protocol="UDP",
type="host",
)
candidate.sdpMid = "audio"
candidate.sdpMLineIndex = 0
self.assertEqual(
object_to_string(candidate),
'{"candidate": "candidate:0 1 UDP 2122252543 192.168.99.7 33543 typ host", "id": "audio", "label": 0, "type": "candidate"}',
)
| 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_jitterbuffer.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_jitterbuffer.py | from unittest import TestCase
from aiortc.jitterbuffer import JitterBuffer
from aiortc.rtp import RtpPacket
class JitterBufferTest(TestCase):
def assertPackets(self, jbuffer, expected):
found = [x.sequence_number if x else None for x in jbuffer._packets]
self.assertEqual(found, expected)
def test_create(self):
jbuffer = JitterBuffer(capacity=2)
self.assertEqual(jbuffer._packets, [None, None])
self.assertEqual(jbuffer._origin, None)
jbuffer = JitterBuffer(capacity=4)
self.assertEqual(jbuffer._packets, [None, None, None, None])
self.assertEqual(jbuffer._origin, None)
def test_add_ordered(self):
jbuffer = JitterBuffer(capacity=4)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=0, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [0, None, None, None])
self.assertEqual(jbuffer._origin, 0)
self.assertFalse(pli_flag)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=1, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [0, 1, None, None])
self.assertEqual(jbuffer._origin, 0)
self.assertFalse(pli_flag)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=2, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [0, 1, 2, None])
self.assertEqual(jbuffer._origin, 0)
self.assertFalse(pli_flag)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=3, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [0, 1, 2, 3])
self.assertEqual(jbuffer._origin, 0)
self.assertFalse(pli_flag)
def test_add_unordered(self):
jbuffer = JitterBuffer(capacity=4)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=1, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [None, 1, None, None])
self.assertEqual(jbuffer._origin, 1)
self.assertFalse(pli_flag)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=3, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [None, 1, None, 3])
self.assertEqual(jbuffer._origin, 1)
self.assertFalse(pli_flag)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=2, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [None, 1, 2, 3])
self.assertEqual(jbuffer._origin, 1)
self.assertFalse(pli_flag)
def test_add_seq_too_low_drop(self):
jbuffer = JitterBuffer(capacity=4)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=2, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [None, None, 2, None])
self.assertEqual(jbuffer._origin, 2)
self.assertFalse(pli_flag)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=1, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [None, None, 2, None])
self.assertEqual(jbuffer._origin, 2)
self.assertFalse(pli_flag)
def test_add_seq_too_low_reset(self):
jbuffer = JitterBuffer(capacity=4)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=2000, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [2000, None, None, None])
self.assertEqual(jbuffer._origin, 2000)
self.assertFalse(pli_flag)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=1, timestamp=1234))
self.assertIsNone(frame)
self.assertPackets(jbuffer, [None, 1, None, None])
self.assertEqual(jbuffer._origin, 1)
self.assertFalse(pli_flag)
def test_add_seq_too_high_discard_one(self):
jbuffer = JitterBuffer(capacity=4)
jbuffer.add(RtpPacket(sequence_number=0, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=1, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=2, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=3, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=4, timestamp=1234))
self.assertEqual(jbuffer._origin, 4)
self.assertPackets(jbuffer, [4, None, None, None])
def test_add_seq_too_high_discard_one_v2(self):
jbuffer = JitterBuffer(capacity=4)
jbuffer.add(RtpPacket(sequence_number=0, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=2, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=3, timestamp=1235))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=4, timestamp=1235))
self.assertEqual(jbuffer._origin, 3)
self.assertPackets(jbuffer, [4, None, None, 3])
def test_add_seq_too_high_discard_four(self):
jbuffer = JitterBuffer(capacity=4)
jbuffer.add(RtpPacket(sequence_number=0, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=1, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=3, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=7, timestamp=1235))
self.assertEqual(jbuffer._origin, 7)
self.assertPackets(jbuffer, [None, None, None, 7])
def test_add_seq_too_high_discard_more(self):
jbuffer = JitterBuffer(capacity=4)
jbuffer.add(RtpPacket(sequence_number=0, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=1, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=2, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=3, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
jbuffer.add(RtpPacket(sequence_number=8, timestamp=1234))
self.assertEqual(jbuffer._origin, 8)
self.assertPackets(jbuffer, [8, None, None, None])
def test_add_seq_too_high_reset(self):
jbuffer = JitterBuffer(capacity=4)
jbuffer.add(RtpPacket(sequence_number=0, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
self.assertPackets(jbuffer, [0, None, None, None])
jbuffer.add(RtpPacket(sequence_number=3000, timestamp=1234))
self.assertEqual(jbuffer._origin, 3000)
self.assertPackets(jbuffer, [3000, None, None, None])
def test_remove(self):
jbuffer = JitterBuffer(capacity=4)
jbuffer.add(RtpPacket(sequence_number=0, timestamp=1234))
jbuffer.add(RtpPacket(sequence_number=1, timestamp=1234))
jbuffer.add(RtpPacket(sequence_number=2, timestamp=1234))
jbuffer.add(RtpPacket(sequence_number=3, timestamp=1234))
self.assertEqual(jbuffer._origin, 0)
self.assertPackets(jbuffer, [0, 1, 2, 3])
# remove 1 packet
jbuffer.remove(1)
self.assertEqual(jbuffer._origin, 1)
self.assertPackets(jbuffer, [None, 1, 2, 3])
# remove 2 packets
jbuffer.remove(2)
self.assertEqual(jbuffer._origin, 3)
self.assertPackets(jbuffer, [None, None, None, 3])
def test_smart_remove(self):
jbuffer = JitterBuffer(capacity=4)
jbuffer.add(RtpPacket(sequence_number=0, timestamp=1234))
jbuffer.add(RtpPacket(sequence_number=1, timestamp=1234))
jbuffer.add(RtpPacket(sequence_number=3, timestamp=1235))
self.assertEqual(jbuffer._origin, 0)
self.assertPackets(jbuffer, [0, 1, None, 3])
# remove 1 packet
jbuffer.smart_remove(1)
self.assertEqual(jbuffer._origin, 3)
self.assertPackets(jbuffer, [None, None, None, 3])
def test_remove_audio_frame(self):
"""
Audio jitter buffer.
"""
jbuffer = JitterBuffer(capacity=16, prefetch=4)
packet = RtpPacket(sequence_number=0, timestamp=1234)
packet._data = b"0000"
pli_flag, frame = jbuffer.add(packet)
self.assertIsNone(frame)
packet = RtpPacket(sequence_number=1, timestamp=1235)
packet._data = b"0001"
pli_flag, frame = jbuffer.add(packet)
self.assertIsNone(frame)
packet = RtpPacket(sequence_number=2, timestamp=1236)
packet._data = b"0002"
pli_flag, frame = jbuffer.add(packet)
self.assertIsNone(frame)
packet = RtpPacket(sequence_number=3, timestamp=1237)
packet._data = b"0003"
pli_flag, frame = jbuffer.add(packet)
self.assertIsNone(frame)
packet = RtpPacket(sequence_number=4, timestamp=1238)
packet._data = b"0003"
pli_flag, frame = jbuffer.add(packet)
self.assertIsNotNone(frame)
self.assertEqual(frame.data, b"0000")
self.assertEqual(frame.timestamp, 1234)
packet = RtpPacket(sequence_number=5, timestamp=1239)
packet._data = b"0004"
pli_flag, frame = jbuffer.add(packet)
self.assertIsNotNone(frame)
self.assertEqual(frame.data, b"0001")
self.assertEqual(frame.timestamp, 1235)
def test_remove_video_frame(self):
"""
Video jitter buffer.
"""
jbuffer = JitterBuffer(capacity=128, is_video=True)
packet = RtpPacket(sequence_number=0, timestamp=1234)
packet._data = b"0000"
pli_flag, frame = jbuffer.add(packet)
self.assertIsNone(frame)
packet = RtpPacket(sequence_number=1, timestamp=1234)
packet._data = b"0001"
pli_flag, frame = jbuffer.add(packet)
self.assertIsNone(frame)
packet = RtpPacket(sequence_number=2, timestamp=1234)
packet._data = b"0002"
pli_flag, frame = jbuffer.add(packet)
self.assertIsNone(frame)
packet = RtpPacket(sequence_number=3, timestamp=1235)
packet._data = b"0003"
pli_flag, frame = jbuffer.add(packet)
self.assertIsNotNone(frame)
self.assertEqual(frame.data, b"000000010002")
self.assertEqual(frame.timestamp, 1234)
def test_pli_flag(self):
"""
Video jitter buffer.
"""
jbuffer = JitterBuffer(capacity=128, is_video=True)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=2000, timestamp=1234))
self.assertIsNone(frame)
self.assertEqual(jbuffer._origin, 2000)
self.assertFalse(pli_flag)
# test_add_seq_too_low_reset for video (capacity >= 128)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=1, timestamp=1234))
self.assertIsNone(frame)
self.assertEqual(jbuffer._origin, 1)
self.assertTrue(pli_flag)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=128, timestamp=1235))
self.assertIsNone(frame)
self.assertEqual(jbuffer._origin, 1)
self.assertFalse(pli_flag)
# test_add_seq_too_high_discard_one for video (capacity >= 128)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=129, timestamp=1235))
self.assertIsNone(frame)
self.assertEqual(jbuffer._origin, 128)
self.assertTrue(pli_flag)
# test_add_seq_too_high_reset for video (capacity >= 128)
pli_flag, frame = jbuffer.add(RtpPacket(sequence_number=2000, timestamp=2345))
self.assertIsNone(frame)
self.assertEqual(jbuffer._origin, 2000)
self.assertTrue(pli_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/aiortc/tests/test_clock.py | ctfs/WMCTF/2023/pwn/PDC_2_5/aiortc/tests/test_clock.py | import datetime
from unittest import TestCase
from unittest.mock import patch
from aiortc import clock
class ClockTest(TestCase):
@patch("aiortc.clock.current_datetime")
def test_current_ms(self, mock_now):
mock_now.return_value = datetime.datetime(
2018, 9, 11, tzinfo=datetime.timezone.utc
)
self.assertEqual(clock.current_ms(), 3745612800000)
mock_now.return_value = datetime.datetime(
2018, 9, 11, 0, 0, 1, tzinfo=datetime.timezone.utc
)
self.assertEqual(clock.current_ms(), 3745612801000)
def test_datetime_from_ntp(self):
dt = datetime.datetime(
2018, 6, 28, 9, 3, 5, 423998, tzinfo=datetime.timezone.utc
)
self.assertEqual(clock.datetime_from_ntp(16059593044731306503), dt)
def test_datetime_to_ntp(self):
dt = datetime.datetime(
2018, 6, 28, 9, 3, 5, 423998, tzinfo=datetime.timezone.utc
)
self.assertEqual(clock.datetime_to_ntp(dt), 16059593044731306503)
| 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.