2319 lines
76 KiB
Text
Executable file
2319 lines
76 KiB
Text
Executable file
% HTTP/2 Campaign
|
|
# Frames expressed as binary str were generated using the solicit and hpack-rs
|
|
# Rust crates (https://github.com/mlalic/solicit, https://github.com/mlalic/hpack-rs)
|
|
# except Continuation Frames, Priority Frames and Push Promise Frames that we generated
|
|
# using Go x/net/http2 and x/net/http2/hpack modules.
|
|
|
|
+ Syntax check
|
|
= Configuring Scapy
|
|
~ http2 frame hpack build dissect data headers priority settings rststream pushpromise ping goaway winupdate continuation hpackhdrtable helpers
|
|
|
|
import scapy.config
|
|
scapy.config.conf.debug_dissector=True
|
|
import scapy.packet
|
|
import scapy.fields
|
|
import scapy.contrib.http2 as h2
|
|
import re
|
|
flags_bit_pattern = re.compile(r'''^\s+flags\s+=\s+\[.*['"]bit [0-9]+['"].*\]$''', re.M)
|
|
def expect_exception(e, c):
|
|
try:
|
|
eval(c)
|
|
return False
|
|
except e:
|
|
return True
|
|
|
|
+ HTTP/2 UVarIntField Test Suite
|
|
|
|
= HTTP/2 UVarIntField.any2i
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 5)
|
|
expect_exception(AssertionError, 'f.any2i(None, None)')
|
|
assert(f.any2i(None, 0) == 0)
|
|
assert(f.any2i(None, 3) == 3)
|
|
assert(f.any2i(None, 1<<5) == 1<<5)
|
|
assert(f.any2i(None, 1<<16) == 1<<16)
|
|
f = h2.UVarIntField('value', 0, 8)
|
|
assert(f.any2i(None, b'\x1E') == 30)
|
|
|
|
= HTTP/2 UVarIntField.m2i on full byte
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 8)
|
|
assert(f.m2i(None, b'\x00') == 0)
|
|
assert(f.m2i(None, b'\x03') == 3)
|
|
assert(f.m2i(None, b'\xFE') == 254)
|
|
assert(f.m2i(None, b'\xFF\x00') == 255)
|
|
assert(f.m2i(None, b'\xFF\xFF\x03') == 766) #0xFF + (0xFF ^ 0x80) + (3<<7)
|
|
|
|
= HTTP/2 UVarIntField.m2i on partial byte
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 5)
|
|
assert(f.m2i(None, (b'\x00', 3)) == 0)
|
|
assert(f.m2i(None, (b'\x03', 3)) == 3)
|
|
assert(f.m2i(None, (b'\x1e', 3)) == 30)
|
|
assert(f.m2i(None, (b'\x1f\x00', 3)) == 31)
|
|
assert(f.m2i(None, (b'\x1f\xe1\xff\x03', 3)) == 65536)
|
|
|
|
= HTTP/2 UVarIntField.getfield on full byte
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 8)
|
|
|
|
r = f.getfield(None, b'\x00\x00')
|
|
assert(r[0] == b'\x00')
|
|
assert(r[1] == 0)
|
|
|
|
r = f.getfield(None, b'\x03\x00')
|
|
assert(r[0] == b'\x00')
|
|
assert(r[1] == 3)
|
|
|
|
r = f.getfield(None, b'\xFE\x00')
|
|
assert(r[0] == b'\x00')
|
|
assert(r[1] == 254)
|
|
|
|
r = f.getfield(None, b'\xFF\x00\x00')
|
|
assert(r[0] == b'\x00')
|
|
assert(r[1] == 255)
|
|
|
|
r = f.getfield(None, b'\xFF\xFF\x03\x00')
|
|
assert(r[0] == b'\x00')
|
|
assert(r[1] == 766)
|
|
|
|
= HTTP/2 UVarIntField.getfield on partial byte
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 5)
|
|
|
|
r = f.getfield(None, (b'\x00\x00', 3))
|
|
assert(r[0] == b'\x00')
|
|
assert(r[1] == 0)
|
|
|
|
r = f.getfield(None, (b'\x03\x00', 3))
|
|
assert(r[0] == b'\x00')
|
|
assert(r[1] == 3)
|
|
|
|
r = f.getfield(None, (b'\x1e\x00', 3))
|
|
assert(r[0] == b'\x00')
|
|
assert(r[1] == 30)
|
|
|
|
r = f.getfield(None, (b'\x1f\x00\x00', 3))
|
|
assert(r[0] == b'\x00')
|
|
assert(r[1] == 31)
|
|
|
|
r = f.getfield(None, (b'\x1f\xe1\xff\x03\x00', 3))
|
|
assert(r[0] == b'\x00')
|
|
assert(r[1] == 65536)
|
|
|
|
= HTTP/2 UVarIntField.i2m on full byte
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 8)
|
|
assert(f.i2m(None, 0) == b'\x00')
|
|
assert(f.i2m(None, 3) == b'\x03')
|
|
assert(f.i2m(None, 254).lower() == b'\xfe')
|
|
assert(f.i2m(None, 255).lower() == b'\xff\x00')
|
|
assert(f.i2m(None, 766).lower() == b'\xff\xff\x03')
|
|
|
|
= HTTP/2 UVarIntField.i2m on partial byte
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 5)
|
|
assert(f.i2m(None, 0) == b'\x00')
|
|
assert(f.i2m(None, 3) == b'\x03')
|
|
assert(f.i2m(None, 30).lower() == b'\x1e')
|
|
assert(f.i2m(None, 31).lower() == b'\x1f\x00')
|
|
assert(f.i2m(None, 65536).lower() == b'\x1f\xe1\xff\x03')
|
|
|
|
= HTTP/2 UVarIntField.addfield on full byte
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 8)
|
|
|
|
assert(f.addfield(None, b'Toto', 0) == b'Toto\x00')
|
|
assert(f.addfield(None, b'Toto', 3) == b'Toto\x03')
|
|
assert(f.addfield(None, b'Toto', 254).lower() == b'toto\xfe')
|
|
assert(f.addfield(None, b'Toto', 255).lower() == b'toto\xff\x00')
|
|
assert(f.addfield(None, b'Toto', 766).lower() == b'toto\xff\xff\x03')
|
|
|
|
= HTTP/2 UVarIntField.addfield on partial byte
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 5)
|
|
|
|
assert(f.addfield(None, (b'Toto', 3, 4), 0) == b'Toto\x80')
|
|
assert(f.addfield(None, (b'Toto', 3, 4), 3) == b'Toto\x83')
|
|
assert(f.addfield(None, (b'Toto', 3, 4), 30).lower() == b'toto\x9e')
|
|
assert(f.addfield(None, (b'Toto', 3, 4), 31).lower() == b'toto\x9f\x00')
|
|
assert(f.addfield(None, (b'Toto', 3, 4), 65536).lower() == b'toto\x9f\xe1\xff\x03')
|
|
|
|
= HTTP/2 UVarIntField.i2len on full byte
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 8)
|
|
|
|
assert(f.i2len(None, 0) == 1)
|
|
assert(f.i2len(None, 3) == 1)
|
|
assert(f.i2len(None, 254) == 1)
|
|
assert(f.i2len(None, 255) == 2)
|
|
assert(f.i2len(None, 766) == 3)
|
|
|
|
= HTTP/2 UVarIntField.i2len on partial byte
|
|
~ http2 frame field uvarintfield
|
|
|
|
f = h2.UVarIntField('value', 0, 5)
|
|
|
|
assert(f.i2len(None, 0) == 1)
|
|
assert(f.i2len(None, 3) == 1)
|
|
assert(f.i2len(None, 30) == 1)
|
|
assert(f.i2len(None, 31) == 2)
|
|
assert(f.i2len(None, 65536) == 4)
|
|
|
|
+ HTTP/2 FieldUVarLenField Test Suite
|
|
|
|
= HTTP/2 FieldUVarLenField.i2m without adjustment
|
|
~ http2 frame field fielduvarlenfield
|
|
|
|
|
|
f = h2.FieldUVarLenField('len', None, 8, length_of='data')
|
|
class TrivialPacket(Packet):
|
|
name = 'Trivial Packet'
|
|
fields_desc= [
|
|
f,
|
|
StrField('data', '')
|
|
]
|
|
|
|
assert(f.i2m(TrivialPacket(data='a'*5), None) == b'\x05')
|
|
assert(f.i2m(TrivialPacket(data='a'*255), None).lower() == b'\xff\x00')
|
|
assert(f.i2m(TrivialPacket(data='a'), 2) == b'\x02')
|
|
assert(f.i2m(None, 2) == b'\x02')
|
|
assert(f.i2m(None, 0) == b'\x00')
|
|
|
|
= HTTP/2 FieldUVarLenField.i2m with adjustment
|
|
~ http2 frame field fielduvarlenfield
|
|
|
|
class TrivialPacket(Packet):
|
|
name = 'Trivial Packet'
|
|
fields_desc= [
|
|
f,
|
|
StrField('data', '')
|
|
]
|
|
|
|
f = h2.FieldUVarLenField('value', None, 8, length_of='data', adjust=lambda x: x-1)
|
|
assert(f.i2m(TrivialPacket(data='a'*5), None) == b'\x04')
|
|
assert(f.i2m(TrivialPacket(data='a'*255), None).lower() == b'\xfe')
|
|
#Adjustment does not affect non-None value!
|
|
assert(f.i2m(TrivialPacket(data='a'*3), 2) == b'\x02')
|
|
|
|
+ HTTP/2 HPackZString Test Suite
|
|
|
|
= HTTP/2 HPackZString Compression
|
|
~ http2 hpack huffman
|
|
|
|
string = 'Test'
|
|
s = h2.HPackZString(string)
|
|
assert(len(s) == 3)
|
|
assert(raw(s) == b"\xdeT'")
|
|
assert(s.origin() == string)
|
|
|
|
string = 'a'*65535
|
|
s = h2.HPackZString(string)
|
|
assert(len(s) == 40960)
|
|
assert(raw(s) == (b'\x18\xc61\x8cc' * 8191) + b'\x18\xc61\x8c\x7f')
|
|
assert(s.origin() == string)
|
|
|
|
= HTTP/2 HPackZString Decompression
|
|
~ http2 hpack huffman
|
|
|
|
s = b"\xdeT'"
|
|
i, ibl = h2.HPackZString.huffman_conv2bitstring(s)
|
|
assert(b'Test' == h2.HPackZString.huffman_decode(i, ibl))
|
|
|
|
s = (b'\x18\xc61\x8cc' * 8191) + b'\x18\xc61\x8c\x7f'
|
|
i, ibl = h2.HPackZString.huffman_conv2bitstring(s)
|
|
assert(b'a'*65535 == h2.HPackZString.huffman_decode(i, ibl))
|
|
|
|
assert(
|
|
expect_exception(h2.InvalidEncodingException,
|
|
'h2.HPackZString.huffman_decode(*h2.HPackZString.huffman_conv2bitstring(b"\\xdeT"))')
|
|
)
|
|
|
|
+ HTTP/2 HPackStrLenField Test Suite
|
|
|
|
= HTTP/2 HPackStrLenField.m2i
|
|
~ http2 hpack field hpackstrlenfield
|
|
|
|
f = h2.HPackStrLenField('data', h2.HPackLiteralString(''), length_from=lambda p: p.len, type_from='type')
|
|
class TrivialPacket(Packet):
|
|
name = 'Trivial Packet'
|
|
fields_desc = [
|
|
IntField('type', None),
|
|
IntField('len', None),
|
|
f
|
|
]
|
|
|
|
s = f.m2i(TrivialPacket(type=0, len=4), b'Test')
|
|
assert(isinstance(s, h2.HPackLiteralString))
|
|
assert(s.origin() == 'Test')
|
|
|
|
s = f.m2i(TrivialPacket(type=1, len=3), b"\xdeT'")
|
|
assert(isinstance(s, h2.HPackZString))
|
|
assert(s.origin() == 'Test')
|
|
|
|
= HTTP/2 HPackStrLenField.any2i
|
|
~ http2 hpack field hpackstrlenfield
|
|
|
|
f = h2.HPackStrLenField('data', h2.HPackLiteralString(''), length_from=lambda p: p.len, type_from='type')
|
|
class TrivialPacket(Packet):
|
|
name = 'Trivial Packet'
|
|
fields_desc = [
|
|
IntField('type', None),
|
|
IntField('len', None),
|
|
f
|
|
]
|
|
|
|
s = f.any2i(TrivialPacket(type=0, len=4), b'Test')
|
|
assert(isinstance(s, h2.HPackLiteralString))
|
|
assert(s.origin() == 'Test')
|
|
|
|
s = f.any2i(TrivialPacket(type=1, len=3), b"\xdeT'")
|
|
assert(isinstance(s, h2.HPackZString))
|
|
assert(s.origin() == 'Test')
|
|
|
|
s = h2.HPackLiteralString('Test')
|
|
s2 = f.any2i(TrivialPacket(type=0, len=4), s)
|
|
assert(s.origin() == s2.origin())
|
|
|
|
s = h2.HPackZString('Test')
|
|
s2 = f.any2i(TrivialPacket(type=1, len=3), s)
|
|
assert(s.origin() == s2.origin())
|
|
|
|
s = h2.HPackLiteralString('Test')
|
|
s2 = f.any2i(None, s)
|
|
assert(s.origin() == s2.origin())
|
|
|
|
s = h2.HPackZString('Test')
|
|
s2 = f.any2i(None, s)
|
|
assert(s.origin() == s2.origin())
|
|
|
|
# Verifies that one can fuzz
|
|
s = h2.HPackLiteralString('Test')
|
|
s2 = f.any2i(TrivialPacket(type=1, len=1), s)
|
|
assert(s.origin() == s2.origin())
|
|
|
|
= HTTP/2 HPackStrLenField.i2m
|
|
~ http2 hpack field hpackstrlenfield
|
|
|
|
f = h2.HPackStrLenField('data', h2.HPackLiteralString(''), length_from=lambda p: p.len, type_from='type')
|
|
|
|
s = b'Test'
|
|
s2 = f.i2m(None, h2.HPackLiteralString(s))
|
|
assert(s == s2)
|
|
|
|
s = b'Test'
|
|
s2 = f.i2m(None, h2.HPackZString(s))
|
|
assert(s2 == b"\xdeT'")
|
|
|
|
= HTTP/2 HPackStrLenField.addfield
|
|
~ http2 hpack field hpackstrlenfield
|
|
|
|
f = h2.HPackStrLenField('data', h2.HPackLiteralString(''), length_from=lambda p: p.len, type_from='type')
|
|
|
|
s = b'Test'
|
|
s2 = f.addfield(None, b'Toto', h2.HPackLiteralString(s))
|
|
assert(b'Toto' + s == s2)
|
|
|
|
s = b'Test'
|
|
s2 = f.addfield(None, b'Toto', h2.HPackZString(s))
|
|
assert(s2 == b"Toto\xdeT'")
|
|
|
|
= HTTP/2 HPackStrLenField.getfield
|
|
~ http2 hpack field hpackstrlenfield
|
|
|
|
f = h2.HPackStrLenField('data', h2.HPackLiteralString(''), length_from=lambda p: p.len, type_from='type')
|
|
class TrivialPacket(Packet):
|
|
name = 'Trivial Packet'
|
|
fields_desc = [
|
|
IntField('type', None),
|
|
IntField('len', None),
|
|
f
|
|
]
|
|
|
|
r = f.getfield(TrivialPacket(type=0, len=4), b'TestToto')
|
|
assert(isinstance(r, tuple))
|
|
assert(r[0] == b'Toto')
|
|
assert(isinstance(r[1], h2.HPackLiteralString))
|
|
assert(r[1].origin() == 'Test')
|
|
|
|
r = f.getfield(TrivialPacket(type=1, len=3), b"\xdeT'Toto")
|
|
assert(isinstance(r, tuple))
|
|
assert(r[0] == b'Toto')
|
|
assert(isinstance(r[1], h2.HPackZString))
|
|
assert(r[1].origin() == 'Test')
|
|
|
|
= HTTP/2 HPackStrLenField.i2h / i2repr
|
|
~ http2 hpack field hpackstrlenfield
|
|
|
|
f = h2.HPackStrLenField('data', h2.HPackLiteralString(''), length_from=lambda p: p.len, type_from='type')
|
|
|
|
s = b'Test'
|
|
assert(f.i2h(None, h2.HPackLiteralString(s)) == 'HPackLiteralString(Test)')
|
|
assert(f.i2repr(None, h2.HPackLiteralString(s)) == repr('HPackLiteralString(Test)'))
|
|
|
|
assert(f.i2h(None, h2.HPackZString(s)) == 'HPackZString(Test)')
|
|
assert(f.i2repr(None, h2.HPackZString(s)) == repr('HPackZString(Test)'))
|
|
|
|
= HTTP/2 HPackStrLenField.i2len
|
|
~ http2 hpack field hpackstrlenfield
|
|
|
|
f = h2.HPackStrLenField('data', h2.HPackLiteralString(''), length_from=lambda p: p.len, type_from='type')
|
|
|
|
s = b'Test'
|
|
assert(f.i2len(None, h2.HPackLiteralString(s)) == 4)
|
|
assert(f.i2len(None, h2.HPackZString(s)) == 3)
|
|
|
|
+ HTTP/2 HPackMagicBitField Test Suite
|
|
# Magic bits are not supposed to be modified and if they are anyway, they must
|
|
# be assigned the magic|default value only...
|
|
|
|
= HTTP/2 HPackMagicBitField.addfield
|
|
~ http2 hpack field hpackmagicbitfield
|
|
|
|
f = h2.HPackMagicBitField('value', 3, 2)
|
|
r = f.addfield(None, b'Toto', 3)
|
|
assert(isinstance(r, tuple))
|
|
assert(r[0] == b'Toto')
|
|
assert(r[1] == 2)
|
|
assert(r[2] == 3)
|
|
|
|
r = f.addfield(None, (b'Toto', 2, 1) , 3)
|
|
assert(isinstance(r, tuple))
|
|
assert(r[0] == b'Toto')
|
|
assert(r[1] == 4)
|
|
assert(r[2] == 7)
|
|
|
|
assert(expect_exception(AssertionError, 'f.addfield(None, "toto", 2)'))
|
|
|
|
= HTTP/2 HPackMagicBitField.getfield
|
|
~ http2 hpack field hpackmagicbitfield
|
|
|
|
f = h2.HPackMagicBitField('value', 3, 2)
|
|
|
|
r = f.getfield(None, b'\xc0')
|
|
assert(isinstance(r, tuple))
|
|
assert(len(r) == 2)
|
|
assert(isinstance(r[0], tuple))
|
|
assert(len(r[0]) == 2)
|
|
assert(r[0][0] == b'\xc0')
|
|
assert(r[0][1] == 2)
|
|
assert(r[1] == 3)
|
|
|
|
r = f.getfield(None, (b'\x03', 6))
|
|
assert(isinstance(r, tuple))
|
|
assert(len(r) == 2)
|
|
assert(isinstance(r[0], bytes))
|
|
assert(r[0] == b'')
|
|
assert(r[1] == 3)
|
|
|
|
expect_exception(AssertionError, 'f.getfield(None, b"\\x80")')
|
|
|
|
= HTTP/2 HPackMagicBitField.h2i
|
|
~ http2 hpack field hpackmagicbitfield
|
|
|
|
f = h2.HPackMagicBitField('value', 3, 2)
|
|
assert(f.h2i(None, 3) == 3)
|
|
expect_exception(AssertionError, 'f.h2i(None, 2)')
|
|
|
|
= HTTP/2 HPackMagicBitField.m2i
|
|
~ http2 hpack field hpackmagicbitfield
|
|
|
|
f = h2.HPackMagicBitField('value', 3, 2)
|
|
assert(f.m2i(None, 3) == 3)
|
|
expect_exception(AssertionError, 'f.m2i(None, 2)')
|
|
|
|
= HTTP/2 HPackMagicBitField.i2m
|
|
~ http2 hpack field hpackmagicbitfield
|
|
|
|
f = h2.HPackMagicBitField('value', 3, 2)
|
|
assert(f.i2m(None, 3) == 3)
|
|
expect_exception(AssertionError, 'f.i2m(None, 2)')
|
|
|
|
= HTTP/2 HPackMagicBitField.any2i
|
|
~ http2 hpack field hpackmagicbitfield
|
|
|
|
f = h2.HPackMagicBitField('value', 3, 2)
|
|
assert(f.any2i(None, 3) == 3)
|
|
expect_exception(AssertionError, 'f.any2i(None, 2)')
|
|
|
|
+ HTTP/2 HPackHdrString Test Suite
|
|
|
|
= HTTP/2 Dissect HPackHdrString
|
|
~ http2 pack dissect hpackhdrstring
|
|
|
|
p = h2.HPackHdrString(b'\x04Test')
|
|
assert(p.type == 0)
|
|
assert(p.len == 4)
|
|
assert(isinstance(p.getfieldval('data'), h2.HPackLiteralString))
|
|
assert(p.getfieldval('data').origin() == 'Test')
|
|
|
|
p = h2.HPackHdrString(b"\x83\xdeT'")
|
|
assert(p.type == 1)
|
|
assert(p.len == 3)
|
|
assert(isinstance(p.getfieldval('data'), h2.HPackZString))
|
|
assert(p.getfieldval('data').origin() == 'Test')
|
|
|
|
= HTTP/2 Build HPackHdrString
|
|
~ http2 hpack build hpackhdrstring
|
|
|
|
p = h2.HPackHdrString(data=h2.HPackLiteralString('Test'))
|
|
assert(raw(p) == b'\x04Test')
|
|
|
|
p = h2.HPackHdrString(data=h2.HPackZString('Test'))
|
|
assert(raw(p) == b"\x83\xdeT'")
|
|
|
|
#Fuzzing-able tests
|
|
p = h2.HPackHdrString(type=1, len=3, data=h2.HPackLiteralString('Test'))
|
|
assert(raw(p) == b'\x83Test')
|
|
|
|
+ HTTP/2 HPackIndexedHdr Test Suite
|
|
|
|
= HTTP/2 Dissect HPackIndexedHdr
|
|
~ http2 hpack dissect hpackindexedhdr
|
|
|
|
p = h2.HPackIndexedHdr(b'\x80')
|
|
assert(p.magic == 1)
|
|
assert(p.index == 0)
|
|
|
|
p = h2.HPackIndexedHdr(b'\xFF\x00')
|
|
assert(p.magic == 1)
|
|
assert(p.index == 127)
|
|
|
|
= HTTP/2 Build HPackIndexedHdr
|
|
~ http2 hpack build hpackindexedhdr
|
|
|
|
p = h2.HPackIndexedHdr(index=0)
|
|
assert(raw(p) == b'\x80')
|
|
|
|
p = h2.HPackIndexedHdr(index=127)
|
|
assert(raw(p) == b'\xFF\x00')
|
|
|
|
+ HTTP/2 HPackLitHdrFldWithIncrIndexing Test Suite
|
|
|
|
= HTTP/2 Dissect HPackLitHdrFldWithIncrIndexing without indexed name
|
|
~ http2 hpack dissect hpacklithdrfldwithincrindexing
|
|
|
|
p = h2.HPackLitHdrFldWithIncrIndexing(b'\x40\x04Test\x04Toto')
|
|
assert(p.magic == 1)
|
|
assert(p.index == 0)
|
|
assert(isinstance(p.hdr_name, h2.HPackHdrString))
|
|
assert(p.hdr_name.type == 0)
|
|
assert(p.hdr_name.len == 4)
|
|
assert(p.hdr_name.getfieldval('data').origin() == 'Test')
|
|
assert(isinstance(p.hdr_value, h2.HPackHdrString))
|
|
assert(p.hdr_value.type == 0)
|
|
assert(p.hdr_value.len == 4)
|
|
assert(p.hdr_value.getfieldval('data').origin() == 'Toto')
|
|
|
|
= HTTP/2 Dissect HPackLitHdrFldWithIncrIndexing with indexed name
|
|
~ http2 hpack dissect hpacklithdrfldwithincrindexing
|
|
|
|
p = h2.HPackLitHdrFldWithIncrIndexing(b'\x41\x04Toto')
|
|
assert(p.magic == 1)
|
|
assert(p.index == 1)
|
|
assert(p.hdr_name is None)
|
|
assert(isinstance(p.hdr_value, h2.HPackHdrString))
|
|
assert(p.hdr_value.type == 0)
|
|
assert(p.hdr_value.len == 4)
|
|
assert(p.hdr_value.getfieldval('data').origin() == 'Toto')
|
|
|
|
|
|
= HTTP/2 Build HPackLitHdrFldWithIncrIndexing without indexed name
|
|
~ http2 hpack build hpacklithdrfldwithincrindexing
|
|
|
|
p = h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackLiteralString('Test')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString(b'Toto'))
|
|
)
|
|
assert(raw(p) == b'\x40\x04Test\x04Toto')
|
|
|
|
= HTTP/2 Build HPackLitHdrFldWithIncrIndexing with indexed name
|
|
~ http2 hpack build hpacklithdrfldwithincrindexing
|
|
|
|
p = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=1,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString(b'Toto'))
|
|
)
|
|
assert(raw(p) == b'\x41\x04Toto')
|
|
|
|
+ HTTP/2 HPackLitHdrFldWithoutIndexing Test Suite
|
|
|
|
= HTTP/2 Dissect HPackLitHdrFldWithoutIndexing : don't index and no index
|
|
~ http2 hpack dissect hpacklithdrfldwithoutindexing
|
|
|
|
p = h2.HPackLitHdrFldWithoutIndexing(b'\x00\x04Test\x04Toto')
|
|
assert(p.magic == 0)
|
|
assert(p.never_index == 0)
|
|
assert(p.index == 0)
|
|
assert(isinstance(p.hdr_name, h2.HPackHdrString))
|
|
assert(p.hdr_name.type == 0)
|
|
assert(p.hdr_name.len == 4)
|
|
assert(isinstance(p.hdr_name.getfieldval('data'), h2.HPackLiteralString))
|
|
assert(p.hdr_name.getfieldval('data').origin() == 'Test')
|
|
assert(isinstance(p.hdr_value, h2.HPackHdrString))
|
|
assert(p.hdr_value.type == 0)
|
|
assert(p.hdr_value.len == 4)
|
|
assert(isinstance(p.hdr_value.getfieldval('data'), h2.HPackLiteralString))
|
|
assert(p.hdr_value.getfieldval('data').origin() == 'Toto')
|
|
|
|
= HTTP/2 Dissect HPackLitHdrFldWithoutIndexing : never index index and no index
|
|
~ http2 hpack dissect hpacklithdrfldwithoutindexing
|
|
|
|
p = h2.HPackLitHdrFldWithoutIndexing(b'\x10\x04Test\x04Toto')
|
|
assert(p.magic == 0)
|
|
assert(p.never_index == 1)
|
|
assert(p.index == 0)
|
|
assert(isinstance(p.hdr_name, h2.HPackHdrString))
|
|
assert(p.hdr_name.type == 0)
|
|
assert(p.hdr_name.len == 4)
|
|
assert(isinstance(p.hdr_name.getfieldval('data'), h2.HPackLiteralString))
|
|
assert(p.hdr_name.getfieldval('data').origin() == 'Test')
|
|
assert(isinstance(p.hdr_value, h2.HPackHdrString))
|
|
assert(p.hdr_value.type == 0)
|
|
assert(p.hdr_value.len == 4)
|
|
assert(isinstance(p.hdr_value.getfieldval('data'), h2.HPackLiteralString))
|
|
assert(p.hdr_value.getfieldval('data').origin() == 'Toto')
|
|
|
|
= HTTP/2 Dissect HPackLitHdrFldWithoutIndexing : never index and indexed name
|
|
~ http2 hpack dissect hpacklithdrfldwithoutindexing
|
|
|
|
p = h2.HPackLitHdrFldWithoutIndexing(b'\x11\x04Toto')
|
|
assert(p.magic == 0)
|
|
assert(p.never_index == 1)
|
|
assert(p.index == 1)
|
|
assert(p.hdr_name is None)
|
|
assert(isinstance(p.hdr_value, h2.HPackHdrString))
|
|
assert(p.hdr_value.type == 0)
|
|
assert(p.hdr_value.len == 4)
|
|
assert(isinstance(p.hdr_value.getfieldval('data'), h2.HPackLiteralString))
|
|
assert(p.hdr_value.getfieldval('data').origin() == 'Toto')
|
|
|
|
= HTTP/2 Build HPackLitHdrFldWithoutIndexing : don't index and no index
|
|
~ http2 hpack build hpacklithdrfldwithoutindexing
|
|
|
|
p = h2.HPackLitHdrFldWithoutIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackLiteralString('Test')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString(b'Toto'))
|
|
)
|
|
assert(raw(p) == b'\x00\x04Test\x04Toto')
|
|
|
|
= HTTP/2 Build HPackLitHdrFldWithoutIndexing : never index index and no index
|
|
~ http2 hpack build hpacklithdrfldwithoutindexing
|
|
|
|
p = h2.HPackLitHdrFldWithoutIndexing(
|
|
never_index=1,
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackLiteralString('Test')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString(b'Toto'))
|
|
)
|
|
assert(raw(p) == b'\x10\x04Test\x04Toto')
|
|
|
|
= HTTP/2 Build HPackLitHdrFldWithoutIndexing : never index and indexed name
|
|
~ http2 hpack build hpacklithdrfldwithoutindexing
|
|
|
|
p = h2.HPackLitHdrFldWithoutIndexing(
|
|
never_index=1,
|
|
index=1,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString(b'Toto'))
|
|
)
|
|
assert(raw(p) == b'\x11\x04Toto')
|
|
|
|
+ HTTP/2 HPackDynamicSizeUpdate Test Suite
|
|
|
|
= HTTP/2 Dissect HPackDynamicSizeUpdate
|
|
~ http2 hpack dissect hpackdynamicsizeupdate
|
|
|
|
p = h2.HPackDynamicSizeUpdate(b'\x25')
|
|
assert(p.magic == 1)
|
|
assert(p.max_size == 5)
|
|
p = h2.HPackDynamicSizeUpdate(b'\x3F\x00')
|
|
assert(p.magic == 1)
|
|
assert(p.max_size == 31)
|
|
|
|
= HTTP/2 Build HPackDynamicSizeUpdate
|
|
~ http2 hpack build hpackdynamicsizeupdate
|
|
|
|
p = h2.HPackDynamicSizeUpdate(max_size=5)
|
|
assert(raw(p) == b'\x25')
|
|
p = h2.HPackDynamicSizeUpdate(max_size=31)
|
|
assert(raw(p) == b'\x3F\x00')
|
|
|
|
+ HTTP/2 Data Frame Test Suite
|
|
|
|
= HTTP/2 Dissect Data Frame: Simple data frame
|
|
~ http2 frame dissect data
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x04\x00\x00\x00\x00\x00\x01ABCD')
|
|
assert(pkt.type == 0)
|
|
assert(pkt.len == 4)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2DataFrame))
|
|
assert(pkt[h2.H2DataFrame])
|
|
assert(pkt.payload.data == b'ABCD')
|
|
assert(isinstance(pkt.payload.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Data Frame: Simple data frame
|
|
~ http2 frame build data
|
|
|
|
pkt = h2.H2Frame(stream_id = 1)/h2.H2DataFrame(data='ABCD')
|
|
assert(raw(pkt) == b'\x00\x00\x04\x00\x00\x00\x00\x00\x01ABCD')
|
|
try:
|
|
pkt.show2(dump=True)
|
|
assert(True)
|
|
except Exception:
|
|
assert(False)
|
|
|
|
= HTTP/2 Dissect Data Frame: Simple data frame with padding
|
|
~ http2 frame dissect data
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\r\x00\x08\x00\x00\x00\x01\x08ABCD\x00\x00\x00\x00\x00\x00\x00\x00') #Padded data frame
|
|
assert(pkt.type == 0)
|
|
assert(pkt.len == 13)
|
|
assert(len(pkt.flags) == 1)
|
|
assert('P' in pkt.flags)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2PaddedDataFrame))
|
|
assert(pkt[h2.H2PaddedDataFrame])
|
|
assert(pkt.payload.padlen == 8)
|
|
assert(pkt.payload.data == b'ABCD')
|
|
assert(pkt.payload.padding == b'\x00'*8)
|
|
assert(flags_bit_pattern.search(pkt.show(dump=True)) is None)
|
|
assert(isinstance(pkt.payload.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Data Frame: Simple data frame with padding
|
|
~ http2 frame build data
|
|
|
|
pkt = h2.H2Frame(flags = {'P'}, stream_id = 1)/h2.H2PaddedDataFrame(data='ABCD', padding=b'\x00'*8)
|
|
assert(raw(pkt) == b'\x00\x00\r\x00\x08\x00\x00\x00\x01\x08ABCD\x00\x00\x00\x00\x00\x00\x00\x00')
|
|
try:
|
|
pkt.show2(dump=True)
|
|
assert(True)
|
|
except Exception:
|
|
assert(False)
|
|
|
|
= HTTP/2 Dissect Data Frame: Simple data frame with padding and end stream flag
|
|
~ http2 frame dissect data
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\r\x00\t\x00\x00\x00\x01\x08ABCD\x00\x00\x00\x00\x00\x00\x00\x00') #Padded data frame with end stream flag
|
|
assert(pkt.type == 0)
|
|
assert(pkt.len == 13)
|
|
assert(len(pkt.flags) == 2)
|
|
assert('P' in pkt.flags)
|
|
assert('ES' in pkt.flags)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2PaddedDataFrame))
|
|
assert(pkt[h2.H2PaddedDataFrame])
|
|
assert(pkt.payload.padlen == 8)
|
|
assert(pkt.payload.data == b'ABCD')
|
|
assert(pkt.payload.padding == b'\x00'*8)
|
|
assert(flags_bit_pattern.search(pkt.show(dump=True)) is None)
|
|
assert(isinstance(pkt.payload.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Data Frame: Simple data frame with padding and end stream flag
|
|
~ http2 frame build data
|
|
|
|
pkt = h2.H2Frame(flags = {'P', 'ES'}, stream_id=1)/h2.H2PaddedDataFrame(data='ABCD', padding=b'\x00'*8)
|
|
assert(raw(pkt) == b'\x00\x00\r\x00\t\x00\x00\x00\x01\x08ABCD\x00\x00\x00\x00\x00\x00\x00\x00')
|
|
try:
|
|
pkt.show2(dump=True)
|
|
assert(True)
|
|
except Exception:
|
|
assert(False)
|
|
|
|
+ HTTP/2 Headers Frame Test Suite
|
|
|
|
= HTTP/2 Dissect Headers Frame: Simple header frame
|
|
~ http2 frame dissect headers
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x0e\x01\x00\x00\x00\x00\x01\x88\x0f\x10\ntext/plain') #Header frame
|
|
assert(pkt.type == 1)
|
|
assert(pkt.len == 14)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2HeadersFrame))
|
|
assert(pkt[h2.H2HeadersFrame])
|
|
hf = pkt[h2.H2HeadersFrame]
|
|
assert(len(hf.hdrs) == 2)
|
|
assert(isinstance(hf.hdrs[0], h2.HPackIndexedHdr))
|
|
assert(hf.hdrs[0].magic == 1)
|
|
assert(hf.hdrs[0].index == 8)
|
|
assert(isinstance(hf.hdrs[1], h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hf.hdrs[1].magic == 0)
|
|
assert(hf.hdrs[1].never_index == 0)
|
|
assert(hf.hdrs[1].index == 31)
|
|
assert(hf.hdrs[1].hdr_name is None)
|
|
assert(expect_exception(AttributeError, 'hf.hdrs[1].non_existant'))
|
|
assert(isinstance(hf.hdrs[1].hdr_value, h2.HPackHdrString))
|
|
s = hf.hdrs[1].hdr_value
|
|
assert(s.type == 0)
|
|
assert(s.len == 10)
|
|
assert(s.getfieldval('data').origin() == 'text/plain')
|
|
assert(isinstance(hf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Headers Frame: Simple header frame
|
|
~ http2 frame build headers
|
|
|
|
p = h2.H2Frame(stream_id=1)/h2.H2HeadersFrame(hdrs=[
|
|
h2.HPackIndexedHdr(index=8),
|
|
h2.HPackLitHdrFldWithoutIndexing(
|
|
index=31,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('text/plain'))
|
|
)
|
|
]
|
|
)
|
|
assert(raw(p) == b'\x00\x00\x0e\x01\x00\x00\x00\x00\x01\x88\x0f\x10\ntext/plain')
|
|
|
|
= HTTP/2 Dissect Headers Frame: Header frame with padding
|
|
~ http2 frame dissect headers
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x17\x01\x08\x00\x00\x00\x01\x08\x88\x0f\x10\ntext/plain\x00\x00\x00\x00\x00\x00\x00\x00') #Header frame with padding
|
|
assert(pkt.type == 1)
|
|
assert(pkt.len == 23)
|
|
assert(len(pkt.flags) == 1)
|
|
assert('P' in pkt.flags)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2PaddedHeadersFrame))
|
|
assert(flags_bit_pattern.search(pkt.show(dump=True)) is None)
|
|
assert(pkt[h2.H2PaddedHeadersFrame])
|
|
hf = pkt[h2.H2PaddedHeadersFrame]
|
|
assert(hf.padlen == 8)
|
|
assert(hf.padding == b'\x00' * 8)
|
|
assert(len(hf.hdrs) == 2)
|
|
assert(isinstance(hf.hdrs[0], h2.HPackIndexedHdr))
|
|
assert(hf.hdrs[0].magic == 1)
|
|
assert(hf.hdrs[0].index == 8)
|
|
assert(isinstance(hf.hdrs[1], h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hf.hdrs[1].magic == 0)
|
|
assert(hf.hdrs[1].never_index == 0)
|
|
assert(hf.hdrs[1].index == 31)
|
|
assert(hf.hdrs[1].hdr_name is None)
|
|
assert(expect_exception(AttributeError, 'hf.hdrs[1].non_existant'))
|
|
assert(isinstance(hf.hdrs[1].hdr_value, h2.HPackHdrString))
|
|
s = hf.hdrs[1].hdr_value
|
|
assert(s.type == 0)
|
|
assert(s.len == 10)
|
|
assert(s.getfieldval('data').origin() == 'text/plain')
|
|
assert(isinstance(hf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Headers Frame: Header frame with padding
|
|
~ http2 frame build headers
|
|
|
|
p = h2.H2Frame(flags={'P'}, stream_id=1)/h2.H2PaddedHeadersFrame(
|
|
hdrs=[
|
|
h2.HPackIndexedHdr(index=8),
|
|
h2.HPackLitHdrFldWithoutIndexing(
|
|
index=31,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('text/plain'))
|
|
)
|
|
],
|
|
padding=b'\x00'*8,
|
|
)
|
|
assert(raw(p) == b'\x00\x00\x17\x01\x08\x00\x00\x00\x01\x08\x88\x0f\x10\ntext/plain\x00\x00\x00\x00\x00\x00\x00\x00')
|
|
|
|
= HTTP/2 Dissect Headers Frame: Header frame with priority
|
|
~ http2 frame dissect headers
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x13\x01 \x00\x00\x00\x01\x00\x00\x00\x02d\x88\x0f\x10\ntext/plain') #Header frame with priority
|
|
assert(pkt.type == 1)
|
|
assert(pkt.len == 19)
|
|
assert(len(pkt.flags) == 1)
|
|
assert('+' in pkt.flags)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2PriorityHeadersFrame))
|
|
assert(flags_bit_pattern.search(pkt.show(dump=True)) is None)
|
|
assert(pkt[h2.H2PriorityHeadersFrame])
|
|
hf = pkt[h2.H2PriorityHeadersFrame]
|
|
assert(hf.exclusive == 0)
|
|
assert(hf.stream_dependency == 2)
|
|
assert(hf.weight == 100)
|
|
assert(len(hf.hdrs) == 2)
|
|
assert(isinstance(hf.hdrs[0], h2.HPackIndexedHdr))
|
|
assert(hf.hdrs[0].magic == 1)
|
|
assert(hf.hdrs[0].index == 8)
|
|
assert(isinstance(hf.hdrs[1], h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hf.hdrs[1].magic == 0)
|
|
assert(hf.hdrs[1].never_index == 0)
|
|
assert(hf.hdrs[1].index == 31)
|
|
assert(hf.hdrs[1].hdr_name is None)
|
|
assert(expect_exception(AttributeError, 'hf.hdrs[1].non_existant'))
|
|
assert(isinstance(hf.hdrs[1].hdr_value, h2.HPackHdrString))
|
|
s = hf.hdrs[1].hdr_value
|
|
assert(s.type == 0)
|
|
assert(s.len == 10)
|
|
assert(s.getfieldval('data').origin() == 'text/plain')
|
|
assert(isinstance(hf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Headers Frame: Header frame with priority
|
|
~ http2 frame build headers
|
|
|
|
p = h2.H2Frame(flags={'+'}, stream_id=1)/h2.H2PriorityHeadersFrame(
|
|
exclusive=0,
|
|
stream_dependency=2,
|
|
weight=100,
|
|
hdrs=[
|
|
h2.HPackIndexedHdr(index=8),
|
|
h2.HPackLitHdrFldWithoutIndexing(
|
|
index=31,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('text/plain'))
|
|
)
|
|
]
|
|
)
|
|
assert(raw(p) == b'\x00\x00\x13\x01 \x00\x00\x00\x01\x00\x00\x00\x02d\x88\x0f\x10\ntext/plain')
|
|
|
|
= HTTP/2 Dissect Headers Frame: Header frame with priority and padding and flags
|
|
~ http2 frame dissect headers
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x1c\x01-\x00\x00\x00\x01\x08\x00\x00\x00\x02d\x88\x0f\x10\ntext/plain\x00\x00\x00\x00\x00\x00\x00\x00') #Header frame with priority and padding and flags ES|EH
|
|
assert(pkt.type == 1)
|
|
assert(pkt.len == 28)
|
|
assert(len(pkt.flags) == 4)
|
|
assert('+' in pkt.flags)
|
|
assert('P' in pkt.flags)
|
|
assert('ES' in pkt.flags)
|
|
assert('EH' in pkt.flags)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2PaddedPriorityHeadersFrame))
|
|
assert(flags_bit_pattern.search(pkt.show(dump=True)) is None)
|
|
assert(pkt[h2.H2PaddedPriorityHeadersFrame])
|
|
hf = pkt[h2.H2PaddedPriorityHeadersFrame]
|
|
assert(hf.padlen == 8)
|
|
assert(hf.padding == b'\x00' * 8)
|
|
assert(hf.exclusive == 0)
|
|
assert(hf.stream_dependency == 2)
|
|
assert(hf.weight == 100)
|
|
assert(len(hf.hdrs) == 2)
|
|
assert(isinstance(hf.hdrs[0], h2.HPackIndexedHdr))
|
|
assert(hf.hdrs[0].magic == 1)
|
|
assert(hf.hdrs[0].index == 8)
|
|
assert(isinstance(hf.hdrs[1], h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hf.hdrs[1].magic == 0)
|
|
assert(hf.hdrs[1].never_index == 0)
|
|
assert(hf.hdrs[1].index == 31)
|
|
assert(hf.hdrs[1].hdr_name is None)
|
|
assert(expect_exception(AttributeError, 'hf.hdrs[1].non_existant'))
|
|
assert(isinstance(hf.hdrs[1].hdr_value, h2.HPackHdrString))
|
|
s = hf.hdrs[1].hdr_value
|
|
assert(s.type == 0)
|
|
assert(s.len == 10)
|
|
assert(s.getfieldval('data').origin() == 'text/plain')
|
|
assert(isinstance(hf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Headers Frame: Header frame with priority and padding and flags
|
|
~ http2 frame build headers
|
|
|
|
p = h2.H2Frame(flags={'P', '+', 'ES', 'EH'}, stream_id=1)/h2.H2PaddedPriorityHeadersFrame(
|
|
exclusive=0,
|
|
stream_dependency=2,
|
|
weight=100,
|
|
padding=b'\x00'*8,
|
|
hdrs=[
|
|
h2.HPackIndexedHdr(index=8),
|
|
h2.HPackLitHdrFldWithoutIndexing(
|
|
index=31,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('text/plain'))
|
|
)
|
|
]
|
|
)
|
|
|
|
+ HTTP/2 Priority Frame Test Suite
|
|
|
|
= HTTP/2 Dissect Priority Frame
|
|
~ http2 frame dissect priority
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x05\x02\x00\x00\x00\x00\x03\x80\x00\x00\x01d')
|
|
assert(pkt.type == 2)
|
|
assert(pkt.len == 5)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 3)
|
|
assert(isinstance(pkt.payload, h2.H2PriorityFrame))
|
|
assert(pkt[h2.H2PriorityFrame])
|
|
pp = pkt[h2.H2PriorityFrame]
|
|
assert(pp.stream_dependency == 1)
|
|
assert(pp.exclusive == 1)
|
|
assert(pp.weight == 100)
|
|
|
|
= HTTP/2 Build Priority Frame
|
|
~ http2 frame build priority
|
|
|
|
p = h2.H2Frame(stream_id=3)/h2.H2PriorityFrame(
|
|
exclusive=1,
|
|
stream_dependency=1,
|
|
weight=100
|
|
)
|
|
assert(raw(p) == b'\x00\x00\x05\x02\x00\x00\x00\x00\x03\x80\x00\x00\x01d')
|
|
|
|
+ HTTP/2 Reset Stream Frame Test Suite
|
|
|
|
= HTTP/2 Dissect Reset Stream Frame: Protocol Error
|
|
~ http2 frame dissect rststream
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x04\x03\x00\x00\x00\x00\x01\x00\x00\x00\x01') #Reset stream with protocol error
|
|
assert(pkt.type == 3)
|
|
assert(pkt.len == 4)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2ResetFrame))
|
|
assert(pkt[h2.H2ResetFrame])
|
|
rf = pkt[h2.H2ResetFrame]
|
|
assert(rf.error == 1)
|
|
assert(isinstance(rf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Reset Stream Frame: Protocol Error
|
|
~ http2 frame build rststream
|
|
|
|
p = h2.H2Frame(stream_id=1)/h2.H2ResetFrame(error='Protocol error')
|
|
assert(raw(p) == b'\x00\x00\x04\x03\x00\x00\x00\x00\x01\x00\x00\x00\x01')
|
|
|
|
p = h2.H2Frame(stream_id=1)/h2.H2ResetFrame(error=1)
|
|
assert(raw(p) == b'\x00\x00\x04\x03\x00\x00\x00\x00\x01\x00\x00\x00\x01')
|
|
|
|
= HTTP/2 Dissect Reset Stream Frame: Raw 123456 error
|
|
~ http2 frame dissect rststream
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x04\x03\x00\x00\x00\x00\x01\x00\x01\xe2@') #Reset stream with raw error
|
|
assert(pkt.type == 3)
|
|
assert(pkt.len == 4)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2ResetFrame))
|
|
assert(pkt[h2.H2ResetFrame])
|
|
rf = pkt[h2.H2ResetFrame]
|
|
assert(rf.error == 123456)
|
|
assert(isinstance(rf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Dissect Reset Stream Frame: Raw 123456 error
|
|
~ http2 frame dissect rststream
|
|
|
|
p = h2.H2Frame(stream_id=1)/h2.H2ResetFrame(error=123456)
|
|
assert(raw(p) == b'\x00\x00\x04\x03\x00\x00\x00\x00\x01\x00\x01\xe2@')
|
|
|
|
+ HTTP/2 Settings Frame Test Suite
|
|
|
|
= HTTP/2 Dissect Settings Frame: Settings Frame
|
|
~ http2 frame dissect settings
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00$\x04\x00\x00\x00\x00\x00\x00\x01\x07[\xcd\x15\x00\x02\x00\x00\x00\x01\x00\x03\x00\x00\x00{\x00\x04\x00\x12\xd6\x87\x00\x05\x00\x01\xe2@\x00\x06\x00\x00\x00{') #Settings frame
|
|
assert(pkt.type == 4)
|
|
assert(pkt.len == 36)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 0)
|
|
assert(isinstance(pkt.payload, h2.H2SettingsFrame))
|
|
assert(pkt[h2.H2SettingsFrame])
|
|
sf = pkt[h2.H2SettingsFrame]
|
|
assert(len(sf.settings) == 6)
|
|
assert(isinstance(sf.settings[0], h2.H2Setting))
|
|
assert(sf.settings[0].id == 1)
|
|
assert(sf.settings[0].value == 123456789)
|
|
assert(isinstance(sf.settings[1], h2.H2Setting))
|
|
assert(sf.settings[1].id == 2)
|
|
assert(sf.settings[1].value == 1)
|
|
assert(isinstance(sf.settings[2], h2.H2Setting))
|
|
assert(sf.settings[2].id == 3)
|
|
assert(sf.settings[2].value == 123)
|
|
assert(isinstance(sf.settings[3], h2.H2Setting))
|
|
assert(sf.settings[3].id == 4)
|
|
assert(sf.settings[3].value == 1234567)
|
|
assert(isinstance(sf.settings[4], h2.H2Setting))
|
|
assert(sf.settings[4].id == 5)
|
|
assert(sf.settings[4].value == 123456)
|
|
assert(isinstance(sf.settings[5], h2.H2Setting))
|
|
assert(sf.settings[5].id == 6)
|
|
assert(sf.settings[5].value == 123)
|
|
assert(isinstance(sf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Settings Frame: Settings Frame
|
|
~ http2 frame build settings
|
|
|
|
p = h2.H2Frame()/h2.H2SettingsFrame(settings=[
|
|
h2.H2Setting(id='Header table size',value=123456789),
|
|
h2.H2Setting(id='Enable push', value=1),
|
|
h2.H2Setting(id='Max concurrent streams', value=123),
|
|
h2.H2Setting(id='Initial window size', value=1234567),
|
|
h2.H2Setting(id='Max frame size', value=123456),
|
|
h2.H2Setting(id='Max header list size', value=123)
|
|
]
|
|
)
|
|
assert(raw(p) == b'\x00\x00$\x04\x00\x00\x00\x00\x00\x00\x01\x07[\xcd\x15\x00\x02\x00\x00\x00\x01\x00\x03\x00\x00\x00{\x00\x04\x00\x12\xd6\x87\x00\x05\x00\x01\xe2@\x00\x06\x00\x00\x00{')
|
|
|
|
= HTTP/2 Dissect Settings Frame: Incomplete Settings Frame
|
|
~ http2 frame dissect settings
|
|
|
|
#We use here the decode('hex') method because null-bytes are rejected by eval()
|
|
assert(expect_exception(AssertionError, 'h2.H2Frame(bytes_hex("0000240400000000000001075bcd1500020000000100030000007b00040012d68700050001e2400006000000"))'))
|
|
|
|
= HTTP/2 Dissect Settings Frame: Settings Frame acknowledgement
|
|
~ http2 frame dissect settings
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x00\x04\x01\x00\x00\x00\x00') #Settings frame w/ ack flag
|
|
assert(pkt.type == 4)
|
|
assert(pkt.len == 0)
|
|
assert(len(pkt.flags) == 1)
|
|
assert('A' in pkt.flags)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 0)
|
|
assert(flags_bit_pattern.search(pkt.show(dump=True)) is None)
|
|
assert(isinstance(pkt.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Settings Frame: Settings Frame acknowledgement
|
|
~ http2 frame build settings
|
|
|
|
p = h2.H2Frame(type=h2.H2SettingsFrame.type_id, flags={'A'})
|
|
assert(raw(p) == b'\x00\x00\x00\x04\x01\x00\x00\x00\x00')
|
|
|
|
+ HTTP/2 Push Promise Frame Test Suite
|
|
|
|
= HTTP/2 Dissect Push Promise Frame: no flag & headers with compression and hdr_name
|
|
~ http2 frame dissect pushpromise
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x15\x05\x00\x00\x00\x00\x01\x00\x00\x00\x03@\x8c\xfc[i{ZT$\xb2-\xc8\xc9\x9f\x02Me')
|
|
assert(pkt.type == 5)
|
|
assert(pkt.len == 21)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2PushPromiseFrame))
|
|
assert(pkt[h2.H2PushPromiseFrame])
|
|
pf = pkt[h2.H2PushPromiseFrame]
|
|
assert(pf.reserved == 0)
|
|
assert(pf.stream_id == 3)
|
|
assert(len(pf.hdrs) == 1)
|
|
assert(isinstance(pf.payload, scapy.packet.NoPayload))
|
|
hdr = pf.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithIncrIndexing))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.type == 1)
|
|
assert(hdr.hdr_name.len == 12)
|
|
assert(hdr.hdr_name.getfieldval('data').origin() == 'X-Requested-With')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.type == 0)
|
|
assert(hdr.hdr_value.len == 2)
|
|
assert(hdr.hdr_value.getfieldval('data').origin() == 'Me')
|
|
|
|
= HTTP/2 Build Push Promise Frame: no flag & headers with compression and hdr_name
|
|
~ http2 frame build pushpromise
|
|
|
|
p = h2.H2Frame(stream_id=1)/h2.H2PushPromiseFrame(stream_id=3,hdrs=[
|
|
h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Requested-With')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('Me')),
|
|
)
|
|
])
|
|
assert(raw(p) == b'\x00\x00\x15\x05\x00\x00\x00\x00\x01\x00\x00\x00\x03@\x8c\xfc[i{ZT$\xb2-\xc8\xc9\x9f\x02Me')
|
|
|
|
= HTTP/2 Dissect Push Promise Frame: with padding, the flag END_Header & headers with compression and hdr_name
|
|
~ http2 frame dissect pushpromise
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x1e\x05\x0c\x00\x00\x00\x01\x08\x00\x00\x00\x03@\x8c\xfc[i{ZT$\xb2-\xc8\xc9\x9f\x02Me\x00\x00\x00\x00\x00\x00\x00\x00')
|
|
assert(pkt.type == 5)
|
|
assert(pkt.len == 30)
|
|
assert(len(pkt.flags) == 2)
|
|
assert('P' in pkt.flags)
|
|
assert('EH' in pkt.flags)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(flags_bit_pattern.search(pkt.show(dump=True)) is None)
|
|
assert(isinstance(pkt.payload, h2.H2PaddedPushPromiseFrame))
|
|
assert(pkt[h2.H2PaddedPushPromiseFrame])
|
|
pf = pkt[h2.H2PaddedPushPromiseFrame]
|
|
assert(pf.padlen == 8)
|
|
assert(pf.padding == b'\x00'*8)
|
|
assert(pf.stream_id == 3)
|
|
assert(len(pf.hdrs) == 1)
|
|
hdr = pf.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithIncrIndexing))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.type == 1)
|
|
assert(hdr.hdr_name.len == 12)
|
|
assert(hdr.hdr_name.getfieldval('data').origin() == 'X-Requested-With')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.type == 0)
|
|
assert(hdr.hdr_value.len == 2)
|
|
assert(hdr.hdr_value.getfieldval('data').origin() == 'Me')
|
|
|
|
= HTTP/2 Build Push Promise Frame: with padding, the flag END_Header & headers with compression and hdr_name
|
|
~ http2 frame build pushpromise
|
|
|
|
p = h2.H2Frame(flags={'P', 'EH'}, stream_id=1)/h2.H2PaddedPushPromiseFrame(
|
|
stream_id=3,
|
|
hdrs=[
|
|
h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Requested-With')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('Me'))
|
|
)
|
|
],
|
|
padding=b'\x00'*8
|
|
)
|
|
assert(raw(p) == b'\x00\x00\x1e\x05\x0c\x00\x00\x00\x01\x08\x00\x00\x00\x03@\x8c\xfc[i{ZT$\xb2-\xc8\xc9\x9f\x02Me\x00\x00\x00\x00\x00\x00\x00\x00')
|
|
|
|
+ HTTP/2 Ping Frame Test Suite
|
|
|
|
= HTTP/2 Dissect Ping Frame: Ping frame
|
|
~ http2 frame dissect ping
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x08\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xe2@') #Ping frame with payload
|
|
assert(pkt.type == 6)
|
|
assert(pkt.len == 8)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 0)
|
|
assert(isinstance(pkt.payload, h2.H2PingFrame))
|
|
assert(pkt[h2.H2PingFrame])
|
|
pf = pkt[h2.H2PingFrame]
|
|
assert(pf.opaque == 123456)
|
|
assert(isinstance(pf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Ping Frame: Ping frame
|
|
~ http2 frame build ping
|
|
|
|
p = h2.H2Frame()/h2.H2PingFrame(opaque=123456)
|
|
assert(raw(p) == b'\x00\x00\x08\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xe2@')
|
|
|
|
= HTTP/2 Dissect Ping Frame: Pong frame
|
|
~ http2 frame dissect ping
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x08\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xe2@') #Pong frame
|
|
assert(pkt.type == 6)
|
|
assert(pkt.len == 8)
|
|
assert(len(pkt.flags) == 1)
|
|
assert('A' in pkt.flags)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 0)
|
|
assert(isinstance(pkt.payload, h2.H2PingFrame))
|
|
assert(flags_bit_pattern.search(pkt.show(dump=True)) is None)
|
|
assert(pkt[h2.H2PingFrame])
|
|
pf = pkt[h2.H2PingFrame]
|
|
assert(pf.opaque == 123456)
|
|
assert(isinstance(pf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Dissect Ping Frame: Pong frame
|
|
~ http2 frame dissect ping
|
|
|
|
p = h2.H2Frame(flags={'A'})/h2.H2PingFrame(opaque=123456)
|
|
assert(raw(p) == b'\x00\x00\x08\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xe2@')
|
|
|
|
+ HTTP/2 Go Away Frame Test Suite
|
|
|
|
= HTTP/2 Dissect Go Away Frame: No error
|
|
~ http2 frame dissect goaway
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x08\x07\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00') #Go Away for no particular reason :)
|
|
assert(pkt.type == 7)
|
|
assert(pkt.len == 8)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 0)
|
|
assert(isinstance(pkt.payload, h2.H2GoAwayFrame))
|
|
assert(pkt[h2.H2GoAwayFrame])
|
|
gf = pkt[h2.H2GoAwayFrame]
|
|
assert(gf.reserved == 0)
|
|
assert(gf.last_stream_id == 1)
|
|
assert(gf.error == 0)
|
|
assert(len(gf.additional_data) == 0)
|
|
assert(isinstance(gf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Go Away Frame: No error
|
|
~ http2 frame build goaway
|
|
|
|
p = h2.H2Frame()/h2.H2GoAwayFrame(last_stream_id=1, error='No error')
|
|
assert(raw(p) == b'\x00\x00\x08\x07\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00')
|
|
|
|
= HTTP/2 Dissect Go Away Frame: Arbitrary error with additional data
|
|
~ http2 frame dissect goaway
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x10\x07\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\xe2@\x00\x00\x00\x00\x00\x00\x00\x00') #Go Away with debug data
|
|
assert(pkt.type == 7)
|
|
assert(pkt.len == 16)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 0)
|
|
assert(isinstance(pkt.payload, h2.H2GoAwayFrame))
|
|
assert(pkt[h2.H2GoAwayFrame])
|
|
gf = pkt[h2.H2GoAwayFrame]
|
|
assert(gf.reserved == 0)
|
|
assert(gf.last_stream_id == 2)
|
|
assert(gf.error == 123456)
|
|
assert(gf.additional_data == 8*b'\x00')
|
|
assert(isinstance(gf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Go Away Frame: Arbitrary error with additional data
|
|
~ http2 frame build goaway
|
|
|
|
p = h2.H2Frame()/h2.H2GoAwayFrame(
|
|
last_stream_id=2,
|
|
error=123456,
|
|
additional_data=b'\x00'*8
|
|
)
|
|
assert(raw(p) == b'\x00\x00\x10\x07\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\xe2@\x00\x00\x00\x00\x00\x00\x00\x00')
|
|
|
|
+ HTTP/2 Window Update Frame Test Suite
|
|
|
|
= HTTP/2 Dissect Window Update Frame: global
|
|
~ http2 frame dissect winupdate
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x04\x08\x00\x00\x00\x00\x00\x00\x01\xe2@') #Window update with increment for connection
|
|
assert(pkt.type == 8)
|
|
assert(pkt.len == 4)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 0)
|
|
assert(isinstance(pkt.payload, h2.H2WindowUpdateFrame))
|
|
assert(pkt[h2.H2WindowUpdateFrame])
|
|
wf = pkt[h2.H2WindowUpdateFrame]
|
|
assert(wf.reserved == 0)
|
|
assert(wf.win_size_incr == 123456)
|
|
assert(isinstance(wf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Window Update Frame: global
|
|
~ http2 frame build winupdate
|
|
|
|
p = h2.H2Frame()/h2.H2WindowUpdateFrame(win_size_incr=123456)
|
|
assert(raw(p) == b'\x00\x00\x04\x08\x00\x00\x00\x00\x00\x00\x01\xe2@')
|
|
|
|
= HTTP/2 Dissect Window Update Frame: a stream
|
|
~ http2 frame dissect winupdate
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x04\x08\x00\x00\x00\x00\x01\x00\x01\xe2@') #Window update with increment for a stream
|
|
assert(pkt.type == 8)
|
|
assert(pkt.len == 4)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2WindowUpdateFrame))
|
|
assert(pkt[h2.H2WindowUpdateFrame])
|
|
wf = pkt[h2.H2WindowUpdateFrame]
|
|
assert(wf.reserved == 0)
|
|
assert(wf.win_size_incr == 123456)
|
|
assert(isinstance(wf.payload, scapy.packet.NoPayload))
|
|
|
|
= HTTP/2 Build Window Update Frame: a stream
|
|
~ http2 frame build winupdate
|
|
|
|
p = h2.H2Frame(stream_id=1)/h2.H2WindowUpdateFrame(win_size_incr=123456)
|
|
assert(raw(p) == b'\x00\x00\x04\x08\x00\x00\x00\x00\x01\x00\x01\xe2@')
|
|
|
|
+ HTTP/2 Continuation Frame Test Suite
|
|
|
|
= HTTP/2 Dissect Continuation Frame: no flag & headers with compression and hdr_name
|
|
~ http2 frame dissect continuation
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x11\t\x00\x00\x00\x00\x01@\x8c\xfc[i{ZT$\xb2-\xc8\xc9\x9f\x02Me')
|
|
assert(pkt.type == 9)
|
|
assert(pkt.len == 17)
|
|
assert(len(pkt.flags) == 0)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(isinstance(pkt.payload, h2.H2ContinuationFrame))
|
|
assert(pkt[h2.H2ContinuationFrame])
|
|
hf = pkt[h2.H2ContinuationFrame]
|
|
assert(len(hf.hdrs) == 1)
|
|
assert(isinstance(hf.payload, scapy.packet.NoPayload))
|
|
hdr = hf.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithIncrIndexing))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.type == 1)
|
|
assert(hdr.hdr_name.len == 12)
|
|
assert(hdr.hdr_name.getfieldval('data').origin() == 'X-Requested-With')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.type == 0)
|
|
assert(hdr.hdr_value.len == 2)
|
|
assert(hdr.hdr_value.getfieldval('data').origin() == 'Me')
|
|
|
|
= HTTP/2 Build Continuation Frame: no flag & headers with compression and hdr_name
|
|
~ http2 frame build continuation
|
|
|
|
p = h2.H2Frame(stream_id=1)/h2.H2ContinuationFrame(
|
|
hdrs=[
|
|
h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Requested-With')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('Me'))
|
|
)
|
|
]
|
|
)
|
|
assert(raw(p) == b'\x00\x00\x11\t\x00\x00\x00\x00\x01@\x8c\xfc[i{ZT$\xb2-\xc8\xc9\x9f\x02Me')
|
|
|
|
= HTTP/2 Dissect Continuation Frame: flag END_Header & headers with compression, sensitive flag and hdr_name
|
|
~ http2 frame dissect continuation
|
|
|
|
pkt = h2.H2Frame(b'\x00\x00\x11\t\x04\x00\x00\x00\x01\x10\x8c\xfc[i{ZT$\xb2-\xc8\xc9\x9f\x02Me')
|
|
assert(pkt.type == 9)
|
|
assert(pkt.len == 17)
|
|
assert(len(pkt.flags) == 1)
|
|
assert('EH' in pkt.flags)
|
|
assert(pkt.reserved == 0)
|
|
assert(pkt.stream_id == 1)
|
|
assert(flags_bit_pattern.search(pkt.show(dump=True)) is None)
|
|
assert(isinstance(pkt.payload, h2.H2ContinuationFrame))
|
|
assert(pkt[h2.H2ContinuationFrame])
|
|
hf = pkt[h2.H2ContinuationFrame]
|
|
assert(len(hf.hdrs) == 1)
|
|
assert(isinstance(hf.payload, scapy.packet.NoPayload))
|
|
hdr = hf.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 1)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.type == 1)
|
|
assert(hdr.hdr_name.len == 12)
|
|
assert(hdr.hdr_name.getfieldval('data').origin() == 'X-Requested-With')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.type == 0)
|
|
assert(hdr.hdr_value.len == 2)
|
|
assert(hdr.hdr_value.getfieldval('data').origin() == 'Me')
|
|
|
|
= HTTP/2 Build Continuation Frame: flag END_Header & headers with compression, sensitive flag and hdr_name
|
|
~ http2 frame build continuation
|
|
|
|
p = h2.H2Frame(flags={'EH'}, stream_id=1)/h2.H2ContinuationFrame(
|
|
hdrs=[
|
|
h2.HPackLitHdrFldWithoutIndexing(
|
|
never_index=1,
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Requested-With')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('Me'))
|
|
)
|
|
]
|
|
)
|
|
assert(raw(p) == b'\x00\x00\x11\t\x04\x00\x00\x00\x01\x10\x8c\xfc[i{ZT$\xb2-\xc8\xc9\x9f\x02Me')
|
|
|
|
+ HTTP/2 HPackHdrTable Test Suite
|
|
|
|
= HTTP/2 HPackHdrEntry Tests
|
|
~ http2 hpack hpackhdrtable
|
|
|
|
n = 'X-Requested-With'
|
|
v = 'Me'
|
|
h = h2.HPackHdrEntry(n, v)
|
|
assert(len(h) == 32 + len(n) + len(v))
|
|
assert(h.name() == n.lower())
|
|
assert(h.value() == v)
|
|
assert(str(h) == '{}: {}'.format(n.lower(), v))
|
|
|
|
n = ':status'
|
|
v = '200'
|
|
h = h2.HPackHdrEntry(n, v)
|
|
assert(len(h) == 32 + len(n) + len(v))
|
|
assert(h.name() == n.lower())
|
|
assert(h.value() == v)
|
|
assert(str(h) == '{} {}'.format(n.lower(), v))
|
|
|
|
= HTTP/2 HPackHdrTable : Querying Static Entries
|
|
~ http2 hpack hpackhdrtable
|
|
|
|
# In RFC7541, the table is 1-based
|
|
assert(expect_exception(KeyError, 'h2.HPackHdrTable()[0]'))
|
|
|
|
h = h2.HPackHdrTable()
|
|
assert(h[1].name() == ':authority')
|
|
assert(h[7].name() == ':scheme')
|
|
assert(h[7].value() == 'https')
|
|
assert(str(h[14]) == ':status 500')
|
|
assert(str(h[16]) == 'accept-encoding: gzip, deflate')
|
|
|
|
assert(expect_exception(KeyError, 'h2.HPackHdrTable()[h2.HPackHdrTable._static_entries_last_idx+1]'))
|
|
|
|
= HTTP/2 HPackHdrTable : Addind Dynamic Entries without overflowing the table
|
|
~ http2 hpack hpackhdrtable
|
|
|
|
tbl = h2.HPackHdrTable(dynamic_table_max_size=1<<32, dynamic_table_cap_size=1<<32)
|
|
hdr = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString('PHPSESSID=abcdef0123456789'))
|
|
)
|
|
tbl.register(hdr)
|
|
|
|
tbl = h2.HPackHdrTable(dynamic_table_max_size=1<<32, dynamic_table_cap_size=1<<32)
|
|
hdr2 = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString('JSESSID=abcdef0123456789'))
|
|
)
|
|
tbl.register([hdr,hdr2])
|
|
|
|
tbl = h2.HPackHdrTable(dynamic_table_max_size=1<<32, dynamic_table_cap_size=1<<32)
|
|
hdr3 = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString('Test=abcdef0123456789'))
|
|
)
|
|
frm = h2.H2Frame(stream_id=1)/h2.H2HeadersFrame(hdrs=[hdr, hdr2, hdr3])
|
|
tbl.register(frm)
|
|
|
|
|
|
= HTTP/2 HPackHdrTable : Querying Dynamic Entries
|
|
~ http2 hpack hpackhdrtable
|
|
|
|
tbl = h2.HPackHdrTable(dynamic_table_max_size=1<<32, dynamic_table_cap_size=1<<32)
|
|
hdrv = 'PHPSESSID=abcdef0123456789'
|
|
hdr = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString(hdrv))
|
|
)
|
|
tbl.register(hdr)
|
|
|
|
hdrv2 = 'JSESSID=abcdef0123456789'
|
|
hdr2 = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString(hdrv2))
|
|
)
|
|
tbl.register(hdr2)
|
|
|
|
hdr3 = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=0,
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackLiteralString('x-requested-by')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString('me'))
|
|
)
|
|
tbl.register(hdr3)
|
|
|
|
assert(tbl.get_idx_by_name('x-requested-by') == h2.HPackHdrTable._static_entries_last_idx+1)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+2].value() == hdrv2)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+3].value() == hdrv)
|
|
|
|
= HTTP/2 HPackHdrTable : Addind already registered Dynamic Entries without overflowing the table
|
|
~ http2 hpack hpackhdrtable
|
|
|
|
tbl = h2.HPackHdrTable(dynamic_table_max_size=1<<32, dynamic_table_cap_size=1<<32)
|
|
|
|
assert(len(tbl) == 0)
|
|
|
|
hdrv = 'PHPSESSID=abcdef0123456789'
|
|
hdr = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString(hdrv))
|
|
)
|
|
tbl.register(hdr)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv)
|
|
|
|
hdr2v = 'JSESSID=abcdef0123456789'
|
|
hdr2 = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString(hdr2v))
|
|
)
|
|
tbl.register(hdr2)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdr2v)
|
|
|
|
l = len(tbl)
|
|
tbl.register(hdr)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+2].value() == hdr2v)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+3].value() == hdrv)
|
|
|
|
= HTTP/2 HPackHdrTable : Addind Dynamic Entries and overflowing the table
|
|
~ http2 hpack hpackhdrtable
|
|
|
|
tbl = h2.HPackHdrTable(dynamic_table_max_size=80, dynamic_table_cap_size=80)
|
|
hdrv = 'PHPSESSID=abcdef0123456789'
|
|
hdr = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString(hdrv))
|
|
)
|
|
tbl.register(hdr)
|
|
assert(len(tbl) <= 80)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv)
|
|
|
|
hdrv2 = 'JSESSID=abcdef0123456789'
|
|
hdr2 = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString(hdrv2))
|
|
)
|
|
tbl.register(hdr2)
|
|
assert(len(tbl) <= 80)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv2)
|
|
try:
|
|
tbl[h2.HPackHdrTable._static_entries_last_idx+2]
|
|
ret = False
|
|
except Exception:
|
|
ret = True
|
|
|
|
assert(ret)
|
|
|
|
|
|
= HTTP/2 HPackHdrTable : Resizing
|
|
~ http2 hpack hpackhdrtable
|
|
|
|
tbl = h2.HPackHdrTable()
|
|
hdrv = 'PHPSESSID=abcdef0123456789'
|
|
hdr = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString(hdrv))
|
|
)
|
|
tbl.register(hdr)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv)
|
|
|
|
hdrv2 = 'JSESSID=abcdef0123456789'
|
|
hdr2 = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString(hdrv2))
|
|
)
|
|
tbl.register(hdr2)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv2)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+2].value() == hdrv)
|
|
|
|
#Resizing to a value higher than cap (default:4096)
|
|
try:
|
|
tbl.resize(8192)
|
|
ret = False
|
|
except AssertionError:
|
|
ret = True
|
|
|
|
assert(ret)
|
|
#Resizing to a lower value by that is not small enough to cause eviction
|
|
tbl.resize(1024)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv2)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+2].value() == hdrv)
|
|
#Resizing to a higher value but thatt is lower than cap
|
|
tbl.resize(2048)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv2)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+2].value() == hdrv)
|
|
#Resizing to a lower value that causes eviction
|
|
tbl.resize(80)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv2)
|
|
try:
|
|
tbl[h2.HPackHdrTable._static_entries_last_idx+2]
|
|
ret = False
|
|
except Exception:
|
|
ret = True
|
|
|
|
assert(ret)
|
|
|
|
= HTTP/2 HPackHdrTable : Recapping
|
|
~ http2 hpack hpackhdrtable
|
|
|
|
tbl = h2.HPackHdrTable()
|
|
hdrv = 'PHPSESSID=abcdef0123456789'
|
|
hdr = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString(hdrv))
|
|
)
|
|
tbl.register(hdr)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv)
|
|
|
|
hdrv2 = 'JSESSID=abcdef0123456789'
|
|
hdr2 = h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=32,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString(hdrv2))
|
|
)
|
|
tbl.register(hdr2)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv2)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+2].value() == hdrv)
|
|
|
|
#Recapping to a higher value
|
|
tbl.recap(8192)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv2)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+2].value() == hdrv)
|
|
|
|
#Recapping to a low value but without causing eviction
|
|
tbl.recap(1024)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv2)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+2].value() == hdrv)
|
|
|
|
#Recapping to a low value that causes evictiontbl.recap(1024)
|
|
tbl.recap(80)
|
|
assert(tbl[h2.HPackHdrTable._static_entries_last_idx+1].value() == hdrv2)
|
|
try:
|
|
tbl[h2.HPackHdrTable._static_entries_last_idx+2]
|
|
ret = False
|
|
except Exception:
|
|
ret = True
|
|
|
|
assert(ret)
|
|
|
|
= HTTP/2 HPackHdrTable : Generating Textual Representation
|
|
~ http2 hpack hpackhdrtable helpers
|
|
|
|
h = h2.HPackHdrTable()
|
|
h.register(h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Generation-Date')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('2016-08-11'))
|
|
))
|
|
|
|
hdrs_lst = [
|
|
h2.HPackIndexedHdr(index=2), #Method Get
|
|
h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=h.get_idx_by_name(':path'),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('/index.php'))
|
|
),
|
|
h2.HPackIndexedHdr(index=7), #Scheme HTTPS
|
|
h2.HPackIndexedHdr(index=h2.HPackHdrTable._static_entries_last_idx+2),
|
|
h2.HPackLitHdrFldWithIncrIndexing(
|
|
index=58,
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackZString('Mozilla/5.0 Generated by hand'))
|
|
),
|
|
h2.HPackLitHdrFldWithoutIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Generated-By')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('Me'))
|
|
)
|
|
]
|
|
|
|
p = h2.H2Frame(stream_id = 1)/h2.H2HeadersFrame(hdrs=hdrs_lst)
|
|
|
|
expected_output = ''':method GET
|
|
:path /index.php
|
|
:scheme https
|
|
x-generation-date: 2016-08-11
|
|
user-agent: Mozilla/5.0 Generated by hand
|
|
X-Generated-By: Me'''
|
|
|
|
assert(h.gen_txt_repr(p) == expected_output)
|
|
|
|
= HTTP/2 HPackHdrTable : Parsing Textual Representation
|
|
~ http2 hpack hpackhdrtable helpers
|
|
|
|
body = b'login=titi&passwd=toto'
|
|
hdrs = ''':method POST
|
|
:path /login.php
|
|
:scheme https
|
|
content-type: application/x-www-form-urlencoded
|
|
content-length: {}
|
|
user-agent: Mozilla/5.0 Generated by hand
|
|
x-generated-by: Me
|
|
x-generation-date: 2016-08-11
|
|
x-generation-software: scapy
|
|
'''.format(len(body)).encode()
|
|
|
|
h = h2.HPackHdrTable()
|
|
h.register(h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Generation-Date')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('2016-08-11'))
|
|
))
|
|
seq = h.parse_txt_hdrs(
|
|
hdrs,
|
|
stream_id=1,
|
|
body=body,
|
|
should_index=lambda name: name in ['user-agent', 'x-generation-software'],
|
|
is_sensitive=lambda name, value: name in ['x-generated-by', ':path']
|
|
)
|
|
assert(isinstance(seq, h2.H2Seq))
|
|
assert(len(seq.frames) == 2)
|
|
p = seq.frames[0]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 1)
|
|
assert(len(p.flags) == 1)
|
|
assert('EH' in p.flags)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2HeadersFrame))
|
|
hdrs_frm = p[h2.H2HeadersFrame]
|
|
assert(len(p.hdrs) == 9)
|
|
hdr = p.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 3)
|
|
hdr = p.hdrs[1]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 1)
|
|
assert(hdr.index in [4, 5])
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(/login.php)')
|
|
hdr = p.hdrs[2]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 7)
|
|
hdr = p.hdrs[3]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 31)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(application/x-www-form-urlencoded)')
|
|
hdr = p.hdrs[4]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 28)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(22)')
|
|
hdr = p.hdrs[5]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithIncrIndexing))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 58)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(Mozilla/5.0 Generated by hand)')
|
|
hdr = p.hdrs[6]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 1)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-generated-by)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(Me)')
|
|
hdr = p.hdrs[7]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 63)
|
|
hdr = p.hdrs[8]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithIncrIndexing))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-generation-software)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(scapy)')
|
|
|
|
p = seq.frames[1]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 0)
|
|
assert(len(p.flags) == 1)
|
|
assert('ES' in p.flags)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2DataFrame))
|
|
pay = p[h2.H2DataFrame]
|
|
assert(pay.data == body)
|
|
|
|
= HTTP/2 HPackHdrTable : Parsing Textual Representation without body
|
|
~ http2 hpack hpackhdrtable helpers
|
|
|
|
hdrs = b''':method POST
|
|
:path /login.php
|
|
:scheme https
|
|
user-agent: Mozilla/5.0 Generated by hand
|
|
x-generated-by: Me
|
|
x-generation-date: 2016-08-11
|
|
'''
|
|
|
|
h = h2.HPackHdrTable()
|
|
h.register(h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Generation-Date')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('2016-08-11'))
|
|
))
|
|
|
|
# Without body
|
|
seq = h.parse_txt_hdrs(hdrs, stream_id=1)
|
|
assert(isinstance(seq, h2.H2Seq))
|
|
#This is the first major difference with the first test
|
|
assert(len(seq.frames) == 1)
|
|
p = seq.frames[0]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 1)
|
|
assert(len(p.flags) == 2)
|
|
assert('EH' in p.flags)
|
|
#This is the second major difference with the first test
|
|
assert('ES' in p.flags)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2HeadersFrame))
|
|
hdrs_frm = p[h2.H2HeadersFrame]
|
|
assert(len(p.hdrs) == 6)
|
|
hdr = p.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 3)
|
|
hdr = p.hdrs[1]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index in [4, 5])
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(/login.php)')
|
|
hdr = p.hdrs[2]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 7)
|
|
hdr = p.hdrs[3]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 58)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(Mozilla/5.0 Generated by hand)')
|
|
hdr = p.hdrs[4]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-generated-by)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(Me)')
|
|
hdr = p.hdrs[5]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 62)
|
|
|
|
|
|
= HTTP/2 HPackHdrTable : Parsing Textual Representation with too small max frame
|
|
~ http2 hpack hpackhdrtable helpers
|
|
|
|
body = b'login=titi&passwd=toto'
|
|
hdrs = ''':method POST
|
|
:path /login.php
|
|
:scheme https
|
|
content-type: application/x-www-form-urlencoded
|
|
content-length: {}
|
|
user-agent: Mozilla/5.0 Generated by hand
|
|
x-generated-by: Me
|
|
x-generation-date: 2016-08-11
|
|
x-long-header: {}
|
|
'''.format(len(body), 'a'*5000).encode()
|
|
|
|
h = h2.HPackHdrTable()
|
|
h.register(h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Generation-Date')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('2016-08-11'))
|
|
))
|
|
|
|
#x-long-header is too long to fit in any frames (whose default max size is 4096)
|
|
expect_exception(Exception, "seq = h.parse_txt_hdrs('''{}''', stream_id=1".format(hdrs))
|
|
|
|
= HTTP/2 HPackHdrTable : Parsing Textual Representation with very large header and a large authorized frame size
|
|
~ http2 hpack hpackhdrtable helpers
|
|
|
|
body = b'login=titi&passwd=toto'
|
|
hdrs = ''':method POST
|
|
:path /login.php
|
|
:scheme https
|
|
content-type: application/x-www-form-urlencoded
|
|
content-length: {}
|
|
user-agent: Mozilla/5.0 Generated by hand
|
|
x-generated-by: Me
|
|
x-generation-date: 2016-08-11
|
|
x-long-header: {}
|
|
'''.format(len(body), 'a'*5000).encode()
|
|
|
|
h = h2.HPackHdrTable()
|
|
h.register(h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Generation-Date')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('2016-08-11'))
|
|
))
|
|
|
|
# Now trying to parse it with a max frame size large enough for x-long-header to
|
|
# fit in a frame
|
|
seq = h.parse_txt_hdrs(hdrs, stream_id=1, max_frm_sz=8192)
|
|
assert(isinstance(seq, h2.H2Seq))
|
|
assert(len(seq.frames) == 1)
|
|
p = seq.frames[0]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 1)
|
|
assert(len(p.flags) == 2)
|
|
assert('EH' in p.flags)
|
|
assert('ES' in p.flags)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2HeadersFrame))
|
|
hdrs_frm = p[h2.H2HeadersFrame]
|
|
assert(len(p.hdrs) == 9)
|
|
hdr = p.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 3)
|
|
hdr = p.hdrs[1]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index in [4, 5])
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(/login.php)')
|
|
hdr = p.hdrs[2]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 7)
|
|
hdr = p.hdrs[3]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 31)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(application/x-www-form-urlencoded)')
|
|
hdr = p.hdrs[4]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 28)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(22)')
|
|
hdr = p.hdrs[5]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 58)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(Mozilla/5.0 Generated by hand)')
|
|
hdr = p.hdrs[6]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-generated-by)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(Me)')
|
|
hdr = p.hdrs[7]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 62)
|
|
hdr = p.hdrs[8]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-long-header)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString({})'.format('a'*5000))
|
|
|
|
= HTTP/2 HPackHdrTable : Parsing Textual Representation with two very large headers and a large authorized frame size
|
|
~ http2 hpack hpackhdrtable helpers
|
|
|
|
body = b'login=titi&passwd=toto'
|
|
hdrs = ''':method POST
|
|
:path /login.php
|
|
:scheme https
|
|
content-type: application/x-www-form-urlencoded
|
|
content-length: {}
|
|
user-agent: Mozilla/5.0 Generated by hand
|
|
x-generated-by: Me
|
|
x-generation-date: 2016-08-11
|
|
x-long-header: {}
|
|
x-long-header: {}
|
|
'''.format(len(body), 'a'*5000, 'b'*5000).encode()
|
|
|
|
h = h2.HPackHdrTable()
|
|
h.register(h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Generation-Date')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('2016-08-11'))
|
|
))
|
|
|
|
# Now trying to parse it with a max frame size large enough for x-long-header to
|
|
# fit in a frame but a maximum header fragment size that is not large enough to
|
|
# store two x-long-header
|
|
seq = h.parse_txt_hdrs(hdrs, stream_id=1, max_frm_sz=8192)
|
|
assert(isinstance(seq, h2.H2Seq))
|
|
assert(len(seq.frames) == 2)
|
|
p = seq.frames[0]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 1)
|
|
assert(len(p.flags) == 1)
|
|
assert('ES' in p.flags)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2HeadersFrame))
|
|
hdrs_frm = p[h2.H2HeadersFrame]
|
|
assert(len(p.hdrs) == 9)
|
|
hdr = p.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 3)
|
|
hdr = p.hdrs[1]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index in [4, 5])
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(/login.php)')
|
|
hdr = p.hdrs[2]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 7)
|
|
hdr = p.hdrs[3]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 31)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(application/x-www-form-urlencoded)')
|
|
hdr = p.hdrs[4]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 28)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(22)')
|
|
hdr = p.hdrs[5]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 58)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(Mozilla/5.0 Generated by hand)')
|
|
hdr = p.hdrs[6]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-generated-by)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(Me)')
|
|
hdr = p.hdrs[7]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 62)
|
|
hdr = p.hdrs[8]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-long-header)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString({})'.format('a'*5000))
|
|
p = seq.frames[1]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 9)
|
|
assert(len(p.flags) == 1)
|
|
assert('EH' in p.flags)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2ContinuationFrame))
|
|
hdrs_frm = p[h2.H2ContinuationFrame]
|
|
assert(len(p.hdrs) == 1)
|
|
hdr = p.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-long-header)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString({})'.format('b'*5000))
|
|
|
|
= HTTP/2 HPackHdrTable : Parsing Textual Representation with two very large headers, a large authorized frame size and a "small" max header list size
|
|
~ http2 hpack hpackhdrtable helpers
|
|
|
|
body = b'login=titi&passwd=toto'
|
|
hdrs = ''':method POST
|
|
:path /login.php
|
|
:scheme https
|
|
content-type: application/x-www-form-urlencoded
|
|
content-length: {}
|
|
user-agent: Mozilla/5.0 Generated by hand
|
|
x-generated-by: Me
|
|
x-generation-date: 2016-08-11
|
|
x-long-header: {}
|
|
x-long-header: {}
|
|
'''.format(len(body), 'a'*5000, 'b'*5000).encode()
|
|
|
|
h = h2.HPackHdrTable()
|
|
h.register(h2.HPackLitHdrFldWithIncrIndexing(
|
|
hdr_name=h2.HPackHdrString(data=h2.HPackZString('X-Generation-Date')),
|
|
hdr_value=h2.HPackHdrString(data=h2.HPackLiteralString('2016-08-11'))
|
|
))
|
|
|
|
# Now trying to parse it with a max frame size large enough for x-long-header to
|
|
# fit in a frame but and a max header list size that is large enough to fit one
|
|
# but not two
|
|
seq = h.parse_txt_hdrs(hdrs, stream_id=1, max_frm_sz=8192, max_hdr_lst_sz=5050)
|
|
assert(isinstance(seq, h2.H2Seq))
|
|
assert(len(seq.frames) == 3)
|
|
p = seq.frames[0]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 1)
|
|
assert(len(p.flags) == 1)
|
|
assert('ES' in p.flags)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2HeadersFrame))
|
|
hdrs_frm = p[h2.H2HeadersFrame]
|
|
assert(len(p.hdrs) == 8)
|
|
hdr = p.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 3)
|
|
hdr = p.hdrs[1]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index in [4, 5])
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(/login.php)')
|
|
hdr = p.hdrs[2]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 7)
|
|
hdr = p.hdrs[3]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 31)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(application/x-www-form-urlencoded)')
|
|
hdr = p.hdrs[4]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 28)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(22)')
|
|
hdr = p.hdrs[5]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 58)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(Mozilla/5.0 Generated by hand)')
|
|
hdr = p.hdrs[6]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-generated-by)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(Me)')
|
|
hdr = p.hdrs[7]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 62)
|
|
p = seq.frames[1]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 9)
|
|
assert(len(p.flags) == 0)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2ContinuationFrame))
|
|
hdrs_frm = p[h2.H2ContinuationFrame]
|
|
assert(len(p.hdrs) == 1)
|
|
hdr = p.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-long-header)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString({})'.format('a'*5000))
|
|
p = seq.frames[2]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 9)
|
|
assert(len(p.flags) == 1)
|
|
assert('EH' in p.flags)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2ContinuationFrame))
|
|
hdrs_frm = p[h2.H2ContinuationFrame]
|
|
assert(len(p.hdrs) == 1)
|
|
hdr = p.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-long-header)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString({})'.format('b'*5000))
|
|
|
|
= HTTP/2 HPackHdrTable : Parsing Textual Representation with sensitive headers and non-indexable ones
|
|
~ http2 hpack hpackhdrtable helpers
|
|
|
|
hdrs = ''':method POST
|
|
:path /login.php
|
|
:scheme https
|
|
content-type: application/x-www-form-urlencoded
|
|
content-length: {}
|
|
user-agent: Mozilla/5.0 Generated by hand
|
|
x-generated-by: Me
|
|
x-generation-date: 2016-08-11
|
|
'''.format(len(body)).encode()
|
|
|
|
h = h2.HPackHdrTable()
|
|
seq = h.parse_txt_hdrs(hdrs, stream_id=1, body=body, is_sensitive=lambda n,v: n in ['x-generation-date'], should_index=lambda x: x != 'x-generated-by')
|
|
assert(isinstance(seq, h2.H2Seq))
|
|
assert(len(seq.frames) == 2)
|
|
p = seq.frames[0]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 1)
|
|
assert(len(p.flags) == 1)
|
|
assert('EH' in p.flags)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2HeadersFrame))
|
|
hdrs_frm = p[h2.H2HeadersFrame]
|
|
assert(len(p.hdrs) == 8)
|
|
hdr = p.hdrs[0]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 3)
|
|
hdr = p.hdrs[1]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithIncrIndexing))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index in [4, 5])
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(/login.php)')
|
|
hdr = p.hdrs[2]
|
|
assert(isinstance(hdr, h2.HPackIndexedHdr))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 7)
|
|
hdr = p.hdrs[3]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithIncrIndexing))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 31)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(application/x-www-form-urlencoded)')
|
|
hdr = p.hdrs[4]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithIncrIndexing))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 28)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(22)')
|
|
hdr = p.hdrs[5]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithIncrIndexing))
|
|
assert(hdr.magic == 1)
|
|
assert(hdr.index == 58)
|
|
assert(hdr.hdr_name is None)
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(Mozilla/5.0 Generated by hand)')
|
|
hdr = p.hdrs[6]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 0)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-generated-by)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackLiteralString(Me)')
|
|
hdr = p.hdrs[7]
|
|
assert(isinstance(hdr, h2.HPackLitHdrFldWithoutIndexing))
|
|
assert(hdr.magic == 0)
|
|
assert(hdr.never_index == 1)
|
|
assert(hdr.index == 0)
|
|
assert(isinstance(hdr.hdr_name, h2.HPackHdrString))
|
|
assert(hdr.hdr_name.data == 'HPackZString(x-generation-date)')
|
|
assert(isinstance(hdr.hdr_value, h2.HPackHdrString))
|
|
assert(hdr.hdr_value.data == 'HPackZString(2016-08-11)')
|
|
p = seq.frames[1]
|
|
assert(isinstance(p, h2.H2Frame))
|
|
assert(p.type == 0)
|
|
assert(len(p.flags) == 1)
|
|
assert('ES' in p.flags)
|
|
assert(p.stream_id == 1)
|
|
assert(isinstance(p.payload, h2.H2DataFrame))
|
|
pay = p[h2.H2DataFrame]
|
|
assert(pay.data == body)
|