Pastable version of Sniffer base

<div style="overflow:auto;border:solid 1px #ccc;background:#000;color:#F8F8F8">
 <div class="section">
 
 <pre style="float:left;margin:0 10px;border-right:0;color:#666;">1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235</pre>
 <pre class="sunburst">/*
 * Sniffer base
 * by Gnix &lt;gnixmail@gmail.com&gt;
 * http://gnix.netsons.org
 */

#include &lt;stdio.h&gt; // Standard I/O
#include &lt;stdlib.h&gt; // Standard Library
#include &lt;string.h&gt; // String functions
#include &lt;unistd.h&gt; // Standard Unix
#include &lt;errno.h&gt; // Gestione errori
#include &lt;net/if.h&gt; // Contiene la struttura ifreq e la costante simbolica IF_NAMESIZE
#include &lt;sys/ioctl.h&gt; // ioctl
#include &lt;sys/socket.h&gt; // Socket functions
#include &lt;linux/if_packet.h&gt; // Contiene la struttura sockaddr_ll
#include &lt;linux/if_ether.h&gt; // Contiene la costante simbolica ETH_P_IP
#include &lt;linux/ip.h&gt; // Contiene la struttura iphdr
#include &lt;linux/tcp.h&gt; // Contiene la struttura tcphdr
#include &lt;linux/udp.h&gt; // Contiene la struttura udphdr
#include &lt;netinet/in.h&gt; // Contiene la costante simbolica IPPROTO_TCP
#define STAT(x) ((x)) ? 1 : 0
#define BUFFER_SIZE 2048

// Crea un raw socket
int raw_socket(int protocol)
{
 int rawsock;

if((rawsock = socket(PF_PACKET, SOCK_RAW, htons(protocol)))== -1) {
 perror(&quot;Error creating raw socket: &quot;);
 exit(-1);
 }

return rawsock;
}

// Collega il raw socket a una data interfaccia. L'interfaccia e' gestita
// come un semplice numero dal Kernel. Questo numero viene ricavato con la
// chiamata a ioctl.
int raw_bind(char *device, int rawsock, int protocol)
{
 struct sockaddr_ll sll;
 struct ifreq ifr;

bzero(&amp;sll, sizeof(sll));
 bzero(&amp;ifr, sizeof(ifr));

// Ricava l'interface index
 strncpy((char *)ifr.ifr_name, device, IFNAMSIZ);
 if((ioctl(rawsock, SIOCGIFINDEX, &amp;ifr)) == -1) {
 printf(&quot;Error getting Interface index !\n&quot;);
 exit(-1);
 }

// Popola struttura sll e fai bind
 sll.sll_family = AF_PACKET;
 sll.sll_ifindex = ifr.ifr_ifindex;
 sll.sll_protocol = htons(protocol);

if((bind(rawsock, (struct sockaddr *)&amp;sll, sizeof(sll)))== -1) {
 perror(&quot;Error binding raw socket to interface\n&quot;);
 exit(-1);
 }

return 0;
}

// Stampa in esadecimale
void printHex(char *mesg, unsigned char *p, int len)
{
 printf(&quot;%s&quot;, mesg);

while(len--) {
 printf(&quot;%.2X &quot;, *p);
 p++;
 }

printf(&quot;\n&quot;);
}

// Stampa il pachetto
void printPacket(unsigned char *packet, int len)
{
 // Variabili
 struct ethhdr *ethernet_header;
 struct iphdr *ip_header;
 struct tcphdr *tcp_header;
 struct udphdr *udp_header;
 unsigned char *data;
 int data_len = 0;

// Stampa messaggio iniziale
 printf(&quot;\n\n################[ Packet Starts ]################&quot;);

// Controlla che la dimensione del pacchetto sia maggiore degli header ethernet e ip sommati.
 if(len &gt;= (sizeof(struct ethhdr) + sizeof(struct iphdr))) {

// Casting in ethhdr
 ethernet_header = (struct ethhdr*)packet;

// Stampa header ethernet
 printf(&quot;\n----- Ethernet Header -----\n&quot;);
 printHex(&quot;ETH: Dest MAC : &quot;, ethernet_header-&gt;h_dest, 6);
 printHex(&quot;ETH: Source MAC : &quot;, ethernet_header-&gt;h_source, 6);
 printHex(&quot;ETH: Protocol : &quot;, (void*)&amp;ethernet_header-&gt;h_proto, 2);

// Controlla che il protocollo sia IP
 if(ntohs(ethernet_header-&gt;h_proto) == ETH_P_IP) {

// Casting in iphdr
 ip_header = (struct iphdr*)(packet + sizeof(struct ethhdr));

printf(&quot;\n----- IP Header -----\n&quot;);
 printf(&quot;IP: Header length : %d bytes\n&quot;, ip_header-&gt;ihl*4);
 printf(&quot;IP: Version : %d \n&quot;, ip_header-&gt;version);
 printf(&quot;IP: Type of Service : %d \n&quot;, ip_header-&gt;tos);
 printf(&quot;IP: Total length : %d \n&quot;, ntohs(ip_header-&gt;tot_len));
 printf(&quot;IP: Identification : %d \n&quot;, ntohs(ip_header-&gt;id));
 printf(&quot;IP: Flags : %.2x\n&quot;, (unsigned char)((ip_header-&gt;frag_off)&gt;&gt;12));
 printf(&quot;IP: Fragment offset : %d \n&quot;, ntohs(ip_header-&gt;frag_off) &amp; 0x0FFF);
 printf(&quot;IP: Time to live : %d \n&quot;, ip_header-&gt;ttl);
 printf(&quot;IP: Protocol : %d \n&quot;, ip_header-&gt;protocol);
 printf(&quot;IP: Header checksum : %d \n&quot;, ntohs(ip_header-&gt;check));
 printf(&quot;IP: Source IP Address: %s \n&quot;, inet_ntoa(ip_header-&gt;saddr));
 printf(&quot;IP: Dest IP Address : %s \n&quot;, inet_ntoa(ip_header-&gt;daddr));

// Controlla che il protocollo sia tcp e che la dimensione del pacchetto sia almeno la somma di header eth,ip e tcp
 if((ip_header-&gt;protocol == IPPROTO_TCP) &amp;&amp; (len &gt;= (sizeof(struct ethhdr) + sizeof(struct iphdr) + sizeof(struct tcphdr)))) {

// Casting in tcphdr
 tcp_header = (struct tcphdr*)(packet + sizeof(struct ethhdr) + ip_header-&gt;ihl*4);

printf(&quot;\n----- TCP Header -----\n&quot;);
 printf(&quot;TCP: Source port : %d\n&quot;, ntohs(tcp_header-&gt;source));
 printf(&quot;TCP: Dest port : %d\n&quot;, ntohs(tcp_header-&gt;dest));
 printf(&quot;TCP: Sequence number : %u\n&quot;, ntohl(tcp_header-&gt;seq));
 printf(&quot;TCP: Acknowledgment number: %u\n&quot;, ntohl(tcp_header-&gt;ack_seq));
 printf(&quot;TCP: Reserved : %d\n&quot;, tcp_header-&gt;res1);
 printf(&quot;TCP: Data offset : %d\n&quot;, tcp_header-&gt;doff*4);
 printf(&quot;TCP: Flags\n&quot;);
 printf(&quot;TCP: FIN : %d\n&quot;, STAT(tcp_header-&gt;fin));
 printf(&quot;TCP: SYN : %d\n&quot;, STAT(tcp_header-&gt;syn));
 printf(&quot;TCP: RST : %d\n&quot;, STAT(tcp_header-&gt;rst));
 printf(&quot;TCP: PSH : %d\n&quot;, STAT(tcp_header-&gt;psh));
 printf(&quot;TCP: ACK : %d\n&quot;, STAT(tcp_header-&gt;ack));
 printf(&quot;TCP: URG : %d\n&quot;, STAT(tcp_header-&gt;urg));
 printf(&quot;TCP: ECE : %d\n&quot;, STAT(tcp_header-&gt;ece));
 printf(&quot;TCP: CWR : %d\n&quot;, STAT(tcp_header-&gt;cwr));
 printf(&quot;TCP: Window : %d\n&quot;, ntohs(tcp_header-&gt;window));
 printf(&quot;TCP: Checksum : %d\n&quot;, ntohs(tcp_header-&gt;check));

// Ricava posizione dei dati e stampa
 data = (packet + sizeof(struct ethhdr) + ip_header-&gt;ihl*4 + sizeof(struct tcphdr));
 data_len = ntohs(ip_header-&gt;tot_len) - ip_header-&gt;ihl*4 - sizeof(struct tcphdr);
 printHex(&quot;DATA: &quot;, data, data_len);
 }
 // Controlla che il protocollo sia udp e che la dimensione del pacchetto sia almeno la somma di header eth, ip e udp
 else if((ip_header-&gt;protocol == IPPROTO_UDP) &amp;&amp; (len &gt;= (sizeof(struct ethhdr) + sizeof(struct iphdr) + sizeof(struct udphdr)))) {

// Casting in udphdr
 udp_header = (struct udphdr*)(packet + sizeof(struct ethhdr) + ip_header-&gt;ihl*4);

// Ricava posizione dei dati e stampa
 data = (packet + sizeof(struct ethhdr) + ip_header-&gt;ihl*4 + sizeof(struct udphdr));
 data_len = ntohs(ip_header-&gt;tot_len) - ip_header-&gt;ihl*4 - sizeof(struct udphdr);
 printHex(&quot;DATA: &quot;, data, data_len);
 }
 else {
 printf(&quot;Not a TCP or UDP packet.\n&quot;);

}
 }
 }
 else {
 printf(&quot;Packet size too small!\n&quot;);
 }

// Stampa messaggio finale
 printf(&quot;################[ Packet Ends ]################\n\n&quot;);

}

// Programma principale
int main(int argc, char **argv)
{
 // Variabili
 int raw; // raw socket descriptor
 unsigned char buffer[BUFFER_SIZE]; // buffer per i dati
 int len; // lunghezza buffer di dati ricevuto
 int n_packets; // numero pacchetti da sniffare
 struct sockaddr_ll info; // struttura utilizzata in recvfrom
 int info_size = sizeof(info); // dimensione struttura sockaddr_ll

// crea raw socket
 raw = raw_socket(ETH_P_IP);

// Bind socket all'interface
 raw_bind(argv[1], raw, ETH_P_IP);

// Numero pacchetti da sniffare
 n_packets = atoi(argv[2]);

// Inizia sniffing
 while(n_packets--) {
 if((len = recvfrom(raw, buffer, BUFFER_SIZE, 0, (struct sockaddr*)&amp;info, &amp;info_size)) == -1) {
 perror(&quot;Recv from returned -1: &quot;);
 exit(-1);
 }
 else {
 // Pacchetto ricevuto.
 printPacket(buffer, len);
 }
 }

return 0;
}
</pre>
 </div>
 </div>

Refactor :my => 'code'

Recent

Popular

Pastable version of Sniffer base