h" dZddlZddlZddlmZddlZddlmZmZm Z m Z m Z m Z ddl mZmZmZmZmZmZmZmZddlmZddlmZddlmZddlmZddlmZddl m!Z!Gddej"Z#Gd d ej$Z%Gd d e%Z&Gd de%Z'Gddeej(Z)Gdde)Z*Gdde+Z,Gdde+Z-Gdde.Z/Gdde)Z0Gddej$Z1Gddej2Z3Gd d!ej2Z4Gd"d#e4Z5Gd$d%e4Z6Gd&d'e4Z7Gd(d)e4Z8Gd*d+ej2Z9Gd,d-e9Z:Gd.d/e:Z;Gd0d1e9Z<Gd2d3e<Z=Gd4d5e<Z>Gd6d7e<Z?Gd8d9e<Z@Gd:d;e9ZAGd<d=e+ZBGd>d?e9ZCGd@dAej2ZDGdBdCe9ZEGdDdEe9ZFGdFdGeFZGGdHdIe9ZHGdJdKe9ZIGdLdMe9ZJGdNdOe9ZKdPdQdRdSdTdUdVdWdXdYdZ ZLGd[d\ej2ZMGd]d^ej2ZNejOeMe:d_e:jPiejOeMe;d_e:jPiejOeMe=d_e=jPiejOeMe>d_e=jPiejOeMe?d_e=jPiejOeMe@d_e=jPiejOeMeAd_eAjPiejOeMeCd_eCjPiejOeMeEd_eEjPiejOeMeHd_eHjPiejOeMeFd_eFjPiejOeMeGd_eGjPiejOeMeId_eIjPiejOeMeJd_eJjPiejOeMeKd_eKjPie d`ZQGdadbeZRGdcddeZSdS)ez http2 HTTP/2 support for Scapy see RFC7540 and RFC7541 for more information Implements packets and fields required to encode/decode HTTP/2 Frames and HPack encoded headers N)BytesIO)raw plain_str hex_bytesorbchb bytes_encode)OptionalListUnionCallableAnyTupleSizedPattern)Packet_metaclasscneZdZdZdgZfdZfdZfdZfdZfdZ fdZ fd Z fd Z xZ S) HPackMagicBitFielda, HPackMagicBitField is a BitField variant that cannot be assigned another value than the default one. This field must not be used where there is potential for fuzzing. OTOH, this field makes sense (for instance, if the magic bits are used by a dispatcher to select the payload class) _magicc|dksJ|dksJ||_tt||||dS)z :param str name: this field instance name. :param int default: this field only valid value. :param int size: this bitfield bitlength. :return: None :raises: AssertionError rN)rsuperr__init__selfnamedefaultsize __class__s W/mounts/lovelace/software/anaconda3/lib/python3.11/site-packages/scapy/contrib/http2.pyrzHPackMagicBitField.__init__>sO!||||qyyyy   $''00wEEEEEc||jks#Jd|j|tt||||jS)a% :param packet.Packet|None pkt: the packet instance containing this field instance; probably unused. # noqa: E501 :param str|(str, int, long) s: either a str if 0 == size%8 or a tuple with the string to add this field to, the # noqa: E501 number of bits already generated and the generated value so far. :param int val: unused; must be equal to default value :return: str|(str, int, long): the s string extended with this field machine representation # noqa: E501 :raises: AssertionError z)val parameter must value {}; received: {})rformatrraddfieldrpktsvalrs rr#zHPackMagicBitField.addfieldMs[dk!!!#N#U#UVZVacf#g#g!!!'..77Q LLLr c*tt|||}t|tr.t |dkrt|dt s Jd|d|jks Jd|S)ad :param packet.Packet|None pkt: the packet instance containing this field instance; probably unused. # noqa: E501 :param str|(str, int) s: either a str if size%8==0 or a tuple with the string to parse from and the number of # noqa: E501 bits already consumed by previous bitfield-compatible fields. :return: (str|(str, int), int): Returns the remaining string and the parsed value. May return a tuple if there # noqa: E501 are remaining bits to parse in the first byte. Returned value is equal to default value # noqa: E501 :raises: AssertionError zeSecond element of BitField.getfield return value expected to be an int or a long; API change detectedz>Invalid value parsed from s; error in class guessing detected!)rrgetfield isinstancetuplelenintr)rr%r&rrs rr+zHPackMagicBitField.getfieldZs $d + + 4 4S! < < q%  s FFaKK qtS ! ! K r KKtt{"""$d"""r c||jks"Jd|jtt|||jSa :param packet.Packet|None pkt: the packet instance containing this field instance; probably unused # noqa: E501 :param int x: unused; must be equal to default value :return: int; default value :raises: AssertionError zOEINVAL: x: This field is magic. Do not attempt to modify it. Expected value: {})rr"rrh2irr%xrs rr3zHPackMagicBitField.h2imXDK ] d deiep q q '..223 DDDr c||jks"Jd|jtt|||jSr2)rr"rri2hr4s rr8zHPackMagicBitField.i2hyr6r ctt|||}||jks Jd|S)a :param packet.Packet|None pkt: the packet instance containing this field instance; probably unused # noqa: E501 :param int x: must be the machine representatino of the default value :return: int; default value :raises: AssertionError z@Invalid value parsed from m2i; error in class guessing detected!)rrm2ir)rr%r5r0rs rr:zHPackMagicBitField.m2isF $d + + / /Q 7 7DK!cr c||jks"Jd|jtt|||jSr2)rr"rri2mr4s rr<zHPackMagicBitField.i2mr6r c||jks"Jd|jtt|||jSr2)rr"rrany2ir4s rr>zHPackMagicBitField.any2isXDK ] d deiep q q '..44S$+FFFr )__name__ __module__ __qualname____doc__ __slots__rr#r+r3r8r:r<r> __classcell__rs@rrr5s  I F F F F F M M M M M& E E E E E E E E E E      E E E E E G G G G G G G G Gr rceZdZdZgdZ fdZdZdZdZdZ dZ d Z d Z d Z d Zed ZdZdZdZxZS)AbstractUVarIntFieldzEAbstractUVarIntField represents an integer as defined in RFC7541 ) _max_valuerrevc|t|tr|dksJd|cxkrdksnJtt|||||_d|jzdz |_d|_dS)aS :param str name: the name of this field instance :param int|None default: positive, null or None default value for this field instance. # noqa: E501 :param int size: the number of bits to consider in the first byte. Valid range is ]0;8] # noqa: E501 :return: None :raises: AssertionError Nrr*F)r,r/rrGrrrHrIrs rrzAbstractUVarIntField.__init__s:gs#;#;1 4}}}}1}}}}}} "D))224AAA  >Q.r c@t|tr|dksJ|S)z :param packet.Packet|None pkt: unused. :param int|None x: the value to convert. :return: int|None: the converted value. :raises: AssertionError r)r,r/rr%r5s rr3zAbstractUVarIntField.h2is%a%%/ar c|S)z :param packet.Packet|None pkt: unused. :param int|None x: the value to convert. :return:: int|None: the converted value. rMs rr8zAbstractUVarIntField.i2hs r ct|tst|dksJt||jz|jkS)a _detect_multi_byte returns whether the AbstractUVarIntField is represented on # noqa: E501 multiple bytes or not. A multibyte representation is indicated by all of the first size bits being set # noqa: E501 :param str fb: first byte, as a character. :return: bool: True if multibyte repr detected, else False. :raises: AssertionError r*)r,r/r.rrH)rfbs r_detect_multi_bytez'AbstractUVarIntField._detect_multi_bytes@"c""2c"ggllllB$/)do==r ct|dksJt|}d}d}t||}d}|dzrm||dz d|dz zzz }||kr'tjd||dz }||ks Jdt||}|dzm||d|dz zzz }||jz }|dksJ|S) a _parse_multi_byte parses x as a multibyte representation to get the int value of this AbstractUVarIntField. :param str s: the multibyte string to parse. :return: int: The parsed int value represented by this AbstractUVarIntField. # noqa: E501 :raises:: AssertionError :raises:: Scapy_Exception if the input value encodes an integer larger than 1<<64 # noqa: E501 r)rr*lzPout-of-bound value: the string encodes a value that is too large (>2^{{64}}): {}zNEINVAL: x: out-of-bound read: the string ends before the AbstractUVarIntField!)r.rerrorScapy_Exceptionr"rH)rr&tmp_lenvalueibyte max_values r_parse_multi_bytez&AbstractUVarIntField._parse_multi_bytes 1vv{{{{a&& 1Q4yy Tk  dTkqAE{3 3Ey  +fmmnstt FAw;;; p;;;qt99DTk  !q1u+&&  zzzz r ct|ts#t|tr |ddksJt|tr'd|dz |jks Jd|d}n,t|tr |jdks Jd|}||dr||}nt |d|jz}|dksJ|S)a A tuple is expected for the "x" param only if "size" is different than 8. If a tuple is received, some bits # noqa: E501 were consumed by another field. This field consumes the remaining bits, therefore the int of the tuple must # noqa: E501 equal "size". :param packet.Packet|None pkt: unused. :param str|(str, int) x: the string to convert. If bits were consumed by a previous bitfield-compatible field. # noqa: E501 :raises: AssertionError r*rrKzGEINVAL: x: not enough bits remaining in current byte to read the prefixzzAbstractUVarIntField.any2iGs ad $ $ H a   6666((3""Cc3'' 4C1HHHHJ 5 ! ! ((3""CsC(( 6SAXXXXJGGGGGr cHt|||S)z :param packet.Packet|None pkt: probably unused. :param x: int|None: the positive, null or none value to convert. :return: str: the representation of the value. reprr8rMs ri2reprzAbstractUVarIntField.i2repr_s DHHS!$$%%%r c |dksJt|tr.|jdks Jd||||zS||jkrM|dt |d|jz|jzz|||ddzS|dt |d|jzt |||zzS)a An AbstractUVarIntField prefix always consumes the remaining bits of a BitField;if no current BitField is in use (no tuple in entry) then the prefix length is 8 bits and the whole byte is to be consumed :param packet.Packet|None pkt: the packet containing this field. Probably unused. :param str|(str, int, long) s: the string to append this field to. A tuple indicates that some bits were already generated by another bitfield-compatible field. This MUST be the case if "size" is not 8. The int is the number of bits already generated in the first byte of the str. The long is the value that was generated by the previous bitfield-compatible fields. :param int val: the positive or null value to be added. :return: str: s concatenated with the machine representation of this field. :raises: AssertionError rrK>>#a>>>txxS))) ) $/ ! !Q4#qtty0DOCDDDtxxPSUXGYGYZ[Z\Z\G]] ]tc1Q449,DHHS#4F4F0G0GGHHHHr ct|dksJt|}d}t||dzdkr1|dz }||ks Jdt||dzdk1|dz}|dksJ|S)a _detect_bytelen_from_str returns the length of the machine representation of an AbstractUVarIntField starting at the beginning of s and which is assumed to expand over multiple bytes (value > _max_prefix_value). :param str s: the string to parse. It is assumed that it is a multibyte int. # noqa: E501 :return: The bytelength of the AbstractUVarIntField. :raises: AssertionError r)r*rTrzFEINVAL: s: out-of-bound read: unfinished AbstractUVarIntField detectedr.r)r&rXrZr`s r_detect_bytelen_from_strz-AbstractUVarIntField._detect_bytelen_from_strs1vv{{{{a&& !A$ii$"" FAw;;; h;;;!A$ii$""!eaxxxx r c|dksJ||jkrdS||jz}d}|dkr|dz }|dkr|dz}|dz }|dk|}|dksJ|S)z :param packet.Packet|None pkt: unused. :param int x: the positive or null value whose binary size if requested. # noqa: E501 :raises: AssertionError rr*rU)rH)rr%r5rZr`s ri2lenzAbstractUVarIntField.i2lensAvvvv t  1 T_  66 FA!ee !GA FA!eeaxxxx r ct|tr?t|dksJ|}|\}}|dksJd|z |jks Jd|}n,t|tr |jdks Jd|}||dr||}nd}||d|||f}|ddksJ|S)aI :param packet.Packet|None pkt: the packet instance containing this field; probably unused. :param str|(str, int) s: the input value to get this field value from. If size is 8, s is a string, else it is a tuple containing the value and an int indicating the number of bits already consumed in the first byte of the str. The number of remaining bits to consume in the first byte must be equal to "size". :return: (str, int): the remaining bytes of s and the parsed value. :raises: AssertionError r)rrKzGEINVAL: s: not enough bits remaining in current byte to read the prefixrmr*N)r,r-r.rr_rRrqr:) rr%r&temptstir'rXr`s rr+zAbstractUVarIntField.getfields a   q66Q;;;;DFB7777r6TY&&&(q&&&CCa'' zDINNNrkr# staticmethodrqrsr+r|rDrEs@rrGrGs,.--I &    > > >"""H8   .HHH0&&&#I#I#IJ\.0B#######r rGcFeZdZfdZfdZfdZfdZfdZxZS) UVarIntFieldc|dksJd|cxkrdksnJtt||||||_d|jzdz |_d|_dS)z :param str name: the name of this field instance. :param default: the default value for this field instance. default must be positive or null. # noqa: E501 :raises: AssertionError rrKr*FN)rrrrrHrIrs rrzUVarIntField.__init__su!||||4}}}}1}}}}}} lD!!**4$???  >Q.r ctt|||}t|t ds|dksJ|S)a< h2i is overloaded to restrict the acceptable x values (not None) :param packet.Packet|None pkt: the packet instance containing this field instance; probably unused. # noqa: E501 :param int x: the value to convert. :return: int: the converted value. :raises: AssertionError Nr)rrr3r,rgrr%r5r`rs rr3zUVarIntField.h2iKL$''++C33c4::..;3!8888 r ctt|||}t|t ds|dksJ|S)a< i2h is overloaded to restrict the acceptable x values (not None) :param packet.Packet|None pkt: the packet instance containing this field instance; probably unused. # noqa: E501 :param int x: the value to convert. :return: int: the converted value. :raises: AssertionError Nr)rrr8r,rgrs rr8zUVarIntField.i2hrr ctt|||}t|t ds|dksJ|S)aB any2i is overloaded to restrict the acceptable x values (not None) :param packet.Packet|None pkt: the packet instance containing this field instance; probably unused. # noqa: E501 :param str|int x: the value to convert. :return: int: the converted value. :raises: AssertionError Nr)rrr>r,rgrs rr>zUVarIntField.any2isKL$''--c155c4::..;3!8888 r cVtt|||S)a i2repr is overloaded to restrict the acceptable x values (not None) :param packet.Packet|None pkt: the packet instance containing this field instance; probably unused. # noqa: E501 :param int x: the value to convert. :return: str: the converted value. )rrrkr4s rrkzUVarIntField.i2repr s%\4((//Q777r ) r?r@rArr3r8r>rkrDrEs@rrrs$               888888888r rcFeZdZddgZdffd ZfdZfdZdZxZS)FieldUVarLenField _length_of_adjustc|SNrOr5s rzFieldUVarLenField..sr c||dksJd|cxkrdksnJtt||||||_||_dS)a Initializes a FieldUVarLenField :param str name: The name of this field instance. :param int|None default: the default value of this field instance. :param int size: the number of bits that are occupied by this field in the first byte of a binary string. # noqa: E501 size must be in the range ]0;8]. :param str length_of: The name of the field this field value is measuring/representing. # noqa: E501 :param callable adjust: A function that modifies the value computed from the "length_of" field. # noqa: E501 adjust can be used for instance to add a constant to the length_of field # noqa: E501 length. For instance, let's say that i2len of the length_of field returns 2. If adjust is lambda x: x+1 In that case, this field will value 3 at build time. :return: None :raises: AssertionError NrrK)rrrrr)rrrr length_ofadjustrs rrzFieldUVarLenField.__init__.sf$'Q,,,,4}}}}1}}}}}} &&//gtDDD# r c|Yt|tjs*Jdt |||}t t||||S)aq :param packet.Packet|None pkt: the packet instance containing this field instance. This parameter must not be # noqa: E501 None if the val parameter is. :param str|(str, int, long) s: the string to append this field to. A tuple indicates that some bits were already # noqa: E501 generated by another bitfield-compatible field. This MUST be the case if "size" is not 8. The int is the # noqa: E501 number of bits already generated in the first byte of the str. The long is the value that was generated by the # noqa: E501 previous bitfield-compatible fields. :param int|None val: the positive or null value to be added. If None, the value is computed from pkt. # noqa: E501 :return: str: s concatenated with the machine representation of this field. # noqa: E501 :raises: AssertionError Nz:EINVAL: pkt: Packet expected when val is None; received {}) r,packetPacketr"rg_compute_valuerrr#r$s rr#zFieldUVarLenField.addfieldGs ;c6=11 _ _LSSTXY\T]T]^^ _ _ _%%c**C&--66sAsCCCr c |Yt|tjs*Jdt |||}t t|||S)ab :param packet.Packet|None pkt: the packet instance containing this field instance. This parameter must not be # noqa: E501 None if the x parameter is. :param int|None x: the positive or null value to be added. If None, the value is computed from pkt. # noqa: E501 :return: str :raises: AssertionError Nz8EINVAL: pkt: Packet expected when x is None; received {}) r,rrr"rgrrrr<r4s rr<zFieldUVarLenField.i2mZs 9c6=11 ] ]JQQRVWZR[R[\\ ] ] ]##C((A&--11#q999r c||j\}}|||}||}|dksJ|S)a Computes the value of this field based on the provided packet and the length_of field and the adjust callback :param packet.Packet pkt: the packet from which is computed this field value. # noqa: E501 :return: int: the computed value for this field. :raises: KeyError: the packet nor its payload do not contain an attribute with the length_of name. :raises: AssertionError :raises: KeyError if _length_of is not one of pkt fields r)getfield_and_valrrsr)rr%fldfvalr'r`s rrz FieldUVarLenField._compute_valueisS((99 TiiT""ll3axxxx r ) r?r@rArCrr#r<rrDrEs@rrr+sy)I>Ik2DDDDD& : : : : :r rcteZdZejdZdZejdZejdZdS)HPackStringsInterfacecdSrrOr{s r__str__zHPackStringsInterface.__str__ r cH|}t|Sr)rr )rr0s r __bytes__zHPackStringsInterface.__bytes__s LLNNAr cdSrrOr{s roriginzHPackStringsInterface.originrr cdSrrOr{s r__len__zHPackStringsInterface.__len__rr N) r?r@rAabcabstractmethodrrrrrOr rrrs~             r r) metaclassc0eZdZdZdgZdZdZdZdZdS)HPackLiteralStringz HPackLiteralString is a string. This class is used as a marker and implements an interface in common with HPackZString _sc||_dSrrrr&s rrzHPackLiteralString.__init__s r c|jSrrr{s rrzHPackLiteralString.__str__s wr c*t|jSrrrr{s rrzHPackLiteralString.origin!!!r c*t|jSr)r.rr{s rrzHPackLiteralString.__len__s47||r N) r?r@rArBrCrrrrrOr rrrscI"""r rceZdZdZdS)EOSzP Simple "marker" to designate the End Of String symbol in the huffman table Nr?r@rArBrOr rrrsr rc:eZdZdZddgZ dZdZdZdZdZ d S) HuffmanNodezo HuffmanNode is an entry of the binary tree used for encoding/decoding HPack compressed HTTP/2 headers leftrightc"||_||_dSr)rr)rrrs rrzHuffmanNode.__init__s  r c"|r|jn|jSrrr)rbs r __getitem__zHuffmanNode.__getitem__s-tzzDI-r c*|r ||_dS||_dSrr)rrr's r __setitem__zHuffmanNode.__setitem__s  DJJJDIIIr c*|Sr)__repr__r{s rrzHuffmanNode.__str__s}}r cBd|j|jS)Nz({}, {}))r"rrr{s rrzHuffmanNode.__repr__s  DJ777r N) r?r@rArBrCrrrrrrOr rrrsz!I ...88888r rceZdZdZdS)InvalidEncodingExceptionz} InvalidEncodingException is raised when a supposedly huffman-encoded string is decoded and a decoding error arises NrrOr rrrr rceZdZddgZgdZdZedZedZedZ edZ ed Z ed Z d Z d Zd ZdZdS) HPackZStringr_encoded()i )i)i)ir)ir)ir)ir)ir)ir)i)i?)ir)ir)i?r)ir)ir)ir)ir)ir)ir)ir)ir)i?r)ir)ir)ir)ir)ir)ir)ir)ir)ir))i )ir)i )ir)r)rK)i )ir)ir)rK)ir)rK)r)rr)rr)r)r*r)r)r)r)r)r)rr)r)rr)r)\rU)rK)i) r)ir)ir)ir)!r)]rU)^rU)_rU)`rU)arU)brU)crU)drU)erU)frU)grU)hrU)irU)jrU)krU)lrU)mrU)nrU)orU)prU)qrU)rrU)rK)srU)rK)ir)i)ir)i?)"r)ir)r)#r)r)$r)rr)%r)&r)'r)rr)trU)urU)(r))r)*r)rUr)+r)vrU),r)rKr) r)-r)wrU)xrU)yrU)zrU){rU)ir)ir)i?r)ir)ir)ir)i?r)ir)ir)i?r)i?r)i?r)ir)i?r)ir)ir)ir)ir)ir)ir)ir)ir)ir)i?r)ir)ir)ir)ir)ir)ir)ir)i?r)ir)i?r)ir)ir)ir)i?r)ir)ir)i?r)i?r)ir)ir)ir)ir)i?r)i?r)ir)ir)i?r)ir)ir)ir)ir)i?r)ir)ir)i?r)ir)ir)ir)i?r)i?r)i?r)ir)i?r)i?r)ir)ir)ir)ir)ir)i?r)ir)i?r)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)i?r)ir)ir)ir)i?r)i?r)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)ir)i?rNct|tr |jdSt|tst |dksJ|jt |S)z huffman_encode_char assumes that the static_huffman_tree was previously initialized :param str|EOS c: a symbol to encode :return: (int, int): the bitstring of the symbol and its bitlength :raises: AssertionError r*)r,rstatic_huffman_coder/r.r)clscs r_huffman_encode_charz!HPackZString._huffman_encode_charsZ a   5*2. .a%% 4Q1&s1vv..r c,d}d}|D]'}||\}}||z|z}||z }(d|dzz }|dkr7|t\}}||z|||z z z}||z }||f}|ddksJ|ddksJ|S)a huffman_encode returns the bitstring and the bitlength of the bitstring representing the string provided as a parameter :param str s: the string to encode :return: (int, int): the bitstring of s and its bitlength :raises: AssertionError rrKr*)rr) rr&rZiblrr'blpadlenr`s rhuffman_encodezHPackZString.huffman_encodes   A..q11GCbCA 2ICCcAg Q;;..suu55GCff!56A 6MCf1v{{{{A!  r c|dksJ|dksJt|jtdr|t|jtdrJg}d}d}|j}d}d}||kr|||z dz z dz} |dz| z}|dz }|| } t| tr0d}| }t|tdrt nkt| t rtdt| tr#d}| | |j}d}d}ntd|dz }||k|rK|dkrtd |j d } | d| d|z z } | |krtd d |S) a huffman_decode decodes the bitstring provided as parameters. :param int i: the bitstring to decode :param int ibl: the bitlength of i :return: str: the string decoded from the bitstring :raises: AssertionError, InvalidEncodingException rNFr*Tz'Huffman decoder met the full EOS symbolz,Should never happen, so incidentally it willrUz7Huffman decoder is detecting padding longer than 7 bitsrz6Huffman decoder is detecting unexpected padding formatr ) r,static_huffman_treerghuffman_compute_decode_treerAssertionErrorrrr_rcrrd) rrZrr&j interruptedcurcur_sym cur_sym_blrelmt eos_symboleos_msbs rhuffman_decodezHPackZString.huffman_decodesAvvvvaxxxx c-tDzz : : .  + + - - -c5tDzzBBBBB   % #ggsQw{#q(A!|q(G !OJq6D$ ,, _" c4::..+(***+D#&& _./XYYYD%(( _# - ./]^^^ FA+#gg.  iA~~./hiii04J m 1 (BCG'!!./ghhhxx{{r c|dksJ|dksJ|dz}|dz}|dkr |d|z z}|dz }g}d}||kr7|dt||dzz dz|dz }||k7d|S)a] huffman_conv2str converts a bitstring of bit_len bitlength into a binary string. It DOES NOT compress/decompress the bitstring! :param int bit_str: the bitstring to convert. :param int bit_len: the bitlength of bit_str. :return: str: the converted bitstring as a bytestring. :raises: AssertionError rrKr*r )insertrrd)rbit_strbit_lenbyte_lenrem_bitr&rZs rhuffman_conv2strzHPackZString.huffman_conv2strNs!||||!||||a<A+ a<< G #G MH  (ll HHQWQ/4788 9 9 9 FA(llxx{{r cd}t|dz}|D]}|dzt|z}||f}|ddksJ|ddksJ|S)ag huffman_conv2bitstring converts a string into its bitstring representation. It returns a tuple: the bitstring and its bitlength. This function DOES NOT compress/decompress the string! :param str s: the bytestring to convert. :return: (int, int): the bitstring of s, and its bitlength. :raises: AssertionError rrKr*rp)rr&rZrrr`s rhuffman_conv2bitstringz#HPackZString.huffman_conv2bitstringksm !ffqj " "Aa3q66!AAf1v{{{{1v{{{{ r ctdd|_d}|jD]}|j}t|ddz ddD]}|d|z dz}t ||t rt d|dkr'|dkrt|n t||<n||tdd||<||}|dz }dS)z huffman_compute_decode_tree initializes/builds the static_huffman_tree :return: None :raises: InvalidEncodingException if there is an encoding problem Nrr*rz"Huffman unique prefix violation :/) rr#rranger,r_rrr)rrZentryparentidxrs rr$z(HPackZString.huffman_compute_decode_trees#.dD"9"9 ,  E,FU1X\2r22 # #1X_)fQi//Y23WXXX!88*+c''AsuuF1IIAY& +D$ 7 7F1I FAA  r c||_t||\}}t||||_dSr)rrgr!r6r)rr&rZrs rrzHPackZString.__init__sGd**1--3T 33As;; r c|jSr)rr{s rrzHPackZString.__str__s }r c*t|jSrrr{s rrzHPackZString.originrr c*t|jSr)r.rr{s rrzHPackZString.__len__s4=!!!r )r?r@rArCrr# classmethodrr!r.r6r8r$rrrrrOr rrrsz"I BBBH / /[ /[677[7r[8[([,<<< """"""""r rcveZdZdZddgZfdZdZedZdZ dZ d Z d Z d Z d Zd ZdZxZS)HPackStrLenFieldz HPackStrLenField is a StrLenField variant specialized for HTTP/2 HPack This variant uses an internal representation that implements HPackStringsInterface. # noqa: E501 _length_from _type_fromcvtt|||||_||_dSr)rrErrFrG)rrr length_from type_fromrs rrzHPackStrLenField.__init__s7 %%..tW==='#r c4||||zSr)r<rns rr#zHPackStrLenField.addfields488C%%%%r c|rEt|\}}tt||St|S)a :param bool t: whether this string is a huffman compressed string. :param str s: the string to parse. :return: HPackStringsInterface: either a HPackLiteralString or HPackZString, depending on t. # noqa: E501 :raises: InvalidEncodingException )rr8r.r)tr&rZrs r_parsezHPackStrLenField._parsesP  E!88;;FAs ; ;As C CDD D!!$$$r c||}||jdk}||d|||d|fS)a :param packet.Packet pkt: the packet instance containing this field instance. # noqa: E501 :param str s: the string to parse this field from. :return: (str, HPackStringsInterface): the remaining string after this field was carved out & the extracted # noqa: E501 value. :raises: KeyError if "type_from" is not a field of pkt or its payloads. :raises: InvalidEncodingException r*N)rF getfieldvalrGrN)rr%r&rXrMs rr+zHPackStrLenField.getfieldsX##C(( OODO , , 1{DKK1XgX;7777r cd}t|trd}nt|trd}||S)NzHPackLiteralString({})zHPackZString({}))r,rrr"r)rr%r5fmts rr8zHPackStrLenField.i2hsR a+ , , %*CC < ( ( %$Czz!((**%%%r c t|Sr)rrMs rr3zHPackStrLenField.h2is!!$$$r c||j}||}|| Jd||dk|d|S)a :param packet.Packet pkt: the packet instance containing this field instance. # noqa: E501 :param str x: the string to parse. :return: HPackStringsInterface: the internal type of the value parsed from x. # noqa: E501 :raises: AssertionError :raises: InvalidEncodingException :raises: KeyError if _type_from is not one of pkt fields. Nz>Conversion from string impossible: no type or length specifiedr*)rPrGrFrN)rr%r5rMrXs rr:zHPackStrLenField.m2isc OODO , ,##C((}!4!46v!4!4!4{{161XgX;///r ct|tr2t|tjsJ|||St|t sJ|S)a= :param packet.Packet|None pkt: the packet instance containing this field instance. # noqa: E501 :param str|HPackStringsInterface x: the value to convert :return: HPackStringsInterface: the Scapy internal value for this field :raises: AssertionError, InvalidEncodingException )r,r_rrr:rrMs rr>zHPackStrLenField.any2is^ a   $c6=11 1 1 188C## #!233333r c t|Sr)rrMs rr<zHPackStrLenField.i2m 1vv r c t|Srr.rMs rrszHPackStrLenField.i2lenrXr cHt|||SrrirMs rrkzHPackStrLenField.i2repr sDHHS!$$%%%r )r?r@rArBrCrr#r}rNr+r8r3r:r>r<rsrkrDrEs@rrErEs .I$$$$$ &&& % %\ % 8 8 8&&&%%%000"   &&&&&&&r rEceZdZdZdZejdddddded dd d ed e d ddgZ dZ fdZ xZ S)HPackHdrStringzg HPackHdrString is a packet that that is serialized into a RFC7541 par5.2 string literal repr. zHPack Header StringrgNr*Literal Compressedrr*r.rUdata)rrRc,|dS)Nr.rPr%s rrzHPackHdrString.sCOOE$:$:r )rIrJc$tjjSrconfigconf padding_layerrpayloads rguess_payload_classz"HPackHdrString.guess_payload_class#s {((r c |d1t|dtrdnd|_t t |jdi|S)zself_build is overridden because type and len are determined at build time, based on the "data" field internal type rgNrar*rrO)rPr,rrgrr] self_build)rkwargsrs rrnzHPackHdrString.self_build*se   F # # +'(8(8(@(@,OOVUVDI5u^T**5?????r )r?r@rArBrfields BitEnumFieldrrEr fields_descrlrnrDrEs@rr]r]s !DFD!|-L-LMM%qF;;; &&r**::   K)))@@@@@@@@@r r]c0eZdZdZeddZdZdS) HPackHeaderszHPackHeaders uses the "dispatch_hook" trick of Packet_metaclass to select the correct HPack header packet type. For this, the first byte of the string # noqa: E501 to dissect is snooped on. Nc|tjjSt|d}|dzdkrtS|dzdkrt S|dzdkrt StS)zldispatch_hook returns the subclass of HPackHeaders that must be used to dissect the string. NrrT@r)rgrh raw_layerrHPackIndexedHdrHPackLitHdrFldWithIncrIndexingHPackDynamicSizeUpdateHPackLitHdrFldWithoutIndexing)rr&_args_kwdsrQs r dispatch_hookzHPackHeaders.dispatch_hook9sb 9;( ( 1YY 9>>" " 9>>1 1 9>>) ),,r c$tjjSrrfrjs rrlz HPackHeaders.guess_payload_classJ {((r r)r?r@rArBrCr~rlrOr rrtrt4sM---[- )))))r rtcJeZdZdZdZedddedddgZdS) rxz0 HPackIndexedHdr implements RFC 7541 par6.1 zHPack Indexed Header Fieldmagicr*indexr)rUNr?r@rArBrrrrrrOr rrxrxOsG 'D7Aq)) Wa##KKKr rxc eZdZdZdZedddedddejej d d e d ej d d e gZ d S) ryzA HPackLitHdrFldWithIncrIndexing implements RFC 7541 par6.2.1 z.HPack Literal Header With Incremental Indexingrr*r)rrrhdr_nameNc4|ddkSNrrrcrds rrz'HPackLitHdrFldWithIncrIndexing.b00A5r hdr_value) r?r@rArBrrrrpConditionalField PacketFieldr]rrrOr rryryYs ;D7Aq)) Wa## F z4 @ @ 5 5   ;n==KKKr ryc eZdZdZdZedddejddddd d ed dd ej ej d de dej dde gZ dS)r{zR HPackLitHdrFldWithIncrIndexing implements RFC 7541 par6.2.2 and par6.2.3 z9HPack Literal Header Without Indexing (or Never Indexing)rrr never_indexr*z Don't Indexz Never Indexr`rrrNc4|ddkSrrcrds rrz&HPackLitHdrFldWithoutIndexing.vrr r) r?r@rArBrrrprqrrrr]rrrOr rr{r{hs GD7Aq)) 1a- 0 0    Wa## F z4 @ @ 5 5   ;n== KKKr r{cJeZdZdZdZedddedddgZd S) rzz7 HPackDynamicSizeUpdate implements RFC 7541 par6.3 zHPack Dynamic Size Updaterr*rmax_sizerrNrrOr rrzrz|sG &D7Aq)) ZA&&KKKr rzceZdZdZdS)H2FramePayloadzb H2FramePayload is an empty class that is a super class of all Scapy HTTP/2 Frame Packets NrrOr rrrrr rceZdZdZdZdZdZeejddeejddiZ dZ ej d d gZ d S) H2DataFramezn H2DataFrame implements RFC7540 par6.1 This packet is the Data Frame to use when there is no padding. rrES End StreamPPaddedzHTTP/2 Data FramerarRN) r?r@rArBtype_idEND_STREAM_FLAG PADDED_FLAGrpMultiFlagsEntryflagsrStrFieldrrrOr rrrsyGOK//lCC+V+C:: E D##KKKr rceZdZdZdgZdZejddddejd d d ejdd d gZ dZ dZ dS)H2PaddedDataFramezk H2DataFrame implements RFC7540 par6.1 This packet is the Data Frame to use when there is padding. s_lenzHTTP/2 Padded Data Framer NpaddingBrrSrarRc*|Sr) get_data_lenrds rrzH2PaddedDataFrame.s33C3C3E3Er rIc,|dSNr rcrds rrzH2PaddedDataFrame.3??83L3Lr c|d}|d\}}|||}|j|z |z }|dksJ|S)a get_data_len computes the length of the data field To do this computation, the length of the padlen field and the actual padding is subtracted to the string that was provided to the pre_dissect # noqa: E501 fun of the pkt parameter :return: int; length of the data part of the HTTP/2 frame packet provided as parameter # noqa: E501 :raises: AssertionError r rrPrrsrr padding_lenrrpadding_len_lenr`s rrzH2PaddedDataFrame.get_data_lend&&x00 ))(33 T))D$//j?*[8axxxx r c.t||_|S)apre_dissect is filling the s_len property of this instance. This property is later used during the getfield call of the "data" field when # noqa: E501 trying to evaluate the length of the StrLenField! This "trick" works because the underlayer packet (H2Frame) is assumed to override the "extract_padding" method and to only provide to this packet the data necessary for this packet. Tricky, tricky, will break some day probably! # noqa: E501 r.rrs r pre_dissectzH2PaddedDataFrame.pre_dissectVV r ) r?r@rArBrCrrp FieldLenField StrLenFieldrrrrrOr rrrs I %DXtycJJJ62'E'E    9b'L'L    K$     r rceZdZdZdS)H2AbstractHeadersFramezbSuperclass of all variants of HTTP/2 Header Frame Packets. May be used for type checking. NrrOr rrrrr rc eZdZdZdZdZdZdZdZee j ddee j d d ee j d d ee j d diZ dZ e j dgegZdS)H2HeadersFramea H2HeadersFrame implements RFC 7540 par6.2 Headers Frame when there is no padding and no priority information The choice of decomposing into four classes is probably preferable to having # noqa: E501 numerous conditional fields based on the underlayer :/ r*rr)rrrrEH End Headersrr+PriorityzHTTP/2 Headers FramehdrsN)r?r@rArBrrEND_HEADERS_FLAGr PRIORITY_FLAGrprrrPacketListFieldrtrrrOr rrrs GOKM//lCC0&0}EE+V+C::-v-c:>>  E "Dvr<88KKKr rceZdZdZdgZdZejddddejd ge d ej dd d gZ dZ dZ dS)H2PaddedHeadersFramezv H2PaddedHeadersFrame is the variant of H2HeadersFrame where padding flag is set and priority flag is cleared rz!HTTP/2 Headers Frame with Paddingr Nrrrrc*|Sr get_hdrs_lenrds rrzH2PaddedHeadersFrame.s7G7G7I7Ir rrRc,|dSrrcrds rrzH2PaddedHeadersFrame.rr c|d}|d\}}|||}|j|z |z }|dksJ|S)a get_hdrs_len computes the length of the hdrs field To do this computation, the length of the padlen field and the actual padding is subtracted to the string that was provided to the pre_dissect # noqa: E501 fun of the pkt parameter. :return: int; length of the data part of the HTTP/2 frame packet provided as parameter # noqa: E501 :raises: AssertionError r rrrs rrz!H2PaddedHeadersFrame.get_hdrs_lenrr c.t||_|Sapre_dissect is filling the s_len property of this instance. This property is later used during the parsing of the hdrs PacketListField when trying to evaluate the length of the PacketListField! This "trick" works because the underlayer packet (H2Frame) is assumed to override the # noqa: E501 "extract_padding" method and to only provide to this packet the data necessary for this packet. Tricky, tricky, will break some day probably! # noqa: E501 rrs rrz H2PaddedHeadersFrame.pre_dissectrr )r?r@rArBrCrrprrrtrrrrrrOr rrrs I .DXtycJJJvr<+I+I ! ! ! 9b'L'L    K$     r rceZdZdZdgZdZejdddejdddejd dej d ge gZ d S) H2PriorityHeadersFramezx H2PriorityHeadersFrame is the variant of H2HeadersFrame where priority flag is set and padding flag is cleared rz"HTTP/2 Headers Frame with Priority exclusiverr*stream_dependencyrweightrN) r?r@rArBrCrrpBitField ByteFieldrrtrrrOr rrr%s| I /D Q**+Q331%% vr<88KKKr rc eZdZdZdgZdZejddddejd d d ejd d d ej dd ej dge dej dddgZ dZdZdS)H2PaddedPriorityHeadersFramezu H2PaddedPriorityHeadersFrame is the variant of H2HeadersFrame where both priority and padding flags are set rz.HTTP/2 Headers Frame with Padding and Priorityr Nrrrrrr*rrrrc*|Srrrds rrz%H2PaddedPriorityHeadersFrame.Drr rrRc,|dSrrcrds rrz%H2PaddedPriorityHeadersFrame.Grr c|d}|d\}}|||}|dj}||djz }|d\}}|||}t |j|z |z |dz z |z }|dksJ|S)ar get_hdrs_len computes the length of the hdrs field To do this computation, the length of the padlen field, the priority information fields and the actual padding is subtracted to the string that was provided to the pre_dissect fun of the pkt parameter. :return: int: the length of the hdrs field :raises: AssertionError r rrrrKr)rPrrs get_fieldrr/r)rrrrrbit_cnt weight_lenr`s rrz)H2PaddedPriorityHeadersFrame.get_hdrs_lenKs&&x00 ))(33 T))D$//..--24>>"566;;))(33 TYYtT** $*!"Q;   axxxx r c.t||_|Srrrs rrz(H2PaddedPriorityHeadersFrame.pre_dissectfrr )r?r@rArBrCrrprrrrrtrrrrrrOr rrr7s I ;DXtycJJJ Q**+Q331%%vr<+I+I ! ! ! 9b'L'L    K6     r rceZdZdZdZdZejdddejdddejd dgZ d S) H2PriorityFramez0 H2PriorityFrame implements RFC 7540 par6.3 r)zHTTP/2 Priority Framerrr*rrrN) r?r@rArBrrrprrrrrOr rrrusbG "D Q**+Q331%%KKKr rceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZededededede de de de de dedededediZdS) H2ErrorCodesz H2ErrorCodes is an enumeration of the error codes defined in RFC7540 par7. This enumeration is not part of any frame because the error codes are in common with H2ResetFrame and H2GoAwayFrame. rr*r)rrrrrUrKrrrrrzNo errorzProtocol errorzInternal errorzFlow control errorzSettings timeoutz Stream closedzFrame size errorzRefused streamCancelzCompression errorz Control errorzEnhance your calmzInadequate securityzHTTP/1.1 requiredN)r?r@rArBNO_ERRORPROTOCOL_ERRORINTERNAL_ERRORFLOW_CONTROL_ERRORSETTINGS_TIMEOUT STREAM_CLOSEDFRAME_SIZE_ERRORREFUSED_STREAMCANCELCOMPRESSION_ERROR CONNECT_ERRORENHANCE_YOUR_CALMINADEQUATE_SECURITYHTTP_1_1_REQUIREDliteralrOr rrrs HNNMN FM *((0,,(..2.GGGr rcNeZdZdZdZdZejddej dgZ dS) H2ResetFramez- H2ResetFrame implements RFC 7540 par6.4 rzHTTP/2 Reset FramerVr!IrSN) r?r@rArBrrrp EnumFieldrrrrrOr rrrsEG D!\%9tDDDKKKr rceZdZdZdZdZdZdZdZdZ dZ e j d d ed ed ed edede dide j dd gZdZdS) H2SettingzD H2Setting implements a setting, as defined in RFC7540 par6.5.1 r*r)rrrrzHTTP/2 SettingidrzHeader table sizez Enable pushzMax concurrent streamszInitial window sizezMax frame sizezMax header list sizez!HrrYc$tjjSrrfrjs rrlzH2Setting.guess_payload_classrr N)r?r@rArBSETTINGS_HEADER_TABLE_SIZESETTINGS_ENABLE_PUSHSETTINGS_MAX_CONCURRENT_STREAMSSETTINGS_INITIAL_WINDOW_SIZESETTINGS_MAX_FRAME_SIZESETTINGS_MAX_HEADER_LIST_SIZErrprIntFieldrrrlrOr rrrs!$&)##& !$'! Dq &(; - +-E (*? #%5 )+A #     ## K)))))r rczeZdZdZdZdZeejddiZdZ ej dge gZ fdZ xZS) H2SettingsFramez/ H2SettingsFrame implements RFC7540 par6.5 rrAACKzHTTP/2 Settings Framesettingsct|dksAt|dtrt|ddzdks Jdtt|j|i|dS)a__init__ initializes this H2SettingsFrame If a _pkt arg is provided (by keyword), then this is an initialization from a string to dissect and therefore the length of the string to dissect have distinctive characteristics that we might want to check. This is possible because the underlayer packet (H2Frame) overrides extract_padding method to provided only the string that must be parsed by this packet! :raises: AssertionError rrz5Invalid settings frame; length is not a multiple of 6N)r.r,r_rrrrargsrors rrzH2SettingsFrame.__init__s IINN47E** DG q A%%% B&%% .ot$$-t>v>>>>>r )r?r@rArBrACK_FLAGrprrrrrrrrrDrEs@rrrsGH(&(e44 E #Dz2y99K?????????r rceZdZdZdZdZdZeejddeejddiZ d Z ej d d d ej d d dej dge gZdS)H2PushPromiseFramez H2PushPromiseFrame implements RFC7540 par6.6. This packet is the variant to use when the underlayer padding flag is cleared rr)rrrrrzHTTP/2 Push Promise Framereservedrr* stream_idrrN)r?r@rArBrrrrprrrrrrtrrrOr rr r sGK0&0}EE+V+C:: E 'D Aq)) Q++vr<88KKKr r c eZdZdZdgZdZejddddejd d d ejd d d ej dge dej dddgZ dZ dZdS)H2PaddedPushPromiseFramez H2PaddedPushPromiseFrame implements RFC7540 par6.6. This packet is the variant to use when the underlayer padding flag is set rz HTTP/2 Padded Push Promise Framer Nrrrr rr*rrrc*|Srrrds rrz!H2PaddedPushPromiseFrame.rr rrRc,|dSrrcrds rrz!H2PaddedPushPromiseFrame.rr c |d\}}|||}|dj}||djz }t |j|z |z |dz z }|dksJ|S)af get_hdrs_len computes the length of the hdrs field To do this computation, the length of the padlen field, reserved, stream_id and the actual padding is subtracted to the string that was provided to the pre_dissect fun of the pkt parameter. :return: int: the length of the hdrs field :raises: AssertionError r r rrKr)rrsrrr/r)rrrrr3r`s rrz%H2PaddedPushPromiseFrame.get_hdrs_len"s 00::[))D+66..,,14>>+..33$*!"Q;  axxxx r c.t||_|Srrrs rrz$H2PaddedPushPromiseFrame.pre_dissect9rr )r?r@rArBrCrrprrrrtrrrrrrOr rrrs I -DXtycJJJ Aq)) Q++vr<+I+I ! ! ! 9b'L'L    K.     r rcxeZdZdZdZdZeejddiZdZ ej ddgZ fdZ xZ S) H2PingFramez0 H2PingFrame implements the RFC 7540 par6.7 rrrrzHTTP/2 Ping Frameopaquect|dksEt|dttfrt|ddks Jdt t |j|i|dS)) :raises: AssertionError rrKz#Invalid ping frame; length is not 8N)r.r,r_strrrrrs rrzH2PingFrame.__init__Vs~ IINN47UCL11 DG !!! 0"!! *k4  )4:6:::::r )r?r@rArBrr rprrr LongFieldrrrrDrEs@rrrHsGH(&(e44 E D1%%K ; ; ; ; ; ; ; ; ;r rceZdZdZdZdZejdddejdddejd de j d ej d d gZ dS) H2GoAwayFramez2 H2GoAwayFrame implements the RFC 7540 par6.8 rUzHTTP/2 Go Away Framer rr*last_stream_idrrVrradditional_datarRN) r?r@rArBrrrprrrrrrrrOr rrrfs~G !D Aq))(!R00!\%9tDDD)2.. KKKr rcreZdZdZdZdZejdddejdddgZfd Z xZ S) H2WindowUpdateFramez8 H2WindowUpdateFrame implements the RFC 7540 par6.9 rKzHTTP/2 Window Update Framer rr* win_size_incrrct|dksEt|dttfrt|ddks Jdt t |j|i|dS)rrrz,Invalid window update frame; length is not 4N)r.r,r_rrr!rrs rrzH2WindowUpdateFrame.__init__s IINN47UCL11 DG !!! 9"!! 2!4((14B6BBBBBr ) r?r@rArBrrrprrrrrDrEs@rr!r!vsG 'D Aq))B//K C C C C C C C C Cr r!cjeZdZdZdZdZeejddiZdZ ej dge gZ dS) H2ContinuationFramez9 H2ContinuationFrame implements the RFC 7540 par6.10 rr)rrzHTTP/2 Continuation FramerN) r?r@rArBrrrprrrrrtrrrOr rr%r%saG0&0}EE E 'Dvr<88KKKr r%DataFrmHdrsFrmPrioFrmRstFrmSetFrmPushFrmPingFrm GoawayFrmWinFrmContFrm) rr*r)rrrrrUrKrceZdZdZdZejddejddedej de de j e j ej ej ej ej ej ej ej ej ej ej id ejd d d ejdd dgZdZdZfdZxZS)H2Framez H2Frame implements the frame structure as defined in RFC 7540 par4.1 This packet may have a payload (one of the H2FramePayload) or none, in some rare cases such as settings acknowledgement) z HTTP/2 Framer.NrgrrrKc,|dS)Nrgrcrds rrzH2Frame.s3??6#:#:r ) depends_onr rr*rrct|dkr tjS|d}|tjkrDtjtjj|dvrtStS|tjkrtjtjj|dvrDtjtj j|dvrtStStjtj j|dvrtStS|tjkrtS|t jkrt S|t"jkrt"S|t$jkrDt$jt$jj|dvrt&St$S|t(jkrt(S|t*jkrt*S|t,jkrt,S|t.jkrt.St0jjS)a guess_payload_class returns the Class object to use for parsing a payload This function uses the H2Frame.type field value to decide which payload to parse. The implement cannot be # noqa: E501 performed using the simple bind_layers helper because sometimes the selection of which Class object to return # noqa: E501 also depends on the H2Frame.flags value. :param payload: :return:: rrgr)r.r NoPayloadrPrrrrshortrrrrrrrrrr rrrr!r%rgrhri)rrkrMs rrlzH2Frame.guess_payload_classs w<<1  # #   V $ $ # # # !89?4CSCST[C\C\\\((  & & &#N$>?EIYIYZaIbIbbb!'(DEKtO_O_`gOhOhhh77//%n&BCITM]M]^eMfMfff--! ! ' ' '" " $ $ $  ' ' '" " "* * *!'(:(FGMQUQaQabiQjQjjj//% % # # #  % % % #+ + +& & #+ + +& &{((r ct|jtr |jdks Jdt||jks Jd|d|j||jdfS)z :param str s: the string from which to tell the padding and the payload data apart # noqa: E501 :return: (str, str): the padding and the payload data strings :raises: AssertionError rzInvalid length: negative len?z0Invalid length: string too short for this lengthN)r,r.r/rs rextract_paddingzH2Frame.extract_paddingsl$(C(([TX]]]<[]]]1vv!!!#U!!!$(|Qtxyy\))r c$|dRt|dks Jdtjdt|dd|ddz}t t |||S)z :param str p: the stringified packet :param str pay: the stringified payload :return: str: the stringified packet and payload, with the packet length field "patched" # noqa: E501 :raises: AssertionError r.Niz#Invalid length: payload is too longz!Lr*r)rPr.structpackrr1 post_build)rppayrs rr<zH2Frame.post_build s   E " " *s88w''')N''' D#c((++ABB/!ABB%7AWd##..q#666r )r?r@rArBrrp X3BytesFieldr _HTTP2_typesMultiFlagsFieldsetrrrrr rrr%rrrrlr8r<rDrEs@rr1r1s3 DE4((|S99wq  !2  "N$8  &(:(@  #_%:  !2  ')<)B 3 ;:   Aq)) Q++K"7)7)7)r * * * 7 7 7 7 7 7 7 7 7r r1cBeZdZdZdZejdgegZdZ dS)H2Seqz H2Seq is a helper packet that contains several H2Frames and their payload. This packet can be used, for instance, while reading manually from a TCP socket. zHTTP/2 Frame Sequenceframesc$tjjSrrfrjs rrlzH2Seq.guess_payload_class&rr N) r?r@rArBrrprr1rrrlrOr rrDrDsO #DxW55K)))))r rDrg0505249202a20485454502f322e300d0a0d0a534d0d0a0d0acBeZdZdZgdZdZdZdZdZeZ dZ dZ d S) HPackHdrEntryz HPackHdrEntry is an entry of the HPackHdrTable helper Each HPackHdrEntry instance is a header line (name and value). Names are normalized (lowercase), according to RFC 7540 par8.1.2 )_name_len_valuect|dksJ||_||_dt|jzt|jz|_dS)rrrN)r.lowerrJrLrK)rrrYs rrzHPackHdrEntry.__init__MsV 4yy1}}}}ZZ\\  #dj//)C ,<,<< r c|jSr)rJr{s rrzHPackHdrEntry.nameZs zr c|jSr)rLr{s rrYzHPackHdrEntry.value^s {r c|jS)z_ size returns the "length" of the header entry, as defined in RFC 7541 par4.1. )rKr{s rrzHPackHdrEntry.sizebs yr c|jdr d|j|jSd|j|jS)zO __str__ returns the header as it would be formatted in textual format :{} {}{}: {})rJ startswithr"rLr{s rrzHPackHdrEntry.__str__ksL :  % % <>>$*dk:: :??4:t{;; ;r cDt|Sr)r rr{s rrzHPackHdrEntry.__bytes__tsDLLNN+++r N) r?r@rArBrCrrrYrrrrrOr rrIrIEs ,++I > > >G<<<,,,,,r rIceZdZdZgdZ idedddeddd edd d ed d ded ddedddedddedddedddedddedddeddd edd!d"edd#d$ed%dd&ed'd(d)ed*did+ed,dd-ed.dd/ed0dd1ed2dd3ed4dd5ed6dd7ed8dd9ed:dd;eddd?ed@ddAedBddCedDddEedFddGedHddIedJddKedLdidMedNddOedPddQedRddSedTddUedVddWedXddYedZdd[ed\dd]ed^dd_ed`ddaedbddceddddeedfddgedhddiedjddkedlddmedndedodedpdedqdedrdedsdedtdedudedvdedwdedxddy ZdzZed{Z dd}Z d~Z dZ dZ ddZdZdZdZdZddZedZdZdZddzd|ddddfdZdzS) HPackHdrTableaT HPackHdrTable is a helper class that implements some of the logic associated with indexing of headers (read and write operations in this "registry". THe HPackHdrTable also implements convenience functions to easily # noqa: E501 convert to and from textual representation and binary representation of a HTTP/2 requests )_dynamic_table_dynamic_table_max_size_dynamic_table_cap_size_regexpr*z :authorityrRr)z:methodGETrPOSTrz:path/rz /index.htmlrz:schemehttprUhttpsrKz:status200r204r206r304r400r404r500rzaccept-charsetzaccept-encodingz gzip, deflatezaccept-languagez accept-rangesracceptrzaccess-control-allow-originragerallowr authorizationrz cache-controlrzcontent-dispositionrzcontent-encodingrzcontent-languagerzcontent-lengthrzcontent-locationrz content-rangerz content-typercookierdateretagrexpectrexpiresrfromrhostrzif-matchr zif-modified-sincer z if-none-matchr zif-ranger zif-unmodified-sincerz last-modifiedrlink.location/z max-forwards0zproxy-authenticate1zproxy-authorization2r;3refererrefreshz retry-afterserverz set-cookiezstrict-transport-securityztransfer-encodingz user-agentvaryviazwww-authenticate) 456789:;<=Nc8t|j|_dSr)max_static_entries_static_entries_last_idx)rs rinit_static_tablezHPackHdrTable.init_static_tables(+3+>'?'?$$$r cd|_tt|jtdr!t|||ks Jdg|_||_||_dS)a :param int dynamic_table_max_size: the current maximum size of the dynamic entry table in bytes # noqa: E501 :param int dynamic_table_cap_size: the maximum-maximum size of the dynamic entry table in bytes # noqa: E501 :raises:s AssertionError NzcEINVAL: dynamic_table_max_size too large; expected value is less or equal to dynamic_table_cap_size)r]r,rgrrrZr[r\)rdynamic_table_max_sizedynamic_table_cap_sizes rrzHPackHdrTable.__init__s d4jj94:: F F + JJ ( ( * * *%)???? q@??!'=$'=$$$r c^|dksJ|t|jkrt|t|jdzz}|t|jkr5t d|t|j|j|St|j|S)aGets an element from the header tables (static or dynamic indifferently) :param int idx: the index number of the entry to retrieve. If the index value is superior to the last index of the static entry table, then the dynamic entry type is requested, following the procedure described in RFC 7541 par2.3.3 :return: HPackHdrEntry: the entry defined at this requested index. If the entry does not exist, KeyError is # noqa: E501 raised :raises: KeyError, AssertionError rr*z5EINVAL: idx: out-of-bound read: {}; maximum index: {})rgrr.rZKeyErrorr"r)rr>s rrzHPackHdrTable.__getitem__saxxxx d4 4 4 4::6: :Cc$-....KRRSVX[\`\oXpXpqq&s+ +Dzz)#..r cd|cxkr |jks$nJd|j|j}||_||jkr|dSdS)aResize the dynamic table. If the new size (ns) must be between 0 and the cap size. If the new size is lower than the current size of the dynamic table, entries are evicted. :param int ns: the new size of the dynamic table :raises: AssertionError rzEEINVAL: ns: out-of-range value; expected value is in the range [0;{}[N)r\r"r[_reduce_dynamic_table)rnsold_sizes rresizezHPackHdrTable.resize sB6666$666666 S Z Z[_[w x x766/')$ d2 2 2  & & ( ( ( ( ( 3 2r cl|dksJ|j|k}||_|r||dSdS)a$recap changes the maximum size limit of the dynamic table. It also proceeds to a resize(), if the new size is lower than the previous one. :param int nc: the new cap of the dynamic table (that is the maximum-maximum size) # noqa: E501 :raises: AssertionError rN)r\r)rncrMs rrecapzHPackHdrTable.recap sMQwwww  (2 -')$   KKOOOOO  r rc2|dksJt|}t|j}|dkra||z|jkrWt|jd}|j|dz}||z}|dkr||z|jkQdSdSdSdS)a_reduce_dynamic_table evicts entries from the dynamic table until it fits in less than the current size limit. The optional parameter, new_entry_size, allows the resize to happen so that a new entry of this size fits in. :param int new_entry_size: if called before adding a new entry, the size of the new entry in bytes (following # noqa: E501 the RFC7541 definition of the size of an entry) :raises: AssertionError rrr*N)r.rZr[pop)rnew_entry_sizecur_sz dyn_tbl_sz last_elmt_szs rrz#HPackHdrTable._reduce_dynamic_table" s""""T,-- 1nn.!84;W!W!Wt22677L   # # % % % !OJ l "F 1nn.!84;W!W!W!W!Wnnnn!W!Wr ct|trd|jjD}n%t|tr|g}n d|D}|D]}|jdkr-|jd}n.t|j}|| }|j d}t||}t|}||||jksJ|jd|dS)aregister adds to this table the instances of HPackLitHdrFldWithIncrIndexing provided as parameters. A H2Frame with a H2HeadersFrame payload can be provided, as much as a python list of HPackHeaders or a single HPackLitHdrFldWithIncrIndexing instance. :param HPackLitHdrFldWithIncrIndexing|H2Frame|list of HPackHeaders hdrs: the header(s) to register # noqa: E501 :raises: AssertionError c<g|]}t|t|SrOr,ry.0hdrs r z*HPackHdrTable.register..A s(hhhC 3Hf8g8ghChhhr c<g|]}t|t|SrOrrs rrz*HPackHdrTable.register..E s([[[C:c;Y+Z+Z[C[[[r rraN)r,r1rkrryrrrPrr/rrrIr.rr[rZr1)rrrrr>rr< new_entry_lens rregisterzHPackHdrTable.register5 sK dG $ $ \hh4<#4hhhDD < = = \6DD[[4[[[D 1 1CyA~~<33F;;BBDD#)nn9>>++ 11&99@@BBI "(I66E JJM  & &} 5 5 5 D$@@@@@   & &q% 0 0 0 05 1 1r cZ|}t|jD]!\}}||kr|cS"t |jD]9\}}||krt|j|zdzcS:dS)a get_idx_by_name returns the index of a matching registered header This implementation will prefer returning a static entry index whenever possible. If multiple matching header name are found in the static table, there is insurance that the first entry (lowest index number) will be returned. If no matching header is found, this method returns None. r*N)rNrgritemsr enumeraterZr)rrkeyr'r>s rget_idx_by_namezHPackHdrTable.get_idx_by_namec szz||T 288::  HCxxzzT!! "!$"566 E EHCxxzzT!!Dzz:S@1DDDD"tr c|}t|jD]9\}}||kr||kr|cS:t |jD]Q\}}||kr4||krt|j|zdzcSRdS)ad get_idx_by_name_and_value returns the index of a matching registered header This implementation will prefer returning a static entry index whenever possible. If multiple matching headers are found in the dynamic table, the lowest index is returned If no matching header is found, this method returns None. r*N) rNrgrrrrYrrZr)rrrYrr'r>s rget_idx_by_name_and_valuez'HPackHdrTable.get_idx_by_name_and_valuev szz||T 288::  HCxxzzT!!ciikkU&:&: !$"566 E EHCxxzzT!!ciikkU&:&:Dzz:S@1DDDDtr c>td|jDS)zB __len__ returns the summed length of all dynamic entries c34K|]}t|VdSrrZ)rr5s r z(HPackHdrTable.__len__.. s(77a3q66777777r )sumrZr{s rrzHPackHdrTable.__len__ s$774#6777777r Tc g}t|tr |jj}|D]} t|tr5|d||jn0t|ttfr|jdkr ||j }n,|j d }|drT|d||j d nS|d||j d |r*t|tr||#t"$r}t%|Yd}~d}~wwxYwd|S) a% gen_txt_repr returns a "textual" representation of the provided headers. The output of this function is compatible with the input of parse_txt_hdrs. :param H2Frame|list of HPackHeaders hdrs: the list of headers to convert to textual representation. :param bool: whether incremental headers should be added to the dynamic table as we generate the text representation :return: str: the textual representation of the provided headers :raises: AssertionError z{}rrarSrTrUN )r,r1rkrrxrcr"rryr{rrrPrrVrrrprintrd)rrrlstrres r gen_txt_reprzHPackHdrTable.gen_txt_repr s dG $ $ %<$D  C c?33JJt{{4 ?;;<<<<21&yA~~#CI3355"|77??FFHHs++  #NN $ # 9 9& A A H H J J $OO $ # 9 9& A A H H J J ' 30N O O'MM#&&&   a yy~~sF&G G6G11G6ct|}t|t|krtt|St|S)Nra)rr.r]r)r&zss r%_optimize_header_length_and_packetifyz3HPackHdrTable._optimize_header_length_and_packetify sQ!__ r77c!ff  !'9!'<'<=== =2&&&&r c |||}|%t|t||fS||}||}|~|||drltd||tt|| |dfS||rkt||tt|| |dfSt||tt|| |dfS||}||d|drztdd||tt|d|dfS||drytd|| tt|d|dfStd|| tt|d|dfS) a _convert_a_header_to_a_h2_header builds a HPackHeaders from a header name and a value. It returns a HPackIndexedHdr whenever possible. If not, # noqa: E501 it returns a HPackLitHdrFldWithoutIndexing or a HPackLitHdrFldWithIncrIndexing, based on the should_index callback. HPackLitHdrFldWithoutIndexing is forced if the is_sensitive callback returns True and its never_index bit is set. N)rrar*)rrr)rrr)rrrr)rrr) rrxr.rrrPrr{rIrry)rrr is_sensitive should_indexr> _hdr_value _hdr_names r _convert_a_header_to_a_h2_headerz.HPackHdrTable._convert_a_header_to_a_h2_header s ,,XyAA ?"---s49~~= =?? JJ ""8,, ?|&&v..5577 5 !(!S (("..v66==??  |H%% 5(!S (("..v66==??1$INN$$**62299;; >>xHH <  ! !& ) ) 0 0 2 2  " "6 * * 1 1 3 3   1"$  ))&1188::**62299;;   < --f55<<>> ? ? 1"$))&1188::**62299;;  -      %%f--4466&&v..5577     r c|jtjd|_|}|j|}|%t |dkrdS|dd|dz}n|d}t| t|dfS)Ns*^(?::([a-z\-0-9]+)|([a-z\-0-9]+):)\s+(.+)$r)NNr*:r)) r]recompilerstripmatchr.groupsgrouprrN)rlinehdr_linegrprs r_parse_header_linez HPackHdrTable._parse_header_line* s < :&TUUDL;;==l  ** ;#cjjll++q00: 99Q<< #ciill*HHyy||H))**Iciill,C,CCCr cdSNFrO)nvs rrzHPackHdrTable.B sr cdSrrOrs rrzHPackHdrTable.C ser c rtt|tr|n|} t t t } t} t} d} | D]t}| |\}}|| ||||\}}t t |}|r*t|tr| ||| z|ks |dkr(||kr"td||t t | | z|zks|dkr|| |zkrvt}t| tr|s|d| jt ||| z t'} d} | j}||z }| |z } vdh}t| tr|s|d| jt ||| z |rt t t+}t|} | ||z | z }|r| ||z | z }t}t |dkr|d| jt ||t+|z |}|| S)a parse_txt_hdrs parses headers expressed in text and converts them into a series of H2Frames with the "correct" flags. A body can be provided in which case, the data frames are added, bearing the End Stream flag, instead of the H2HeadersFrame/H2ContinuationFrame. The generated frames may respect max_frm_sz (SETTINGS_MAX_FRAME_SIZE) and max_hdr_lst_sz (SETTINGS_MAX_HEADER_LIST_SIZE) if provided. The headers are split into multiple headers fragment (and H2Frames) to respect these limits. Also, a callback can be provided to tell if a header should be never indexed (sensitive headers, such as cookies), and another callback say if the header should be registered into the index table at all. For an header to be registered, the is_sensitive callback must return False AND the should_index callback should return True. This is the default behavior. :param str s: the string to parse for headers :param int stream_id: the stream id to use in the generated H2Frames :param str/None body: the eventual body of the request, that is added to the generated frames :param int max_frm_sz: the maximum frame size. This is used to split the headers and data frames according to the maximum frame size negotiated for this connection. :param int max_hdr_lst_sz: the maximum size of a "header fragment" as defined in RFC7540 :param callable is_sensitive: callback that returns True if the provided header is sensible and must be stored in a header packet requesting this header never to be indexed :param callable should_index: callback that returns True if the provided header should be stored in a header packet requesting indexation in the dynamic header table. :param bool register: whether to register new headers with incremental indexing as we parse them :raises: Exception rNzHeader too long: {}r)rrrr)rr,rencoder.rr1rDrrrryr Exceptionr"rBaddrErcr%rrread)rr&rbody max_frm_szmax_hdr_lst_szrrrsio base_frm_lenr`cur_frm cur_hdr_szrrrnew_hdr new_hdr_lennew_hdr_bin_lenrhdr_listbase_data_frm_lenfrgmt nxt_frgmts rparse_txt_hdrszHPackHdrTable.parse_txt_hdrs< s=^Jq#$6$6=ahhjjjA>>3wyy>>** gg "" % &% &H"&"9"9("C"C Hi#'#H#H)\<$$ G["#g,,//O 'Jw0NOO ' g&&& ,.;;#q(([>-I-I 5 < >Q&&IIdOOO !!iu=== QV@W@W@WW" " r )rr)r)T)r?r@rArBrCrIrrrCrrrrrrrrrrrr}rrrrrOr rrYrYxs6 I > ==r * *> ==E * *> ==F + +> ==# & & > ==- 0 0 > ==F + + > ==G , ,> ==E * *> ==E * *> MM)U + +> MM)U + +> MM)U + +> MM)U + +> MM)U + +> MM*B / /> MM+_ = =!>" MM+R 0 0#>>$ MM/2 . .%>& MM(B ' ''>( MM7 < <)>* MM% $ $+>, MM'2 & &->. MM/2 . ./>0 MM/2 . .1>2 MM/ 4 43>4 MM,b 1 15>6 MM,b 1 17>8 MM*B / /9>: MM,b 1 1;>< MM/2 . .=>> MM." - -?>@ MM(B ' 'A>B MM&" % %C>D MM&" % %E>>>F MM(B ' 'G>H MM)R ( (I>J MM&" % %K>L MM&" % %M>N MM*b ) )O>P MM-r 2 2Q>R MM/2 . .S>T MM*b ) )U>V MM/ 4 4W>X MM/2 . .Y>Z MM&" % %[>\ MM*b ) )]>^ MM." - -_>` MM. 3 3a>b MM/ 4 4c>d MM'2 & &e>f MM)R ( (g>>h M)R ( ( M- , , M(B ' ' M, + + M5r : : M-r 2 2 M, + + M&" % % M% $ $ M,b 1 1{>>>OD $@@[@>>>>$///,)))  ####&,1,1,1\&&888 2222h''\'] ] ] ~DDD("# "&&'$6$6$3O $qqqqqqr rY)TrBrriorr: scapy.compatrrrrrr typingr r r r rrrrscapy.base_classesr scapy.fieldsrp scapy.packetr scapy.configrgscapy.volatilery scapy.errorrVrrFieldrGrrABCMetarrobjectrrrrrrErr]rtrxryr{rzrrrrrrrrrrrrrr rrrr!r%r@r1rD bind_layersrH2_CLIENT_CONNECTION_PREFACErIrYrOr rrs    JJJJJJJJJJJJJJJJ                    0/////!!!!!!rGrGrGrGrGrGrGrGjy#y#y#y#y#6<y#y#y#x B8B8B8B8B8'B8B8B8JNNNNN,NNNj     ES[    $..& $8$8$8$8$8&$8$8$8Ny L"L"L"L"L"(L"L"L"^c&c&c&c&c&v|c&c&c&T@@@@@V]@@@@)))))6=)))6l     \   L(\V].$----- ---d^ +2-----1---`3$99999#9999|     n   %%%%%6%%%T>))))) )))8!?!?!?!?!?n!?!?!?L(444441444r;;;;;.;;;<     N    CCCCC.CCC6     .   $   i7i7i7i7i7fmi7i7i7X ) ) ) ) )FM ) ) )7K&+2E)FGGG7- 8K/LMMM7NV^5K,LMMM706>;Q2RSSS72V^=S4TUUU786>CY:Z[[[7Ofo6M-NOOO7L6<3G*HIII7Ofo6M-NOOO7K&+2E)FGGG7.9K9S0TUUU74v?W?_6`aaa7MFM4I+JKKK7/&:M:U1VWWW7/&:M:U1VWWW )y)[\\0,0,0,0,0,E0,0,0,fuuuuuEuuuuur