Complete Tutorial On Sniffing

This tutorial given you a complete introduction about Sniffing.Sniffers mainly developed for debugging network problems.Sniffers could capture,interpret and save packets sent across a network.This helpful for admin to later analyze captured packets and debug or troubleshoot network problems.

In market you found many type of sniffers but most used sniffer is Ethernet-based Sniffer.This Sniffer works with NIC(Network Interface Card).With Ethernet-based Sniffer NIC works in a special state called Promiscuous Mode.This mode ensure that your sniffer receives all the packets within specified range of system.

Sniffers can't catch packets traversing beyond switches and routers.

Sniffer dangerous for you,if an attacker used it against you after install on your system,your all data,password,private messages,e-mail and so on -get captured.

Protocol like FTP,POP,IMAP and HTTP are vulnerable to the sniffers.

Type of Attack:

Sniffer Attack consider as a Passive attack.A passive attack is one that doesn't directly intrude onto a foreign network or computer.

Popular Sniffer

1.Name: tcpdump

Download Here

2:Name:Ethereal

Download Here

3:Name:DSniff

Download Here

4:Name:Sniffer

Download Here

5.Name:SSLdump

Download Here

Code Your Own Sniffer In 'C'

1. //sniffer.c
2. //To compile : gcc -o sniffer sniffer.c
3. //To run : ./sniffer [interface-name]
5. #include
6. #include
7. #include
8. #include
9. #include
10. #include
11. #include
12. #include
13. #include
14. #include
16. /* default snap length (maximum bytes per packet to capture) */
17. #define SNAP_LEN 1518
19. /* ethernet headers are always exactly 14 bytes [1] */
20. #define SIZE_ETHERNET 14
22. /* Ethernet addresses are 6 bytes */
23. #define ETHER_ADDR_LEN 6
25. /* Ethernet header */
26. struct sniff_ethernet {
27. u_char ether_dhost[ETHER_ADDR_LEN]; /* destination host address */
28. u_char ether_shost[ETHER_ADDR_LEN]; /* source host address */
29. u_short ether_type; /* IP? ARP? RARP? etc */
30. };
32. /* IP header */
33. struct sniff_ip {
34. u_char ip_vhl; /* version << 4 | header length >> 2 */
35. u_char ip_tos; /* type of service */
36. u_short ip_len; /* total length */
37. u_short ip_id; /* identification */
38. u_short ip_off; /* fragment offset field */
39. #define IP_RF 0x8000 /* reserved fragment flag */
40. #define IP_DF 0x4000 /* dont fragment flag */
41. #define IP_MF 0x2000 /* more fragments flag */
42. #define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
43. u_char ip_ttl; /* time to live */
44. u_char ip_p; /* protocol */
45. u_short ip_sum; /* checksum */
46. struct in_addr ip_src,ip_dst; /* source and dest address */
47. };
48. #define IP_HL(ip) (((ip)->ip_vhl) & 0x0f)
49. #define IP_V(ip) (((ip)->ip_vhl) >> 4)
51. /* TCP header */
52. typedef u_int tcp_seq;
54. struct sniff_tcp {
55. u_short th_sport; /* source port */
56. u_short th_dport; /* destination port */
57. tcp_seq th_seq; /* sequence number */
58. tcp_seq th_ack; /* acknowledgement number */
59. u_char th_offx2; /* data offset, rsvd */
60. #define TH_OFF(th) (((th)->th_offx2 & 0xf0) >> 4)
61. u_char th_flags;
62. #define TH_FIN 0x01
63. #define TH_SYN 0x02
64. #define TH_RST 0x04
65. #define TH_PUSH 0x08
66. #define TH_ACK 0x10
67. #define TH_URG 0x20
68. #define TH_ECE 0x40
69. #define TH_CWR 0x80
70. #define TH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
71. u_short th_win; /* window */
72. u_short th_sum; /* checksum */
73. u_short th_urp; /* urgent pointer */
74. };
76. void
77. got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet);
79. void
80. print_payload(const u_char *payload, int len);
82. void
83. print_hex_ascii_line(const u_char *payload, int len, int offset);
87. /*
88. * print data in rows of 16 bytes: offset hex ascii
89. *
90. * 00000 47 45 54 20 2f 20 48 54 54 50 2f 31 2e 31 0d 0a GET / HTTP/1.1..
91. */
92. void
93. print_hex_ascii_line(const u_char *payload, int len, int offset)
94. {
96. int i;
97. int gap;
98. const u_char *ch;
100. /* offset */
101. printf("%05d ", offset);
103. /* hex */
104. ch = payload;
105. for(i = 0; i < len; i++) {
106. printf("%02x ", *ch);
107. ch++;
108. /* print extra space after 8th byte for visual aid */
109. if (i == 7)
110. printf(" ");
111. }
112. /* print space to handle line less than 8 bytes */
113. if (len < 8)
114. printf(" ");
116. /* fill hex gap with spaces if not full line */
117. if (len < 16) {
118. gap = 16 - len;
119. for (i = 0; i < gap; i++) {
120. printf(" ");
121. }
122. }
123. printf(" ");
125. /* ascii (if printable) */
126. ch = payload;
127. for(i = 0; i < len; i++) {
128. if (isprint(*ch))
129. printf("%c", *ch);
130. else
131. printf(".");
132. ch++;
133. }
135. printf("\n");
137. return;
138. }
140. /*
141. * print packet payload data (avoid printing binary data)
142. */
143. void
144. print_payload(const u_char *payload, int len)
145. {
147. int len_rem = len;
148. int line_width = 16; /* number of bytes per line */
149. int line_len;
150. int offset = 0; /* zero-based offset counter */
151. const u_char *ch = payload;
153. if (len <= 0)
154. return;
156. /* data fits on one line */
157. if (len <= line_width) {
158. print_hex_ascii_line(ch, len, offset);
159. return;
160. }
162. /* data spans multiple lines */
163. for ( ;; ) {
164. /* compute current line length */
165. line_len = line_width % len_rem;
166. /* print line */
167. print_hex_ascii_line(ch, line_len, offset);
168. /* compute total remaining */
169. len_rem = len_rem - line_len;
170. /* shift pointer to remaining bytes to print */
171. ch = ch + line_len;
172. /* add offset */
173. offset = offset + line_width;
174. /* check if we have line width chars or less */
175. if (len_rem <= line_width) {
176. /* print last line and get out */
177. print_hex_ascii_line(ch, len_rem, offset);
178. break;
179. }
180. }
182. return;
183. }
185. /*
186. * dissect/print packet
187. */
188. void
189. got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet)
190. {
192. static int count = 1; /* packet counter */
194. /* declare pointers to packet headers */
195. const struct sniff_ethernet *ethernet; /* The ethernet header [1] */
196. const struct sniff_ip *ip; /* The IP header */
197. const struct sniff_tcp *tcp; /* The TCP header */
198. const char *payload; /* Packet payload */
200. int size_ip;
201. int size_tcp;
202. int size_payload;
204. printf("\nPacket number %d:\n", count);
205. count++;
207. /* define ethernet header */
208. ethernet = (struct sniff_ethernet*)(packet);
210. /* define/compute ip header offset */
211. ip = (struct sniff_ip*)(packet + SIZE_ETHERNET);
212. size_ip = IP_HL(ip)*4;
213. if (size_ip < 20) {
214. printf(" * Invalid IP header length: %u bytes\n", size_ip);
215. return;
216. }
218. /* print source and destination IP addresses */
219. printf(" From: %s\n", inet_ntoa(ip->ip_src));
220. printf(" To: %s\n", inet_ntoa(ip->ip_dst));
222. /* determine protocol */
223. switch(ip->ip_p) {
224. case IPPROTO_TCP:
225. printf(" Protocol: TCP\n");
226. break;
227. case IPPROTO_UDP:
228. printf(" Protocol: UDP\n");
229. return;
230. case IPPROTO_ICMP:
231. printf(" Protocol: ICMP\n");
232. return;
233. case IPPROTO_IP:
234. printf(" Protocol: IP\n");
235. return;
236. default:
237. printf(" Protocol: unknown\n");
238. return;
239. }
241. /*
242. * OK, this packet is TCP.
243. */
245. /* define/compute tcp header offset */
246. tcp = (struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip);
247. size_tcp = TH_OFF(tcp)*4;
248. if (size_tcp < 20) {
249. printf(" * Invalid TCP header length: %u bytes\n", size_tcp);
250. return;
251. }
253. printf(" Src port: %d\n", ntohs(tcp->th_sport));
254. printf(" Dst port: %d\n", ntohs(tcp->th_dport));
256. /* define/compute tcp payload (segment) offset */
257. payload = (u_char *)(packet + SIZE_ETHERNET + size_ip + size_tcp);
259. /* compute tcp payload (segment) size */
260. size_payload = ntohs(ip->ip_len) - (size_ip + size_tcp);
262. /*
263. * Print payload data; it might be binary, so don't just
264. * treat it as a string.
265. */
266. if (size_payload > 0) {
267. printf(" Payload (%d bytes):\n", size_payload);
268. print_payload(payload, size_payload);
269. }
271. return;
272. }
274. int main(int argc, char **argv)
275. {
277. char *dev = NULL; /* capture device name */
278. char errbuf[PCAP_ERRBUF_SIZE]; /* error buffer */
279. pcap_t *handle; /* packet capture handle */
281. char filter_exp[] = "ip"; /* filter expression */
282. struct bpf_program fp; /* compiled filter program (expression) */
283. bpf_u_int32 mask; /* subnet mask */
284. bpf_u_int32 net; /* ip */
285. int num_packets ; /* number of packets to capture */
287. /* check for capture device name on command-line */
288. if (argc == 2) {
289. dev = argv[1];
290. }
291. else if (argc > 3) {
292. fprintf(stderr, "error: unrecognized command-line options\n\n");
293. printf("Usage: %s [interface]\n", argv[0]);
294. printf("\n");
295. printf("Options:\n");
296. printf(" interface Listen on for packets.\n");
297. printf("\n");
298. exit(EXIT_FAILURE);
299. }
300. else {
301. /* find a capture device if not specified on command-line */
302. dev = pcap_lookupdev(errbuf);
303. if (dev == NULL) {
304. fprintf(stderr, "Couldn't find default device: %s\n",
305. errbuf);
306. exit(EXIT_FAILURE);
307. }
308. }
309. printf("\nEnter no. of packets you want to capture: ");
310. scanf("%d",&num_packets);
311. printf("\nWhich kind of packets you want to capture : ");
312. scanf("%s",filter_exp);
313. /* get network number and mask associated with capture device */
314. if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {
315. fprintf(stderr, "Couldn't get netmask for device %s: %s\n",
316. dev, errbuf);
317. net = 0;
318. mask = 0;
319. }
321. /* print capture info */
322. printf("Device: %s\n", dev);
323. printf("Number of packets: %d\n", num_packets);
324. printf("Filter expression: %s\n", filter_exp);
326. /* open capture device */
327. handle = pcap_open_live(dev, SNAP_LEN, 1, 1000, errbuf);
328. if (handle == NULL) {
329. fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);
330. exit(EXIT_FAILURE);
331. }
333. /* make sure we're capturing on an Ethernet device [2] */
334. if (pcap_datalink(handle) != DLT_EN10MB) {
335. fprintf(stderr, "%s is not an Ethernet\n", dev);
336. exit(EXIT_FAILURE);
337. }
339. /* compile the filter expression */
340. if (pcap_compile(handle, &fp, filter_exp, 0, net) == -1) {
341. fprintf(stderr, "Couldn't parse filter %s: %s\n",
342. filter_exp, pcap_geterr(handle));
343. exit(EXIT_FAILURE);
344. }
346. /* apply the compiled filter */
347. if (pcap_setfilter(handle, &fp) == -1) {
348. fprintf(stderr, "Couldn't install filter %s: %s\n",
349. filter_exp, pcap_geterr(handle));
350. exit(EXIT_FAILURE);
351. }
353. /* now we can set our callback function */
354. pcap_loop(handle, num_packets, got_packet, NULL);
356. /* cleanup */
357. pcap_freecode(&fp);
358. pcap_close(handle);
360. printf("\nCapture complete.\n");
361. return 0;

362 }

(My Thanks to Varun Gupta for save my time)

Making Sniffer Hard To Detect:

There is a method to help make it more difficult to detect a sniffer on a network. For this to work, you have to deploy two NICs in on computer. For the first NIC, configure the interface with the address of 0.0.0.0. This will allow the sniffer to monitor traffic but to not be detected. But there is still the issue of messages and alerts which will be handed off from the card the sniffer is on to another card to finish being delivered. The second card has a regular address but is not in promiscuous mode so it will be very hard for someone to detect this type of setup.

Save Yourself:

Kitty Litter The Anti-Sniffer is a handy application that can prevent hackers from capturing logins and passwords and viewing traffic on your wireless network by spamming thousands of false-leads per second that are unidentifiable from your regular browsing habits.

Free Download Here

I am Spend 2 hr for this complete article,you spend only 1 Minute for your good Comment.

Read more..

Backtrack 5 Wireless Penetration Testing by Vivek Ramachandran

BackTrack 5 Wireless Penetration Testing: Beginner's Guide is aimed at helping the

reader understand the insecurities associated with wireless networks, and how to conduct

penetration tests to find and plug them. This is an essential read for those who would like

to conduct security audits on wireless networks and always wanted a step-by-step

practical guide for the same. As every wireless attack explained in this book is

immediately followed by a practical demo, the learning is very complete.

About the Author:

Vivek Ramachandran has been working on Wi-Fi Security since 2003. He discovered

the Caffe Latte attack and also broke WEP Cloaking, a WEP protection schema publicly

in 2007 at Defcon. In 2011, Vivek was the first to demonstrate how malware could use

Wi-Fi to create backdoors, worms, and even botnets.

Earlier, he was one of the programmers of the 802.1x protocol and Port Security in

Cisco's 6500 Catalyst series of switches and was also one of the winners of the Microsoft

Security Shootout contest held in India among a reported 65,000 participants.

You Can Purchase this book from:

Global:http://www.amazon.com/gp/product/1849515581?tag=apture-20

India:http://www.packtpub.com/backtrack-5-wireless-penetration-testing-beginners-guide/book

Sample of Book Download here:

http://www.packtpub.com/sites/default/files/5580OS-Chapter-6-Attacking-the-Client_0.pdf

Read more..

Make Private Folder And Save Your Data

Today post tell you how you make a private folder and save your information by other person.

By making Private Folder nobody can open,delete,rename and see properties of folder.

For make private folder go to desktop and make new folder with any name but mind your folder name in my case i am make a hrde name folder.

Go to run and type cmd or open command prompt.

Here write cd desktop like below picture...

After it write Cacls hrde /E /P everyone:n like given below...

Here we use 'n' for locked folder. When you click on folder then a message come like below...

For open folder go to cmd and type Cacls hrde /E /P everyone:f

And your folder open.

Enjoy it!!!

Read more..

USBCrypt for Windows 7,Vista,XP,2000

USBCrypt is a powerful software tool who encrypt and protect your important information from unauthorized access.

It stop the bad guys or hacker,and protect your personal,business and financial data.

I am use it to encrypt our USB and other removable and fixed drives with strong encryption security.USBCrypt uses the industry standard AES encryption algorithm to protect your files.

With USBCrypt,you can create a Virtual Encrypted Disk Backup your files directly to the encrypted storage area,No any one extract your backup without password.

For Download USBCrypt Click Here

Plz do not forget given your reply.

Read more..

Protect Your Computer From The Attacking Live CD

Today post about your System Security,here i am tell you how you secure your system login password by crack.

Many hacker use the Live CDs for crack the password of Windows OS.

If you do some change on your system BIOS,then you enhance the security of the PC.

If you should change boot sequence in the BIOS so when your computer start boot then it boot from Hard Disk in place of CDs.

This will protect you from live attacking CDs.

For go to change the boot sequence,first open your system power button when system start boot then press Delete or F2 Key then you see a BIOS window.

Click on boot option like given below...

And change the settings.

Read more..

Hook Analyser Malware Tool Released

Hook analyser is a hook tool which can be potentially helpful in reversing applications and analysing malware. It can hook to an API in a process and search for a pattern in memory or dump the buffer. The tool can hook to an API in a process and can do following tasks.

• 1. Hook to API in a process
• 2. Hook to API and search for pattern in memory of a process
• 3. Hook to API and dump buffer (memory).

Download Here

Source:Thehackernews

Read more..

Encrypt Your Messages And Secure Your Email

Blender xxTea edition

You can use for encrypting your messages and any other information is Blender.You can download Blender at...

handheld.softpedia.com

With Blender,all you need to do is store your messages like you normally do.

Send this encrypted data over email or send it as a file or your recipient as a message who can decrypt it using Blender so that only the two of you can understand the message.

Read more..

Hack and Shutdown Other Person System Who Online On Your Wi-Fi Network

Today,i am going to tell you how you shutdown a system on your wi-fi network by your own system.Many hacker already post it but his work incomplete and his trick does not work for you.I am a network engg. so i am capable to write about it.

I am inform you that this post copyright to hrde and hackarde blog so if you post this thread on another place then given credit to hrde and also paste link of this page,Thanx!

First u know that if you find IP address in range of

172.16.0.0 to 172.31.255.255

and

192.168.0.0 to 192.168.255.255

it's come into Private IP address.

When you use school Wi-fi and broadband than always you connected with private IP address to public IP address.

Here i am suggest a tool which help you for trace a IP address which present in your private IP address area,Name of tool 'Advance Ip Scanner' which help you for tracing the IP.You download it with help of Google Uncle. A view of AIS given below...

You trace a IP and go to CMD and type...

Shutdown -i

Window pop-up you enter choose IP and press OK,like given below...

But it not work for u?

Because You do not directly connected with another Private IP address becoz here Puble IP work as a server. when you doing upper write activities you find a message say path not specified, so first work here specified a path. How?

If u directly connected with Victim IP then your path specified,i think you know what i am say,for directly connection to Victim IP you send a long file via chating look below..

you chat with victim <---> server <----> Victim chat with u

Server work between both and hide your IP with another person.when you send a long file to victim then server remove between both becoz server want remove his load than your IP directly connected with Victim.

you chat with victim <------> Victim chat with u

Here use Advance IP Scanner,it tell you victim IP with Victim System name(u also use it on public IP address),that means you directly connected.

Go to CMD type

shutdown -i

In pop-up type private IP address or name of computer(which shown on ADVANCE IP Scanner) click OK,your Victim system shutdown after your set time,again run Advance IP Scanner you see your Victim Private IP address out of list.

It's very difficult to check Public IP address by Advance Scanner becoz when one IP remove then simultanously it go to another System by DHCP.But this problem never come into Wi-Fi,so you see a live example on your private network.

So i think after it how to connect with victim ip address,for find victim IP address use my post...

http://hackarde.blogspot.com/2011/08/hack-and-find-ip-address-of-chat-buddy.html

why i am suggest you use Advance IP Scanner ?

Some time AIS already trace a Private IP which connected with you then you go to cmd and shutdown the computer.

4 month before i am also suffer with this problem,i am read many tutorial of other hacker on his website but i do not found solution but one night i am success full when i am shutdown 3 System 9 times on my hostel wi-fi network and last user go to sleep mode when many times his system shutdown.

I am always share my knowledge with other person.

If you like it,plz reply back.

Read more..

Set your play video as Desktop wallpaper

Hi guys,i am again come for u with new trick.Today i am gonna tell you how we set a play video as desktop wallpaper.

Please post your good comment below if u like it.

Necessary Tool:: Only VLC Media Player.

Here i am tell you two different method by which you set your video as wallpaper in desktop because with different version of Media Player different trick work.

So ready guys,let's go...

Method 1: Run VLC,go to settings>>preferences>>Interface>>Main Interface, then click on

wxWidgets.remove

then tick the Taskbar and Systray icon.

Go to Video option on VLC>>Output Modules>>DirectX. When you done it then a Advance option come check it.You also see a option 'Enable Wallpaper Mode' check it.

Make a Playlist and click on 'Repeat current item' and save.

Close VLC and again play it.Right click on play video then a option come 'Wallpaper' click on it and look you desktop Screen .

It look like my desktop Screen which shown below...

Method 2: If above write Method and option not work on your VLC then do not fear because 'hrde' hear.

Go to Tool on VLC>>Preferences>>a window pop up>>click on Video>>in right side See DirectX

in under it click on 'Wallpaper Mode' and save it.

Go to Video option on VLC click on it,you see a option "Direct3D desktop Mode" click on it and watch desktop.

Enjoy!!!

Plz do not forget given your comment.

Read more..