In scapy there are many methods to send or receive a packet in network. We have the families of commands, below:

• Send family - Just send packets in layer 2 or 3.
• Send and Receive family - Send packets in layer 2 or 3 and print or store results.
• Sniff family - Receive packets in promisc mode and return them in a packet list.

This post is not intended as a reference for each of the families above. For more informations, execute lsc() in scapy and see Scapy doc.

You can see a sample of Sniff family in action, below (execute scapy as root):

>>> a=sniff(count=2)
>>> a
<Sniffed: UDP:2 ICMP:0 TCP:0 Other:0>
>>> a.nsummary()
0000 Ether / IP / UDP / DNS Qry "www.google.com."
0001 Ether / IP / UDP / DNS Ans "www.l.google.com."
>>> a[0].show()
###[ Ethernet ]###
dst= 00:03:99:89:83:a9
src= 00:1e:c9:1b:7b:da
type= 0x800
###[ IP ]###
version= 4L
ihl= 5L
tos= 0x0
len= 60
id= 12959
flags= DF
frag= 0L
ttl= 64
proto= udp
chksum= 0xd5af
src= 10.1.0.1
dst= 200.170.95.182
options= ''
###[ UDP ]###
sport= 54584
dport= domain
len= 40
chksum= 0x329c
###[ DNS ]###
id= 16628
qr= 0L
opcode= QUERY
aa= 0L
tc= 0L
rd= 1L
ra= 0L
z= 0L
rcode= ok
qdcount= 1
ancount= 0
nscount= 0
arcount= 0
qd
|###[ DNS Question Record ]###
|  qname= 'www.google.com.'
|  qtype= A
|  qclass= IN
an= 0
ns= 0
ar= 0
>>>

You can have many parameters in sniff() function, like a filter , timeout , an interface (iface ), and a function to apply to each packet (prn and lfilter ).

>>>  sniff(filter="udp and port 53", count=2, iface="eth0")
<Sniffed: UDP:2 ICMP:0 TCP:0 Other:0>
>>>

Sending a simple ICMP packet

>>> pkt=IP(dst="10.0.0.1")/ICMP()
>>> pkt
<IP  frag=0 proto=icmp dst=10.0.0.1 |<ICMP  |>>
>>> send(pkt,count=2)
..
Sent 2 packets.

Ok, this is a simple sample, I know, but you now can use your mind and play with Scapy.

This is a simple post, only to show the basic concepts of scapy.

What is scapy?

From Scapy:

"Scapy is a powerful interactive packet manipulation program. It is able to forge or decode packets of a wide number of protocols, send them on the wire, capture them, match requests and replies, and much more. It can easily handle most classical tasks like scanning, tracerouting, probing, unit tests, attacks or network discovery (it can replace hping, 85% of nmap, arpspoof, arp-sk, arping, tcpdump, tethereal, p0f, etc.). It also performs very well at a lot of other specific tasks that most other tools can't handle, like sending invalid frames, injecting your own 802.11 frames, combining technics (VLAN hopping+ARP cache poisoning, VOIP decoding on WEP encrypted channel, ...), etc."

What you saw in scapy?

If you, like me, needs tools to:

• Does unitary tests (ping, arp, traceroute, hping2, etc...);
• Sniffing tool for captures packets and possibly dissects them (tcpdump, ethereal, vomit, iptraf, etc...);
• Scanning a given range (nmap, amap, firewalk, etc...);
• Forges packets and sends them (packeth, packit, packet excalibur, nemesis, tcpinject, libnet, etc...), and possibly
• know the service / version of some host. (nmap, xprobe, p0f, cron-OS, queso, etc...)

Then you need know scapy.

Scapy, has the following principle: Machines are good at decoding and humans are good at interpreting:

When a nmap tool say:

Interesting ports on 10.0.0.1:
PORT   STATE    SERVICE
22/tcp filtered ssh

Is different to say: It was an ICMP host unreachable. The port is not filtered, but there is no host behing the firewall.

Okay, its show time!

Install Scapy in your Unix box. Detail in Scapy portability page.

Start scapy:

anita:~# scapy
Welcome to Scapy (v1.1.1 / -)
>>>

First steps with packet manipulation:

>>> ip=IP(ttl=10)
>>> ip
< IP ttl=10 |>
>>> ip.src
’127.0.0.1’
>>> ip.dst="192.168.1.1"
>>> ip
< IP ttl=10 dst=192.168.1.1 |>
>>> ip.src
’192.168.8.14’
>>> del(ip.ttl)
>>> ip
< IP dst=192.168.1.1 |>
>>> ip.ttl
64
>>> tcp=TCP(flags="SF")
>>> pkt=ip/tcp
>>> pkt
>
>>> pkt.command()
"IP(dst='192.168.1.1', ttl=10)/TCP(flags=3)"
>>> pkt.show()
###[ IP ]###
version= 4
ihl= 0
tos= 0x0
len= 0
id= 1
flags=
frag= 0
ttl= 10
proto= tcp
chksum= 0x0
src= 10.1.0.1
dst= 192.168.1.1
options= ''
###[ TCP ]###
sport= ftp_data
dport= www
seq= 0
ack= 0
dataofs= 0
reserved= 0
flags= FS
window= 8192
chksum= 0x0
urgptr= 0
options= {}
>>>

Some stuff you can do on a packet:

• str(pkt) to assemble the packet
• hexdump(pkt) to have an hexa dump
• ls(pkt) to have the list of fields values
• pkt.summary() for a one-line summary
• pkt.show() for a developped view of the packet
• pkt.show2() same as show but on the assembled packet (checksum is calculated, for instance)
• pkt.sprintf() fills a format string with fields values of the packet
• pkt.decode_payload_as() changes the way the payload is decoded
• pkt.psdump() draws a postscript with explained dissection
• pkt.pdfdump() draws a PDF with explained dissection
• pkt.command() return a Scapy command that can generate the packet

You can send, receive, sniffer, and more. I will try show others methods in nexts parts.

And the grand finale:

>>> pkt.pdfdump()

The output:

If I have time, I will write part 2. Bye.

"Development is really fast right now, because of the hackathon in Edmonton.

We are testing as much as we can before we commit, but as always during these hackathon processes we really depend on our user community -- to track our changes and help spot the occasional bug we accidentally introduce.

We are developing really fast and hard; please help us by testing really fast and hard too.

There are some snapshots being made, of course, but people who are familiar with checking out their own trees can really help us by buildind and running it immediately."

- Theo de Raddt, in a June 11th, 2008 message.

It is my great pleasure to announce the availability of KIDS 0.1b, an Kernel (Network) Intrusion Detection System. This project is the result of a year of research on kernel and Network IDS. The Kernel Intrusion Detection System-KIDS, is a Network IDS, where the main part, packets grab/string match, is running at kernelspace, with a hook of Netfilter Framework. This project is not ready for use. It is only a proof of concept and should not be put in an environment in production, yet.

The main goal of KIDS is to try to reduce the delay in the processing of the rules, with the elimination of two changes in context (kernel-user-user-kernel), as this task is performed in kernelspace.

The main goal of KIDS is to try to reduce the delay in the processing of the rules, with the elimination of two changes in context (kernel-user-user-kernel), as this task is performed in kernelspace.

Very thanks to Amador Pahim, my boss and Teacher Advisor.

A more detailed document for development / hacking will be drafted later.

For more information about KIDS project, please see:

http://sourceforge.net/projects/ids-kids/

Bom.. depois de mais de um mês out, voltei, espero. Ano novo, vida nova, cidade nova (estou morando agora em Sampa) e eu na luta para conseguir tempo para postar algo aqui.

Bom... eu sou fã do tal do IRC, desde de mil novecentos e bolinha, e depois que passei a usar o bitlbee, mais ainda! Para quem não conhece, trata-se de um gateway IRC para redes de instant messaging (atualmente suporta gtalk, jabber, yahoo, icq, msn, aim e skype). Se você fica conectado full time no IRC, trocando ideias com outros nerds, e não quer ter outras aplicações abertas como Gaim, Gtalk, amsn, ou qualquer outro IM, para falar com as pessoas que não usam IRC, seus problemas acabaram!! Instale hoje mesmo o bitlbee, e tenha seus contatos em uma sala IRC, normalmente, com seu client preferido. Tem até integração com o emacs!

Instalação fácil fácil (disponível no apt-get mais próximo de você), conectou, registrou, logou, tá lá.. todos os contatos, perfeito! Ou quase, por default vem sem suporte a SSL, então trate de fazer um túnel seguro (stunnel é uma boa sugestão), e seja feliz.

Adicionando ou modificando apenas um caracter, no código abaixo, faça este código imprimir exatamente 20 asteriscos:

int main()
{
        int i, n = 20;
        for (i = 0; i < n; i--)
                printf("*");
	return 0;
}

É simples, e existem algumas soluções para isto!

Abaixo um exemplo de uma mensagem de Oops:

Unable to handle kernel paging request at virtual address 00010015
 printing eip:
c01e6608
*pde = 00000000
Oops: 0000
CPU:    0
EIP:    0010:[usb_unlink_urb+8/64]    Tainted: P
EFLAGS: 00010202
eax: 00010001   ebx: d70c6494   ecx: c7c81000   edx: 00010001
esi: c7c81640   edi: d70c6400   ebp: d70c64f0   esp: d2daded0
ds: 0018   es: 0018   ss: 0018
Process kpilotDaemon (pid: 30778, stackpage=d2dad000)
Stack: d892a2ed 00010001 d70c6494 d70c6400 d3df51c0 00000000 d8924350 d70c6494
       d3df51c0 d725a000 cc5faa40 c16063c0 c018c460 d725a000 d3df51c0 d3df51c0
       cc5faa40 c16063c0 c8117e40 00000001 d3df51c0 bffff0e8 00000000 00000000
Call Trace: [] [] [release_dev+576/1280]
[n_tty_ioctl+257/1200] [tty_release+10/16]
   [fput+76/224] [filp_close+92/112] [sys_close+67/96] [system_call+51/56] 

Code: 8b 42 14 85 c0 74 21 8b 80 bc 00 00 00 85 c0 74 17 8b 40 18

Esta mensagem pode ajudar aos desenvolvedores do kernel a depurar melhor o problema, e mesmo que você não reporte o bug, você pode se utilizar de um recurso que foi desenvolvido pensando nisto: As Magic SysRq Keys.

Trata-se de uma combinação de teclas que é utilizada para comunicar-se com o kernel do Linux, caso a opção CONFIG_MAGIC_SYSRQ tiver sido habilitada durante a compilação do kernel, ou em /proc/sys/kernel/sysrq.

Basta apertar Alt+PrintScreen+Tecla e a saída (dependendo da tecla) é enviada para o dmesg. Abaixo apenas algumas teclas:

Existe a famosa combinação: Alt+PrintScreen+R E I S U B, onde basicamente mata todos os processos, sincroniza os discos, remonta todas os filesystems montados em read-only, e só então reinicia a máquina. Por tanto, antes de "meter o dedão" no botão de power, REISUB.

Click na imagem acima para ampliar.

O vimdiff, analisa a diferença entre dois ou três arquivos, dividindo a janela de edição e destacando as linhas que são diferentes entre estes arquivos. A navegação, ocorre da mesma forma quando se divide a janela de edição do vim através do comando :split, ou seja:

Ctrl-W + j = Vai para janela de baixo
Ctrl-W + k =Vai para a janela de cima
Ctrl-W + l = Vai para a janela da direita
Ctrl-W + h = Vai para a janela da esquerada

Um exemplo do comando vimdiff em execução pode ser visto aqui.