Recently I’ve been working on a project where I implement a bunch of tiny toy working versions of computer networking protocols in Python without using any libraries, as a way to explain how computer networking works.
I’m still working on writing up that project, but today I wanted to talk about how to do the very first step: sending network packets in Python.
In this post we’re going to send a SYN packet (the first packet in a TCP
connection) from a tiny Python program, and get a reply from
example.com. All the code from this post is in this gist.
what’s a network packet?
A network packet is a byte string. For example, here’s the first packet in a TCP connection:
I’m not going to talk about the structure of this byte string in this post (though I’ll say that this particular byte string has two parts: the first 20 bytes are the IP address part and the rest is the TCP part)
The point is that to send network packets, we need to be able to send and receive strings of bytes.
The problem with writing your own TCP implementation on Linux (or any operating system) is – the Linux kernel already has a TCP implementation!
So if you send out a SYN packet on your normal network interface to a host like example.com, here’s what will happen:
- you send a SYN packet to example.com
- example.com replies with a SYN ACK (so far so good!)
- the Linux kernel on your machine gets the SYN ACK, thinks “wtf?? I didn’t make this connection??”, and closes the connection
- you’re sad. no TCP connection for you.
I was talking to a friend about this problem a few years ago and he said “you should use tun/tap!“. It took quite a few hours to figure out how to do that though, which is why I’m writing this blog post :)
tun/tap gives you a “virtual network device”
The way I like to think of
tun/tap is – imagine I have a tiny computer in my
network which is sending and receiving network packets. But instead of it being
a real computer, it’s just a Python program I wrote.
That explanation is honestly worse than I would like. I wish I understood exactly how tun/tap devices interfaced with the real Linux network stack but unfortunately I do not, so “virtual network device” is what you’re getting. Hopefully the code examples below will make all it a bit more clear.
tun vs tap
The system called “tun/tap” lets you create two kinds of network interfaces:
- “tun”, which lets you set IP-layer packets
- “tap”, which lets you set Ethernet-layer packets
We’re going to be using tun, because that’s what I could figure out how to get to work. It’s possible that tap would work too.
how to create a tun interface
Here’s how I created a tun interface with IP address 192.0.2.2.
sudo ip tuntap add name tun0 mode tun user $USER sudo ip link set tun0 up sudo ip addr add 192.0.2.1 peer 192.0.2.2 dev tun0 sudo iptables -t nat -A POSTROUTING -s 192.0.2.2 -j MASQUERADE sudo iptables -A FORWARD -i tun0 -s 192.0.2.2 -j ACCEPT sudo iptables -A FORWARD -o tun0 -d 192.0.2.2 -j ACCEPT
These commands do two things:
- Create the
tundevice with the IP
192.0.2.2(and give your user access to write to it)
- set up
iptablesto proxy packets from that tun device to the internet using NAT
The iptables part is very important because otherwise the packets would only exist inside my computer and wouldn’t be sent to the internet, and what fun would that be?
I’m not going to explain this
ip addr add command because I don’t understand
it, I find
ip to be very inscrutable and for now I’m resigned to just copying
ip commands without fully understanding them. It does work
how to connect to the tun interface in Python
Here’s a function to open a tun interface, you call it like
I figured out how to write it by searching through the
scapy source code for “tun”.
import struct from fcntl import ioctl def openTun(tunName): tun = open("/dev/net/tun", "r+b", buffering=0) LINUX_IFF_TUN = 0x0001 LINUX_IFF_NO_PI = 0x1000 LINUX_TUNSETIFF = 0x400454CA flags = LINUX_IFF_TUN | LINUX_IFF_NO_PI ifs = struct.pack("16sH22s", tunName, flags, b"") ioctl(tun, LINUX_TUNSETIFF, ifs) return tun
All this is doing is
/dev/net/tunin binary mode
- calling an
ioctlto tell Linux that we want a
tundevice, and that the one we want is called
tunNamewe’ve passed to the function).
Once it’s open, we can
read from and
write to it like any other file in Python.
let’s send a SYN packet!
Now that we have the
openTun function, we can send a SYN packet!
Here’s what the Python code looks like, using the
syn = b'E\x00\x00,\x00\x01\x00\x00@\x06\x00\xc4\xc0\x00\x02\x02"\xc2\x95Cx\x0c\x00P\xf4p\x98\x8b\x00\x00\x00\x00`\x02\xff\xff\x18\xc6\x00\x00\x02\x04\x05\xb4' tun = openTun(b"tun0") tun.write(syn) reply = tun.read(1024) print(repr(reply))
If I run this as
sudo python3 syn.py, it prints out the reply from
Obviously this is a pretty silly way to send a SYN packet – a real implementation would have actual code to generate that byte string instead of hardcoding it, and we would parse the reply instead of just printing out the raw byte string. But I didn’t want to go into the structure of TCP in this post so that’s what we’re doing.
looking at these packets with tcpdump
If we run tcpdump on the
tun0 interface, we can see the packet we sent and the answer from
$ sudo tcpdump -ni tun0 12:51:01.905933 IP 192.0.2.2.30732 > 18.104.22.168.80: Flags [S], seq 4101019787, win 65535, options [mss 1460], length 0 12:51:01.932178 IP 22.214.171.124.80 > 192.0.2.2.30732: Flags [S.], seq 3300937416, ack 4101019788, win 64480, options [mss 1240], length 0
Flags [S] is the SYN we sent, and
Flags [S.] is the SYN ACK packet in
response! We successfully communicated! And the Linux network stack didn’t
interfere at all!
tcpdump also shows us how NAT is working
We can also run
tcpdump on my real network interface (
wlp3so, my wireless card), to see the packets being sent and received. We’ll pass
-i wlp3s0 instead of
$ sudo tcpdump -ni wlp3s0 host 126.96.36.199 tcpdump: verbose output suppressed, use -v[v]... for full protocol decode listening on wlp3s0, link-type EN10MB (Ethernet), snapshot length 262144 bytes 12:56:01.204382 IP 192.168.1.181.30732 > 188.8.131.52.80: Flags [S], seq 4101019787, win 65535, options [mss 1460], length 0 12:56:01.228239 IP 184.108.40.206.80 > 192.168.1.181.30732: Flags [S.], seq 144769955, ack 4101019788, win 64480, options [mss 1240], length 0 12:56:05.334427 IP 220.127.116.11.80 > 192.168.1.181.30732: Flags [S.], seq 144769955, ack 4101019788, win 64480, options [mss 1240], length 0 12:56:13.524973 IP 18.104.22.168.80 > 192.168.1.181.30732: Flags [S.], seq 144769955, ack 4101019788, win 64480, options [mss 1240], length 0 12:56:29.705007 IP 22.214.171.124.80 > 192.168.1.181.30732: Flags [S.], seq 144769955, ack 4101019788, win 64480, options [mss 1240], length 0
A couple of things to notice here:
- The IP addresses are different – that IPtables rule from above has rewritten them from
192.168.1.181. This rewriting is called “network address translation”, or “NAT”.
- We’re getting a bunch of replies from
example.com– it’s doing an exponential backoff where it retries after 4 seconds, then 8 seconds, then 16 seconds. This is because we didn’t finish the TCP handshake – we just sent a SYN and left it hanging! There’s actually a type of DDOS attack like this called SYN flooding, but just sending one or two SYN packets isn’t a big deal.
- I had to add
host 126.96.36.199because there are a lot of TCP packets being sent on my real wifi connection so I needed to ignore those
I’m not totally sure why we see more SYN replies on
wlp3s0 than on
guess is that it’s because we only read 1 reply in our Python program.
this is pretty easy and really reliable
The last time I tried to implement TCP in Python I did it with something called “ARP spoofing”. I won’t talk about that here (there are some posts about it on this blog back in 2013), but this way is a lot more reliable.
And ARP spoofing is kind of a sketchy thing to do on a network you don’t own.
here’s the code
I put all the code from this blog post in this gist, if you want to try it yourself, you can run
bash setup.sh # needs to run as root, has lots of `sudo` commands python3 syn.py # runs as a regular user
It only works on Linux, but I think there’s a way to set up tun/tap on Mac too.
a plug for scapy
I’ll close with a plug for scapy here: it’s a really great Python networking library for doing this kind of experimentation without writing all the code yourself.
This post is about writing all the code yourself though so I won’t say more about it than that.