| % 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') |
| #Adjustement 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: |
| 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: |
| 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: |
| 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: |
| 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: |
| 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: |
| 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 = raw(''':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))) |
| |
| 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 = raw(''':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)) |
| |
| 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 = raw(''':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)) |
| |
| 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 = raw(''':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)) |
| |
| 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 = raw(''':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)) |
| |
| 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 = raw(''':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))) |
| |
| 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) |
