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.9-1 ▾
|
wlanpi-profiler
/
opt
/
wlanpi-profiler
/
lib
/
python3.7
/
site-packages
/
scapy
/
__pycache__
/
sendrecv.cpython-37.pyc
|
|---|
B
ä£ »Oã @ s d Z ddlmZmZ ddlZddlmZmZ ddlZddl Z ddl
Z
ddl Z ddl Z ddl
mZ ddlmZ ddlmZ ddlmZ dd lmZmZmZ dd
lmZ dd lm Z m Z m Z m Z m Z dd l!m"Z"m#Z#m$Z$ dd
lm%Z%m&Z&m'Z' ddl(m)Z)m*Z* ddl+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2m3Z3 ddl
m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z= ddlm>Z> ddl!m?Z? ej@dkrddlAZBG dd dZCdZDe<e;e0 e0f ZEG dd deFZGdd ZHdPd d ZIdQd d!ZJejKjLdRd"d#ZMejKjLdSd$d%ZNejKjLdTd&d'ZOd(d) ZPejKjLdUd*d+ZQd,d- ZRejKjLdVd.d/ZSejKjLdddddefd0d1ZTejKjLd2d3 ZUx0eTeUeQeSgD ] ZVeVj dk r|eV j eD7 _ q|W d4d5 d6d5 d7dddd7fd8d9ZWejKjLd:d; ZXejKjLd<d= ZYdWd>d?ZZejKjLdXd@dAZ[ejKjLdYdBdCZ\ejKjLdZdDdEZ]ejKjLd[dFdGZ^G dHdI dIeFZ_ejKjLdJdK Z`e_j e`_ ejKjLd\dLdMZaejKjLdNdO ZbdS )]z(
Functions to send and receive packets.
é )Úabsolute_importÚprint_functionN)ÚThreadÚEvent)Ú plain_str)Ú ETH_P_ALL)Úconf)Úwarning)Ú network_nameÚ
resolve_ifaceÚNetworkInterface)ÚPacket)Ú
get_temp_fileÚtcpdumpÚwrpcapÚContextManagerSubprocessÚ
PcapReader)Ú
PacketListÚ QueryAnswerÚ
SndRcvList)Ú log_runtimeÚlog_interactiveÚScapy_Exception)ÚGenÚSetGen)Úsix)Úmap)ÚDefaultSession)Ú SuperSocketÚ
IterSocket)
ÚAnyÚCallableÚDictÚIteratorÚListÚOptionalÚTupleÚTypeÚUnionÚcast)Ú_GlobInterfaceType)Ú_PacketIterablec @ s. e Zd Zeg dZeg dZeg dZdZdS )ÚdebugÚReceivedÚSentÚMatchedN) Ú__name__Ú
__module__Ú __qualname__r ÚrecvÚsentr ÚmatchZ
crashed_on© r6 r6 ú/build/wlanpi-profiler-8o1rr4/wlanpi-profiler-1.0.9/debian/wlanpi-profiler/opt/wlanpi-profiler/lib/python3.7/site-packages/scapy/sendrecv.pyr, D s
r, a
:param pks: SuperSocket instance to send/receive packets
:param pkt: the packet to send
:param rcv_pks: if set, will be used instead of pks to receive packets.
packets will still be sent through pks
:param nofilter: put 1 to avoid use of BPF filters
:param retry: if positive, how many times to resend unanswered packets
if negative, how many times to retry when no more packets
are answered
:param timeout: how much time to wait after the last packet has been sent
:param verbose: set verbosity level
:param multi: whether to accept multiple answers for the same stimulus
:param prebuild: pre-build the packets before starting to send them.
Automatically enabled when a generator is passed as the packet
c @ s: e Zd ZdZdddZdd Zd d
Zd d Zd
d ZdS )Ú
SndRcvHandleraÝ
Util to send/receive packets, used by sr*().
Do not use directly.
This matches the requests and answers.
Notes::
- threaded mode: enabling threaded mode will likely
break packet timestamps, but might result in a speedup
when sending a big amount of packets. Disabled by default
- DEVS: store the outgoing timestamp right BEFORE sending the packet
to avoid races that could result in negative latency. We aren't Stadia
Nr Fc C s¢ |d krt j}t jr8tg dt_tg dt_tg dt_d| _ g | _
|| _ | pP|| _ || _
|| _|| _|| _|| _|
| _| r|| _| d | _nLt|tjs|
r¶t|| _t| j| _n$t|tsÈt|n|| _| j ¡ | _|dk rî| }}nd}|d k r |dk r d | _xð|dkrüi | _ | s*| rft | j d}| d¡ | !|j"¡ | r\| d | #¡ n | !| j ¡ |rdd t$j%t& '| j ¡ D }ntt$j%t& '| j ¡ }|rØt|dkrØt|t| jkrØ|}|| _t| jdkrðP |d8 }qW t jr.t|d d
dt_t| j
d d
t_|rZx$| j
D ]\}}t(|d
r<|`)q<W |rt*d | j t| j
t| j
| jf t| j
| _+t|d | _,d S )
Nr- r. r/ r )ÚtargetTé c S s g | ]}t |d s|qS )Ú _answered)Úhasattr)Ú.0Úpr6 r6 r7 ú
<listcomp>À s z*SndRcvHandler.__init__.<locals>.<listcomp>r; z:
Received %i packets, got %i answers, remaining %i packetsZ
Unanswered)-r ÚverbÚ debug_matchr r, r3 r4 r r5 ÚnbrecvÚansÚpksÚrcv_pksÚinterÚverboseÚchainCCÚmultiÚtimeoutÚsessionÚtobesentÚnotansÚ
isinstanceÚtypesÚ
GeneratorTypeÚlistÚlenr r Ú __iterlen__Úhsentr Ú _sndrcv_sndÚ setDaemonÚ _sndrcv_rcvÚstartÚjoinÚ itertoolsÚchainr Ú
itervaluesr< r; ÚprintÚ
ans_resultÚ unans_result)ÚselfrD ÚpktrJ rF rG rH ÚretryrI rE ZprebuildÚ_floodZthreadedrK ZautostopZ
snd_threadÚremainZsndÚ_r6 r6 r7 Ú__init__q s~
" zSndRcvHandler.__init__c C s | j | jfS )N)r^ r_ )r` r6 r6 r7 Úresultsä s zSndRcvHandler.resultsc C s¦ yp| j rtd d}xF| jD ]<}| j | ¡ g ¡ |¡ | j |¡ t
| j ¡ |d7 }q W | j rntd| W n0 t k
r Y n t
k
r t d¡ Y nX dS )z/Function used in the sending thread of sndrcv()zBegin emission:r r: z Finished sending %i packets.z--- Error sending packetsN)rG r] rL rT Ú
setdefaultÚhashretÚappendrD ÚsendÚtimeÚsleeprF Ú
SystemExitÚ Exceptionr Ú exception)r` Úir> r6 r6 r7 rU è s zSndRcvHandler._sndrcv_sndc C s |dkr dS d}| ¡ }|| jkr´| j| }xt|D ]z\}}| |¡r6| j t||¡ | jdkrpt dd¡ d}| j
s||= | j d8 _ n t |ds¨| j d8 _ d|_
P q6W | j dkrØ| j
sØ| jrØ| jjdd |s| jdkrôt dd ¡ | jd7 _tjrtj |¡ dS )
z.Internal function used to process each packet.NFr: ó *Tr; r )rY ó .)ri rT Ú enumerateZanswersrC rj r rG ÚosÚwriterI rM r< r; ÚsnifferÚstoprB r rA r, r3 )r` ÚrÚokÚhZhlstrq Zsentpktr6 r6 r7 Ú_process_packetÿ s8
z SndRcvHandler._process_packetc C sT d| _ y,t | _ | j j| j| jd| j| j|d W n tk
rN | jrJ Y nX dS )z8Function used to receive packets and check their hashretNF)ÚprnrJ ÚstoreÚ
opened_socketrK Ústarted_callback) rw Ú AsyncSnifferÚ_runr| rJ rE rK ÚKeyboardInterruptrH )r` Úcallbackr6 r6 r7 rW s zSndRcvHandler._sndrcv_rcv) Nr NFr FNFNFN) r0 r1 r2 Ú__doc__rf rg rU r| rW r6 r6 r6 r7 r8 c s
f!r8 c O s t | |}| ¡ S )z§Scapy raw function to send a packet and receive its answer.
WARNING: This is an internal function. Using sr/srp/sr1/srp is
more appropriate in many cases.
)r8 rg )ÚargsÚkwargsZsndrcverr6 r6 r7 Úsndrcv3 s
r Fc O sD t |trtj|d}t |ts(t|}|dkr6tj}d}
|dk rJ| }n|sRd}|r\t } y°xª|rd} x|D ]}
|r¸t ¡ }| rª| t |
j | }|dkr¸t
|¡ n|t |
j } | |
¡ |rÐ| |
¡ |
d7 }
|rèt
dd¡ t
|¡ qpW |dk r`|d7 }q`W W n tk
r" Y nX |r6td|
|r@| S dS )z±
An internal function used by send/sendp to actually send the packets,
implement the send logic...
It will take care of iterating through the different packets
)ÚloadNr éÿÿÿÿr: rs z
Sent %i packets.)rN Ústrr Z raw_layerr r r@ r rl Úfloatrm rk rj ru rv r r] )ÚsÚxrF ÚloopÚcountrG ÚrealtimeÚreturn_packetsr ÚkargsÚnZ sent_packetsZdt0r> ÚctÚstr6 r6 r7 Ú
__gen_send= sP
r c
K sX | dk} t |ptj}| p.||f d|i|
} t| | ||||||d} | rT| ¡ | S )z(Internal function used by send and sendpNÚiface)rF r r rG r r )r r r r Úclose)
r Z_funcrF r r r rG r r Úsocketr Z need_closingrg r6 r6 r7 Ú_sendz s
r c K s$ t || }t| dd fd|i|S )as
Send packets at layer 3
:param x: the packets
:param inter: time (in s) between two packets (default 0)
:param loop: send packet indefinetly (default 0)
:param count: number of packets to send (default None=1)
:param verbose: verbose mode (default None=conf.verbose)
:param realtime: check that a packet was sent before sending the next one
:param return_packets: return the sent packets
:param socket: the socket to use (default is conf.L3socket(kargs))
:param iface: the interface to send the packets on
:param monitor: (not on linux) send in monitor mode
:returns: None
c S s | ¡ S )N)Úl3socket)r r6 r6 r7 Ú<lambda>« ó zsend.<locals>.<lambda>r )Ú_interface_selectionr )r r r r6 r6 r7 rk s
rk c K sD |dkr(|dk r(|dkr(t j |¡d }t| dd f||d|S )as
Send packets at layer 2
:param x: the packets
:param inter: time (in s) between two packets (default 0)
:param loop: send packet indefinetly (default 0)
:param count: number of packets to send (default None=1)
:param verbose: verbose mode (default None=conf.verbose)
:param realtime: check that a packet was sent before sending the next one
:param return_packets: return the sent packets
:param socket: the socket to use (default is conf.L3socket(kargs))
:param iface: the interface to send the packets on
:param monitor: (not on linux) send in monitor mode
:returns: None
Nr c S s | ¡ S )N)Úl2socket)r r6 r6 r7 r Ì r zsendp.<locals>.<lambda>)r r )r Úrouter )r r Ú
iface_hintr r r6 r6 r7 Úsendp± s r£ c C s |dkrt j}t jjdt| g} |dk r:| d| ¡ n:|dk rR| d| ¡ n"|dk rj| d| ¡ n
| d¡ |r| d| ¡ |r| d¡ |dk r¦| |¡ t }
| |
¡ t|
| d} t t jj® yt
j | t
j t
j d } W n@ t
k
r
t d
¡ Y np tk
r* t |
¡ Y nPX | ¡ \}
}|rLt | ¡ ¡ |r`t|
|| } nt jd krzt |
¡ ¡ W dQ R X t |
¡ | S ) aq Send packets at layer 2 using tcpreplay for performance
:param pps: packets per second
:param mpbs: MBits per second
:param realtime: use packet's timestamp, bending time with real-time value
:param loop: number of times to process the packet list
:param file_cache: cache packets in RAM instead of reading from
disk at each iteration
:param iface: output interface
:param replay_args: List of additional tcpreplay args (List[str])
:param parse_results: Return a dictionary of information
outputted by tcpreplay (default=False)
:returns: stdout, stderr, command used
Nz
--intf1=%sz--pps=%iz --mbps=%fz--multiplier=%fz
--topspeedz --loop=%iz--preload-pcap)ÚstdoutÚstderrzInterrupted by useré )r r ÚprogZ tcpreplayr
rj Úextendr r r Ú
subprocessÚPopenÚPIPEr r Úinforo ru ÚunlinkÚ communicater r ÚdecodeÚ_parse_tcpreplay_resultr@ )r ÚppsÚmbpsr r Ú
file_cacher Z replay_argsZ
parse_resultsÚargvÚfrg Úcmdr¤ r¥ r6 r6 r7 Ú sendpfastÓ sL
r· c
s yFi }t | ¡ }t | ¡ d¡}tttftttfttttftftftftftftfd }dddddd}d }d
} d }
t| t|i x | d¡D ]} | ¡ } x| ¡ D ]x\} }
| | ¡r¨|
fd d
|
D ¡}t
|| ¡}x@t |
D ]4\}}| | | g¡| }|rè||
|d ¡||< qèW q¨W qW d |¡|d< |dd
|d< |S tk
r } ztjsf t d|¡ i S d}~X Y nX dS )a
Parse the output of tcpreplay and modify the results_dict to populate output information. # noqa: E501
Tested with tcpreplay v3.4.4
Tested with tcpreplay v4.1.2
:param stdout: stdout of tcpreplay subprocess call
:param stderr: stderr of tcpreplay subprocess call
:param argv: the command used in the subprocess call
:return: dictionary containing the results
Ú
) ÚactualÚratedÚflowsZ attemptedZ
successfulÚfailedZ truncatedzretried packets (enozretried packets (eag)ZpacketsÚbytesrl )Zbpsr² r± )r» ZfpsZ flow_packetsZnon_flow)Zretried_enobufs)Zretried_eagain)r¹ rº r» zretried packets (enozretried packets (eagz([0-9]*\.[0-9]+|[0-9]+)z([0-9]+)z[^0-9]*c s g | ] } | qS r6 r6 )r= r )Úr_typesr6 r7 r? D s z+_parse_tcpreplay_result.<locals>.<listcomp>r: ú ÚcommandNr ÚwarningszError parsing output: %s)r ÚlowerÚstripÚsplitÚintr ÚitemsÚ
startswithrY ÚreÚsearchrt ÚgetÚgroupro r Ú interactiver Úerror)Zstdout_bZstderr_br´ rg r¤ r¥ ÚelementsrI Z float_regZint_regZany_regÚlineÚeltÚ_typesÚregexÚmatchesrq ÚtypÚnameZparse_exceptionr6 )r¾ r7 r° sP
" r° c O s0 t j||||d}t|| f||}| ¡ |S )z-
Send and receive packets at layer 3
)ÚpromiscÚfilterr Únofilter)r ÚL3socketr r ) r rÖ r× r rØ r r r Úresultr6 r6 r7 ÚsrT s
rÛ c C sH | dkrDyt | ¡ ¡ d }W n tk
r8 d}Y nX |pBtjS | S )zK
Select the network interface according to the layer 3 destination
Nr )ÚnextÚ__iter__r¡ ÚAttributeErrorr r )r ÚpacketZiffr6 r6 r7 r h s
r c
O s\ t || }tj||||d}t|| f||\}} | ¡ t|dkrXtt|d d S dS )zB
Send packets at layer 3 and return only the first answer
)rÖ r× rØ r r r: N)r r rÙ r r rR r) r
)
r rÖ r× r rØ r r r rC re r6 r6 r7 Úsr1z s
rà c O sb |dkr |dk r t j |¡d }t|p*t j}| ¡ |||||d} t| | f||}
| ¡ |
S )z-
Send and receive packets at layer 2
Nr )rÖ r r× rØ Útype)r r¡ r r r r r ) r rÖ r r¢ r× rØ rá r r r rÚ r6 r6 r7 Úsrp s
râ c O s0 t | |\}}t|dkr,tt|d d S dS )zN
Send and receive packets at layer 2 and return only the first answer
r r: N)râ rR r) r
)r r rC re r6 r6 r7 Úsrp1ª s rã c C s | d ¡ S )Nr: )Úsummary)r r6 r6 r7 r Á r r c C s | ¡ S )N)rä )r r6 r6 r7 r  r r: c O s² d} d} t j}
|d kr t j}d}g }g }|d kr>td| d}yx|dN }|
j|
jg| }|d k rx|dkrpP |d8 }t ¡ }|dkrtddd | |f| |ddd |
}| t|d t|d 7 } | t|d 7 } |dkr\|r\t|d dkr\d
t|d }td |
|¡ dd x6|d D ]*}t||| tdt| dd q.W |dkrÜ|rÜt|d dkrÜd t|d }td |
|¡ dd x6|d D ]*}t||| tdt| dd q®W |dkr|s|std
t t t|d d
|r.||d 7 }||d 7 }t ¡ }|| |k rFt
|| | ¡ qFW W n tk
rp Y nX |r¢| dkr¢t|
d| | d| | f ¡ t|t|fS )Nr r¦ é r: z
send...
r¿ )ÚendT)rJ rG rH zRECV %i:ú
zfail %i:zrecv:%i fail:%iz4
Sent %i packets, received %i packets. %3.1f%% hits.g Y@)r Z color_themer@ ÚminZevenZoddrl r] rR ÚsuccessZfailÚtupler rm r Únormalr r )ZsrfuncÚpktsr} ZprnfailrF rJ r rG r~ r r r ry r ZparityrC ZunansÚcolrX ÚresÚmsgr> ræ r6 r6 r7 Ú __sr_loop¿ sb
"" rð c O s t t| f||S )z
Send a packet at layer 3 in loop and print the answer each time
srloop(pkts, [prn], [inter], [count], ...) --> None
)rð rÛ )rì r r r6 r6 r7 Úsrloop s
rñ c O s t t| f||S )z
Send a packet at layer 2 in loop and print the answer each time
srloop(pkts, [prn], [inter], [count], ...) --> None
)rð râ )rì r r r6 r6 r7 Úsrploop
s
rò c C sR t }dd }|||}t|tr*| ¡ nt|} | |jg}
t| ||||||
dS )z sndrcv equivalent for flooding.c s s* x$x | D ]}| ¡ rdS |V qW qW dS )zVInfinite generator that produces the same
packet until stopevent is triggered.N)Úis_set)rL Ú stopeventr> r6 r6 r7 Ú send_in_loop' s
z!sndrcvflood.<locals>.send_in_loop)rF rG rH rJ rc )r rN r rS rR Úsetr ) rD ra rF rG rH rJ rô rõ Z infinite_genZ
_flood_lenrc r6 r6 r7 Ú sndrcvflood s
r÷ c O s@ t |p
tj}| ¡ ||||d}t|| f||}| ¡ |S )a< Flood and receive packets at layer 3
:param prn: function applied to packets received
:param unique: only consider packets whose print
:param nofilter: put 1 to avoid use of BPF filters
:param filter: provide a BPF filter
:param iface: listen answers only on the given interface
)rÖ r× r rØ )r r r r r÷ r ) r rÖ r× r rØ r r r ry r6 r6 r7 Úsrflood< s
rø c
O sb t |p
tj}| ¡ ||||d}t|| f||\}} | ¡ t|dkr^tt|d d S dS )aO Flood and receive packets at layer 3 and return only the first answer
:param prn: function applied to packets received
:param verbose: set verbosity level
:param nofilter: put 1 to avoid use of BPF filters
:param filter: provide a BPF filter
:param iface: listen answers only on the given interface
)rÖ r× rØ r r r: N) r r r r r÷ r rR r) r
)
r rÖ r× r rØ r r r rC re r6 r6 r7 Úsr1floodU s rù c
O s` |dkr |dk r t j |¡d }t|p*t j}| ¡ ||||d}t|| f||} | ¡ | S )a< Flood and receive packets at layer 2
:param prn: function applied to packets received
:param unique: only consider packets whose print
:param nofilter: put 1 to avoid use of BPF filters
:param filter: provide a BPF filter
:param iface: listen answers only on the given interface
Nr )rÖ r× r rØ )r r¡ r r r r÷ r )
r rÖ r× r r¢ rØ r r r ry r6 r6 r7 Úsrpfloodp s rú c
O sb t |p
tj}| ¡ ||||d}t|| f||\}} | ¡ t|dkr^tt|d d S dS )aO Flood and receive packets at layer 2 and return only the first answer
:param prn: function applied to packets received
:param verbose: set verbosity level
:param nofilter: put 1 to avoid use of BPF filters
:param filter: provide a BPF filter
:param iface: listen answers only on the given interface
)rÖ r× rØ r r r: N) r r r r r÷ r rR r) r
)
r rÖ r× r rØ r r r rC re r6 r6 r7 Ú srp1flood s rû c @ s` e Zd ZdZdd Zdd Zdddd dddddddddi fd
d Zd d
ZdddZdd Z dS )r aü
Sniff packets and return a list of packets.
Args:
count: number of packets to capture. 0 means infinity.
store: whether to store sniffed packets or discard them
prn: function to apply to each packet. If something is returned, it
is displayed.
--Ex: prn = lambda x: x.summary()
session: a session = a flow decoder used to handle stream of packets.
--Ex: session=TCPSession
See below for more details.
filter: BPF filter to apply.
lfilter: Python function applied to each packet to determine if
further action may be done.
--Ex: lfilter = lambda x: x.haslayer(Padding)
offline: PCAP file (or list of PCAP files) to read packets from,
instead of sniffing them
quiet: when set to True, the process stderr is discarded
(default: False).
timeout: stop sniffing after a given time (default: None).
L2socket: use the provided L2socket (default: use conf.L2listen).
opened_socket: provide an object (or a list of objects) ready to use
.recv() on.
stop_filter: Python function applied to each packet to determine if
we have to stop the capture after this packet.
--Ex: stop_filter = lambda x: x.haslayer(TCP)
iface: interface or list of interfaces (default: None for sniffing
on all interfaces).
monitor: use monitor mode. May not be available on all OS
started_callback: called as soon as the sniffer starts sniffing
(default: None).
The iface, offline and opened_socket parameters can be either an
element, a list of elements, or a dict object mapping an element to a
label (see examples below).
For more information about the session argument, see
https://scapy.rtfd.io/en/latest/usage.html#advanced-sniffing-sniffing-sessions
Examples: synchronous
>>> sniff(filter="arp")
>>> sniff(filter="tcp",
... session=IPSession, # defragment on-the-flow
... prn=lambda x: x.summary())
>>> sniff(lfilter=lambda pkt: ARP in pkt)
>>> sniff(iface="eth0", prn=Packet.summary)
>>> sniff(iface=["eth0", "mon0"],
... prn=lambda pkt: "%s: %s" % (pkt.sniffed_on,
... pkt.summary()))
>>> sniff(iface={"eth0": "Ethernet", "mon0": "Wifi"},
... prn=lambda pkt: "%s: %s" % (pkt.sniffed_on,
... pkt.summary()))
Examples: asynchronous
>>> t = AsyncSniffer(iface="enp0s3")
>>> t.start()
>>> time.sleep(1)
>>> print("nice weather today")
>>> t.stop()
c O s" || _ || _d| _d | _d | _d S )NF)r r ÚrunningÚthreadrg )r` r r r6 r6 r7 rf è s
zAsyncSniffer.__init__c C s( t | j| j| jdd| _| j d¡ d S )Nr )r9 r r rÕ T)r r r r rý rV )r` r6 r6 r7 Ú
_setup_threadñ s
zAsyncSniffer._setup_threadr TNFc s" d_ t|
ts.|
pt}
|
f ||d|}
n ||
_||
_i }| d k rt| trj| dd t| D ¡ n.t| tr| dd t
| ¡D ¡ nd|| < |d k r d¡t|t r¼|g}t|trôt
dd |D rô| fd d|D ¡ n¢t|tr"| fd
dt
|¡D ¡ ntt|tttfrjt|}||d krN|ntt|d d gdd
< n,||td kr~|nt|d d gdd
< |r¦| d k r6t| p²tj} d krÈ| ¡ t| trð| fdd| D ¡ nFt| tr | fddt
| ¡D ¡ n| | f t| d< tt|}|j|j}t
fdd|D snt d |s¤ddl m } | d|< fdd}|_ nfdd}|_ d y| rÊ| d_ |d k ræt! !¡ | }d }xÔ|rj rÀ|d k r |t! !¡ }|dkr P t| "¡ |}g }xn|D ]d}|krNP y | #¡ }W nØ t$k
r¢ y | %¡ W n t&k
r Y nX | '|¡ w<Y n t&k
r2 } zrd} y | %¡ W n, t&k
rð } z d| } W d d } ~ X Y nX t d||f | | '|¡ tj(d kr w<W d d }~X Y nX |d krBq<|rV||sVq<|| |_)|
*|¡ |
rz|
|sd| k r|
j+kr<n nd _ P q<W x|D ] }||= q¬W qîW W n t,k
rÚ Y nX d _ | d krx&|D ]}| %¡ qòW nr %¡ |
-¡ _.d S ) NT)r} r~ c s s | ]\}}|d | fV qdS )zsocket%dNr6 )r= rq r r6 r6 r7 ú <genexpr> s z$AsyncSniffer._run.<locals>.<genexpr>c s s | ]\}}||fV qd S )Nr6 )r= r Úlabelr6 r6 r7 rÿ " s Zsocket0r× c s s | ]}t |tV qd S )N)rN r )r= rÐ r6 r6 r7 rÿ . s c 3 s8 | ]0}t d kr|nt|ddg dd|fV qd S )Nz-wú-T)r ÚfltÚgetfdÚquiet)r r )r= Úfname)r r r6 r7 rÿ 0 s c 3 s< | ]4\}}t d kr|nt|ddg dd|fV qd S )Nz-wr T)r r r r )r r )r= r r )r r r6 r7 rÿ : s z-wr )r r r r c 3 s& | ] } f t |d |fV qdS ))rá r N)r )r= Úifname)ÚL2socketÚkargr6 r7 rÿ \ s c 3 s* | ]"\}} f t |d |fV qdS ))rá r N)r )r= r Ziflabel)r r r6 r7 rÿ b s )rá r c 3 s | ]} |j kV qd S )N)Úselect)r= Úsock)Ú select_funcr6 r7 rÿ o s zaWarning: inconsistent socket types ! The used select function will be the one of the first socketr )Ú
ObjectPipeZcontrol_socketc s j r d ¡ d_d S )NF)rü rk Úcontinue_sniffr6 )Ú
close_piper` r6 r7 Ústop_cbz s
z"AsyncSniffer._run.<locals>.stop_cbc s
d _ d S )NF)r
r6 )r` r6 r7 r s z It was closed.z close() failed with '%s'zSocket %s failed with '%s'.r¦ F)/rü rN r r} r~ rQ Úupdatert Údictr Ú iteritemsrÊ r Úallr
r r r r r r r Zl2listenr rÜ Úiterr Únonblocking_socketr Zscapy.automatonr r r
rl Úkeysr3 ÚEOFErrorr ro rj Zdebug_dissectorÚ
sniffed_onZon_packet_receivedr r Z toPacketListrg ) r` r r~ Úoffliner r} Zlfilterr rJ r Z stop_filterr r rK Zsession_kwargsr Z
sniff_socketsZ _main_socketr r r Zstoptimerd ÚsocketsZ dead_socketsr r> Úexrï Zex2r6 )r r r r r r r` r7 r ü sî
.
,
zAsyncSniffer._runc C s | ¡ | jr| j ¡ dS )z!Starts AsyncSniffer in async modeN)rþ rý rX )r` r6 r6 r7 rX Í s zAsyncSniffer.startc C sR | j rFy | ¡ W n tk
r. tdY nX |rB| ¡ | jS dS tddS )z'Stops AsyncSniffer if not in async modez+Unsupported (offline or unsupported socket)Nz
Not started !)rü r rÞ r rY rg )r` rY r6 r6 r7 rx Ô s zAsyncSniffer.stopc O s | j r| j j|| d S )N)rý rY )r` r r r6 r6 r7 rY å s zAsyncSniffer.join)T)
r0 r1 r2 r
rf rþ r rX rx rY r6 r6 r6 r7 r © s* = D
r c O s t }|j| | tt|jS )N)r r r) r rg )r r rw r6 r6 r7 Úsniffë s r c sÊ x&dD ] }||krt d|¡ ||= qW |fdd} | | d\}
} | |d\} }| | ||
i i |dk rp|| < |dk r||< fdd |dkr}n|fd
d }t||
| | |i|d |S )
aØ Forward traffic between interfaces if1 and if2, sniff and return
the exchanged packets.
:param if1: the interfaces to use (interface names or opened sockets).
:param if2:
:param xfrm12: a function to call when forwarding a packet from if1 to
if2. If it returns True, the packet is forwarded as it. If it
returns False or None, the packet is discarded. If it returns a
packet, this packet is forwarded instead of the original packet
one.
:param xfrm21: same as xfrm12 for packets forwarded from if2 to if1.
The other arguments are the same than for the function sniff(),
except for offline, opened_socket and iface that are ignored.
See help(sniff) for more.
)r r r z@Argument %s cannot be used in bridge_and_sniff() -- ignoring it.c S sB t | tr| d| fS |s0t| p$tj} | ¡ }|| d| fS d S )Nziface%d)r )rN r r r r r )r r r r6 r6 r7 Ú _init_socket s
z&bridge_and_sniff.<locals>._init_socketr: r¦ Nc sÔ y | j p d }W n tk
r& d S X | j kry| j | }W n, tk
rp tjd| ¡ | j dd d S X t|tr|sd S | }q|}n| }y| |¡ W n, tk
rÎ tjd| ¡ | j dd Y nX d S )NÚ zOException in transformation function for packet [%s] received on %s -- droppingT)Úexc_infoz)Cannot forward packet [%s] received on %s) r ÚKeyErrorro r r rä rN Úboolrk )ra ZsendsockZ_newpktZnewpkt)ÚpeersÚxfrmsr6 r7 Úprn_send, s.
z"bridge_and_sniff.<locals>.prn_sendc s | | S )Nr6 )ra )Úprn_origr$ r6 r7 r} O s z bridge_and_sniff.<locals>.prn)r r} )r r r ) Zif1Zif2Zxfrm12Zxfrm21r} r r r Úargr Zsckt1Zsckt2r6 )r" r% r$ r# r7 Úbridge_and_sniffö s*
r' c s d|kr| d¡}n"d|kr0tt| d¡j}ntj}td| dg fdd}t| |dd| td d d d
krd nd f d
S )z|Sniff packets and print them calling pkt.summary().
This tries to replicate what text-wireshark (tshark) would look liker r zCapturing on '%s'r c s, t d d | ¡ f d d7 < d S )Nz%5d %sr r: )r] rä )ra )rq r6 r7 Ú_cbj s ztshark.<locals>._cbF)r} r~ z
%d packet%s capturedr: r r N)rÊ r) r r r r] r )r r r r( r6 )rq r7 ÚtsharkX s r) )r r NNFF)r r NNNFFN)N)NNN)NNFr FNNF)NNNr )NNNr )r NFN)NNNN)NNNr )NNNNN)NNNr )NNNN)cr
Ú
__future__r r rZ Ú threadingr r ru rÈ r© rl rO Z scapy.compatr Z
scapy.datar Z scapy.configr Z scapy.errorr Zscapy.interfacesr
r r Z scapy.packetr
Z scapy.utilsr r r r r Z scapy.plistr r r r r r Zscapy.base_classesr r Z
scapy.modulesr Zscapy.modules.six.movesr Zscapy.sessionsr Zscapy.supersocketr r r r! r" r# r$ r% r& r' r( r) r* r+ r¡ Z scapy.routeZscapyr, Z_DOC_SNDRCV_PARAMSZ_GlobSessionTypeÚobjectr8 r r r ÚcommandsÚregisterrk r£ r· r° rÛ r rà râ rã Zsr_funcrð rñ rò r÷ rø rù rú rû r r r' r) r6 r6 r6 r7 Ú<module> s 0 Q
8
?9
9
D \