
    hv                       d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ ddlmZmZ ddlmZmZm Z  ddl!m"Z"m#Z#m$Z$m%Z%m&Z& ddl'm(Z( dd	l)m*Z*m+Z+ dd
l,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 ddl3m4Z4m5Z5m6Z6 ddl7m8Z8 ddl9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZG ddlmHZH 	 ddlIZIn# eJ$ r Y nw xY w eDde<eKe:f         e@e<eKe:f                            ZL G d de"e&e%          ZM G d deM          ZN G d deM          ZO G d deO          ZPeOe_Q        ePe_R        ejS        eOe_S        	 d(dZT	 d(dZUejV        jW        	 d(d            ZX	 d(dZY	 d(dZZejV        jW        	 d(d            Z[ejV        jW        d(d            Z\	 d)d!Z]ejV        jW        	 	 	 d*d"            Z^ejV        jW        d+d$            Z_ eDd%eM&          Z`ejV        jW        	 d,d'            ZadS )-z
Packet class

Provides:
 - the default Packet classes
 - binding mechanisms
 - fuzz() method
 - exploration methods: explore() / ls()
    )defaultdictN)AnyFieldBitFieldConditionalFieldEmph	EnumFieldField
FlagsField	FlagValueMayEndMultiEnumFieldMultipleTypeFieldPadFieldPacketListFieldRawValStrField)conf_version_checker)raworbbytes_encode)
BasePacketGenSetGenPacket_metaclass_CanvasDumpExtended)_GlobInterfaceType)	RandFieldVolatileValue)import_hexcap
tex_escapecolgen	issubtypepretty_listEDecimal)Scapy_Exceptionlog_runtimewarning)PYX)AnyCallableDictIteratorListNoReturnOptionalSetTupleTypeTypeVarUnionSequencecast)Self_Tc                      e Zd Zg dZdZg Zi Zi Zg ZdZ	dZ
dZi Zi Zi Zi Zi Zed             Zed             Zed             Z	 	 	 	 	 	 djdZeeeef         eeeedf                  ee         ee         ee         ee         f         Zd Zd Z d Z!dkdZ"d Z#dkdZ$d Z%d Z&d Z'd Z(d Z)d Z*d Z+d Z,d Z-d Z.de/fdZ0d Z1d Z2d  Z3d! Z4d" Z5d# Z6d$ Z7d% Z8d& Z9d' Z:d( Z;d) Z<d* Z=d+ Z>e>Z?d, Z@e@ZAd- ZBd. ZCd/ ZDeDZEd0 ZFd1 ZGd2 ZHdkd3ZId4 ZJd5 ZKd6 ZLd7 ZMd8 ZNd9 ZOd: ZPd; ZQd< ZRdld=ZSdmd>ZTd? ZUd@ ZVdA ZWdB ZXdC ZYdD ZZdE Z[dF Z\dG Z]dndHZ^dI Z_dJ Z`dK ZadL ZbdM ZcdN ZddZedO ZfdP ZgdQ ZhdndRZi	 	 	 dodSZjdT ZkdU ZldV ZmdW ZndX ZodY ZpdZ Zqd[ Zr	 	 	 	 	 dpd^Zsdqd_Ztdqd`ZudrdaZvdb Zwdc ZxdlddZydndeZzdf Z{dkdgZ|dh Z}di Z~dS )sPacket)time	sent_timenamedefault_fieldsfields	fieldtypeoverload_fieldsoverloaded_fieldspacketfieldsoriginalexplicitraw_packet_cacheraw_packet_cache_fields_pktpost_transformsstop_dissection_afterpayload
underlayerparentr>   	_answered	direction
sniffed_onwirelencommentprocess_informationN   TFc                 0     | t                                S N)r    )clss    P/mounts/lovelace/software/anaconda3/lib/python3.11/site-packages/scapy/packet.pyfrom_hexcapzPacket.from_hexcapy   s     s=??###    c           
          | j         D ]N\  }}t          |j        ddd                    d |                                D                                  Od S )N20  , c              3   &   K   | ]}d d|z  z  V  dS z%-12sz%s=%rN .0is     rY   	<genexpr>z%Packet.upper_bonds.<locals>.<genexpr>   +      LL!g15LLLLLLr[   )payload_guessprint__name__joinitems)selffvaluppers      rY   upper_bondszPacket.upper_bonds~   st      - 	 	KD%NNNNIILLtzz||LLLLLL   	 	r[   c           
          | j                                         D ]N\  }}t          |j        ddd                    d |                                D                                  Od S )Nr]   r^   r_   c              3   &   K   | ]}d d|z  z  V  dS ra   rb   rc   s     rY   rf   z%Packet.lower_bonds.<locals>.<genexpr>   rg   r[   )_overload_fieldsrl   ri   rj   rk   )rm   lowerrn   s      rY   lower_bondszPacket.lower_bonds   s      06688 	 	KE4NNNNIILLtzz||LLLLLL   	 	r[   r[   r   c                    t          j                     | _         d | _        | j        | j        j        n| j        | _        i | _        | j        | _        i | _	        i | _
        i | _        g | _        t                      | _        |                     t!          |                     || _        || _        t'          |t(                    rt+          |          }|| _        d| _        d | _        d | _        d | _        d | _        d | _        d | _        d | _        || _        |r,|                      |           |s| !                    |            | j"        D ]x}|j        }		 |#                    |	          }
n# tH          $ r Y ,w xY wt'          |
tJ                    r|
n(| &                    |	          '                    | |
          | j
        |	<   y|D ]}	|	| j(        v rf||	         }
| )                    |	          }	t'          |
tJ                    r|
n(| &                    |	          '                    | |
          | j
        |	<   qtU          |	          t'          |tV                    r	|| _,        d S |	g | _,        d S |g| _,        d S Nr   )-r<   r=   _name	__class__rj   r>   r?   rs   rB   rC   r@   rA   rD   	NoPayloadrL   init_fieldsboolrM   rN   
isinstance	bytearraybytesrE   rF   rG   rH   rR   rP   rQ   rS   rT   rK   dissectdissection_donefields_descpopKeyErrorr   	get_fieldany2ideprecated_fields_resolve_aliasAttributeErrorlistrJ   )rm   rI   post_transform	_internal_underlayer_parentrK   r@   fieldfnamevalues              rY   __init__zPacket.__init__   s    IKK	
* ^,,Z 		 !#4!# {{d$$$%dI&& 	;;D $'+$#' %:" 	+LL +$$T*** % 	9 	9EJE

5))   *4UF*C*C "9u%%++D%88 K  	( 	(E...u++E22.8.G.G &=UUNN5))//e<< E" '''nd++ 	4#1D   ##%D   $2#3D   s   E00
E=<E=c                     | j         |                                 f| j        | j        | j        | j        | j        | j        ffS )zUsed by pickling methods)ry   buildr<   r=   rP   rQ   rR   rS   rm   s    rY   
__reduce__zPacket.__reduce__   sB     INNOLL2
  	r[   c                     |d         | _         |d         | _        |d         | _        |d         | _        |d         | _        |d         | _        | S )z$Rebuild state using pickable methodsr   rU               )r<   r=   rP   rQ   rR   rS   )rm   states     rY   __setstate__zPacket.__setstate__   sK     !H	qq(QxQxr[   c                 *    |                                  S )zUsed by copy.deepcopycopy)rm   memos     rY   __deepcopy__zPacket.__deepcopy__   s    
 yy{{r[   c                     | j                             | j        d          r|                     | j                   dS |                     |           dS )@
        Initialize each fields of the fields_desc dict
        F)for_dissect_onlyN)class_dont_cachegetry   do_init_fieldsr   do_init_cached_fields)rm   r   s     rY   r{   zPacket.init_fields   s]      $$T^U;; 	J 011111&&8H&IIIIIr[   c                     i }|D ]S}t          j        |j                  ||j        <   || j        |j        <   |j        r| j                            |           T|| _        dS )r   N)	r   deepcopydefaultr>   rA   holds_packetsrD   appendr?   )rm   flistr?   fs       rY   r   zPacket.do_init_fields  sn      	, 	,A%)]19%=%=N16"%&DN16" ,!((+++,r[   c                    | j         }t          j                            |d          |                     | j                   t          j                            |d          }|r|| _        t          j        |         | _        t          j	        |         | _
        |rdS t          j        |         D ]P}| j        |         }	 |                                | j        |<   -# t          $ r |dd         | j        |<   Y Kw xY wdS dS )zn
        Initialize each fields of the fields_desc dict, or use the cached
        fields information
        N)ry   r;   class_default_fieldsr   prepare_cached_fieldsr   r?   class_fieldtyperA   class_packetfieldsrD   class_default_fields_refr   r@   r   )rm   r   cls_namer?   r   r   s         rY   r   zPacket.do_init_cached_fields  s     > &**8T::B&&t'7888  4884HH 	2"0D#3H=DN & 9( CD     8B 2 2+E22).DK&&% 2 2 2).qqqDK&&&2	2 	22 2s   ?CC;:C;c           	         | j         }|sdS t                      }t                      }t                      }t                      }|D ]}t          |t                    r'd| j        |<   |                     | j                    dS t          j	        |j
                  ||j        <   |||j        <   |j        r|                    |           t          |j
        t          t          t          t          t           f          r|                    |j                   |t           j        |<   |t           j        |<   |t           j        |<   |t           j        |<   dS )zC
        Prepare the cached fields of the fields_desc dict
        NT)ry   dictr   r}   r   r   r   r   r   r   r   r>   r   r   setr   r;   r   r   r   r   )rm   r   r   r   r   r   r   r   s           rY   r   zPacket.prepare_cached_fields<  sH    >  	F#vv#'66 &&!VV  	8 	8A!.// 26%h/##D$4555+/=+C+C (&'OAF# -"))!,,, !)dD#y&%IJJ 8(//777 5M'1+:x(.@!(+0D#H---r[   c                 d    |                      |           | j                            |           dS )z3DEV: will be called after a dissection is completedN)post_dissectionrL   r   rm   pkts     rY   r   zPacket.dissection_donee  s4     	S!!!$$S)))))r[   c                     dS )z7DEV: is called after the dissection of the whole packetNrb   r   s     rY   r   zPacket.post_dissectionk  s	     	r[   c                     | j         |         S )z:DEV: returns the field instance from the name of the field)rA   )rm   flds     rY   r   zPacket.get_fieldp  s     ~c""r[   c                    |d S t          | j        t                    s| j                            |           d S t          |t                    rF|| _        |                    |            | j        D ] }||j        v r|j        |         | _         d S !d S t          |t          t          t          t          f          r)t          j        t          |                    | _        d S t!          dt#          |          z            )NloadzPpayload must be 'Packet', 'bytes', 'str', 'bytearray', or 'memoryview', not [%s])r}   rL   rz   add_payloadr;   add_underlayer
aliastypesrB   rC   r   strr~   
memoryviewr   	raw_layerr   	TypeErrorrepr)rm   rL   ts      rY   r   zPacket.add_payloadu  s$   ?FDL)44 	DL$$W-----'6** 
D&&&t,,,  AG333181H1K. 4  GeS)Z%HII D#~<3H3HIII ruy  {B  vC  vC  !C  D  D  Dr[   c                 n    | j                             |            t                      | _         i | _        d S rW   )rL   remove_underlayerrz   rC   r   s    rY   remove_payloadzPacket.remove_payload  s1    &&t,,, {{!#r[   c                     || _         d S rW   rM   rm   rM   s     rY   r   zPacket.add_underlayer  s    $r[   c                     d | _         d S rW   r   rm   others     rY   r   zPacket.remove_underlayer  s    r[   c                     || _         dS )zSet packet parent.
        When packet is an element in PacketListField, parent field would
        point to the list owner packet.NrN   rm   rN   s     rY   
add_parentzPacket.add_parent  s    
 r[   c                     d| _         dS )zRemove packet parent.
        When packet is an element in PacketListField, parent field would
        point to the list owner packet.Nr   r   s     rY   remove_parentzPacket.remove_parent  s    
 r[   returnc                    |                                  }|                     | j                  |_        |                     | j                  |_        | j                                        |_        | j        |_        | j        |_        | j        |_        | j	        |_	        |                     | j
                  |_
        | j        |_        | j        dd         |_        | j                                        |_        |j                            |           | j        |_        | j        |_        | j        |_        | j        |_        |S )z$Returns a deep copy of the instance.N)ry   copy_fields_dictr@   r?   rC   r   rM   rN   rF   rG   rH   rR   rJ   rL   r   r<   rS   rP   rQ   )rm   clones     rY   r   zPacket.copy  s     ,,T[99#44T5HII"&"8"="="?"??{!%!6(,(=(=()
 )
%  $ 4QQQ 7))++$$U+++Y
.?r[   c                 l    | j         |         \  }}t          j        |d|d|dt                     |S )Nz! has been deprecated in favor of z since z !)r   warningswarnDeprecationWarning)rm   attrnew_attrversions       rY   r   zPacket._resolve_alias  sJ     248'hhh!	
 	
 	

 r[   c                    | j         r|| j         v r|                     |          }|| j        v r| j        |         S || j        v r| j        |         S || j        v r| j        |         S | j                            |          S rW   )r   r   r@   rC   r?   rL   getfieldvalrm   r   s     rY   r   zPacket.getfieldval  s    ! 	-dd.D&D&D&&t,,D4;;t$$4))))$//4&&&&t,,|''---r[   c                 \   | j         r|| j         v r|                     |          }|| j        v r"|                     |          | j        |         fS || j        v r"|                     |          | j        |         fS || j        v r"|                     |          | j        |         fS t          rW   )r   r   r@   r   rC   r?   
ValueErrorr   s     rY   getfield_and_valzPacket.getfield_and_val  s    ! 	-dd.D&D&D&&t,,D4;>>$''T):::4)))>>$'')?)EEE4&&&>>$'')<T)BBBr[   c                     	 |                      |          \  }}n*# t          $ r | j                            |          cY S w xY w|-t	          |t
                    r|n|                    | |          S |S rW   )r   r   rL   __getattr__r}   r   i2h)rm   r   r   vs       rY   r   zPacket.__getattr__  s    	2**400FC 	2 	2 	2<++D11111	2?"1f--C1137743C3CCs    $AAc                    | j         r|| j         v r|                     |          }|| j        v rk|                     |          }|d }n|j        }t          |t                    r|n || |          | j        |<   d| _        d | _	        d | _
        d | _        d S |dk    r+|                                  |                     |           d S | j                            ||           d S )Nc                     |S rW   rb   )xys     rY   <lambda>z$Packet.setfieldval.<locals>.<lambda>  s    Q r[   r   rL   )r   r   r?   r   r   r}   r   r@   rF   rG   rH   rR   r   r   rL   setfieldval)rm   r   valr   r   s        rY   r   zPacket.setfieldval  s	   ! 	-dd.D&D&D&&t,,D4&&&..&&C{&	'1#v'>'> !!dC   KDM$(D!+/D(DLLLY!!!S!!!!!L$$T3/////r[   c                     || j         v rt                              | ||          S 	 |                     ||          S # t          $ r Y nw xY wt                              | ||          S rW   )__all_slots__object__setattr__r   r   rm   r   r   s      rY   r   zPacket.__setattr__  s{    4%%%%%dD#666	##D#... 	 	 	D	!!$c222s   = 
A
	A
c                     || j         v r&| j         |= d| _        d | _        d | _        d | _        d S || j        v rd S |dk    r|                                  d S | j                            |           d S )Nr   rL   )	r@   rF   rG   rH   rR   r?   r   rL   delfieldvalr   s     rY   r   zPacket.delfieldval  s    4;D!DM$(D!+/D(DLLLT(((DY!!!!!L$$T*****r[   c                     |dk    r|                                  S || j        v rt                              | |          S 	 |                     |          S # t
          $ r Y nw xY wt                              | |          S )NrL   )r   r   r   __delattr__r   r   r   s     rY   r  zPacket.__delattr__  s    9&&(((4%%%%%dD111	##D))) 	 	 	D	!!$---s    A 
A"!A"c                     t                      }| j        }t          |d          r|                    |j                   |j        D ],}t          |d          r|                    |j                   -|S )zV
        Return a list of slots and methods, including those from subclasses.
        r   __dict__)r   ry   hasattrupdater   __mro__r  )rm   attrsrX   bclss       rY   	_superdirzPacket._superdir"  sx    
 n3(( 	,LL*+++K 	, 	,DtZ(( ,T]+++r[   c                 t    t          t          j        |                                 | j                            S )z4
        Add fields to tab completion list.
        )sorted	itertoolschainr	  r?   r   s    rY   __dir__zPacket.__dir__0  s+    
 iodnn&6&68KLLMMMr[   c           
          d}t           j        }| j        D ]}t          |t                    r|                    |           s.|j        | j        v r_| j        |j                 }t          |t          t          t          f          rt          |          dk    r|                    | |          }no|j        | j        v r_| j        |j                 }t          |t          t          t          f          rt          |          dk    r|                    | |          }n
t          |t                    s|t           j        v r|j        }|j        }n|j        }|j        }|d ||j                  |                    d           ||          z  }|                    d          |                    | j        j                  d|d|                    d          t1          | j                  |                    d          S )N r    =<|>)r   color_themer   r}   r   	_evalcondr>   r@   r   r   r   leni2reprrC   r   emphemph_field_nameemph_field_value
field_namefield_valuepunct
layer_namery   rj   r   rL   )	rm   sctr   rn   r   foverncolvcols	            rY   __repr__zPacket.__repr__7  s   ! 	) 	)A!-.. q{{47H7H v$${16*dT4$566 3t99>>hhtT**4111.qv6edD#%677 CJJ!OOhhtU++!T"" &a49nn)*}~Add16lll hhsmmm"d3iii) )AA $&88C===#%==1H#I#I#I#I#$11#%88C===#'#5#5#5#%88C===2 	2r[   c                 *    |                                  S rW   )summaryr   s    rY   __str__zPacket.__str__[  s    ||~~r[   c                 *    |                                  S rW   )r   r   s    rY   	__bytes__zPacket.__bytes___  s    zz||r[   c                 n   t          |t                    r?|                                 }|                                }|                    |           |S t          |t          t
          t          t          f          r%| t          j	        t          |                    z  S |                    |           S Nr   )r}   r;   r   r   r   r   r~   r   r   r   r   __rdiv__)rm   r   cloneAcloneBs       rY   __div__zPacket.__div__c  s    eV$$ 	(YY[[FZZ\\Fv&&&MsIzBCC 	($.l5.A.ABBBBB>>$'''r[   c                     t          |t          t          t          t          f          r%t          j        t          |                    | z  S t          r-  )	r}   r   r   r~   r   r   r   r   r   r   s     rY   r.  zPacket.__rdiv__p  sB    eeS)Z@AA 	>|E':':;;;dBBOr[   c                 F    t          |t                    r| g|z  S t          rW   )r}   intr   r   s     rY   __mul__zPacket.__mul__x  s%    eS!! 	6E>!Or[   c                 ,    |                      |          S rW   )r5  r   s     rY   __rmul__zPacket.__rmul__  s    ||E"""r[   c                     dS )NTrb   r   s    rY   __nonzero__zPacket.__nonzero__  s    tr[   c                 D    t          |                                           S rW   )r  r+  r   s    rY   __len__zPacket.__len__  s    4>>##$$$r[   c                 R    |                      |                              |          S rW   )r   do_copy)rm   	fieldnamer   s      rY   copy_field_valuezPacket.copy_field_value  s"    ~~i((00777r[   c                 L     |d S  fd|                                 D             S )Nc                 D    i | ]\  }}|                     ||          S rb   )r?  )rd   r   rn   rm   s      rY   
<dictcomp>z+Packet.copy_fields_dict.<locals>.<dictcomp>  s?     3 3 3E4 t,,UD99 3 3 3r[   )rl   )rm   r@   s   ` rY   r   zPacket.copy_fields_dict  s@    >43 3 3 3#)<<>>3 3 3 	3r[   c                     fdj         r1j        rfd|D             S  |j                  |j        j        fS j        sj        r |          S dS )z?Get a value representative of a mutable field to detect changesc                 6    r                     |           n| S rW   )r=  )r   r   r   s    rY   r   z6Packet._raw_packet_cache_field_value.<locals>.<lambda>  s    46QQ r[   c                 H    g | ]} |j                   |j        j        fS rb   )r@   rL   rG   )rd   r   _cpys     rY   
<listcomp>z8Packet._raw_packet_cache_field_value.<locals>.<listcomp>  s:       EFTT!(^^QY%?@  r[   N)r   islistr@   rL   rG   	ismutable)rm   r   r   r   rF  s    ` `@rY   _raw_packet_cache_field_valuez$Packet._raw_packet_cache_field_value  s     76666 		z H   JM    SZ((#+*FGGZ 	3= 	499tr[   c                 l   d| _         | j                                        D ]y\  }}|                     |          }|j        rXt          |t                    r|                                 Kt          |t                    r|D ]}|                                 z| j	                                         dS )z>Clear the raw packet cache for the field and all its subfieldsN)
rG   r@   rl   r   r   r}   r;   clear_cacher   rL   )rm   r   rn   r   fsubvals        rY   rL  zPacket.clear_cache  s     !%;,,.. 	. 	.KE4..''C  .dF++ .$$&&&&d++ .#' . .++----  """""r[   c                    | j         }| j        v| j                                        D ]N\  }}|                     |          \  }}|                     ||          |k    rd| _         d| _        d| _         nO| j         | j         S d}| j        D ]}|                     |j                  }t          |t                    r|t          |          z  }D	 |                    | ||          }]# t          $ rN}	 d|j        z  |j        d         z   f|j        dd         z   |_        n# t          t           f$ r Y nw xY w|d}~ww xY w|S )ze
        Create the default layer regarding fields_desc dict

        :param field_pos_list:
        Nr[   zWhile dissecting field '%s': r   rU   )rG   rH   rl   r   rJ  rR   r   r   r>   r}   r   r   addfield	Exceptionargsr   
IndexError)rm   r   rn   r   r   pr   exs           rY   
self_buildzPacket.self_build  s     ,,8#;AACC  t0077S55c3??4GG,0D)37D0#'DLE	 H
 $0,,! 	 	A""16**C#v&& U3ZZ


4C00AA    ;afDGAJ'# GABBK#( +J7   H s6   C++
E6.D%$D>%D96D>8D99D>>Ec                 4    | j                                         S )zm
        Create the default version of the payload layer

        :return: a string of payload layer
        )rL   do_buildr   s    rY   do_build_payloadzPacket.do_build_payload  s     |$$&&&r[   c                    | j         st          t          |                     } |                                 }| j        D ]} ||          }|                                 }| j        |                     ||          S ||z   S )zs
        Create the default version of the layer

        :return: a string of the packet with the payload
        )rF   nextiterrU  rJ   rX  rG   
post_build)rm   r   r   pays       rY   rW  zPacket.do_build  s     } 	$T

##Doo% 	 	A!C&&CC##%% (??3,,,9r[   c                 4    | j                                         S rW   )rL   build_paddingr   s    rY   r_  zPacket.build_padding  s    |))+++r[   c                     |                                  }||                                 z  }|                     |          }|S )zb
        Create the current layer

        :return: string of the packet with the payload
        )rW  r_  
build_donerm   rS  s     rY   r   zPacket.build  s=     MMOO	T!!!OOAr[   c                     ||z   S )a  
        DEV: called right after the current layer is build.

        :param str pkt: the current packet (build by self_build function)
        :param str pay: the packet payload (build by do_build_payload function)
        :return: a string of the packet with the payload
        rb   )rm   r   r]  s      rY   r\  zPacket.post_build  s     Syr[   c                 6    | j                             |          S rW   )rL   ra  rb  s     rY   ra  zPacket.build_done  s    |&&q)))r[   c           
      <   d}g }d}| j         D ]}t          |t                    r|                    |           s-|                    | ||                     |j                            }t          |t                    r|t          |          d          }|}nd}|	                    ||
                    | |                     |j                            |f           | j                            d          \  }}||z  }|	                    | |f           ||fS )Nr[   rU   )internal)r   r}   r   r  rO  r   r>   r   r  r   r  rL   build_ps)rm   rS  plqr   rr   lsts           rY   do_build_pszPacket.do_build_ps  s"   ! 		H 		HA!-.. q{{47H7H 

4D$4$4QV$<$<==A!U## c!ffggJIIq!((4)9)9!&)A)ABBAFGGGG<((!(44S	S

D":#vr[   c                 8    |                                  \  }}||fS rW   )rl  )rm   rf  rS  rk  s       rY   rg  zPacket.build_ps*  s"    !!##3 #vr[   c           
      
  &'()*+, t           dk    rt          d          t          j                                        }|r8|                     t          |                                                     \  }}n|                                 \  }}t          |          }|D ]\  }}|t          |          z  }t          |          }|(d}	d&d}
d}d'd)t          dd	d
t          j
        j                  }t          ddd	t          j
        j                  }d *&'()*fd+d }d ,	 	 	 	 	 d&+,fd	}d\  }}|r&t          |          }|                                \  }}|
dz  }
t          j                            |	||
z
  )z  dt          t!          |j                            z  t          j        j        j        g          }|
dz  }
|                                }|                    t          j        j        dz             |                    |                                t          j
        j        j        t          j                            |g          g           |                    |           |D ]\  }}}t          |          }t          j                            |	||
z
  )z  dt          |j                  z            }t=          |t>                    rd|j        z  }ndt          |          z  }tA          |d          rd|j!        j        j"        d d         v sd|j        j"        d d         v rd|z   }t          j                            |	dz   ||
z
  )z  d|z  t          j        j#        j$        g          }t=          |t                     r!t          |          dk    r|d d         d z   }nd!}t          j                            |	d"z   ||
z
  )z  dt          |          z            }|
d
z  }
|r ||||||          \  }} }}| }!|                                }" ||"          }# ||!          }$|!                    t          j        j                   	 |dk     r$t          j%        &                    |#|$dd#$          }%n#t          j%        &                    |#|$dd%$          }%|                    |%t          j'        j(        j)        t          j        j*        j+        |g           n# tX          $ r Y nw xY w|                    |           |                    |           |                    |           |                    |           ||z  }|&|S )'Nr   z*PyX and its dependencies must be installedrU   
           g?g?g333333?g?g      ?)transg?      ?c                 @    d                     d | D                       S )Nr  c              3   :   K   | ]}d t          |          z  V  dS )z%02xN)r   )rd   cs     rY   rf   z5Packet.canvas_dump.<locals>.hexstr.<locals>.<genexpr>R  s,      77FSVVO777777r[   )rk   r   s    rY   hexstrz"Packet.canvas_dump.<locals>.hexstrP  s#    8877Q777777r[   c                     t           j                            | z  z   |z
  z  d |          z  t           j        j        j        g          S )Nz\tt{%s})pyxtextsizeLarge)r   r   txtXDSTARTXMULYDUMPYMULrw  s      rY   make_dump_txtz)Packet.canvas_dump.<locals>.make_dump_txtT  sP    8==!d("d"VVC[[($%	  r[   c                     t           j                            |                                 |                                 |                                 |                                 d          S )N)rr  rr  )	relcenter)ry  boxrectleftbottomwidthheight)os    rY   make_boxz$Packet.canvas_dump.<locals>.make_box]  sK    7<<!((**aggii$     r[   c                 p   t          |           dk    rR| d                                         }|                    t          j        j                   |                                S | d                                         }|                    t          j        j                   | d                                         }|                    t          j        j                   t          |           dk    ra|                                |                                k    r6t          j                            t          j        	                    |                                |
                                          t          j                            |                                |
                                          t          j                            |                                |                                          t          j                            |                                |                                          t          j        	                    |                                |
                                          t          j                            |                                |
                                          t          j                            |                                |                                          t          j                            |                                |                                                    S | d                                         }||k    r$|                    t          j        j                   | d                                         }||k    r*||k    r$|                    t          j        j                   t          j                            t          j        	                    |                                |
                                          t          j                            |                                |
                                          t          j                            |                                |                                          t          j                            |                                |                                          t          j                            |                                |                                          t          j                            |                                |                                          t          j                            |                                |
                                          t          j                            |                                |
                                          t          j                                        	  	        S )NrU   r   r   )r  bboxenlargery  unitu_ptpathr  rightmovetotoplinetor  	closepath)rk  bfblbgbkbs         rY   
make_framez&Packet.canvas_dump.<locals>.make_framed  s   3xx1}}FKKMM		#(-(((vvxxV[[]]

38=)))W\\^^

38=)))s88q==RWWYY%;%;8==RVVXX)N)N),BFFHH)M)M),BIIKK)P)P),RYY[[)Q)Q),BFFHH)M)M),RVVXX)N)N),RYY[[)Q)Q),BIIKK)P)PR R R QBRxx

38=111RBRxxB"HH

38=1118==BFFHH)M)M),RVVXX)N)N),RYY[[)Q)Q),RYY[[)Q)Q),RYY[[)Q)Q),BIIKK)P)P),BFFHH)M)M),BFFHH)M)M),););)=)=@ @ @r[      c                 z   t           j                                        }g }| r]| d ||z
           | ||z
  d          } } 
|||          }	|                    |	           |t          |          z  }|dk    rd}|dz  }| ]|t           j        j        j        }|t           j        j        j        }|                     |          |t           j	        
                    |g          t           j        j        j        g           |D ]}	|                    |	           ||d                                         ||fS )Nr  r   rU   r  )ry  canvasr   r  colorrgbredwhitestrokedecofilledstyle	linewidthThickinsertr  )r!  shiftr   colbkcollargeru  tlistdmpr}  r  r  s             rY   	make_dumpz%Packet.canvas_dump.<locals>.make_dump  s<    
!!##AE >EEM>*Aeemnn,=Q#mE1c22S!!!S!B;;EFA   {im'}	+HHZZ&&chooug.F.F	H[Ha(bccc  eBinn&&q00r[   )r   rp  z"\font\cmssfont=cmss10\cmssfont{%s}r   z%sbz%sBr   LEr   z$\scriptstyle\langle$g333333@z/\font\cmbxfont=cmssbx10 scaled 600\cmbxfont{%s}   z[...]r  g      @i)	absangle1	absangle2Z   )r   rp  NNr  )-r)   ImportErrorry  r  ry   r   rg  r  floatr"   r  r  rZ  r   rz  r!   r   r>   r{  r|  r  r  r  r  r  r  blackr  r  r  r}   r   r  r   rj   halignboxright	connectorcurver  r  thinearrowsmallrP  )-rm   layer_shiftrebuildr  _r   YTXTIlYTXTXSTARTr   yd	backcolor	forecolorr  r  
last_shiftlast_yr  protor@   ptptbbr   rn   fdumpr  ftfsizestvtdttargetdtbvtbbxvtbxdtcnxr~  r  r  r  rw  r  r  s-                                         @@@@@@@rY   canvas_dumpzPacket.canvas_dump6  s   !88JKKK""$$ 	#>>#d)),,5577DAqq==??DAqA 	 	DAqSVVOEEU||3S	>>>	3S	>>>		8 	8 	8	 	 	 	 	 	 	 	 		 	 	$	@ $	@ $	@N  	1 	1 	1 	1 	1 	1 	16 $
F ;	"OOEEEGGME6HAT!5

OO9 9  $% B FA7799DLL*+++MM$))++	(;SX__eW=U=U'VWWWMM"&, )" )""tU9ooX]]6D1H+<>cfpqvq{f|f|>|}}eX.. /!EJ.EE!CJJ.EE7++ = 5 >rr BBB 8! <<<4u<EX]]6C<$(d1BDvy~D~  BE  BJ  BQ  BZ  A[  \  \dC(( 4yy2~~#CRCy72DX]]6C<$(d1BDilvw{l|l|D|}}S &5>YujRXZ]_d5e5e2B
F C''))C#8C==D#8C==DKK...c66"%-"5"5dDAY\"5"]"]CC"%-"5"5dDAY["5"\"\C cCI,?,DchoF[]`+abbbb %   
 MM"%%%b!!!b!!!b!!!!k!Fw  ;	"z s   *AS99
TTc                 
    |dfS )z
        DEV: to be overloaded to extract current layer's padding.

        :param str s: the current layer
        :return: a couple of strings (actual layer, padding)
        Nrb   rm   r!  s     rY   extract_paddingzPacket.extract_padding  s     $wr[   c                     |S )z?DEV: is called right after the current layer has been dissectedrb   r  s     rY   post_dissectzPacket.post_dissect  	     r[   c                     |S )z:DEV: is called right before the current layer is dissectedrb   r  s     rY   pre_dissectzPacket.pre_dissect  r  r[   c                    |}i | _         | j        D ]}|                    | |          \  }}t          |t                    r|3|j        s|j        s|j        r'|%|                     ||d          | j         |j	        <   || j
        |j	        <   |sHt          |t                    s1|1t          |t                    rt          |j        t                    r n|r|d t          |                    n|| _        d| _        |S )NTr   rU   )rH   r   getfieldr}   r   rH  r   rI  rJ  r>   r@   r   r   r  rG   rF   )rm   r!  _rawr   rn   s        rY   
do_dissectzPacket.do_dissect  s#   ')$! 	 	Ajjq))GAt!-.. 4<  KAO Kq{ K@P66q$T6JJ ,QV4"&DK *Q// +
1>N0O0O+%aeV44 ,23 =Xs1vvgXr[   c                 ^   |r)| j         rCt          | | j                   r.t          j        |d|           }|                     |           dS |                     |          }	  ||| j         d|           }n# t          $ r  t          $ r t          j        r`t          |t                    rt          j        d|j                   n-t          j        d| j        j        t          |                     | t          j        |d|           }Y nw xY w|                     |           dS dS )zd
        Perform the dissection of the layer's payload

        :param str s: the raw layer
        rU   r   r   N)rK   r   r   z%s dissector failedz&%s.guess_payload_class() returned [%s])rK   r}   r   r   r   guess_payload_classKeyboardInterruptrP  debug_dissectorr#   r;   r'   errorrj   ry   r   )rm   r!  rS  rX   s       rY   do_dissect_payloadzPacket.do_dissect_payload  s     	 *4!;<<
 N1tDDD  ###**1--CEC*.*D $	   %    
E 
E 
E'  f-- N#)*?NNNN#) +1*..*A499N N N N1tDDD
E Q=	  	 s   $A9 9BDDc                 P   |                      |          }|                     |          }|                     |          }|                     |          \  }}|                     |           |r5t
          j        r+|                     t          j        |                     d S d S d S rW   )	r  r  r  r  r  r   paddingr   padding_layer)rm   r!  paylpads       rY   r   zPacket.dissect8  s    QOOAa  ((++	c%%% 	64< 	6T/4455555	6 	6 	6 	6r[   c                       j         D ]S}|j        D ]I\  }}	 t           fd|                                D                       r|c c S :# t          $ r Y Fw xY wT                     |          S )z
        DEV: Guesses the next payload class from layer bonds.
        Can be overloaded to use a different mechanism.

        :param str payload: the layer's payload
        :return: the payload class
        c              3   P   K   | ] \  }}|                     |          k    V  !d S rW   r   )rd   kr   rm   s      rY   rf   z-Packet.guess_payload_class.<locals>.<genexpr>Q  sN       5 5#q!  0 0 3 33 5 5 5 5 5 5r[   )r   rh   allrl   r   default_payload_class)rm   rL   r   rn   rX   s   `    rY   r  zPacket.guess_payload_classE  s      	 	A_  	c 5 5 5 5'+zz||5 5 5 5 5 #"




# &   D ))'222s   .A
AAc                     t           j        S )a   
        DEV: Returns the default payload class if nothing has been found by the
        guess_payload_class() method.

        :param str payload: the layer's payload
        :return: the default payload class define inside the configuration file
        )r   r   rm   rL   s     rY   r  zPacket.default_payload_classX  s     ~r[   c                     t          | j                                                  D ]4\  }}| j        |         }|| j        v r| j        |         |k    r| j        |= 5| j                                         dS )z;Removes fields' values that are the same as default values.N)r   r@   rl   r?   rL   hide_defaults)rm   r  r   s      rY   r  zPacket.hide_defaultsc  s}     **,,-- 	' 	'DAqAAD'''&q)Q..A""$$$$$r[   c                    |                                  }d|_        ||_        |                     | j                  |_        | j                                        |_        | j        |_        | j        |_        | j	        |_	        | j
        |_
        | j        |_        |                     | j                  |_        | j        |_        | j        |_        | j        |_        | j        |_        ||                    |           |S NrU   )ry   rF   r@   r   r?   rC   r   r<   rM   rN   rJ   rG   rH   rR   rS   rQ   rP   r   )rm   rL   kargsr   s       rY   
clone_withzPacket.clone_withn  s    nn
!2243FGG $ 6 ; ; = =9[
"2#4&*&;&;('
 '
# llOOG$$$
r[   c                 "   | ffd	| j         s| j        
g }| j        }ndd t          j        | j                                        | j                                                  D             t          | j                  z   }i } ||          S )z:Iterates through all sub-packets generated by this Packet.c              3     K   | r|                                  }|                    |          }t          |t                    s:|                    |          j        rt          |g          }nt          |          }|D ]"}|||<    | d d          |          D ]}|V  #d S t          |j        t                    rt          d g          }n|j        }|D ]f}|	                                }	|	D ]:}
t          |	|
         t                    r|	|
                                         |	|
<   ; |j        dd|i|	}|V  gd S )NrL   rb   )r   r   r}   r   r   rH  r   rL   rz   r   r   _fixr  )tododonerm   eltnameelter   payloadsr  done2r  r   loops               rY   r  zPacket.__iter__.<locals>.loop  s{      ((**&&w//!#s++ *~~g..5 *$cUmm$Skk    A$%DM!T$qqq'400        
 dlI66 ,%tf~~HH#|H$  D IIKKE" 7 7%eAh>> 7',Qx}}E!H)$/@@$@%@@CIIII r[   Nc                 B    g | ]\  }}t          |t                    |S rb   )r}   r   rd   r  r   s      rY   rG  z#Packet.__iter__.<locals>.<listcomp>  s:     5 5 5&1a!!]335A 5 5 5r[   )	rF   rG   r@   r  r  r?   rl   rC   r   )rm   r	  r
  r  s      @rY   __iter__zPacket.__iter__  s     #' 	 	 	 	 	 	8 = 	D1=D;DD5 5IOD4G4M4M4O4O484J4P4P4R4R%T %T 5 5 57;DK7H7HID DtD$r[   c              #   L   K   | V  | }|j         r|j         }|V  |j         dS dS )zfUsed to iter through the payloads of a Packet.
        Useful for DNS or 802.11 for instance.
        N)rL   )rm   currents     rY   iterpayloadszPacket.iterpayloads  sP      
 


o 	oGMMM o 	 	 	 	 	r[   c                     t          |t                    r|| k     S t          |t                    rdS t          | |f          )z6True if other is an answer from self (self ==> other).rU   )r}   r;   r   r   r   s     rY   __gt__zPacket.__gt__  sI     eV$$ 	+4<u%% 	+1T5M***r[   c                     t          |t                    r|                     |          S t          |t                    rdS t	          | |f          )z6True if self is an answer from other (other ==> self).rU   )r}   r;   answersr   r   r   s     rY   __lt__zPacket.__lt__  sQ     eV$$ 	+<<&&&u%% 	+1T5M***r[   c                     t          || j                  sdS | j        D ]G}||j        vr dS |                     |j                  |                    |j                  k    r dS H| j        |j        k    S NF)r}   ry   r   r   r>   rL   )rm   r   r   s      rY   __eq__zPacket.__eq__  s    %00 	5! 	 	A)))uu''5+<+<QV+D+DDDuu E|u},,r[   c                 .    |                      |           S rW   )r  r   s     rY   __ne__zPacket.__ne__  s    ;;u%%%%r[   c                 4    | j                                         S )zSDEV: returns a string that has the same value for a request
        and its answer.)rL   hashretr   s    rY   r"  zPacket.hashret  s     |##%%%r[   c                 d    |j         | j         k    r| j                            |j                  S dS )z)DEV: true if self is an answer from otherr   )ry   rL   r  r   s     rY   r  zPacket.answers  s0     ?dn,,<''666qr[   c                     g }| }|r8|                     |j                   |j                            dd          }|8|S )zEreturns a list of layer classes (including subclasses) in this packetr   T	_subclass)r   ry   rL   getlayer)rm   layerslyrs      rY   r(  zPacket.layers  sU      	:MM#-(((+&&qD&99C  	: r[   c                    |	| j         pd}|rt          }nd }|& || j        |          s|| j        j        | j        fv rdS | j        D ]p}|                     |j                  }||j        st          |d          }|D ]6}t          |t                    r|                    ||          }|r|c c S 7q| j                            ||          S )zr
        true if self has a layer that is an instance of cls.
        Superseded by "cls in self" syntax.
        Nc                 (    t          | |k              S rW   r|   r   r   s     rY   r   z!Packet.haslayer.<locals>.<lambda>      a1f r[   Tr   _iterpacketr%  )match_subclassr#   ry   rj   rx   rD   r   r>   rH  r   r}   r;   haslayerrL   )rm   rX   r&  matchr   
fvalue_genfvaluerets           rY   r2  zPacket.haslayer  s    +3tI 	.EE--E;%%44;dn-tz:::4" 
	# 
	#A))!&11J!8 ?#JA>>>
$ # #ff-- # //#/CCC #"




	#
 |$$SI$>>>r[   c           	          |	 j         pd}|rt          }nd }t          |t                    r|dz   }d}n|}d}d}	t          |t                    rd|v r|                    dd          \  }}	n|d}	}|r& | j        |          s| j        j         j        fv rQt           fd|
                                D                       r$|dk    r|	 S                      |	          S |dz  } j        D ]u}
                     |
j                  }||
j        st          |d          }|D ];}t          |t                     r$g } |j        |f|||d	|}||c c S |d         }<v  j        j        |f|||d	|S )
zPReturn the nb^th layer that is an instance of cls, matching flt
values.
        Nc                 (    t          | |k              S rW   r,  r-  s     rY   r   z!Packet.getlayer.<locals>.<lambda>#  r.  r[   rU   r  .c              3   P   K   | ] \  }}                     |          |k    V  !d S rW   r  )rd   fldnamefldvaluerm   s      rY   rf   z"Packet.getlayer.<locals>.<genexpr>5  sN       9 9(w ##G,,8 9 9 9 9 9 9r[   r   r/  )nb_trackr&  )r1  r#   r}   r4  r   splitry   rj   rx   r  rl   r   rD   r>   rH  r   r;   r'  rL   )rm   rX   r=  r>  r&  fltr3  string_class_name
class_namer   r   r4  r5  trackr6  s   `              rY   r'  zPacket.getlayer  sM    +3tI 	.EE--E
 c3 	$qB " #
'-- 	6#9J2J2J/55c1==OJ/J 
	UU4>:>> 
	T^4djAAA 9 9 9 9,/IIKK9 9 9 9 9 77{##//444!GB" 	" 	"A))!&11J!8 ?#JA>>>
$ " "ff-- "E)&/* FE4=F FADF FC"




qB" %t|$Z ABv/8A A<?A A 	Ar[   c                 4    | }|j         |j         }|j         |S rW   r   )rm   ri  s     rY   
firstlayerzPacket.firstlayerO  s%    l&A l&r[   c                    t          |t                    rK|j        }|j        r" | j        |j        fd|j        i|j        pi }n2 | j        |j        fi |j        pi }n|}|                     |          }|it          |t                    r|j        }n:t          |t                    st          |          }nt          t          |          }t          d|z            |S )Nr=  zLayer [%s] not found)r}   slicestartstopr'  steptyperj   r   r   r7   r   rR  )rm   rX   lnamer6  r>   s        rY   __getitem__zPacket.__getitem__V  s    c5!! 	%IEx C#dmCIOO#(Osx~2OO#dmCIBB#(.bBBE--$$C;%&& (~u-- (E{{C''3d:;;;
r[   c                      | |         j         `d S rW   rM   rL   rm   rX   s     rY   __delitem__zPacket.__delitem__k  s    I (((r[   c                 *    || |         j         _        d S rW   rO  )rm   rX   r   s      rY   __setitem__zPacket.__setitem__o  s    '*S	$$$r[   c                 ,    |                      |          S )ze
        "cls in self" returns true if self has a layer which is an
        instance of cls.
        )r2  rP  s     rY   __contains__zPacket.__contains__s  s     }}S!!!r[   c                 4    | j                                         S rW   )rL   router   s    rY   rW  zPacket.route{  s    |!!###r[   c                 &     | j         j        |i |S rW   )rL   fragmentrm   rQ  r  s      rY   rY  zPacket.fragment  s    $t|$d4e444r[   c                       | j         |i | dS )zDeprecated. Use show() method.N)showrZ  s      rY   displayzPacket.display  s!     		4!5!!!!!r[   r   r  c           	      0    |rddl m}m}  |            }nt          j        }||                    d          d|                     j                  d|                    d          d}	 j        	                                }
|
r|

                    d          }t          |t                    r|                               sCt          |d          rs|	||z   d|                    |j                  d	z  }	|d|z   j        z  z  }t#           fd
|j        D                       D ]\  }}|
                    ||           t          |t(                    s|t          j        v r|j        }|j        }n|j        }|j        }t5          ddt7          |j                  z
            dz  }                     |j                  }t          |t:                    s#|j        r|j        rt          |t@                    r|	||z   d|                    d           ||j                  ||                    d          dz  }	tC          |d          }|D ]$}|	|"                    ||||z   dz   d          z  }	%n||z   d ||j                  ||                    d          d}|#                     |          }t          |tH                    rQ|%                    dddt7          |          t7          |          z   t7          |j                  z   dz   z  z             }|	| ||          dz  }	|
 j&        r0|	 j&        "                    |||d|z   j        z  z   |d          z  }	|r|stO          |	           dS |	S )a  
        Internal method that shows or dumps a hierarchical view of a packet.
        Called by show.

        :param dump: determine if it prints or returns the string value
        :param int indent: the size of indentation for each layer
        :param str lvl: additional information about the layer lvl
        :param str label_lvl: additional information about the layer fields
        :param first_call: determine if the current function is the first
        :return: return a hierarchical view if dump, else print it
        r   )
ColorThemeAnsiColorThemez###[r  z]###
r@   r^   z =
c              3   F   K   | ]}t          |j                  |V  d S rW   )r  r>   rd   r   rm   s     rY   rf   z'Packet._show_or_dump.<locals>.<genexpr>  s4      'U'UawtQV?T?T'U'U'U'U'U'U'Ur[   ro  \r/  z   |F)dumpindent	label_lvl
first_callr  r   )re  rf  lvlrg  rh  N)(scapy.themesr_  r`  r   r  r  r   r>   r   r   r   r}   r   r  r  depreciate_field_nameshow_indent	enumerater@   r  r   r  r  r  r  r  maxr  r   r;   rH  r   r   r   _show_or_dumpr  r   replacerL   ri   )rm   re  rf  ri  rg  rh  r_  r`  r"  r!  r@   r   re   r   r$  r%  r  r5  r4  begnreprvals   `                    rY   ro  zPacket._show_or_dump  sD   (  	"????????+^--BB!B'i hhv.... mmDI6666 hhv....0 !&&(( ,	6

1A!-.. q{{47H7H q(## OOO,,QV4444  sV|d&666''U'U'U'U18'U'U'UUU * *FAsMM!S))))!T"" &a49nn)*}~ac!&kk)**S0C%%af--F&&)) 6ah 61? 6zZ`bfOgOg 6S)+$)-af),)+$	9 9
 $ !  
 ) ~ ~F--4R[^aRadjRjw|-}}}AA~ )2C(,QV(+(*8 ((400gs++ F%oodD3#i..BEc((CKBEaf++CN CDCD <E 5E F FG ttG}}}}55Y  ,	6Z < 	++3<$*::;#  ,   A  	d 	!HHH4Hr[   c                 2    |                      ||||          S )a  
        Prints or returns (when "dump" is true) a hierarchical view of the
        packet.

        :param dump: determine if it prints or returns the string value
        :param int indent: the size of indentation for each layer
        :param str lvl: additional information about the layer lvl
        :param str label_lvl: additional information about the layer fields
        :return: return a hierarchical view if dump, else print it
        )ro  rm   re  rf  ri  rg  s        rY   r\  zPacket.show  s     !!$Y???r[   c                 r    |                      t          |                                         ||||          S )a  
        Prints or returns (when "dump" is true) a hierarchical view of an
        assembled version of the packet, so that automatic fields are
        calculated (checksums, etc.)

        :param dump: determine if it prints or returns the string value
        :param int indent: the size of indentation for each layer
        :param str lvl: additional information about the layer lvl
        :param str label_lvl: additional information about the layer fields
        :return: return a hierarchical view if dump, else print it
        )ry   r   r\  rt  s        rY   show2zPacket.show2  s0     ~~c$ii((--dFCKKKr[   c                    dddd}d|v r|                     d          }||dz   d                             d          }||dz   ||z   dz            }|                    d          }|dk     rt          d	|z            |d|         ||dz   d         }}d
}	|d         dk    rd}	|dd         }|                     |          r|	 }	|	sd}|d|         |z   |||z   dz   d         z   }d|v d}
d|v r|                    d          }|
|d|         z  }
||dz   d         }|r&|d         |v r|
||d                  z  }
|dd         }\	 |                    d          }|d|         }|                    d          }t          |          dk    rd}|d         }n t          |          dk    r|\  }}nt          d|v r|                    d          \  }}n| j        j        }|}d}d|v r'|                    d          \  }}t          |          }||dz   d         }|dk    rgt          j        dt          j        t          | j
                                      t          | j
        t          | j
                  z
  dz            z  }n|| j        j        k    rt          | |          r|dk    r.| j                            d|d|d|dz
  d|d	|          }d}n	 |                     |          }n # t$          $ r t'          | |          }Y nw xY w|d         dk    r|dd         }|sd}nK|| j        v r!| j        |                             | |          }n | j                            d|z  |          }d}|
d|z   |z  z  }
n5# t,          $ r( t          d|dd         |dd         odd          w xY wd|v |
|z  }
|
S )ag  
        sprintf(format, [relax=1]) -> str

        Where format is a string that can include directives. A directive
        begins and ends by % and has the following format:
        ``%[fmt[r],][cls[:nb].]field%``

        :param fmt: is a classic printf directive, "r" can be appended for raw
          substitution:
          (ex: IP.flags=0x18 instead of SA), nb is the number of the layer
          (ex: for IP/IP packets, IP:2.src is the src of the upper IP layer).
          Special case : "%.time%" is the creation time.
          Ex::

            p.sprintf(
              "%.time% %-15s,IP.src% -> %-15s,IP.dst% %IP.chksum% "
              "%03xr,IP.proto% %r,TCP.flags%"
            )

          Moreover, the format string can include conditional statements. A
          conditional statement looks like : {layer:string} where layer is a
          layer name, and string is the string to insert in place of the
          condition if it is true, i.e. if layer is present. If layer is
          preceded by a "!", the result is inverted. Conditions can be
          imbricated. A valid statement can be::

            p.sprintf("This is a{TCP: TCP}{UDP: UDP}{ICMP:n ICMP} packet")
            p.sprintf("{IP:%IP.dst% {ICMP:%ICMP.type%}{TCP:%TCP.dport%}}")

          A side effect is that, to obtain "{" and "}" characters, you must use
          "%(" and "%)".
        %{})rx  ()rU   N:r   z8Bad condition in format string: [%s] (read sprintf doc!)F!Tr  r   ,r!  r9  r<   z%H:%M:%S.%%06ii@B r  rj  z%%%s%%zBad format string [%   z...])rindexindexfindr&   r2  r?  r  ry   rj   r4  r<   strftime	localtimer  r  rL   sprintfr   r   getattrrA   r  rP  )rm   fmtrelaxescapere   jcondr  format_resr!  sfclsfldfclsfldr   clsfldrX   r   numsnumr   s                       rY   r  zPacket.sprintf  s   F  
 Sjj

3AAEFF!!#&&Aq1uQUQY'D		#A1uu%&`cg&ghhh !Hd1q566l'DCAw#~~ABBx}}T"" g bqb'G#c!a%!)**o5C! Sjj& Sjj		#ARaRLAa!eff+C s1v''VCF^#!""g0%IIcNNrr7"..--w<<1$$A$QZFF\\Q&& 'IAvv))&==%||C00HC.1C C#:: #		#ICd))C!a%&&k &==-(uTY'7'788  TYTY77BCCDCC DN333c8J8J3Qww"l222333PSVWPWPWPWY\Y\Y\3]_dee5"&"2"23"7"7CC- 5 5 5")$"4"4CCC5R5C<< !#2#A#$ ($'"dn44&*nS&9&@&@s&K&K,..x(/BEJJCAcAg_$7  e e e%oc#2#hhPSTVTWTWPXPb]bPbPb&cddde; Sjjt 	
Ss   CN 'K= =LL2Oc                     dS )aO  DEV: can be overloaded to return a string that summarizes the layer.
           Only one mysummary() is used in a whole packet summary: the one of the upper layer,  # noqa: E501
           except if a mysummary() also returns (as a couple) a list of layers whose  # noqa: E501
           mysummary() must be called if they are present.r  rb   r   s    rY   	mysummaryzPacket.mysummaryx  s	     rr[   c                 J   | j                                         \  }}}d}|r	| j        |v r3|                                 }t	          |t
                    r
|\  }}||z  }|s|rd}|s| j        r| j        j        nd}| j        t          j	        v rg }| j
        D ][}|t          j	        v rK|                    |j        d|                    | |                     |j                                       \|dd                    |          d}|r
|r|d|}n||}|||fS )Nr  rU   r  z [r  r  z / )rL   _do_summaryry   r  r}   tupleshow_summaryrj   r   r  r   r   r>   r  r   rk   )rm   foundr!  neededr6  nimpfr   s           rY   r  zPacket._do_summary  sh   <3355q& 	&00..""C#u%% Q! 	& 	E 	G-1->F$.))BC>TY&&D% ^ ^	>>KK1666188D$BRBRSTSYBZBZ3[3[3[ \]]]"ssCHHTNNNN3C 	$1 	$"ssAA&CCC#Cc6!!r[   c                 6    |                                  d         S )z&Prints a one line summary of a packet.rU   )r  )rm   interns     rY   r(  zPacket.summary  s     !!!$$r[   c                 6    | j                             |           S )z&Returns the uppest layer of the packet)rL   	lastlayerrm   layers     rY   r  zPacket.lastlayer  s     |%%d+++r[   c                     t          | j                  } ||d|           | _        | }|j        |j        }|j        | j                            |           dS )z@Reassembles the payload and decode it using another packet classrU   r  N)r   rL   rM   r   )rm   rX   r!  pps       rY   decode_payload_aszPacket.decode_payload_as  se     s1t<<<m'B m'$$R(((((r[   c                     g }|r fd j         D             }n&t           j                                                  }|D ]2\  }}                     |          }t          |t          t          t          f          r
|s|j	        sGt          |t                    r:|r"d |                    d          D             }n|                                }n|j        rm|j        rft          |t                    rQ|rd t          d |          D             }nCdd                    t          t          j        |                    z  }n|j        rGt          |t                    r2|rd	 |D             }ndd                    d
 |D                       z  }nt          |t"                    rt%          |          }nt'          t)          |dd                    r|                    |          }ni|rDt          |t*                    r|                    dd          }n:|                     |          }n#t1          |                     |                    }|                    ||f           4|S )zG
        Internal method used to generate command() and json()
        c              3   Z   K   | ]%}|j                             |j                   fV  &d S rW   )r>   r   rc  s     rY   rf   z"Packet._command.<locals>.<genexpr>  s:      UUq!1!1!&!9!9:UUUUUUr[   c                     i | ]\  }}||	S rb   rb   r  s      rY   rB  z#Packet._command.<locals>.<dictcomp>  s    DDD6Aq!QDDDr[   Tjsonc                 &    g | ]}d  |D             S )c                     i | ]\  }}||	S rb   rb   r  s      rY   rB  z.Packet._command.<locals>.<listcomp>.<dictcomp>  s    ...&1aA...r[   rb   rd   r   s     rY   rG  z#Packet._command.<locals>.<listcomp>  s6        /.A...  r[   c                 :    t                               | d          S )NTr  )r;   _command)r   s    rY   r   z!Packet._command.<locals>.<lambda>  s    vqt/L/L r[   z[%s]r  c           	      H    g | ] t          d fd                      S )commandc                  "    t                     S rW   r   rv  s   rY   r   z,Packet._command.<locals>.<listcomp>.<lambda>      d1gg r[   r  r  s    @rY   rG  z#Packet._command.<locals>.<listcomp>  sC        ?9oooo>>@@  r[   c              3   P   K   | ]  t          d fd                      V  !dS )r  c                  "    t                     S rW   r  rv  s   rY   r   z+Packet._command.<locals>.<genexpr>.<lambda>  r  r[   Nr  r  s    @rY   rf   z"Packet._command.<locals>.<genexpr>  sQ       + + ?9oooo>>@@+ + + + + +r[   r  Nzutf-8backslashreplace)errors)r   r[  r@   rl   r   r}   r   r   r   r   r;   r  r  rH  r   maprk   r   r4  callabler  r   decoder   r   r   )rm   r  r   iteratorfnfvr   s   `      rY   r  zPacket._command  s   
  	1UUUUDDTUUUHHDK--//00H (	 (	FB..$$C"tT3/00  CK "f%% #1 &DDR[[d[-C-CDDDBBBB 1 1 1jT6J6J 1 D !$%L%Lb!Q!Q  BB
  #((3v~r+B+B"C"CCBB 1
2t 4 4 1 	 !#  BB
  #(( + +!#+ + + # # BB B	** 1WW'"i6677 	1ZZTZ** 1!"e,, /YYw7IYJJ WWT2..cggdB//00BHHb"Xr[   c                     | j         j        dd                    d |                                 D                       d}| j                                        }|r|d|z   z  }|S )zn
        Returns a string representing the command you have to type to
        obtain the same packet
        r{  r_   c              3       K   | ]	}d |z  V  
dS )z%s=%sNrb   r  s     rY   rf   z!Packet.command.<locals>.<genexpr>  s&      ;;agk;;;;;;r[   r|  /)ry   rj   rk   r  rL   r  )rm   ru  pcs      rY   r  zPacket.command  st     N###II;;4==??;;;;;;;
 \!!## 	rMAr[   c                     t          j        d |                     d          D                       }| j                                         }|r|dd         d|z  z   }|S )a$  
        Returns a JSON representing the packet.

        Please note that this cannot be used for bijective usage: data loss WILL occur,
        so it will not make sense to try to rebuild the packet from the output.
        This must only be used for a grepping/displaying purpose.
        c                     i | ]\  }}||	S rb   rb   r  s      rY   rB  zPacket.json.<locals>.<dictcomp>  s    GGGFQ1aGGGr[   Tr  Nr  z, "payload": %s})r  dumpsr  rL   )rm   re  r  s      rY   r  zPacket.json  sh     zGGdmmm.F.FGGGHH\   	993b88Dr[   )r[   Nr   NNNFr   )r   rU   rW   rU   NN)Fr   r  r  TFr   r  r  rU   )rj   
__module____qualname__	__slots__r>   r   r   rB   rh   rl  r  r1  r   r   r   r   r   classmethodrZ   rp   ru   r   r2   r5   r%   r  r0   r4  r   r   _PickleTyper   r   r   r{   r   r   r   r   r   r   r   r   r   r   r   r   r8   r   r   r   r   r   r   r   r   r  r	  r  r&  r)  r+  r1  __truediv__r.  __rtruediv__r5  r7  r9  __bool__r;  r?  r   rJ  rL  rU  rX  rW  r_  r   r\  ra  rl  rg  r  r  r  r  r  r  r   r  r  r  r  r  r  r  r  r  r   __hash__r"  r  r(  r2  r'  rE  rM  rQ  rS  rU  rW  rY  r]  ro  r\  rv  r  r  r  r(  r  r  r  r  r  rb   r[   rY   r;   r;   R   sL       
  I( DKOMKLN!O$ $ [$   [   [  $!'+C4 C4 C4 C4J hox,-.#$	K
 
 
	 	 	  	J 	J 	J 	J- - - 2 2 2 2B'E 'E 'ER* * *  
# # #
D D D&$ $ $% % %      d    .  
. 
. 
.
 
 
  0 0 0,3 3 3+ + +
. 
. 
.  N N N"2 "2 "2H    
( 
( 
( K   L  # # #   H% % %8 8 83 3 3    # # ## # #J' ' '  $, , ,
 
 
	 	 	* * *  ,
 
 
 
m m m m^    
  
  0%  %  % N6 6 63 3 3&	 	 		% 	% 	%   .'  '  ' R	 	 	+ + ++ + +	- 	- 	-& & & H& & &    ? ? ? ?< 	:A :A :A :Ax    *) ) )+ + +" " "$ $ $5 5 5" " " ! "!%X X X Xt@ @ @ @L L L Lw w w wr  " " "2% % % %
, , , ,
) ) )4 4 4 4l      r[   r;   )	metaclassc                      e Zd Zd Zd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zd Zd Zd ZeZd Zd Zd Zd Zd/dZd Zd Zd Zd Zd Zd Zd Zd Zd Z d0d Z!	 	 	 d1d"Z"d# Z#d2d'Z$d3d(Z%d) Z&d* Z'd0d+Z(d, Z)d- Z*d. Z+dS )4rz   c                     | j                             d          }|;t                              |           x| _        }t                              |           t          t          |          S )N	__singl__)r  r   r;   __new__r  r   r7   rz   )rX   rQ  r  singls       rY   r  zNoPayload.__new__  sV      --=$*NN3$7$77CMEOOE"""Iu%%%r[   c                     d S rW   rb   rZ  s      rY   r   zNoPayload.__init__      r[   c                     d S rW   rb   r   s     rY   r   zNoPayload.dissection_done  r  r[   c                      t          d          )Nz'Can't add payload to NoPayload instancer&   r  s     rY   r   zNoPayload.add_payload  s    GHHHr[   c                     d S rW   rb   r   s    rY   r   zNoPayload.remove_payload  r  r[   c                     d S rW   rb   r   s     rY   r   zNoPayload.add_underlayer  r  r[   c                     d S rW   rb   r   s     rY   r   zNoPayload.remove_underlayer  r  r[   c                     d S rW   rb   r   s     rY   r   zNoPayload.add_parent#  r  r[   c                     d S rW   rb   r   s     rY   r   zNoPayload.remove_parent'  r  r[   c                     | S rW   rb   r   s    rY   r   zNoPayload.copy+  s    r[   c                     d S rW   rb   r   s    rY   rL  zNoPayload.clear_cache/  r  r[   c                     dS Nr  rb   r   s    rY   r&  zNoPayload.__repr__3      rr[   c                     dS r  rb   r   s    rY   r)  zNoPayload.__str__7  r  r[   c                     dS Nr[   rb   r   s    rY   r+  zNoPayload.__bytes__;      sr[   c                     dS r  rb   r   s    rY   r9  zNoPayload.__nonzero__?  s    ur[   c                     dS r  rb   r   s    rY   rW  zNoPayload.do_buildD  r  r[   c                     dS r  rb   r   s    rY   r   zNoPayload.buildH  r  r[   c                     dS r  rb   r   s    rY   r_  zNoPayload.build_paddingL  r  r[   c                     |S rW   rb   rb  s     rY   ra  zNoPayload.build_doneP  s    r[   r   c                 
    dg fS r  rb   )rm   rf  s     rY   rg  zNoPayload.build_psT  s    Bwr[   c                      t          |          rW   r   r   s     rY   r   zNoPayload.getfieldvalX      T"""r[   c                      t          |          rW   r  r   s     rY   r   zNoPayload.getfield_and_val\  r  r[   c                      t          |          rW   r  r   s      rY   r   zNoPayload.setfieldval`  r  r[   c                      t          |          rW   r  r   s     rY   r   zNoPayload.delfieldvald  r  r[   c                     d S rW   rb   r   s    rY   r  zNoPayload.hide_defaultsh  r  r[   c                      t          g           S rW   )r[  r   s    rY   r  zNoPayload.__iter__l  s    Bxxr[   c                 4    t          |t                    rdS dS )NTF)r}   rz   r   s     rY   r  zNoPayload.__eq__p  s    eY'' 	4ur[   c                     dS r  rb   r   s    rY   r"  zNoPayload.hashretv  r  r[   c                 D    t          |t          t          j        f          S rW   )r}   rz   r   r  r   s     rY   r  zNoPayload.answersz  s    %)T-?!@AAAr[   Nc                     dS rw   rb   )rm   rX   r&  s      rY   r2  zNoPayload.haslayer~      qr[   rU   c                 4    ||                     |           d S rW   )r   )rm   rX   r=  r>  r&  r@  s         rY   r'  zNoPayload.getlayer  s!     MM"tr[   c                      t          d          )Nzcannot fragment this packetr  rZ  s      rY   rY  zNoPayload.fragment  s    ;<<<r[   Fr   r  c                     d S rW   rb   rt  s        rY   r\  zNoPayload.show  r  r[   c                 .    |rdS t          d|z            )Nz??zFormat not found [%s]r  )rm   r  r  s      rY   r  zNoPayload.sprintf  s$     	A4!"9C"?@@@r[   c                     ddg fS )Nr   r  rb   r   s    rY   r  zNoPayload._do_summary  s    "byr[   c                     g S rW   rb   r   s    rY   r(  zNoPayload.layers  s    	r[   c                 
    |p| S rW   rb   r  s     rY   r  zNoPayload.lastlayer  s    }r[   c                     dS r  rb   r   s    rY   r  zNoPayload.command  r  r[   c                     dS r  rb   r   s    rY   r  zNoPayload.json  r  r[   c                     dS )N)NNNrb   r   s    rY   rW  zNoPayload.route  s    !!r[   r  rW   r  r  r  ),rj   r  r  r  r   r   r   r   r   r   r   r   r   rL  r&  r)  r+  r9  r  rW  r   r_  ra  rg  r   r   r   r   r  r  r  r"  r  r2  r'  rY  r\  r  r  r(  r  r  r  rW  rb   r[   rY   rz   rz     s       & & &    I I I                       H           # # ## # ## # ## # #        B B B    	
 
 
 
= = =   A A A A           " " " " "r[   rz   c                   J     e Zd Zd Z edd          gZd fd	Zd Zd Z xZ	S )Rawr   r[   c                     |rPt          |t                    s;t          |t                    r|\  }}t          |          |f}nt          |          } t	          t
          |           j        |g|R i | d S rW   )r}   r   r  r   superr  r   )rm   rI   rQ  kwargsbnry   s        rY   r   zRaw.__init__  s     	*
4// 	*$&& *b#D))2-#D))!c4!$888888888r[   c                     dS r  rb   r   s     rY   r  zRaw.answers  r  r[   c                     t           j        }|r,t          |          rd || j                  z  S d| j        z  S t                              |           S )NzRaw %szRaw %r)r   raw_summaryr  r   r;   r  )rm   css     rY   r  zRaw.mysummary  sV     	,|| ,""TY--//$)++%%%r[   )r[   )
rj   r  r  r>   r   r   r   r  r  __classcell__)ry   s   @rY   r  r    st        D8FC(()K9 9 9 9 9 9  & & & & & & &r[   r  c                        e Zd Zd ZddZd ZdS )PaddingNc                     dS r  rb   )rm   field_pos_lists     rY   rU  zPadding.self_build  r  r[   c                 z    | j         t          | j                  n| j         | j                                        z   S rW   )rG   r   r   rL   r_  r   s    rY   r_  zPadding.build_padding  s=     (,'<'DL###&L&&(() 	)r[   rW   )rj   r  r  r>   rU  r_  rb   r[   rY   r  r    s<        D   ) ) ) ) )r[   r  c                     ||                     |           | j        dd         | _        | j                            ||f           dS )a  Bind 2 layers for dissection.
    The upper layer will be chosen for dissection on top of the lower layer, if
    ALL the passed arguments are validated. If multiple calls are made with
    the same layers, the last one will be used as default.

    ex:
        >>> bind_bottom_up(Ether, SNAP, type=0x1234)
        >>> Ether(b'\xff\xff\xff\xff\xff\xff\xd0P\x99V\xdd\xf9\x124\x00\x00\x00\x00\x00')  # noqa: E501
        <Ether  dst=ff:ff:ff:ff:ff:ff src=d0:50:99:56:dd:f9 type=0x1234 |<SNAP  OUI=0x0 code=0x0 |>>  # noqa: E501
    N)r  rh   r   rt   ro   __fvalrn   s       rY   bind_bottom_upr     sQ      F-aaa0E	e}-----r[   c                     ||                     |           |j                                        |_        ||j        | <   dS )a  Bind 2 layers for building.
    When the upper layer is added as a payload of the lower layer, all the
    arguments will be applied to them.

    ex:
        >>> bind_top_down(Ether, SNAP, type=0x1234)
        >>> Ether()/SNAP()
        <Ether  type=0x1234 |<SNAP  |>>
    N)r  rs   r   r  s       rY   bind_top_downr"    sF     F"388::E$(E5!!!r[   c                 l    ||                     |           t          | |fi | t          | |fi | dS )aH  Bind 2 layers on some specific fields' values.

    It makes the packet being built and dissected when the arguments
    are present.

    This function calls both bind_bottom_up and bind_top_down, with
    all passed arguments.

    Please have a look at their docs:
     - help(bind_bottom_up)
     - help(bind_top_down)
     N)r  r"  r   r  s       rY   bind_layersr$    sR    & F%''$'''5%((4(((((r[   c                 v    |                     |           fdfd| j        D             | _        dS )zrThis call un-links an association that was made using bind_bottom_up.
    Have a look at help(bind_bottom_up)
    Nc                 p     t           fd                                D                       }|k    p|S )Nc              3   >   K   | ]\  }}|vp|         |k    V  d S rW   rb   )rd   r  r   paramss      rY   rf   z5split_bottom_up.<locals>.do_filter.<locals>.<genexpr>C  sI        
  
26!QAVO-vayA~ 
  
  
  
  
  
r[   )anyrl   )r(  rX   params_is_invalidrn   ro   s   `  rY   	do_filterz"split_bottom_up.<locals>.do_filterA  sT      
  
  
  
:>**,, 
  
  
 
 
 e|000r[   c                     g | ]	} | |
S rb   rb   )rd   r   r+  s     rY   rG  z#split_bottom_up.<locals>.<listcomp>G  s$    KKKYY]K1KKKr[   )r  rh   )rt   ro   r  rn   r+  s    ` `@rY   split_bottom_upr-  5  se     F1 1 1 1 1 1 LKKKe&9KKKEr[   c                    ||                     |           | |j        v rd|j        |          t          fd|                                D                       rdS |j                                        |_        |j        | = dS dS )zpThis call un-links an association that was made using bind_top_down.
    Have a look at help(bind_top_down)
    Nc              3   >   K   | ]\  }}|vp|         |k    V  d S rW   rb   )rd   r  r   ofvals      rY   rf   z!split_top_down.<locals>.<genexpr>W  s8      HH41aq~.qQHHHHHHr[   )r  rs   r)  rl   r   )rt   ro   r  rn   r0  s       @rY   split_top_downr1  J  s     F&&&&u-HHHH4::<<HHHHH 	F!&!7!<!<!>!>"5))) '&r[   c                 l    ||                     |           t          | |fi | t          | |fi | dS )zSplit 2 layers previously bound.
    This call un-links calls bind_top_down and bind_bottom_up. It is the opposite of  # noqa: E501
    bind_layers.

    Please have a look at their docs:
     - help(split_bottom_up)
     - help(split_top_down)
    N)r  r-  r1  r  s       rY   split_layersr3  ]  sR     FE5))D)))5%((4(((((r[   c                 	   | Ot           j        st          d          	 ddl}n# t          $ r t	          d          w xY wt          |d          st	          d          ddlm}m} ddl	m
} d	 }t          |d
          rd } |dt           j        z   |d          g d          } ||          }|dk    r+t           j                                        }d |D             }	nc|dk    r[ddlm}
 t          t           t"          t$          t$          f                   |
d                    }d |D             }	d |	D             }	ndS |dk    rt'          t(                    }|	D ]\  }}d|v rg|                    d          }|}|dd         D ]}||vri ||<   ||         }||d<   d|vrg |d<   |d                             |d         |f           p|d                             ||f           n
|dk    rd|	i}|}g }	 t)          |                                          }d |D             |                    dg           z   }d}|rAd                    t5          j        d |dd         D             |d         f                    }d ||rd|z   ndz   z  } ||dt           j        z   |d!|z             |rd"nd#$          } ||          }||r|                                }dS |                    d%          r&|                    |           ||dd                  }n|r|dz   |z   }n2|dk    rdd&lm}  ||           d'|z   }nt?          | t@          j!                  r| j"        } t?          | t$                    r|                     d(          r| }n|                     d'          r| #                    d'd          } dd&lm}  ||            d)| z  d*| z  }}|t           j        j$        v r|}n9|t           j        j$        v r|}n#t          d+| z            tK          d,           dS 	 t           j        j$        |         }n # tL          $ r t          d+| z            w xY wtO          t           j(        )                    d-|z                       g }d. |D             }tO          tU          |d/gd0                     dS )1aC  Function used to discover the Scapy layers and protocols.
    It helps to see which packets exists in contrib or layer files.

    params:
     - layer: If specified, the function will explore the layer. If not,
              the GUI mode will be activated, to browse the available layers

    examples:
      >>> explore()  # Launches the GUI
      >>> explore("dns")  # Explore scapy.layers.dns
      >>> explore("http2")  # Explore scapy.contrib.http2
      >>> explore(scapy.layers.bluetooth4LE)

    Note: to search a packet by name, use ls("name") rather than explore.
    NzZexplore() GUI-mode cannot be run in interactive mode. Please provide a 'layer' parameter !r   zgprompt_toolkit is not installed ! You may install IPython, which contains it, via `pip install ipython`)r   r   z%prompt_toolkit >= 2.0.0 is required !)radiolist_dialogbutton_dialog)HTMLc                 ,    t          t          |           S rW   )r7   r   rv  s    rY   r   zexplore.<locals>.<lambda>  s    T#q\\ r[   )r   r   c                 *    |                                  S rW   )runrv  s    rY   r   zexplore.<locals>.<lambda>  s     r[   z	Scapy v%szQ<style bg="white" fg="red">Chose the type of packets you want to explore:</style>))Layersr(  )Contribscontribs)Cancelcancel)titlerz  buttonsr(  c                 N    g | ]"}d |d         v sd|d         v s
d|d         v  |#S )r(  r   packetasn1rb   r  s     rY   rG  zexplore.<locals>.<listcomp>  sI     > > >AX1-=-=-51-=-=-3qt^^ -;^^r[   r=  )list_contribT)r6  c                 .    g | ]}|d          |d         fS )r>   descriptionrb   r  s     rY   rG  zexplore.<locals>.<listcomp>  s6     ( ( ( y!M"23 ( ( (r[   c                 &    g | ]}d |d         v|S )canr   rb   r  s     rY   rG  zexplore.<locals>.<listcomp>  s&    ===A5!+<+<a+<+<+<r[   r9  r  rx   _lc                     g | ]@}|                     d           d|z   t          d|                                z             fAS )r  $z[+] )
startswithr   
capitalize)rd   r>   s     rY   rG  zexplore.<locals>.<listcomp>  sY       4??3+?+?tS$//*;*;!;<<=  r[   r  c              3   &   K   | ]}|d          V  dS )rx   Nrb   r  s     rY   rf   zexplore.<locals>.<genexpr>  s&      ::7::::::r[   rU   z0
<style bg="white" fg="green">> scapy.%s</style>zn<style bg="white" fg="red">Please select a fileamong the following, to see all layers contained in it:</style>Backr>  )valuesr@  rz  cancel_textrL  )load_contribzscapy.contrib.zscapy.layers.zscapy.layers.%szscapy.contrib.%szUnknown scapy module '%s'z%Wrong usage ! Check out help(explore)zPackets contained in %s:c                 X    g | ]'}|j         pd t          t          |j                  pd f(S )r  )rj   r7   r   rx   )rd   lays     rY   rG  zexplore.<locals>.<listcomp>+	  s5    TTT#cl b$sCI"6"6"<"=TTTr[   )ClassName)borders)+r   interactiver&   prompt_toolkitr  r    prompt_toolkit.shortcuts.dialogsr5  r6  prompt_toolkit.formatted_textr7  r   r(  
scapy.mainrE  r7   r.   r,   r   r   r   r?  r   keysr   rk   r  r  r   rM  rS  r}   types
ModuleTyperj   rp  ldictr(   r   ri   r  r   r$   )r  rZ  r5  r6  r7  call_ptkbtn_diagactionlvaluesrQ  rE  cvaluestreer>   descpartssubtreepar  previousfolders_radio_valuescur_path
extra_textrd_diagresultrS  result_layerresult_contrib
all_layersrtlsts                                  rY   explorerw  r  s   $ } 	9! #8 9 9 9	8!!!!! 	8 	8 	8 7 8 8 8	8  77 	GEFFF	 	 	 	 	 	 	 	666666))NF33 	)((H =,0   
 
 
 (##Xk((**G> > > > >FF z!!//////4S#X/$1G1G1GHHG( (&( ( (F >====FF FZ
 t$$D$ 4 4
d$;; JJsOOE"G#CRCj . .W,,*,GBK")"++-((7**(*DM((%)T):;;;;J%%tTl33334 x&>D.	7<<>>**G #   D"%%&M H 88O::Xabb\::: )+   DX=3>>2>@J '&$!DL0T' #	#  '/<FFH  G Xg&&F~ &llnnGF  %% (((!&*-  5%^f4F].	` Z//////L   %.F eU-.. 	#NEeS!! 	00 O##$455 @!MM*:B??E333333U###1BU1J1Ce1K -4;#444)FF#t{'888+FF)*E*MNNN;<<<FC[&v.

 C C C9EABBBC 
$

%
%&@6&I
J
JKKKETTTTTE	+e/0$
?
?
?@@@@@s   % ?7Q Q,Fc           
         t          | t                    }t          | t                    s	|st          g }| j        D ]9}|}g }g }t          |t
          t          f          r_t          |t                    r'|                    |j        j	        dd                    |j
        }t          |t
          t          f          _|j        }|j        }	|rt          |t                    rvt          |d          rf|j        r_t!          |j        pg           dk     rC|                    d t%          |j                                                  D                        nt          |t(                    rt          | t                    r| }
n
 |             }
|                    |
          }|                    d|z             |r|j                            |                    |
          i           }t!          |          dk     r>|                    d t%          |                                          D                        n|rEt          |t0                    r0|j        }|                    d                    |                     nrt          |t6                    r]|j        j        }	|                    d                    d	 t;          j        |j        |j        fg          D                                  |j        }|rd
d                    |          z  nd}t          |t@                    r|d|j!        |j!        dk    rdndfz  z  }|                    |||tE          |	          |f           ;|S )zInternal function used to resolve `fields_desc` to display it.

    :param obj: a packet object or class
    :returns: a list containing tuples [(name, clsname, clsname_extras,
        default, long_attrs)]
    Nr   i2s2   c              3   *   K   | ]\  }}d ||fz  V  dS z%s: %dNrb   rd   numvalstrvals      rY   rf   z_pkt_ls.<locals>.<genexpr>J	  sD       " "& //" " " " " "r[   zDepends on %sc              3   *   K   | ]\  }}d ||fz  V  dS r|  rb   r}  s      rY   rf   z_pkt_ls.<locals>.<genexpr>[	  sD       & &*FF !FF#33& & & & & &r[   r_   c              3   :   K   | ]}|d          j         j        V  dS )r   N)ry   rj   r  s     rY   rf   z_pkt_ls.<locals>.<genexpr>e	  s<       # #,-!'# # # # # #r[   z(%s)r  z (%d bit%s)rU   r!  )#r}   r;   r#   r   r   r   r   r   ry   rj   r   r>   r   r   r  ry  r  extendr  rl   r   
depends_on	i2s_multir   r
   namesrk   r   dfltr  r  fldsr   r{  r   )objverboseis_pktr@   r   cur_fldr  
long_attrsr>   r   obj_pkt
fld_dependcur_i2sr  rX   class_name_extrass                   rY   _pkt_lsr  /	  s    V$$FS&!! & F_ <
 <

4)9":;; 	"'#344 =W.7;<<<kG 4)9":;; 	" |/ !	z'955 !	w&&!	+2;!	7;$"%%**!! " " 7;,,..//" " "   
 00 	#v&&  #%% ++G44JLL:5666 	!+//&&w//  w<<"$$%% & & w}}//& & &   
  	GZ88 	MEdii..////!233 	l*GLL # #.?@@# # #     
  FIIe
 
 	 gx(( 	|a''R2 "  	']]		
 	
 	
 	
 Mr[   c                       t           t                    rd} d}t          t          j        d           }nkt          j         |rdnt
          j                  |r fd}n                                   fd}t          fd	t          j        D             |          }|D ]!}t          |j
        d
d|j                   "|rt          j        rt          d           dS dS dS 	 t           |          }t           t                    }|D ]}\  }	}
}}}|
j
        dz   |z   }t          |	d
d|ddd           |r!t          t           |	          dd           t          d|d           |D ]}t          dd|           ~|rVt!          t                      t           j        t$                    rdS t          d           t'           j                   dS dS # t(          $ r t          d           Y dS w xY w)zList  available layers, or infos on a given layer class or name.

    :param obj: Packet / packet name to use
    :param case_sensitive: if obj is a string, is it case sensitive?
    :param verbose:
    NFTc                     | j         S rW   )rj   rv  s    rY   r   zls.<locals>.<lambda>	  s    1: r[   )keyr   c                 `    | j                                       t          | j                   fS rW   )rj   r  r  r   r  s    rY   r   zls.<locals>.<lambda>	  s$    AJ$4$4S$9$93qz??#K r[   c                     | j                                                                       t          | j                   fS rW   )rj   rt   r  r  r  s    rY   r   zls.<locals>.<lambda>	  s3    AJ$4$4$6$6$<$<S$A$A$'
OO$5 r[   c              3      K   | ]n}t          |j        t                    r                    |j                  s4t          |j        t                    P                    |j                  j|V  od S rW   )r}   rj   r   searchr>   )rd   r  patterns     rY   rf   zls.<locals>.<genexpr>	  s       !B !B5%/%D%D!B%,^^EN%C%C!B #-UZ"="=!B &-^^EJ%?%?	!B !B !B !B !B !B !Br[   10z : zL
TIP: You may use explore() to navigate through all layers using a clear GUI)r  r  35z =)end15r{  r|  r  z--z?Not a packet class or name. Type 'ls()' to list packet classes.)r}   r   r  r   r(  recompileIrt   ri   rj   rx   rY  r  r;   r  r7   rL   rz   lsr   )r  case_sensitiver  tipru  sorterr  r@   r  r   rX   clsner  r  clsinfor   r  s   `               @rY   r  r  }	  s    {jc**{;C1E1EFFFJJj#- G
  5KKKKiikk5 5 5 5 !B !B !B !BDK !B !B !B
 %+, , ,J   	@ 	@E%....%++>???? 	.4# 	. - . . . . .	. 	. 	. 	.	U  F  V,,F7= 2 23sE4,,u45555'''':DDDD EWS%%8%8%8%8DDDD&'''& 2 2Drrr44011112   63''ck955 Fd3;     	U 	U 	USTTTTTT	Us   0CG0 	#G0 0HHTc                     t           t                    st          d          dg }g }d }d}dt          t          t
          t          f                  f fd} |            D ]z\  }}	|	z  |dz  }	 t          ddz
            }
 ||	|
z
            }|                    |d	|         ||f           dk    r!|                    |           |
x}	d
}g }|
snnnj{|r|                    |           g }|                    d           t          t          |          dz
            D ]}d}||         ||dz            }}|d         d         |d         d         k    r|t          d |d	d         D                       t          |d	d                   z   dz
  }|d         d         }||k     r,||dz  z   }|d	d|z            d||z
  z  z   |d|z   d	         z   }|                    |           d
}|dd                    d t          d          D                       z   dz   z  }|dd                    d t          d          D                       z   dz   z  }t          ||          D ]4\  }}||z  }|D ]"\  }}	}|d|                    |	d          z   z  }#|dz  }5|dpdz  dz   z  }|r$|dd j        z                       dd          z   z  }|r|S t!          |           d	S )a  
    Generate an RFC-like representation of a packet def.

    :param cls: the Packet class
    :param ret: return the result instead of printing (def. False)
    :param legend: show text under the diagram (default True)

    Ex::

        >>> rfc(Ether)

    zPacket class expectedr   c                     d| z  dz
  S )Nr   rU   rb   rv  s    rY   r   zrfc.<locals>.<lambda>	  s    q1uqy r[   r   c               3   h  K   j         D ]} | j                                                            dd          }t	          | j        dz            }||fV  t          | t                    rEt          | j        t                    r | j        d         dz  z  }n | j        dz  z  }|rd|fV  d S )Nr  r     r   r  )
r   r>   ro   rp  r4  szr}   r   _alignr  )r   r   r  r  rX   cur_lens       rY   _iterfieldszrfc.<locals>._iterfields	  s       	) 	)AFLLNN**344EqMME,!X&& )ah.. 5#)qx{Q7CC#)qx!|4C )#S.(((	) 	)r[   rU   T    Nr  zB+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
r  r   c              3   &   K   | ]}|d          V  dS )rU   Nrb   r  s     rY   rf   zrfc.<locals>.<genexpr>
  s&      55QAaD555555r[   r  z                   c              3   4   K   | ]}t          |          V  d S rW   r   r  s     rY   rf   zrfc.<locals>.<genexpr>
  s9       $ $A$ $ $ $ $ $r[   r   ra  c              3   :   K   | ]}t          |d z            V  dS )ro  Nr  r  s     rY   rf   zrfc.<locals>.<genexpr>"
  s=        AF     r[   r  z|
z+-z+
zFig. B   )
issubclassr;   r   r-   r2   r   r4  rn  r   ranger  sumrk   zipcenterrj   ri   )rX   r6  legendcur_linelinesclsizeidentr  r   flenoverlen1sepsre   sepabovebelow	pos_above	pos_belowrr  liner  r  r  s   `                      @rY   rfcr  	  s    c6"" 1/000GHE ! FE)%S/2 ) ) ) ) ) ) ) #{}}  t4
	q'B,''D6$+&&DOOU5D5\47888"}}X&&&!%%$ 
 	"  XDKK!"""3u::>""   Qxq1uu9Q<58A;&&55%*55555E#2#JG!KIaI9$$ &	A5	Y'9y012I'(  	CF
cXOO $ $a$ $ $    F cCHH  "2YY      F %%  	c#  	2 	2LCqcCJJtS1111FF%
dgm$u,,F B$'CL088SAAAA
 	&MMM4r[   _P)boundc                    |s|                                  } t          t          |           }t          |t                    si }g }|j        D ]}t          |t                    r*t          ||j                  D ]}t          |d           At          |t                    r|                    |j                   q|j        Jt          |t                    r|                    |          r |                                }|
|||j        <   |rd |                                D             }|j                            |           |                                 |D ]X}t          t          |                    |                    }	|	                    |                                          }||||<   Y|j                            |           |j        }t          |t                    | S )z
    Transform a layer into a fuzzy layer by replacing some default values
    by random objects.

    :param p: the Packet instance to fuzz
    :return: the fuzzed packet.
    rU   )_inplaceNc                 l    i | ]1\  }}|t          |t                    r|                                n|2S rb   )r}   r   r  )rd   r  r   s      rY   rB  zfuzz.<locals>.<dictcomp>^
  sI     " " "C JsM$B$BKchhjjj" " "r[   )r   r7   r;   r}   rz   r   r   r  r>   fuzzr   r   r   r   r  randvalrl   r?   r  clearr   _find_fld_pktrL   )
rS  r  ri  new_default_fieldsmultiple_type_fieldsr   rj  rndr>   r   s
             rY   r  r  =
  s
     FFHHVQAI&& ! 	9 	9A!_-- 
9 AF++ ( (AQ'''''(A011 9$++AF3333&!!%566 9!++a.. 9))++C58*162 	3" " 2 8 8 : :" " " ##$6777$$&&&, 3 3,akk$.?.?@@''**2244?/2&t,	 2333I? I&& @ Hr[   rW   r  )NFF)FTr  )b__doc__collectionsr   r  r  r<   r  r   r_  r   scapy.fieldsr   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   scapy.configr   r   scapy.compatr   r   r   scapy.base_classesr   r   r   r   r   scapy.interfacesr   scapy.volatiler   r   scapy.utilsr    r!   r"   r#   r$   r%   scapy.errorr&   r'   r(   scapy.libs.test_pyxr)   typingr*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   ry  r  r   r9   r;   rz   r  r  r   r  
default_l2r   r"  commandsregisterr$  r-  r1  r3  rw  r  r  r  r  r  rb   r[   rY   <module>r     s    $ # # # # #  				                                         " 0 / / / / / / / / / / / / / / / / /              / / / / / / 3 3 3 3 3 3 3 3                = = = = = = = = = = # # # # # #                                      	JJJJ 	 	 	D	 WT4S>8DcN#;<<m m m m mm m m m`5q" q" q" q" q" q" q" q"r& & & & && & & &:) ) ) ) )c ) ) )  ?DO . . . .0 ) ) ) )*  ) ) ) )4  L L L L. * * * *&  ) ) ) )( yA yA yA yAz K K K K\ ?U ?U ?U ?UD r r r rr WT    . . . . . .s   <C C	C	