Why Gemfury? Push, build, and install  RubyGems npm packages Python packages Maven artifacts PHP packages Go Modules Debian packages RPM packages NuGet packages

dfinimundi / wlanpi-profiler deb

Repository URL to install this package:

Version: 
1.0.10  ▾
Details    
wlanpi-profiler / opt / wlanpi-profiler / lib / python3.7 / site-packages / scapy / __pycache__ / utils.cpython-37.pyc
Size: Mime: 
B

Ôà›534^ã@sèdZddlmZddlmZddlmZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddl
Z
ddlZddlZddlZddlZddlZddlZddlZddlmmZddlmZmZmZddlmZddlmZm Z m!Z!dd	l"m#Z#m$Z$dd
l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0m1Z1ddl2m3Z3dd
l%m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBe>r¾ddlCmDZDddlEmFZFmGZGddlHmIZIeIZJneKZJeAe9eLe	jMfZNdd„ZOeAeePfZQGdd„deƒZReBdd„ƒZSeBdÀdd„ƒZSdÁdd„ZSdÂdd„ZTdÃdd„ZUejVjWdd „ƒZXd!d"„ZYejVjWdÄd#d$„ƒZZejVjWdÅd%d&„ƒZ[ejVjWdÆd'd(„ƒZ\ejVjWdÇd)d*„ƒZ]d+d,„Z^ejVjWdÈd-d.„ƒZ_e `d/d0¡d1krÆd2d3„Zand4d3„Zad5d6„Zbd7d8„ZcejVjWd9d:„ƒZdejVjWd;d<„ƒZed=d>„Zfd?d@„ZgdAdB„ZhdCdD„ZidEdF„ZjdGdH„ZkdIdJ„Zlye
 mdK¡Wn e
jnk
rddLdM„ZmYnXe
jmZme
joZodNdO„ZpdPdQ„ZqdRdS„ZrdTdU„ZsdVdW„ZtdXdY„ZudZd[„ZvGd\d]„d]eKƒZwGd^d_„d_eKƒZxdÉd`da„Zydbdcdddedfdgdhdidjdkdldmdndoœ
Zzdpdq„Z{drds„Z|dÊdudv„Z}dwdx„Z~dydz„ZGd{d|„d|ƒZ€Gd}d~„d~eƒZ‚dd€„ZƒdËdd‚„Z„dƒd„„Z…d…d†„Z†ejVjWdÌdˆd‰„ƒZ‡ejVjWdÍdŠd‹„ƒZˆejVjWdŒd„ƒZ‰ejVjWdÎdd„ƒZŠGd‘d’„d’eƒZ‹e Œe‹¡Gd“d”„d”ƒƒZGd•d–„d–eeJƒZŽGd—d˜„d˜eƒZGd™dš„dšeeJƒZGd›dœ„dœƒZ‘Gddž„dže‘ƒZ’ejVjWdÏdŸd „ƒZ“ejVjWdÐd¡d¢„ƒZ”ejVjWdÑd£d¤„ƒZ•d¥d¦„Z–d§d¨„Z—ejVjWdÒdªd«„ƒZ˜ejVjWd¬d­„ƒZ™d®d¯„ZšdÓd°d±„Z›dÔd²d³„Zœd´dµ„Zd¶d·„Zžd¸d¹„ZŸdºd»„Z Gd¼d½„d½ej¡ƒZ¢Gd¾d¿„d¿eKƒZ£dS)Õz
General utility functions.
é)Úabsolute_import)Úprint_function)ÚDecimalN)ÚrangeÚinputÚzip_longest)Úconf)ÚDARWINÚOPENBSDÚWINDOWS)ÚMTUÚ
DLT_EN10MB)ÚorbÚ	plain_strÚchbÚbytes_base64Úbase64_bytesÚ	hex_bytesÚlambda_tuple_converterÚbytes_encode)Úlog_runtimeÚScapy_ExceptionÚwarning)Ú	inet_pton)ÚcastÚAnyÚAnyStrÚCallableÚDictÚIOÚIteratorÚListÚLiteralÚOptionalÚ
TYPE_CHECKINGÚTupleÚTypeÚUnionÚoverload)ÚPacket)Ú_PacketIterableÚ
PacketList)ÚSuperSocketcCs:t|tƒr|dd„|jDƒkSt|tƒr6t||ƒr6dSdS)zòissubtype(C, B) -> bool

    Return whether C is a class and if it is a subclass of class B.
    When using a tuple as the second argument issubtype(X, (A, B, ...)),
    is a shortcut for issubtype(X, A) or issubtype(X, B) or ... (etc.).
    css|]}|jVqdS)N)Ú__name__)Ú.0Úz©r0úŠ/build/wlanpi-profiler-7At3M6/wlanpi-profiler-1.0.10/debian/wlanpi-profiler/opt/wlanpi-profiler/lib/python3.7/site-packages/scapy/utils.pyú	<genexpr>Xszissubtype.<locals>.<genexpr>TF)Ú
isinstanceÚstrÚ	__bases__ÚtypeÚ
issubclass)ÚxÚtr0r0r1Ú	issubtypeMs


r:cs¬eZdZdZd$dd„Zdd„Zdd„Zd	d
„Zdd„Zd
d„Z	dd„Z
dd„Zej
dkrbdd„Zndd„Zdd„Zdd„Zdd„Zd%dd„Z‡fd d!„Z‡fd"d#„Z‡ZS)&ÚEDecimalznExtended Decimal

    This implements arithmetic and comparison with float for
    backward compatibility
    NcCstt |t|ƒ¡ƒS)N)r;rÚ__add__)ÚselfÚotherÚcontextr0r0r1r<hszEDecimal.__add__cCstt |t|ƒ¡ƒS)N)r;rr<)r=r>r0r0r1Ú__radd__lszEDecimal.__radd__cCstt |t|ƒ¡ƒS)N)r;rÚ__sub__)r=r>r0r0r1rApszEDecimal.__sub__cCstt |t|ƒ¡ƒS)N)r;rÚ__rsub__)r=r>r0r0r1rBtszEDecimal.__rsub__cCstt |t|ƒ¡ƒS)N)r;rÚ__mul__)r=r>r0r0r1rCxszEDecimal.__mul__cCstt |t|ƒ¡ƒS)N)r;rrC)r=r>r0r0r1Ú__rmul__|szEDecimal.__rmul__cCstt |t|ƒ¡ƒS)N)r;rÚ__truediv__)r=r>r0r0r1rE€szEDecimal.__truediv__cCstt |t|ƒ¡ƒS)N)r;rÚ__floordiv__)r=r>r0r0r1rF„szEDecimal.__floordiv__)écCs(t |t|ƒ¡}t|dƒt|dƒfS)Nré)rÚ
__divmod__r;)r=r>Úrr0r0r1rI‰szEDecimal.__divmod__cCstt |t|ƒ¡ƒS)N)r;rÚ__div__)r=r>r0r0r1rKŽszEDecimal.__div__cCstt |t|ƒ¡ƒS)N)r;rÚ__rdiv__)r=r>r0r0r1rL’szEDecimal.__rdiv__cCstt |t|ƒ¡ƒS)N)r;rÚ__mod__)r=r>r0r0r1rM–szEDecimal.__mod__cCstt |t|ƒ¡ƒS)N)r;rÚ__rmod__)r=r>r0r0r1rNšszEDecimal.__rmod__cCstt |t|ƒ|¡ƒS)N)r;rÚ__pow__)r=r>Zmodulor0r0r1rOžszEDecimal.__pow__cstt|ƒ |¡pt|ƒ|kS)N)Úsuperr;Ú__eq__Úfloat)r=r>)Ú	__class__r0r1rQ¢szEDecimal.__eq__c	s.t ¡}||_ttt|ƒ |¡ƒSQRXdS)N)ÚdecimalÚlocalcontextÚprecr;rPÚ	normalize)r=Z	precisionÚctx)rSr0r1rW¦s
zEDecimal.normalize)N)N)r-Ú
__module__Ú__qualname__Ú__doc__r<r@rArBrCrDrErFÚsysÚversion_inforIrKrLrMrNrOrQrWÚ
__classcell__r0r0)rSr1r;as$



r;cCsdS)Nr0)ÚkeepÚautoextÚfdr0r0r1Ú
get_temp_file­srbFÚcCsdS)Nr0)r_r`rar0r0r1rb³scCs<tjd|dd}|s"tj |j¡|r*|S| ¡|jSdS)a=Creates a temporary file.

    :param keep: If False, automatically delete the file when Scapy exits.
    :param autoext: Suffix to add to the generated file name.
    :param fd: If True, this returns a file-like object with the temporary
               file opened. If False (default), this returns a file path.
    ÚscapyF)ÚprefixÚsuffixÚdeleteN)ÚtempfileÚNamedTemporaryFilerÚ
temp_filesÚappendÚnameÚclose)r_r`raÚfr0r0r1rb¹s	cCs tjdd}|stj |¡|S)zÚCreates a temporary file, and returns its name.

    :param keep: If False (default), the directory will be recursively
                 deleted when Scapy exits.
    :return: A full path to a temporary directory.
    rd)re)rhÚmkdtemprrjrk)r_Zdnamer0r0r1Úget_temp_dirÏs	rpcCsZd}xP|D]H}t|ƒ}|dks&|dkrF|r<|tj d¡7}qR|d7}q
|t|ƒ7}q
W|S)Nrcé éÚ.)rrÚcolor_themeZ
not_printableÚchr)r8ÚcolorrJÚiÚjr0r0r1Úsaneàs

ryc	Cs„tjrtj tjd¡s tdƒ‚trhz6yt	 
tjgtj¡}Wntk
rVd}YnXWdt 
|¡Xt tjtjgtj¡dS)zRestarts scapyrz"Scapy was not started from consolerHN)rÚinteractiveÚosÚpathÚisfiler\ÚargvÚOSErrorrÚ
subprocessÚcallÚ
executableÚKeyboardInterruptÚ_exitÚexecv)Zres_coder0r0r1Úrestartïsr†cCs|ddlm}t||ƒrt|ƒSt|ƒtjkr4t|ƒSt|tƒrRdd 	t
t|ƒ¡St|tƒrpdd 	t
t|ƒ¡St
|ƒSdS)Nr)Ú
VolatileValuez(%s)z, z[%s])Zscapy.volatiler‡r3Úreprr6ÚsixÚ
integer_typesÚhexÚtupleÚjoinÚmapÚlhexÚlistr4)r8r‡r0r0r1rÿs


rcCsÌd}t|ƒ}t|ƒ}d}x€||kr˜|d|7}x>tdƒD]2}|||krb|dt|||ƒ7}q8|d7}q8W|dt|||d…dd	7}|d7}qW| d
¡r°|dd…n|}|r¼|St|ƒdSdS)
z¼Build a tcpdump like hexadecimal view

    :param p: a Packet
    :param dump: define if the result must be printed or returned in a variable
    :return: a String only when dump=True
    rcrz%04x  éz%02X z   z %s
T)rvÚ
Néÿÿÿÿ)rÚlenrrryÚendswithÚprint)ÚpÚdumpÚsr8Zx_lenrwrxr0r0r1Úhexdumps"	
 ršcCs.d}t||||d}|r|St|ƒdSdS)aeBuild an equivalent view of hexdump() on a single line

    Note that setting both onlyasc and onlyhex to 1 results in a empty output

    :param p: a Packet
    :param onlyasc: 1 to display only the ascii view
    :param onlyhex: 1 to display only the hexadecimal view
    :param dump: print the view if False
    :return: a String only when dump=True
    rc)ÚonlyascÚonlyhexrvN)Úhexstrr–)r—r›rœr˜r™r0r0r1Úlinehexdump-s
ržcCs4t|ƒ}d dd„|Dƒ¡}|r$|St|ƒdSdS)aOBuild a per byte hexadecimal representation

    Example:
        >>> chexdump(IP())
        0x45, 0x00, 0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x40, 0x00, 0x7c, 0xe7, 0x7f, 0x00, 0x00, 0x01, 0x7f, 0x00, 0x00, 0x01  # noqa: E501

    :param p: a Packet
    :param dump: print the view if False
    :return: a String only if dump=True
    z, css|]}dt|ƒVqdS)z%#04xN)r)r.r8r0r0r1r2Qszchexdump.<locals>.<genexpr>N)rrr–)r—r˜r8r™r0r0r1ÚchexdumpCs
rŸcCsJt|ƒ}g}|s*| d dd„|Dƒ¡¡|s@| t||d¡d |¡S)z*Build a fancy tcpdump like hex from bytes.ú css|]}dt|ƒVqdS)z%02XN)r)r.Úbr0r0r1r2`szhexstr.<locals>.<genexpr>)rvz  )rrkrry)r—r›rœrvr8r™r0r0r1rYsrcCsd dd„|Dƒ¡S)z= Convert provided bitstring to a simple string of hex digits rccss|]}dt|ƒVqdS)z%02xN)r)r.r8r0r0r1r2iszrepr_hex.<locals>.<genexpr>)r)r™r0r0r1Úrepr_hexfsr¢c!sðt|ƒ‰t|ƒ‰tjˆˆ|d}‡fdd„ttˆƒƒDƒ}‡fdd„ttˆƒƒDƒ}g}g}xž| ¡D]’}|\}	}
}}}
|	dkr¤|||
|…7}|dg||
7}qf|	dkrÐ|dg|
|7}||||
…7}qf|	dkrf|||
|…7}||||
…7}qfW|rBt|ƒ}t|ƒ}|dgt||ƒ|7}|dgt||ƒ|7}d	}}}d
d„tjj	tjj
dœ}d
}d	}t|ƒ}xr||krê|||d…}|||d…}tdd„|Dƒƒ}tdd„|Dƒƒ}|rÜ|sÜd	}d
}|rð||krðd
}|rJ|}d	}x ||s|d
7}|d
8}qWt|||d|ƒdd||7}|}ntddd|r°|}d	}x ||s„|d
7}|d
8}qfWt|||d|ƒdd||7}|}ntdddtdddd}xØtdƒD]Ì}|||kr~||rh|||||k||} t| dt
||ƒƒdd||||krR|t||dd7}n|| t||ƒƒ7}ntddd|d7}ntddd|dkrÖtdddqÖWtd|ƒ|s¼|sÎd	}d
}|d7}n|rÞd	}d
}n|d7}qzWdS)a×
    Show differences between 2 binary strings, Packets...

    For the autojunk parameter, see
    https://docs.python.org/3.8/library/difflib.html#difflib.SequenceMatcher

    :param a:
    :param b: The binary strings, packets... to compare
    :param autojunk: Setting it to True will likely increase the comparison
        speed a lot on big byte strings, but will reduce accuracy (will tend
        to miss insertion and see replacements instead for instance).
    )Úar¡Úautojunkcsg|]}ˆ||d…‘qS)rHr0)r.rw)Úxbr0r1ú
<listcomp>‚szhexdiff.<locals>.<listcomp>csg|]}ˆ||d…‘qS)rHr0)r.rw)Úybr0r1r¦ƒsrgóÚinsert)ÚequalÚreplacercSs|S)Nr0)r8r0r0r1Ú<lambda>r¨zhexdiff.<locals>.<lambda>)rr“rHrHr‘css|]}t|ƒVqdS)N)r”)r.Úkr0r0r1r2§szhexdiff.<locals>.<genexpr>css|]}t|ƒVqdS)N)r”)r.r­r0r0r1r2¨sz%04xr )Úendz    rcz%02XT)rvz  éN)rÚdifflibZSequenceMatcherrr”Zget_opcodesÚmaxrrtÚleftÚrightÚsumr–rry)!r£r¡r¤ÚsmZxarrZyarrZ
backtrackxZ
backtrackyÚopcodeÚtypZx0Úx1Zy0Úy1ZlbxZlbyr8ÚyrwZcolorizeZdoxZdoyZbtx_lenZlinexZlineyÚxxÚyyZxdrxÚlineZydZclÚcolr0)r¥r§r1Úhexdiffls¨




r¿ÚHrHscCs|S)Nr0)Úchkr0r0r1r¬ér¨r¬cCs|d?d@|d>BS)Nééÿr0)rÁr0r0r1r¬ër¨cCsVt|ƒddkr|d7}tt d|¡ƒ}|d?|d@}||d?7}|}t|ƒd@S)NérHórÀr‘iÿÿ)r”r´ÚarrayÚchecksum_endian_transform)Úpktr™r0r0r1ÚchecksumîsrÉcCsBd}}x |D]}|t|ƒ7}||7}qW|d;}|d;}||fS)NrrÃ)r)ZcharbufÚc0Úc1Úcharr0r0r1Ú_fletcher16ùs
rÍcCst|ƒ\}}|d>|BS)aCalculates Fletcher-16 checksum of the given buffer.

       Note:
       If the buffer contains the two checkbytes derived from the Fletcher-16 checksum  # noqa: E501
       the result of this function has to be 0. Otherwise the buffer has been corrupted.  # noqa: E501
    rÂ)rÍ)ÚbinbufrÊrËr0r0r1Úfletcher16_checksums	rÏcCs t|ƒ|krtdt|ƒƒ‚|d|…d||dd…}t|ƒ\}}t|ƒ|d||d}|dkrt|d7}d||}|dkr|d8}t|ƒt|ƒS)	a¯Calculates the Fletcher-16 checkbytes returned as 2 byte binary-string.

       Including the bytes into the buffer (at the position marked by offset) the  # noqa: E501
       global Fletcher-16 checksum of the buffer will be 0. Thus it is easy to verify  # noqa: E501
       the integrity of the buffer on the receiver side.

       For details on the algorithm, see RFC 2328 chapter 12.1.7 and RFC 905 Annex B.  # noqa: E501
    z"Packet too short for checkbytes %dNsrÄrHrÃriþ)r”Ú	ExceptionrÍr)rÎÚoffsetrÊrËr8rºr0r0r1Úfletcher16_checkbytess
 rÒcCsd dd„t|ƒ d¡Dƒ¡S)Nr¨css|]}tt|dƒƒVqdS)r‘N)rÚint)r.r8r0r0r1r24szmac2str.<locals>.<genexpr>ú:)rrÚsplit)Úmacr0r0r1Úmac2str2sr×cCs*ytt|ƒƒdkStk
r$YnXdS)NéF)r”r×Ú
ValueError)rÖr0r0r1Ú	valid_mac7s
rÚcCs8t|tƒr$ddd…ttt|ƒƒSddd…t|ƒS)Nz%02x:%02x:%02x:%02x:%02x:%02x:r“)r3r4rŒrŽÚord)r™r0r0r1Ústr2mac@s
rÜcCsd dd„t|ƒDƒ¡S)z9
    Returns a random string of length (length >= 0)
    r¨css"|]}t dt dd¡¡VqdS)ÚBrrÃN)ÚstructÚpackÚrandomÚrandint)r.Ú_r0r0r1r2Lszrandstring.<locals>.<genexpr>)rr)Úlengthr0r0r1Ú
randstringGs
räcCsd dd„t|ƒDƒ¡S)zM
    Returns a random string of length (length >= 0) without zero in it.
    r¨css"|]}t dt dd¡¡VqdS)rÝrHrÃN)rÞrßràrá)r.râr0r0r1r2Usz&zerofree_randstring.<locals>.<genexpr>)rr)rãr0r0r1Úzerofree_randstringPs
råcCsd tdd„||ƒ¡S)zk
    Returns the binary XOR of the 2 provided strings s1 and s2. s1 and s2
    must be of same length.
    r¨cSstt|ƒt|ƒAƒS)N)rr)r8rºr0r0r1r¬_r¨zstrxor.<locals>.<lambda>)rrŽ)Ús1Ús2r0r0r1ÚstrxorYsrècCsd tdd„||ƒ¡S)zk
    Returns the binary AND of the 2 provided strings s1 and s2. s1 and s2
    must be of same length.
    r¨cSstt|ƒt|ƒ@ƒS)N)rr)r8rºr0r0r1r¬hr¨zstrand.<locals>.<lambda>)rrŽ)rærçr0r0r1Ústrandbsréz255.255.255.255cCs|dkrdSt |¡SdS)Nz255.255.255.255sÿÿÿÿ)ÚsocketÚ	inet_aton)Z	ip_stringr0r0r1rëosrëcCsHyt|ƒ}Wn$tjk
r0tt |¡ƒ}YnXttt d|¡dƒS)Nz!Ir)rërêÚerrorÚ
gethostbynamerrÓrÞÚunpack)r8Úipr0r0r1Úatol{s
rðc
CsPyt|ƒ}Wntk
r dSXyt|ƒWntttjfk
rJdSXdS)NFT)rÚUnicodeDecodeErrorrðrrÙrêrì)Úaddrr0r0r1Úvalid_ip„srócCsnyt|ƒ}Wntk
r dSXd|krf| dd¡\}}t|ƒod| ¡oddt|ƒko`dkSSt|ƒS)NFú/rHrrq)rrñrÕróÚisdigitrÓ)ròrïÚmaskr0r0r1Ú	valid_net‘s,r÷cCs†yt|ƒ}Wntk
r dSXyttj|ƒWnNtjk
r€y t |dtj¡dddWntjk
rzdSXYnXdS)NFréT)rrñrrêÚAF_INET6rìÚgetaddrinfo)ròr0r0r1Ú	valid_ip6s rûcCsnyt|ƒ}Wntk
r dSXd|krf| dd¡\}}t|ƒod| ¡oddt|ƒko`dkSSt|ƒS)NFrôrHré€)rrñrÕrûrõrÓ)ròrïrör0r0r1Ú
valid_net6­s,rýcCstt d|d@¡ƒS)Nz!Ilÿÿ)Ú	inet_ntoarÞrß)r8r0r0r1Últoa¹srÿcCsd|?d@S)Nlüÿlÿÿr0)r8r0r0r1Úitom¾src@s*eZdZdZd
dd„Zdd„Zdd„Zd	S)ÚContextManagerSubprocessa
    Context manager that eases checking for unknown command, without
    crashing.

    Example:
    >>> with ContextManagerSubprocess("tcpdump"):
    >>>     subprocess.Popen(["tcpdump", "--version"])
    ERROR: Could not execute tcpdump, is it installed?

    TcCs||_||_dS)N)ÚprogÚsuppress)r=rrr0r0r1Ú__init__Ïsz!ContextManagerSubprocess.__init__cCsdS)Nr0)r=r0r0r1Ú	__enter__Ôsz"ContextManagerSubprocess.__enter__cCs\|dks|dkrdSt|tƒr*d|j}nd|j|jjf}|jsJ||ƒ‚tj|dddS)Nz&Could not execute %s, is it installed?z%s: execution failed (%s)T)Úexc_info)r3ÚEnvironmentErrorrrSr-rrrì)r=Úexc_typeÚ	exc_valueÚ	tracebackÚmsgr0r0r1Ú__exit__Øs
z!ContextManagerSubprocess.__exit__N)T)r-rYrZr[rrrr0r0r0r1rÃs

rc@s2eZdZdZdd„Zdd„Zdd„Zdd	d
„ZdS)
ÚContextManagerCaptureOutputzÇ
    Context manager that intercept the console's output.

    Example:
    >>> with ContextManagerCaptureOutput() as cmco:
    ...     print("hey")
    ...     assert cmco.get_output() == "hey"
    cCs4d|_yddl}Wntk
r.tdƒ‚YnXdS)Nrcrz'The mock module needs to be installed !)Úresult_export_objectÚmockrÐÚImportError)r=rr0r0r1røs
z$ContextManagerCaptureOutput.__init__cCs4ddl}|fdd„}| ¡}||_tj|_|t_|S)NrcSs|j|7_dS)N)r)r™Ú	decoratorr0r0r1Úwritesz4ContextManagerCaptureOutput.__enter__.<locals>.write)rZMockrr\ÚstdoutÚ
bck_stdout)r=rrZmock_stdoutr0r0r1rsz%ContextManagerCaptureOutput.__enter__cGs|jt_dS)NF)rr\r)r=Úexcr0r0r1r
sz$ContextManagerCaptureOutput.__exit__FcCs$|j d¡r|rtt|jƒƒS|jS)Nzb')rÚ
startswithrÚeval)r=Z
eval_bytesr0r0r1Ú
get_outputsz&ContextManagerCaptureOutput.get_outputN)F)r-rYrZr[rrrrr0r0r0r1r
îs

r
c	Cs8|dkrd}|r|S|dk	r,t dt¡|}|dkr<tjj}d}|dkrtr`td|d}d}n0ttjj	ƒt
jtjj	gt
jdj
}WdQRX|dk	r d	|}t|tƒr| d
¡rØt
j|dd… ¡dt
jdj
}n4| d
¡rút|dd… ¡dƒ}nttj |¡dƒ}ttt|ƒ}t
jd||p*d|p2dfdt
j|t
jd}| t|ƒ¡\}	}
|jdkrvtdt|
ƒƒ‚y| ¡Wntk
r˜YnX|r4t   ¡}xŠtj !|j"¡sæt  #d¡t   ¡|dkrªt$dt%ƒPqªWtjj	tjj&krt '|j"¡n,ttjj	ƒt
 tjj	|j"g¡WdQRXdS)a	Processes graph description using an external software.
    This method is used to convert a graphviz format to an image.

    :param graph: GraphViz graph description
    :param prog: which graphviz program to use
    :param format: output type (svg, ps, gif, jpg, etc.), passed to dot's "-T"
        option
    :param string: if not None, simply return the graph string
    :param target: filename or redirect. Defaults pipe to Imagemagick's
        display program
    :param options: options to be passed to prog
    NÚsvgz*type is deprecated, and was renamed formatFrs)r`T)Ústdinz-T%sú|rH)Úshellrú>Úwbz
"%s" %s %src)rrrÚstderrrz)GraphViz call failed (is it installed?):
gš™™™™™¹?rGzHTemporary file '%s' could not be written. Graphic will not be displayed.)(ÚwarningsÚwarnÚDeprecationWarningrrÚdotrrbrZdisplayr€ÚPopenÚPIPErr3r4rÚlstripÚopenr{r|ÚabspathrrÚbytesÚcommunicaterÚ
returncoderrrmrÐÚtimeÚexistsrlÚsleeprrhÚ_defaultZ	startfile)ÚgraphrÚformatÚtargetr6ÚstringÚoptionsZstart_viewerÚprocrârZ
waiting_startr0r0r1Údo_graphsl




r6z
{\tt\char123}z
{\tt\char125}z{\tt\char92}z\^{}z\$z\#z\_z\&z\%z
{\tt\char124}z
{\tt\char126}z{\tt\char60}z{\tt\char62})
Ú{Ú}ú\ú^ú$ú#râú&ú%rú~ú<rcCs&d}x|D]}|t ||¡7}q
W|S)Nrc)Ú_TEX_TRÚget)r8r™Úcr0r0r1Ú
tex_escapes
rDc
osÆt|ƒdkr|d9}| ddd„¡}xœx–tt|ƒƒD]†}x€tt|ƒƒD]p}xjtt|ƒƒD]Z}||kst||kst||krX||||t|ƒ|||t|ƒ|||t|ƒƒVqXWqFWq4Wq&WdS)zReturns a generator that mixes provided quantities forever
    trans: a function to convert the three arguments into a color. lambda x,y,z:(x,y,z) by defaultrÄÚtranscSs
|||fS)Nr0)r8rºr/r0r0r1r¬‘r¨zcolgen.<locals>.<lambda>N)r”rBr)ZlstcolÚkargsrErwrxr­r0r0r1Úcolgen‰srGútag%05iccsx||V|d7}qWdS)NrHr0)ÚlabelÚstartr0r0r1Úincremental_labelšs
rKcCst|ƒdd…S)NrÄ)Úbin)Úvalr0r0r1Úbinrepr¡srNcCst| dd¡ dd¡dƒS)Nr’rcr r‘)rÓr«)r™r0r0r1Úlong_converter¦srOc@sTeZdZdd„Zdd„Zdd„Zdd„Zd	d
„Zdd„Zd
d„Z	dd„Z
dd„ZdS)ÚEnumElementcCs||_||_dS)N)Ú_keyÚ_value)r=ÚkeyÚvaluer0r0r1r°szEnumElement.__init__cCs d|j d|jj¡|j|jfS)Nz<%s %s[%r]>Ú_name)Ú__dict__rBrSr-rQrR)r=r0r0r1Ú__repr__µszEnumElement.__repr__cCst|j|ƒS)N)ÚgetattrrR)r=Úattrr0r0r1Ú__getattr__¹szEnumElement.__getattr__cCs|jS)N)rQ)r=r0r0r1Ú__str__½szEnumElement.__str__cCst| ¡ƒS)N)rr[)r=r0r0r1Ú	__bytes__ÁszEnumElement.__bytes__cCs|jS)N)rR)r=r0r0r1Ú__hash__ÅszEnumElement.__hash__cCs
t|jƒS)N)rÓrR)r=r0r0r1Ú__int__ÉszEnumElement.__int__cCs|jt|ƒkS)N)rRrÓ)r=r>r0r0r1rQÍszEnumElement.__eq__cCs| |¡S)N)rQ)r=r>r0r0r1Ú__neq__ÑszEnumElement.__neq__N)r-rYrZrrWrZr[r\r]r^rQr_r0r0r0r1rP¯srPcsBeZdZeZ‡fdd„Zdd„Zdd„Zddd	„Zd
d„Z	‡Z
S)
ÚEnum_metaclasscs`i}x<t |¡D].\}}t|tƒr| ||¡}|||<|||<qW||d<tt|ƒ ||||¡S)NÚ	__rdict__)r‰Ú	iteritemsr3rÓÚ
element_classrPr`Ú__new__)ÚclsrlÚbasesÚdctZrdictr­Úv)rSr0r1rdÙs
zEnum_metaclass.__new__cCs
|j|S)N)ra)r=rYr0r0r1Ú__getitem__äszEnum_metaclass.__getitem__cCs
||jkS)N)ra)r=rMr0r0r1Ú__contains__èszEnum_metaclass.__contains__NcCs|j ||¡S)N)rarB)r=rYrMr0r0r1rBìszEnum_metaclass.getcCsd|j d|j¡S)Nz<%s>rl)rVrBr-)r=r0r0r1rWðszEnum_metaclass.__repr__)N)r-rYrZrPrcrdrirjrBrWr^r0r0)rSr1r`Ös
r`cCs,ddl}tt| tjj |d¡d¡ƒƒdS)NrrÄé	)Úzlibr–rÚcompressr‰ÚmovesÚcPickleÚdumps)Úobjrlr0r0r1Ú
export_objectúsrrcCs6ddl}|dkrtj ¡}tjj | t	| 
¡ƒ¡¡S)Nr)rlr\rÚreadr‰rnroÚloadsÚ
decompressrÚstrip)rqrlr0r0r1Ú
import_objects
rwcCs(t |d¡}tjj ||¡| ¡dS)zPickle a Python objectrN)Úgzipr'r‰rnror˜rm)Úfnamerqrar0r0r1Úsave_objectsrzcCstjj t |d¡¡S)zunpickle a Python objectÚrb)r‰rnroÚloadrxr')ryr0r0r1Úload_objectsr}ç{®Gáz„?cCs~t dt|ƒ¡}t|ƒ}|dkr2tdt||ƒƒ}x4t t|ƒ|¡D] }||t dd¡d||<qDWt	j
rv| ¡S| ¡S)z]
    Corrupt a given percentage (at least one byte) or number of bytes
    from a string
    rÝNrHrÃé)
rÆrr”r±rÓràÚsamplerrár‰ÚPY2ÚtostringÚtobytes)Údatar—Únr™Ús_lenrwr0r0r1Ú
corrupt_bytess r‡cCs‚t dt|ƒ¡}t|ƒd}|dkr6tdt||ƒƒ}x4t t|ƒ|¡D] }||dd|d>N<qHWtj	rz| 
¡S| ¡S)zX
    Flip a given percentage (at least one bit) or number of bits
    from a string
    rÝrÂNrH)rÆrr”r±rÓràr€rr‰rr‚rƒ)r„r—r…r™r†rwr0r0r1Úcorrupt_bits's rˆc	Os*t|f|ž|Ž}| |¡WdQRXdS)a8Write a list of packets to a pcap file

    :param filename: the name of the file to write packets to, or an open,
        writable file-like object. The file descriptor will be
        closed at the end of the call, so do not use an object you
        do not want to close (e.g., running wrpcap(sys.stdout, [])
        in interactive mode will crash Scapy).
    :param gz: set to 1 to save a gzipped capture
    :param linktype: force linktype value
    :param endianness: "<" or ">", force endianness
    :param sync: do not bufferize writes to the capture file
    N)Ú
PcapWriterr)ÚfilenamerÈÚargsrFÚfdescr0r0r1Úwrpcap;srr“c	Cs t|ƒ}|j|dSQRXdS)zeRead a pcap or pcapng file and return a packet list

    :param count: read only <count> packets
    )ÚcountN)Ú
PcapReaderÚread_all)rŠrŽrŒr0r0r1ÚrdpcapRs
r‘cs4eZdZdZ‡fdd„Zdd„Zedd„ƒZ‡ZS)ÚPcapReader_metaclassz"Metaclass for (Raw)Pcap(Ng)Readerscs,tt|ƒ ||||¡}d|kr(||d_|S)zxThe `alternative` class attribute is declared in the PcapNg
        variant, and set here to the Pcap variant.

        Úalternative)rPr’rdr“)rerlrfrgZnewcls)rSr0r1rdls


zPcapReader_metaclass.__new__c	CsÀ| ||j|j|j¡}| |¡\}}}|s2tdƒ‚y| |||¡|Sttfk
r\YnXd|jkr´|jd}| ||j|j|j¡}y| |||¡|Sttfk
r²YnXtdƒ‚dS)zNCreates a cls instance, use the `alternative` if that
        fails.

        zNo data could be read!r“zNot a supported capture fileN)rdr-r5rVr'rrÚEOFError)rerŠrwrŒÚmagicr0r0r1Ú__call__ys&

zPcapReader_metaclass.__call__cCsxt|tƒrT|}yt |d¡}| d¡}Wqntk
rPt|dƒ}| d¡}YqnXn|}t|ddƒ}| d¡}|||fS)z1Open (if necessary) filename, and read the magic.r{rørlzNo name)r3r4rxr'rsÚIOErrorrX)ryrŠrŒr•r0r0r1r'–s


zPcapReader_metaclass.open)	r-rYrZr[rdr–Ústaticmethodr'r^r0r0)rSr1r’is
r’c@s¬eZdZdZdZe dddddg¡Zd$d	d
„Zdd„Z	d
d„Z
e
Zefdd„Z
efdd„Zdd„Zd%dd„Zd&dd„Zefdd„Zdd„Zdd„Zd d!„Zed'd"d#„ƒZdS)(Ú
RawPcapReaderz;A stateful pcap reader. Each packet is returned as a stringTÚPacketMetadataÚsecÚusecÚwirelenÚcaplenNcCs¾||_||_|dkr"d|_d|_nN|dkr8d|_d|_n8|dkrNd|_d|_n"|dkrdd|_d|_ntd	|ƒ‚|j d
¡}t|ƒd
krtdƒ‚t |jd|¡\}}}}}	}
|
|_	|	|_
dS)
Ns¡²ÃÔrFsÔò¡r@s¡²<MTsM<²¡z'Not a pcap capture file (bad magic: %r)ézInvalid pcap file (too short)ZHHIIII)rŠrnÚendianÚnanorrsr”rÞrîÚlinktypeÚsnaplen)r=rŠrŒr•ÚhdrZvermajZverminÚtzÚsigr£r¢r0r0r1r²s.
zRawPcapReader.__init__cCs|S)Nr0)r=r0r0r1Ú__iter__ÏszRawPcapReader.__iter__cCs&y| ¡Stk
r t‚YnXdS)zT
        implement the iterator protocol on a set of packets in a pcap file
        N)Úread_packetr”Ú
StopIteration)r=r0r0r1ÚnextÓszRawPcapReader.nextcCs\|j d¡}t|ƒdkrt‚t |jd|¡\}}}}|j |¡d|…tj||||dfS)z¤return a single packet read from the file as a tuple containing
        (pkt_data, pkt_metadata)

        raise EOFError when no more packets are available
        r‘ÚIIIIN)r›rœrrž)	rnrsr”r”rÞrîr r™rš)r=Úsizer¤r›rœržrr0r0r1Ú_read_packetÞszRawPcapReader._read_packetcCstt| ¡dƒS)Nr)rr)r­)r=r¬r0r0r1r¨íszRawPcapReader.read_packetcCsx|D]}||ƒqWdS)zÑcall the specified callback routine for each packet read

        This is just a convenience function for the main loop
        that allows for easy launching of packet processing in a
        thread.
        Nr0)r=Úcallbackr—r0r0r1Údispatchôs

zRawPcapReader.dispatchr“cCs.| |¡}ddlm}|j|tj |j¡dS)Nr)Úplist)rl)Ú	_read_allrdr°r+r{r|ÚbasenamerŠ)r=rŽÚresr°r0r0r1rs
zRawPcapReader.read_allcCsLg}xB|dkrF|d8}y| ¡}Wntk
r8PYnX| |¡qW|S)z6return a list of all packets in the pcap file
        rrH)r¨r”rk)r=rŽr³r—r0r0r1r±s
zRawPcapReader._read_allcCs|j|ddS)z Emulate a socket
        )r¬r)r­)r=r¬r0r0r1ÚrecvszRawPcapReader.recvcCs
|j ¡S)N)rnÚfileno)r=r0r0r1rµszRawPcapReader.filenocCs
|j ¡S)N)rnrm)r=r0r0r1rmszRawPcapReader.closecCs| ¡dS)N)rm)r=rr	Útracbackr0r0r1r#szRawPcapReader.__exit__cCs|S)Nr0)ÚsocketsZremainr0r0r1Úselect(szRawPcapReader.select)NN)r“)r“)N)r-rYrZr[Znonblocking_socketÚcollectionsÚ
namedtupleršrr§rªÚ__next__rr­r¨r¯rr±r´rµrmrr˜r¸r0r0r0r1r™ªs&
	

r™cs>eZdZd
dd„Zdd„Zef‡fdd„	Zefdd	„Z‡ZS)rNcCslt ||||¡ytjj|j|_WnBtk
rftd|j|jfƒtj	dkrZddl
}tj	|_YnXdS)Nz9PcapReader: unknown LL type [%i]/[%#x]. Using Raw packetsr)r™rrÚl2typesÚ	num2layerr¢ÚLLclsÚKeyErrorrÚ	raw_layerÚscapy.packet)r=rŠrŒr•rdr0r0r1r1s
zPcapReader.__init__cCs|S)Nr0)r=r0r0r1r?szPcapReader.__enter__c	sÖtt|ƒj|d}|dkrt‚|\}}y| |¡}Wndtk
rJ‚YnPtk
r˜tjrxddl	m
}|j|f|_‚tjdkrŠddl
}t |¡}YnXtdƒt|jr¬dndƒ}t|j||jƒ|_|j|_|S)N)r¬r)Údebugé
i÷ÿÿÿiúÿÿÿ)rPrr­r”r¾rƒrÐrÚdebug_dissectorZscapy.sendrecvrÂZ
crashed_onrÀrÁrr¡r;r›rœr,r)	r=r¬Úrpr™Zpkt_infor—rÂrdÚpower)rSr0r1r¨Cs(
zPcapReader.read_packetcCs|j|dS)N)r¬)r¨)r=r¬r0r0r1r´\szPcapReader.recv)NN)	r-rYrZrrrr¨r´r^r0r0)rSr1r0s
rc@sŒeZdZdZeZe ddddddg¡Zdd	d
„Z	e
fdd„Zd
d„Zdd„Z
e
fdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„ZdS) ÚRawPcapNgReaderzEA stateful pcapng reader. Each packet is returned as
    bytes.

    ršr¢ÚtsresolÚtshighÚtslowrNcCs|||_||_g|_ddi|_|j|j|j|jdœ|_d|_	|dkrNt
d|ƒ‚y| ¡Wntk
rvt
dƒ‚YnXdS)NrÈi@B)rHrÄrGrØú!s


z)Not a pcapng capture file (bad magic: %r)z/The first SHB of the pcapng file is malformed !)
rŠrnÚ
interfacesÚdefault_optionsÚ_read_block_idbÚ_read_block_pktÚ_read_block_spbÚ_read_block_epbÚ
blocktypesr rÚ_read_block_shbr”)r=rŠrŒr•r0r0r1rms"

zRawPcapNgReader.__init__cCsÖy"t |jd|j d¡¡d}Wntjk
r<t‚YnX|dkrR| ¡dSy"t |jd|j d¡¡d}Wntjk
rŽt‚YnX|dkr¤tdƒt‚|j |d¡}| 	|¡|j
 |dd„¡||ƒS)	NÚIrøri


ézInvalid block length !cSsdS)Nr0)Úblockr¬r0r0r1r¬Ÿr¨z-RawPcapNgReader._read_block.<locals>.<lambda>)rÞrîr rnrsrìr”rÓrÚ_read_block_tailrÒrB)r=r¬Z	blocktypeÚblocklenrÖr0r0r1Ú_read_blockŠs("
"

zRawPcapNgReader._read_blockcCsx|dr*|j |d¡}td||fƒy.|t |jd|j d¡¡dkrVtdƒ‚Wntjk
rrt‚YnXdS)NrøzDPcapNg: bad blocklen %d (MUST be a multiple of 4. Ignored padding %rrÔrz+PcapNg: Invalid pcapng block (bad blocklen))rnrsrrÞrîr r”rì)r=rØÚpadr0r0r1r×¢sz RawPcapNgReader._read_block_tailcCs–|j d¡}|j d¡}|dkr(d|_n|dkr8d|_ntdƒt‚t |jd|¡d}|d	krntd
ƒt‚|j |d	¡}| |¡| |¡dS)Nrøs+<MrsM<+r@z6Bad magic in Section Header block (not a pcapng file?)rÔrr‘zInvalid SHB block length!)	rnrsr rr”rÞrîr×Ú
_read_options)r=Z	_blocklenr rØr4r0r0r1rÓ¯s
zRawPcapNgReader._read_block_shbcCsx| ¡}|dk	r|SqWdS)z¦Read blocks until it reaches either EOF or a packet, and
        returns None or (packet, (linktype, sec, usec, wirelen)),
        where packet is a string.

        N)rÙ)r=r¬r³r0r0r1r­ÃszRawPcapNgReader._read_packetcCsÈ|j ¡}x¸t|ƒdkrÂt |jd|dd…¡\}}|dkrz|dkrzt|ƒdkrzt|dƒ}|d@rjdnd	|d
@|d<|dkr˜|dkr–td
|ƒP|dr°|d|d7}|d|d…}qW|S)zSection Header BlockrøZHHNrkrHérürÄrÃrrrÈrz2PcapNg: invalid option length %d for end-of-option)rÍÚcopyr”rÞrîr rr)r=r4ÚoptsÚcoderãrÈr0r0r1rÛÏs
zRawPcapNgReader._read_optionscCsv| |dd…¡}y(t |jd|dd…¡|df}Wn*tjk
rdtdt|ƒƒt‚YnX|j 	|¡dS)zInterface Description BlockrÂéüÿÿÿZHxxINrÈzPcapNg: IDB is too small %d/8 !)
rÛrÞrîr rìrr”r”rÌrk)r=rÖrâr4Z	interfacer0r0r1rÎæs
zRawPcapNgReader._read_block_idbcCs*t|jƒ}||kr&td||fƒt‚dS)z;Check the interface id value and raise EOFError if invalid.z"PcapNg: invalid interface id %d/%dN)r”rÌrr”)r=ÚintidÚtmp_lenr0r0r1Ú_check_interface_idös
z#RawPcapNgReader._check_interface_idcCsžy(t |jd|dd…¡\}}}}}Wn*tjk
rRtdt|ƒƒt‚YnX| |¡|dd|…d|…tj	|j
|d|j
|d|||dfS)zEnhanced Packet BlockZ5INrŸz PcapNg: EPB is too small %d/20 !rrÄ)r¢rÈrÉrÊr)rÞrîr rìrr”r”rãrÇršrÌ)r=rÖr¬rárÉrÊržrr0r0r1rÑþs

zRawPcapNgReader._read_block_epbcCs®d}| |¡y t |jd|dd…¡\}Wn*tjk
rXtdt|ƒƒt‚YnXt||j	|dƒ}|dd|…d|…t
j|j	|d|j	|ddd|dfS)	zSimple Packet BlockrrÔNrøzPcapNg: SPB is too small %d/4 !rHrÄ)r¢rÈrÉrÊr)rãrÞrîr rìrr”r”ÚminrÌrÇrš)r=rÖr¬rárržr0r0r1rÐs
 
zRawPcapNgReader._read_block_spbc	Cs y*t |jd|dd…¡\}}}}}}Wn*tjk
rTtdt|ƒƒt‚YnX| |¡|dd|…d|…tj	|j
|d|j
|d|||dfS)z(Obsolete) Packet BlockZHH4INrŸz PcapNg: PKT is too small %d/20 !rrÄ)r¢rÈrÉrÊr)rÞrîr rìrr”r”rãrÇršrÌ)	r=rÖr¬ráZdropsrÉrÊržrr0r0r1rÏ)s

zRawPcapNgReader._read_block_pkt)NN)r-rYrZr[r™r“r¹rºršrrrÙr×rÓr­rÛrÎrãrÑrÐrÏr0r0r0r1rÇas 

rÇcsBeZdZeZd
dd„Zdd„Zef‡fdd„	Zefdd	„Z	‡Z
S)ÚPcapNgReaderNcCst ||||¡dS)N)rÇr)r=rŠrŒr•r0r0r1rBszPcapNgReader.__init__cCs|S)Nr0)r=r0r0r1rFszPcapNgReader.__enter__cs¾tt|ƒj|d}|dkrt‚|\}\}}}}}ytjj|}	|	|ƒ}
WnLtk
r^‚Yn8tk
r”tj	rt‚tj
dkr†ddl}t 
|¡}
YnX|dk	r´t|d>|ƒ||
_
||
_|
S)N)r¬rrq)rPrår­r”rr¼r½rƒrÐrÄrÀrÁr;r,r)r=r¬rÅr™r¢rÈrÉrÊrrer—rd)rSr0r1r¨Js&
zPcapNgReader.read_packetcCs| ¡S)N)r¨)r=r¬r0r0r1r´aszPcapNgReader.recv)NN)r-rYrZrr“rrrr¨r´r^r0r0)rSr1rå>s

råc@s|eZdZdZddddddefdd„Zdd„Zd	d
„Zdd„Zd
d„Z	ddd„Z
ddd„Zdd„Zdd„Z
dd„Zdd„ZdS)Ú
RawPcapWriterz4A stream PCAP writer with more control than wrpcap()NFrcc	
Cs ||_||_d|_||_||_||_||_||_d}	|r<d}	t|t	ƒrˆ||_
|rpttt
 ||rbdpddd¡ƒ|_qœt||r|dp~d|	ƒ|_n||_t|ddƒ|_
dS)	a
        :param filename: the name of the file to write packets to, or an open,
            writable file-like object.
        :param linktype: force linktype to a given value. If None, linktype is
            taken from the first writer packet
        :param gz: compress the capture on the fly
        :param endianness: force an endianness (little:"<", big:">").
            Default is native
        :param append: append packets to the capture file instead of
            truncating it
        :param sync: do not bufferize writes to the capture file
        :param nano: use nanosecond-precision (requires libpcap >= 1.5.0)

        riÚabrrkrlzNo nameN)r¢r£Úheader_presentrkÚgzr Úsyncr¡r3r4rŠrÚ_ByteStreamrxr'rnrX)
r=rŠr¢réZ
endiannessrkrêr¡r£Zbufszr0r0r1ris&
zRawPcapWriter.__init__cCs
|j ¡S)N)rnrµ)r=r0r0r1rµ›szRawPcapWriter.filenocCs| t|ƒ¡S)N)Ú
_write_headerr)r=rÈr0r0r1Úwrite_headerŸszRawPcapWriter.write_headercCsŽd|_|jrL|jr"t |jd¡}nt|jdƒ}z| d¡r>dSWd| ¡X|j 	t
 |jd|j
rhdndddd	d	|j|j¡¡|j ¡dS)
NrHr{r‘ZIHHIIIIlM<dClÔCeCrÄrør)rèrkrérxr'rŠrsrmrnrrÞrßr r¡r£r¢Úflush)r=rÈÚgr0r0r1rì£s

zRawPcapWriter._write_headercCsŽt|tƒr&|js| |¡| |¡ndddlm}xV||ƒjD]H}|jsR| |¡t|tƒs||jt	j
 t|ƒd¡kr|t
dƒ| |¡q>WdS)a 
        Writes a Packet, a SndRcvList object, or bytes to a pcap file.

        :param pkt: Packet(s) to write (one record for each Packet), or raw
                    bytes to write (as one record).
        :type pkt: iterable[scapy.packet.Packet], scapy.packet.Packet or bytes
        r)Ú
IterSocketNzWInconsistent linktypes detected! The resulting PCAP file might contain invalid packets.)r3r)rèríÚwrite_packetÚscapy.supersocketrðÚiterr¢rr¼rBr6r)r=rÈrðr—r0r0r1rºs	



zRawPcapWriter.writecCs|jt|ƒ||||ddS)N)r›rœržr)Ú
_write_packetr))r=Úpacketr›rœržrr0r0r1rñ×szRawPcapWriter.write_packetc	Cs´|dkrt|ƒ}|dkr|}|dks,|dkrtt ¡}t|ƒ}|dkrh|}tt|||jr\dndƒƒ}n|dkrtd}|j t |j	d||||¡¡|j |¡|j
r°|j ¡dS)a°
        Writes a single packet to the pcap file.

        :param packet: bytes for a single packet
        :type packet: bytes
        :param sec: time the packet was captured, in seconds since epoch. If
                    not supplied, defaults to now.
        :type sec: int or long
        :param usec: If ``nano=True``, then number of nanoseconds after the
                     second that the packet was captured. If ``nano=False``,
                     then the number of microseconds after the second the
                     packet was captured
        :type usec: int or long
        :param caplen: The length of the packet in the capture file. If not
                       specified, uses ``len(packet)``.
        :type caplen: int
        :param wirelen: The length of the packet on the wire. If not
                        specified, uses ``caplen``.
        :type wirelen: int
        :return: None
        :rtype: None
        Niʚ;i@Brr«)r”r,rÓÚroundr¡rnrrÞrßr rêrî)r=rõr›rœržrr9Úitr0r0r1rôås$
zRawPcapWriter._write_packetcCs
|j ¡S)N)rnrî)r=r0r0r1rîszRawPcapWriter.flushcCs|js| d¡|j ¡S)N)rèrírnrm)r=r0r0r1rms
zRawPcapWriter.closecCs|S)Nr0)r=r0r0r1r!szRawPcapWriter.__enter__cCs| ¡| ¡dS)N)rîrm)r=rr	r¶r0r0r1r%szRawPcapWriter.__exit__)NNNN)NNNN)r-rYrZr[rrrµrírìrrñrôrîrmrrr0r0r0r1ræfs0*

-ræc@s"eZdZdZdd„Zddd„ZdS)r‰z4A stream PCAP writer with more control than wrpcap()cCsl|jdkr^y*|dkst|tƒr"t‚tjj|j|_Wn(tk
r\td|jj	ƒt
|_YnX| |¡dS)Nz;PcapWriter: unknown LL type for %s. Using type 1 (Ethernet))r¢r3r)r¿rr¼Z	layer2numrSrr-r
rì)r=rÈr0r0r1rí.s
zPcapWriter.write_headerNcCs t|dƒr<|dkr<t|jƒ}tt|j||jr2dndƒƒ}|dkrHd}t|ƒ}|dkr`t|ƒn|}|dkr|t|dƒr||j}|dkrˆ|}|j|||||ddS)a]
        Writes a single packet to the pcap file.

        :param packet: Packet, or bytes for a single packet
        :type packet: scapy.packet.Packet or bytes
        :param sec: time the packet was captured, in seconds since epoch. If
                    not supplied, defaults to now.
        :type sec: int or long
        :param usec: If ``nano=True``, then number of nanoseconds after the
                     second that the packet was captured. If ``nano=False``,
                     then the number of microseconds after the second the
                     packet was captured. If ``sec`` is not specified,
                     this value is ignored.
        :type usec: int or long
        :param caplen: The length of the packet in the capture file. If not
                       specified, uses ``len(raw(packet))``.
        :type caplen: int
        :param wirelen: The length of the packet on the wire. If not
                        specified, tries ``packet.wirelen``, otherwise uses
                        ``caplen``.
        :type wirelen: int
        :return: None
        :rtype: None
        r,Niʚ;i@Brr)r›rœržr)	ÚhasattrrÓr,rör¡rr”rrô)r=rõr›rœržrZrawpktr0r0r1rñ=s$ 


zPcapWriter.write_packet)NNNN)r-rYrZr[rírñr0r0r0r1r‰+sr‰cCs¢t d¡}d}yj|r"t |¡j}nt}xN|ƒ ¡}|s8Py|| |¡ ¡d7}Wq(t	k
rpt
dƒw(Yq(Xq(WWntk
rŒYnX| dd¡}t
|ƒS)zêImports a tcpdump like hexadecimal view

    e.g: exported via hexdump() or tcpdump or wireshark's "export as hex"

    :param input_string: String containing the hexdump input to parse. If None,
        read from standard input.
    z@^((0x)?[0-9a-fA-F]{2,}[ :\t]{,3}|) *(([0-9a-fA-F]{2} {,2}){,16})rcrÄzParsing error during hexcapr )ÚreÚcompiler‰ÚStringIOÚreadlinerrvÚmatchÚgroupsrÐrr”r«r)Zinput_stringZre_extract_hexcapr—Zinput_functionr½r0r0r1Ú
import_hexcapus&


rÿcKst|ftjj|dœ|—ŽS)z³
    Runs Wireshark on a list of packets.

    See :func:`tcpdump` for more parameter description.

    Note: this defaults to wait=False, to run Wireshark in the background.
    )rÚwait)ÚtcpdumprrÚ	wireshark)ÚpktlistrÚkwargsr0r0r1r–s
rcKs(|dkrdg}t|ftjj|dœ|—ŽS)z—
    Run tshark on a list of packets.

    :param args: If not specified, defaults to ``tshark -V``.

    See :func:`tcpdump` for more parameters.
    Nz-V)rr‹)rrrZtshark)rr‹rr0r0r1Útdecode£srcCsddlm}tt||ƒƒ ¡S)z"Guess the DLT name from its value.r)Úpcap_datalink_val_to_name)Úscapy.libs.winpcapyrrr)Údecode)rTrr0r0r1Ú_guess_linktype_name¶sr	cCs8ddlm}tt|| ¡ƒƒ}|dkr4td|ƒtS|S)zGuess the value of a DLT name.r)Úpcap_datalink_name_to_valr“z"Unknown linktype: %s. Using EN10MB)rr
rrÓÚencoderr
)rlr
rMr0r0r1Ú_guess_linktype_value½s
rTc
s¤|p|}|dkr,tjjs tdƒ‚tjjg}nt|tjƒr@|g}ntdƒ‚|
dk	rÞt|
tƒr‚yt	|
ƒ}
WqÂt
k
r~d}
YqÂXn@|
 d¡r˜|
dd…}
|
}
yt|
ƒ}
Wnt
k
rÀd}
YnX|
dkrÒtdƒ‚|d|
g7}|dkrìg}nt|ƒ}|dk	rP|
dkr.tˆtƒr.tˆƒ}|j}
WdQRXd	d
lm}|||
d| |¡|s\|rbtjnd}|rvttjƒnd}d‰|dkržtoœ|d	tjjk}|	dkrò|d	tjjkrÄdd
g}	n,|d	tjjkrètsèddd
g}	ndd
g}	nt|	ƒ}	ˆdkr8t|d	|dtj||||d‰WdQRXntˆtjƒr‚t|d	|d"tj|dˆg|||d‰WdQRXnÂ|r<tt t!t"dfˆƒ‰t#ddd}y| $t%‡fdd„dƒ¡Wn.t&k
rôtdˆƒ‰t'|ˆ|
dYn
X| (¡t|d	|d$tj|d|j)g|||d‰WdQRXnyBˆ *¡t|d	|d tj||	|ˆ||d‰WdQRXWnÄt&tfk
rBt|d	|d"tj||	|tj||d‰WdQRXˆdkrÚdSyˆj+ $t%‡fdd„dƒ¡Wn:t&k
rt'ˆj+ˆ|
dYn t,k
r2YnXˆj+ (¡YnXˆdkrRdS|r|d -t%‡fdd„dƒ¡}ˆ .¡|S|r†ˆS|r’ˆj/S|r ˆ 0¡dS)aRun tcpdump or tshark on a list of packets.

    When using ``tcpdump`` on OSX (``prog == conf.prog.tcpdump``), this uses a
    temporary file to store the packets. This works around a bug in Apple's
    version of ``tcpdump``: http://apple.stackexchange.com/questions/152682/

    Otherwise, the packets are passed in stdin.

    This function can be explicitly enabled or disabled with the
    ``use_tempfile`` parameter.

    When using ``wireshark``, it will be called with ``-ki -`` to start
    immediately capturing packets from stdin.

    Otherwise, the command will be run with ``-r -`` (which is correct for
    ``tcpdump`` and ``tshark``).

    This can be overridden with ``read_stdin_opts``. This has no effect when
    ``use_tempfile=True``, or otherwise reading packets from a regular file.

    :param pktlist: a Packet instance, a PacketList instance or a list of
        Packet instances. Can also be a filename (as a string), an open
        file-like object that must be a file format readable by
        tshark (Pcap, PcapNg, etc.) or None (to sniff)
    :param flt: a filter to use with tcpdump
    :param dump:    when set to True, returns a string instead of displaying it.
    :param getfd:   when set to True, returns a file-like object to read data
        from tcpdump or tshark from.
    :param getproc: when set to True, the subprocess.Popen object is returned
    :param args:    arguments (as a list) to pass to tshark (example for tshark:
        args=["-T", "json"]).
    :param prog:    program to use (defaults to tcpdump, will work with tshark)
    :param quiet:   when set to True, the process stderr is discarded
    :param use_tempfile: When set to True, always use a temporary file to store
        packets.
        When set to False, pipe packets through stdin.
        When set to None (default), only use a temporary file with
        ``tcpdump`` on OSX.
    :param read_stdin_opts: When set, a list of arguments needed to capture
        from stdin. Otherwise, attempts to guess.
    :param linktype: A custom DLT value or name, to overwrite the default
        values.
    :param wait: If True (default), waits for the process to terminate before
        returning to Scapy. If False, the process will be detached to the
        background. If dump, getproc or getfd is True, these have the same
        effect as ``wait=False``.

    Examples::

        >>> tcpdump([IP()/TCP(), IP()/UDP()])
        reading from file -, link-type RAW (Raw IP)
        16:46:00.474515 IP 127.0.0.1.20 > 127.0.0.1.80: Flags [S], seq 0, win 8192, length 0  # noqa: E501
        16:46:00.475019 IP 127.0.0.1.53 > 127.0.0.1.53: [|domain]

        >>> tcpdump([IP()/TCP(), IP()/UDP()], prog=conf.prog.tshark)
          1   0.000000    127.0.0.1 -> 127.0.0.1    TCP 40 20->80 [SYN] Seq=0 Win=8192 Len=0  # noqa: E501
          2   0.000459    127.0.0.1 -> 127.0.0.1    UDP 28 53->53 Len=0

    To get a JSON representation of a tshark-parsed PacketList(), one can::

        >>> import json, pprint
        >>> json_data = json.load(tcpdump(IP(src="217.25.178.5",
        ...                                  dst="45.33.32.156"),
        ...                               prog=conf.prog.tshark,
        ...                               args=["-T", "json"],
        ...                               getfd=True))
        >>> pprint.pprint(json_data)
        [{u'_index': u'packets-2016-12-23',
          u'_score': None,
          u'_source': {u'layers': {u'frame': {u'frame.cap_len': u'20',
                                              u'frame.encap_type': u'7',
        [...]
                                              },
                                   u'ip': {u'ip.addr': u'45.33.32.156',
                                           u'ip.checksum': u'0x0000a20d',
        [...]
                                           u'ip.ttl': u'64',
                                           u'ip.version': u'4'},
                                   u'raw': u'Raw packet data'}},
          u'_type': u'pcap_file'}]
        >>> json_data[0]['_source']['layers']['ip']['ip.ttl']
        u'64'
    Nztcpdump is not availablezprog must be a stringr“ZDLT_røz7Unknown linktype. Try passing its datalink name insteadz-yr)Úcompile_filter)r¢z-kiú-z-Uz-r)r)rrr*z.pcapT)r`racs
ˆ d¡S)Ni)rsr0)rr0r1r¬r¨ztcpdump.<locals>.<lambda>r¨)rrrcs
ˆ d¡S)Ni)rsr0)rr0r1r¬³r¨csˆj d¡S)Ni)rrsr0)r5r0r1r¬Ár¨)1rrrrr3r‰Ústring_typesrÙrÓr	r©rrr¿rr4rr¢Zscapy.arch.commonr
rkr€r%r'r{Údevnullr	rr
rr$rr'rr)rbÚ
writelinesróÚAttributeErrorrrmrlrµrÚUnboundLocalErrorrÚ	terminaterr)rr˜Zgetfdr‹ZfltrZgetprocÚquietZuse_tempfileZread_stdin_optsr¢rZ	_suppressZ
linktype_nameÚrdr
rrZtmpfiler„r0)rr5r1rÈsæd















rc	CsPtƒ}t||ƒttjjƒt tjj|g¡WdQRXt|ƒ}t	 
|¡|S)zARun hexedit on a list of packets, then return the edited packets.N)rbrrrrÚhexeditr€rr‘r{Úunlink)rrnZrpktlistr0r0r1rÍs

rcCs6d}tjs.ddl}|jddd}|dkr.|Str ddlm}m}|j 	d¡}|dƒ}|j 
||¡}|rœt d|j
¡\}}}	}
}}}
}}}}||d	}|S|Syttjd
ƒ}Wntk
rÆYnX|rÐ|SyFddl}ddl}t ddddd¡}| d	|j|¡}t d|¡d	}Wntk
r,YnX|SdS)z§Get terminal width (number of characters) if in a window.

    Notice: this will try several methods in order to
    support as many terminals and OS as possible.
    Nr)rr)Úfallback)ÚwindllÚcreate_string_bufferiôÿÿÿéZhhhhHhhhhhhrHÚCOLUMNSZHHHH)r‰rÚshutilÚget_terminal_sizerÚctypesrrÚkernel32ZGetStdHandleÚGetConsoleScreenBufferInforÞrîÚrawrÓr{ÚenvironrÐÚfcntlÚtermiosrßZioctlÚ
TIOCGWINSZr—)ZsizexrrrÚhÚcsbir³ZbufxZbufyZcurxZcuryZwattrr²Útopr³ZbottomZmaxxZmaxyr%r&r™r8r0r0r1Úget_terminal_widthÚs>	$r+csX|r
d}nd}t|dƒ}t|ƒ|dttƒ}d}|j‡fdd„dxÐt|ƒD]Ä\‰}g}	g}
x6t|ƒD]*\}}t|tƒrn|	 |¡|
 |p”d	¡qnW|
rT|ˆ=d}
xlt|
d
d	iŽD]Z}|
rÎd	g|}nt|ƒ}x t|	ƒD]\}}||||<qàW| 	ˆ|
t
|ƒ¡|
d7}
qºWqTWttt
tdf|ƒ}||}dd
„t|ŽDƒ}tƒ}tjrü|rü||}x’t|ƒ|krúd}| t|ƒ¡‰‡fdd
„|Dƒ}| t|ƒ¡}t||ƒ}|ˆdd…d|ˆ<t
|ƒ||<t|ˆƒ||<t|ƒ|ˆ<qjW|rt d¡| dd
„|Dƒ¡‰|r@| 	dt
dd„|Dƒƒ¡d ‡fdd„|Dƒ¡S)aP
    Pretty list to fit the terminal, and add header.

    :param rtlst: a list of tuples. each tuple contains a value which can
        be either a string or a list of string.
    :param sortBy: the column id (starting with 0) which whill be used for
        ordering
    :param borders: whether to put borders on the table or not
    rz  rrHFcs|ˆS)Nr0)r8)ÚsortByr0r1r¬$	r¨zpretty_list.<locals>.<lambda>)rSr Ú	fillvalue.cSsg|]}tdd„|Dƒƒ‘qS)css|]}t|ƒVqdS)N)r”)r.rºr0r0r1r2=	sz)pretty_list.<locals>.<listcomp>.<genexpr>)r±)r.r8r0r0r1r¦=	szpretty_list.<locals>.<listcomp>Tcsg|]}t|ˆƒ‘qSr0)r”)r.r8)rwr0r1r¦H	sNéþÿÿÿrâz?Table cropped to fit the terminal (conf.auto_crop_tables==True)cSsg|]}d|‘qS)z%%-%dsr0)r.r8r0r0r1r¦U	scss|]}d|VqdS)rNr0)r.r8r0r0r1r2X	szpretty_list.<locals>.<genexpr>r’c3s|]}ˆ|VqdS)Nr0)r.r8)Úfmtr0r1r2Z	s)r”rÓrÚsortÚ	enumerater3rrkrr©rŒrr!r%r4Úzipr+rZauto_crop_tablesr´Úindexr±rÚinfor)ZrtlstÚheaderr,ZbordersZ_spaceÚcolsZ	_spacelenZ_cropedr½ÚidsÚvaluesrxrMr­Zex_valsZ
extra_liner(ZrtslstÚcolwidthÚwidthÚrowr9r0)r/rwr,r1Úpretty_list	s^


r<c	sši‰i}	i}
i}t|ƒ}d}xf|D]^}
dd„||
ŽDƒ\}}}tt|ƒ|ƒ}tˆ |d¡t|ƒt|ƒƒˆ|<d|	|<||
||f<q"Wtˆƒ}t|	ƒ}|r¦|j|dnTy|jtdWnBtk
røy|jtdWntk
rò| ¡YnXYnX|r|j|dnXy|jtdWnFtk
rdy|jtdWntk
r^| ¡YnXYnXd}|r”||‡fdd„|Dƒƒ}||d7}||ƒ}||d7}|d	7}x6|D].}|ˆ|ƒ||<||||7}|d	7}q¶W||d7}|r||d7}xb|D]Z}|||7}|d	7}x2|D]*}||||
 ||fd
¡7}|d	7}q*W||d7}qW|r|||d7}|r†|St	|dddSdS)z@Core function of the make_table suite, which generates the tablercSsg|]}t|ƒ‘qSr0)r4)r.r™r0r0r1r¦t	sz __make_table.<locals>.<listcomp>N)rSrccsg|]}ˆ|‘qSr0r0)r.r8)Úvxr0r1r¦“	sr’r r)r®)
rr±r”rBrr0rÓrÐrðr–)ZyfmtfuncZfmtfuncÚendliner„ZfxyzZsortxZsortyÚseplinefuncr˜ZvyZvzZvxfrâÚer»r¼ÚzzZvxkZvykr™Zsepliner/r8rºr0)r=r1Ú__make_table]	sv

 


rBcOstdd„dd„df|ž|ŽS)NcSsd|S)Nz%%-%isr0)Úlr0r0r1r¬´	r¨zmake_table.<locals>.<lambda>cSsd|S)Nz%%-%isr0)rCr0r0r1r¬µ	r¨rc)rB)r‹rFr0r0r1Ú
make_table±	srDcOs(tdd„dd„df|žddd„i|—ŽS)NcSsd|S)Nz%%-%is |r0)rCr0r0r1r¬¿	r¨z"make_lined_table.<locals>.<lambda>cSsd|S)Nz%%-%is |r0)rCr0r0r1r¬À	r¨rcr?cSs$d dd„|dg|dgDƒ¡S)Nú+css|]}d|dVqdS)rrÄNr0)r.rºr0r0r1r2Ä	sz5make_lined_table.<locals>.<lambda>.<locals>.<genexpr>rHr.)r)r£r8r0r0r1r¬Ã	s)rB)r‹rFr0r0r1Úmake_lined_table¼	srFcOs(tdd„dd„df|žddd„i|—ŽS)NcSsdS)Nz%sr0)rCr0r0r1r¬Í	r¨z make_tex_table.<locals>.<lambda>cSsdS)Nz& %sr0)rCr0r0r1r¬Î	r¨z\\r?cSsdS)Nz\hliner0)r£r8r0r0r1r¬Ñ	r¨)rB)r‹rFr0r0r1Úmake_tex_tableÊ	srGcsèt|ƒ}yt |¡}Wntk
r.|}YnXt tjtj¡}| d¡| | d¡d¡d}x| 	d¡}||7}|sdPqdW| 
¡d‰‡fdd„| d	¡Dƒ}x0td
t
|ƒƒD]}|| ¡sÐ||=q´Pq´Wd	 |dd…¡S)
zWhois client for Python)zwhois.ripe.neté+Úutf8s
r¨isremarks:cs"g|]}|r|r| ˆ¡s|‘qSr0)r)r.r½)Ú
ignore_tagr0r1r¦î	szwhois.<locals>.<listcomp>ó
rHrGN)r4rêrírÐÚAF_INETÚSOCK_STREAMÚconnectÚsendrr´rmrÕrr”rvr)Ú
ip_addressZwhois_ipÚqueryr™ZanswerÚdÚlinesrwr0)rJr1ÚwhoisÚ	s,



rTc@s&eZdZd	dd„Zdd„Zdd„ZdS)
ÚPeriodicSenderThreadçà?cCsFt|tƒstd|ƒg|_n||_||_t ¡|_||_tj	 
|¡dS)zÝ Thread to send packets periodically

        Args:
            sock: socket where packet is sent periodically
            pkt: packet or list of packets to send
            interval: interval between two packets
        r)N)r3rrÚ_pktsÚ_socketÚ	threadingÚEventÚ_stoppedÚ	_intervalÚThreadr)r=ÚsockrÈÚintervalr0r0r1rý	s	

zPeriodicSenderThread.__init__cCsHxB|j ¡sBx2|jD](}|j |¡t |j¡|j ¡rPqWqWdS)N)r[Úis_setrWrXrOr,r.r\)r=r—r0r0r1Úrun
s
zPeriodicSenderThread.runcCs|j ¡dS)N)r[Úset)r=r0r0r1Ústop
szPeriodicSenderThread.stopN)rV)r-rYrZrrarcr0r0r0r1rUü	s
	rUc@s@eZdZdd„Zedd„ƒZdd„Zdd„Zd	d
„Zdd„Z	d
S)ÚSingleConversationSocketcCs||_t ¡|_dS)N)Ú_innerrYÚRLockÚ	_tx_mutex)r=Úor0r0r1r
sz!SingleConversationSocket.__init__cCs|jjS)N)rerV)r=r0r0r1rV#
sz!SingleConversationSocket.__dict__cCst|j|ƒS)N)rXre)r=rlr0r0r1rZ'
sz$SingleConversationSocket.__getattr__c	Os |j|jj||ŽSQRXdS)N)rgreÚsr1)r=r‹rFr0r0r1ri+
szSingleConversationSocket.sr1c	Os |j|jj||ŽSQRXdS)N)rgreÚsr)r=r‹rFr0r0r1rj0
szSingleConversationSocket.src	Cs|j|j |¡SQRXdS)N)rgrerO)r=r8r0r0r1rO5
szSingleConversationSocket.sendN)
r-rYrZrÚpropertyrVrZrirjrOr0r0r0r1rd
srd)FrcF)FrcF)F)F)F)rrF)F)rrF)F)NNNNNN)rHr)N)r~N)r~N)r“)N)F)N)
NFFNNNFFNNNTF)rF)NNNF)¤r[Ú
__future__rrrTrrÆr¹r°rxr{ràrùrêrÞr€r\rhrYr,r Zscapy.modules.sixÚmodulesr‰Zscapy.modules.six.movesrrrZscapy.configrZscapy.constsr	r
rZ
scapy.datarr
Zscapy.compatrrrrrrrrZscapy.errorrrrZscapy.pton_ntoprrrrrrrr r!r"r#r$r%r&r'r(rÁr)Zscapy.plistr*r+ròr,Z_SuperSocketÚobjectr)ÚGzipFilerër:rÓZ_Decimalr;rbrpryÚcommandsÚregisterr†rršržrŸrr¢r¿rßrÇrÉrÍrÏrÒr×rÚrÜrärårèrérërìrþrðrór÷rûrýrÿrrr
r6rArDrGrKrNrOrPr6r`rrrwrzr}r‡rˆrr‘r’Ú
add_metaclassr™rrÇrårær‰rÿrrr	rrrr+r<rBrDrFrGrTr]rUrdr0r0r0r1Ú<module>sT(DL


{


				
	
+-
Q
	'$
	A1^(FJ x
4
T
K"!

Products

About

Resources

Contact Gemfury