Welcome, guest | Sign In | My Account | Store | Cart

Notice! PyPM is being replaced with the ActiveState Platform, which enhances PyPM’s build and deploy capabilities. Create your free Platform account to download ActivePython or customize Python with the packages you require and get automatic updates.


scapy-nflog-capture is unavailable in PyPM, because there aren't any builds for it in the package repositories. Click the linked icons to find out why.

 Python 2.7Python 3.2Python 3.3
Windows (32-bit)
Windows (64-bit)
Mac OS X (10.5+)
13.05.0 Failed View build log
Linux (32-bit)
13.05.0 Failed View build log
Linux (64-bit)
13.05.0 Failed View build log
Lastest release
version 13.05.0 on May 14th, 2013


Driver for scapy network manipulation tool to allow capturing packets via Linux NFLOG interface.


It's a regular package for Python 2.7 (not 3.X).

Using pip is the best way:

% pip install scapy-nflog-capture

If you don't have it, use:

% easy_install pip
% pip install scapy-nflog-capture

Alternatively (see also):

% curl https://raw.github.com/pypa/pip/master/contrib/get-pip.py | python
% pip install scapy-nflog-capture

Or, if you absolutely must:

% easy_install scapy-nflog-capture

But, you really shouldn't do that.

Current-git version can be installed like this:

% pip install 'git+https://github.com/mk-fg/scapy-nflog-capture.git#egg=scapy-nflog-capture'

CFFI uses C compiler to generate bindings, so gcc (or other compiler) should be available if module is being built from source or used from checkout tree.


Two python modules are installed: scapy_nflog and nflog_ctypes.

scapy_nflog has NFLOGListenSocket class (implementing SuperSocket), which can be installed as default L2 listener like this:

>>> import scapy_nflog
>>> scapy_nflog.install_nflog_listener()

install_nflog_listener above is a one-line function, doing conf.L2listen = NFLOGListenSocket, so if you're building custom module on scapy, NFLOGListenSocket class can just be passed directly to scapy internals a listening socket without setting it to be default one.

IDs of NFLOG queues to grab packets from can be controlled via passing optional "queues" keyword on instance init (int or a list of ints) or by overriding default "queues" class attribute in a subclass and setting that one as listener class instead.

Note that NFLOG actually returns L3 packets, so despite the listener being installed as L2 above, it will always return instances of IP class, not Ether or such.


NFLOG is a Linux netfilter subsystem target, somewhat like old and simple LOG target, which dumped info for each packet to kmsg, but using special netlink queues to export netfilter-matched (think iptables rules) packets to userspace.

To export all sent/received packets via nflog:

iptables -t raw -I PREROUTING -j NFLOG
iptables -t raw -I OUTPUT -j NFLOG

Of course, any arbitrary filters can be added there, to dump only packets matching specific protocol, port or whatever arbitrary netfilter matcher - see iptables manpage (or iptables-extensions(8)) for the list/info on the ones shipped with mainline linux.

Note that it's safe to add the above catch-all rules, as with no listeners (nothing queries nflog for these packets), they'll just be discarded regardless of these rules and won't be wasting much ram, cpu or anything like that.

Userspace readers (like this module) can subscribe to receive these packets, setting how many bytes of these will be buffered in-kernel for later recv() calls (optional "nlbufsiz" keyword to nflog_generator), the rest will be just dropped (producing python logging warning by default, unless handle_overflows=False is passed) until userspace catches up.

NFLOG itself is configurable with parameters like --nflog-group and --nflog-range (see iptables-extensions(8)), allowing to have multiple nflog queues for different apps and not passing lots of useless L7 data around.

Performance - especially coupled with in-kernel noise filtering and packet truncation - seem to be more efficient than simpler approaches like using AF_PACKET/SOCK_RAW sockets, but it's highly unlikely to be any kind of a bottleneck with scapy sitting on top of it anyway.

One interesting advantage over libpcap is the ability to capture tunneled packets after decryption (traffic coming from ipsec, pptp, openvpn, ssh, etc) or transformation (stripping of ipip wrapping, netlink re-injection and such) here.


scapy_nflog is based on nflog_cffi module, which can be used from any python code (scapy shell included):

from nflog_cffi import NFLOG

# without extra_attrs just packet payload (possibly truncated) is returned
nflog = NFLOG().generator(0, extra_attrs=['len', 'ts'], nlbufsiz=2*2**20)
fd = next(nflog) # netlink fd to do select/poll on, if necessary

# pkt_len is the *real* length, before nflog-truncation (if any)
# pkt_ts is the packet timestamp, as reported by kernel/lib
pkt, pkt_len, pkt_ts = next(nflog)
print('Got packet, len: {}, ts: {}'.format(pkt_len, pkt_ts))

for pkt, pkt_len, pkt_ts in nflog: # do stuff with each captured packet

Module uses libnetfilter_log via CFFI.

NFLOG generator has the keywords to control parameters of netlink socket that are passed to libnetfilter_log, see libnetfilter_log documentation for more verbose description of these.

Not all libnetfilter_log-exposed attributes are exposed through bindings.

Subscribe to package updates

Last updated May 14th, 2013

What does the lock icon mean?

Builds marked with a lock icon are only available via PyPM to users with a current ActivePython Business Edition subscription.

Need custom builds or support?

ActivePython Enterprise Edition guarantees priority access to technical support, indemnification, expert consulting and quality-assured language builds.

Plan on re-distributing ActivePython?

Get re-distribution rights and eliminate legal risks with ActivePython OEM Edition.