ArkAngel wins the Atrovate AI & Computer Vision Hackathon 2018

I’m grateful and excited that our team is one of the three winners of the Atrovate Artificial Intelligence and Computer Vision Hackathon 2018.

We developed a system that performs real-time detection of violence, nudity, drugs and gambling occurring in a video stream.

In the screenshot, me playing around with our app: it uses the laptop webcam as input video stream and blurs it when something bad is detected. ūüôā

Thank you Intel Movidius for the prize.

Augmented Learning: boosting your brain

Being able to study and learn effectively is an important skill for whoever works in an ever-improving field like the computer science is. There’s always something new to learn that can improve your skills.

So why not leveraging modern tools and technologies to boost your learning and long-term memory effectiveness?

These are tools I found useful.

1) Writing my own private wiki

I feel that writing in my own words all the things I learn really helps me understand clearly the concepts. You can never say you grasped a concept until you can explain it in your own words.
Indeed I think that when you strive to express the concept with your own words, what you are actually doing is organizing your own mental model. It works great.

While it’s a time-consuming job, maintaining my wiki is something I found very amusing and being the wiki private I could use all the material (images, videos, etc.) I found useful without any copyright problems.

When you will read again your own explanations in a couple of years you will find it a lot easier to re-learn the concepts and — last but not least — maintaining your own wiki can help you improve your own writing and expressiveness skills. It seems that your writing skills reflect on your programming skills.

2) Spaced repetition

The spaced repetition technique consists in using flashcards and a spaced repetition tool (I use Anki.)

The technique leverages the spacing effect to your advantage.

[From Wikipedia] The spacing effect is the phenomenon whereby animals (including humans) more easily remember or learn items when they are studied a few times spaced over a long time span (“spaced presentation”) rather than repeatedly studied in a short span of time (“massed presentation”).

So what you do is:

[From Wikipedia] incorporating increasing intervals of time between subsequent review of previously learned material in order to exploit the psychological spacing effect.

I found the spaced repetition technique to be very effective: it just requires you about half an hour of your time each day (your mileage may vary depending on the number of flashcards) and if you keep practicing it every day you can really store a lot of data into your long-term memory. ūüėČ

On the other hand not every piece of information is suitable for a flashcard and learning how to write effective flashcards can require a lot of practice! So I write flashcards only for the concepts that easily fit it.

 

3) Mind maps

Mind maps are diagrams that you use to visually organize information. You can get an idea about them by looking at some examples.

When you are studying you don’t have to express everything you learn in the mind map: just express the correlations among the various concepts.
After that, you can use the mind map to help you repeat all you have learned and to be sure you don’t forget any important part. After a while you won’t need the mind map anymore as you will remember all the relations. Here your eidetic memory¬†may help.

There are various tools you can use to create your own mind maps.

Please share any suggestion or tool you found useful to enhance your learning and brain effectiveness. I will keep this page updated.

Best ways to learn a foreign language

Being a person who gets bored quite easily I always looked for the most interactive, engaging, entertaining ways to learn something.

When it comes to learning a foreign language, I always started yawning after a few pages of any book or on-line course. Not a fault of their authors of course, indeed their texts were really good and well-thought: nice and clear explanations with lots of examples.
What bores me is the lack of engagement of my senses. Probably modern era technology-pervaded world has raised our bar for attention. Or probably it is just me :-). Anyway I wrote down this list of the ways I found most entertaining (and efficient) to study a foreign language.

Duolingo
Duolingo is fun and easy. The process of learning is turned in a game, with dictation, translation and reading exercises. It is good for both beginner and more advanced users.
It uses spaced-repetition, a learning technique that increases memorization efficiency by repeating words at the right intervals of time.
In addition, immersion provides real-world texts to translate in a cooperative manner.
At the moment it supports Spanish, German, French, Portuguese, Italian and English.
Try Duolingo

Anki
Anki is an open-source spaced-repetition software based on flashcards. As the site says, it “makes remembering things easy” and “because it’s a lot more efficient than traditional study methods, you can either greatly decrease your time spent studying, or greatly increase the amount you learn”.
It is to be used with other learning tools. While you are studying the language, create your own deck of flashcards, the way you prefer. Or just use one of the many decks shared by others. I suggest making your own customized deck. I also suggest to give context to the words by adding example phrases. You can read this nice article by Benny Lewis about it.
Try Anki

Dictation
To be able to understand the spoken language and write it down correctly is a very important skill to learn. Not for nothing we were used to do a lot of dictation exercises in our primary schools.
There are various sites to exercise your comprehension of the spoken language with dictations. Some I used for English were Listen and writeEnglish club dictation and Dictations online.

Audio-books with text
There’s nothing better than a nice voice telling you a good fable or reading you a good book. Fortunately on-line there are many audio-books with both audio and text to follow.
One good site to find audio-books is Books should be free. There you will find books in almost 30 different languages.
Let’s say, for example, you’d like to hear the fable of Pinocchio, in English. Just open the text and press ‘play’. Enjoy!

Talking with natives and non-natives
One of the best ways to improve your expressing skills is to talk with natives. But also exercising with other students like you is very useful. Fortunately you don’t need to go abroad to find someone to talk with. You may find local speakers or you can join Shared Talk, enter the voice chat and pick a partner to talk to.

Movies and series with subtitles
Another way to have a good time and improve your skills at the same time is watching your preferred movies, series and TV-shows using the language you want to learn both for audio and subtitles. Fun and usefulness combined.

I hope you will find this list useful.
Please let me know the way you prefer to study foreign languages.
You can find further suggestions in both the comments of this post and the Hacker News thread here.

A scopa game in Common Lisp

This is a scopa game for 2 players, human vs pc, written in Common Lisp mostly for fun, and to put in practice what I learned about CL so far.

This is my first ‚Äúreal program‚ÄĚ (if it can be called so) in Common Lisp, so just don‚Äôt expect it to be well-designed. Comments are very welcome.. and don‚Äôt strive to be polite about it. ūüôā

Source code

Use (play) to play.

Example session at the REPL of GNU CLISP:
I lost against the PC :/

[1]> (load "scopa.clisp")
;; Loading file scopa.clisp ...
;; Loaded file scopa.clisp
T
[2]> (play)

On the table:    [7 OF COPPE],   [6 OF DENARI],   [2 OF DENARI],    [8 OF COPPE]
Your hand:     [5 OF BASTONI],  [9 OF BASTONI],  [2 OF BASTONI]
Stock: 30 cards.

It's PC turn.

Player PC plays [7 OF SPADE] taking [7 OF COPPE]

On the table:   [6 OF DENARI],   [2 OF DENARI],    [8 OF COPPE]
Your hand:     [5 OF BASTONI],  [9 OF BASTONI],  [2 OF BASTONI]
Stock: 30 cards.

It's HUMAN turn.

1) Play [2 OF BASTONI] taking [2 OF DENARI]
2) Play [5 OF BASTONI]
3) Play [9 OF BASTONI]
What do you want to do?
1
Player HUMAN plays [2 OF BASTONI] taking [2 OF DENARI]

On the table:   [6 OF DENARI],    [8 OF COPPE]
Your hand:     [5 OF BASTONI],  [9 OF BASTONI]
Stock: 30 cards.

It's PC turn.

Player PC plays [10 OF COPPE]

On the table:   [6 OF DENARI],    [8 OF COPPE],   [10 OF COPPE]
Your hand:     [5 OF BASTONI],  [9 OF BASTONI]
Stock: 30 cards.

It's HUMAN turn.

1) Play [5 OF BASTONI]
2) Play [9 OF BASTONI]
What do you want to do?
2
Player HUMAN plays [9 OF BASTONI]

...
...

It's PC turn.

Player PC plays [4 OF DENARI]

On the table:    [8 OF SPADE],   [4 OF DENARI]
Your hand:       [2 OF COPPE]
Stock: 0 cards.

It's HUMAN turn.

1) Play [2 OF COPPE]
What do you want to do?
1
Player HUMAN plays [2 OF COPPE]
Player HUMAN collect all the remaining cards on the table.

SCORE ASSIGNMENTS
Greatest number of cards: PC
Greatest number of denari cards: PC
Settebello: PC
Prime: PC
HUMAN
0 + 0 + 0 scopas = 0
-------
PC
0 + 4 + 0 scopas = 4

On the table:    [5 OF SPADE],   [6 OF DENARI],  [3 OF BASTONI],    [3 OF SPADE]
Your hand:     [5 OF BASTONI],    [7 OF SPADE],   [10 OF SPADE]
Stock: 30 cards.

It's HUMAN turn.

1) Play [5 OF BASTONI] taking [5 OF SPADE]
2) Play [10 OF SPADE]
3) Play [7 OF SPADE]
What do you want to do?
1
Player HUMAN plays [5 OF BASTONI] taking [5 OF SPADE]

...
...

It's PC turn.

Player PC plays [5 OF DENARI]
Player PC collect all the remaining cards on the table.

SCORE ASSIGNMENTS
Greatest number of cards: PC
Greatest number of denari cards: PC
Settebello: HUMAN
Prime: PC
HUMAN
0 + 1 + 0 scopas = 1
-------
PC
4 + 3 + 2 scopas = 9

On the table:   [4 OF DENARI],    [5 OF SPADE],   [9 OF DENARI],   [10 OF SPADE]
Your hand:     [7 OF BASTONI],    [8 OF SPADE],   [1 OF DENARI]
Stock: 30 cards.

It's HUMAN turn.

1) Play [8 OF SPADE]
2) Play [1 OF DENARI]
3) Play [7 OF BASTONI]
What do you want to do?
1
Player HUMAN plays [8 OF SPADE]

...
...

It's PC turn.

Player PC plays [6 OF SPADE] taking [2 OF SPADE], [4 OF BASTONI]
Player PC collect all the remaining cards on the table.

SCORE ASSIGNMENTS
Greatest number of cards: PC
Greatest number of denari cards: PC
Settebello: PC
Prime: HUMAN
HUMAN
1 + 1 + 1 scopa = 3
-------
PC
9 + 3 + 2 scopas = 14
The game is over!
The winner is PC with a score of 14!
NIL
[3]>

Entire session.

Lesson learned: never modify literals, quote lists only for constant data

While writing a scopa card game in Common Lisp both as a pet project and a way to practice a little lisp, I had a hard time trying to understand what was going on here:

1
2
3
4
5
6
7
8
9
10
11
(defun prime-points-of-card (card)
  (let ((prime-points '((7 21) (6 18) (1 16) (5 15) (4 14) (3 13) (2 12) (10 10) (9 10) (8 10))))
    (cadr (assoc (card-rank card) prime-points))))
 
(defun prime-points (deck)
  (let ((scores '((denari 0) (coppe 0) (bastoni 0) (spade 0))))
    (loop for card across deck do
         (let ((suit (card-suit card)))
           (setf (cadr (assoc suit scores)) (max (cadr (assoc suit scores))
                                                 (prime-points-of-card card)))))
    (apply #'+ (mapcar #'cadr scores))))

I was expecting prime-points to return the prime points of a sequence of cards, but it kept returning what seemed to me just meaningless numbers.

I added a couple of prints to inspect what was going on:
(yeah I still need to learn how to debug effectively with lisp)

(defun prime-points (deck)
  (let ((scores '((denari 0) (coppe 0) (bastoni 0) (spade 0))))
    (print scores)
    (loop for card across deck do
         (let ((suit (card-suit card)))
           (setf (cadr (assoc suit scores)) (max (cadr (assoc suit scores))
                                                 (prime-points-of-card card)))))
    (print scores)
    (apply #'+ (mapcar #'cadr scores))))

and this is what I found:

[3]> (prime-points #())
 
((DENARI 0) (COPPE 0) (BASTONI 0) (SPADE 0))
((DENARI 0) (COPPE 0) (BASTONI 0) (SPADE 0))
0
[4]> (prime-points #())
 
((DENARI 0) (COPPE 0) (BASTONI 0) (SPADE 0))
((DENARI 0) (COPPE 0) (BASTONI 0) (SPADE 0))
0
[5]> (prime-points (deck 'stock))
 
((DENARI 0) (COPPE 0) (BASTONI 0) (SPADE 0))
((DENARI 21) (COPPE 21) (BASTONI 21) (SPADE 21))
84
[6]> (prime-points #())
 
((DENARI 21) (COPPE 21) (BASTONI 21) (SPADE 21))
((DENARI 21) (COPPE 21) (BASTONI 21) (SPADE 21))
84

scores was keeping its value at each call to prime-points!
Wasn’t let supposed to create a new lexical scope?
Yes, it is and in fact it is what let does.
The problem is to understand that

(quote (foo bar baz))

and its shortcut

'(foo bar baz)

are just list literals the same way as

#(1 2 3) ; Literal array
"literal string"

This means that

(quote (foo bar baz))

is not equivalent to

(list 'foo 'bar 'baz)

In the first case, the list is literal, in the second it is generated by code.
When the list is literal, the compiler could copy it into write-protected memory or share it among more functions (or more calls to the same function) hence the consequences are undefined if it is modified.

As HyperSpec’s QUOTE page states:

Special Operator QUOTE

Syntax:
quote object => object

Arguments and Values:
object‚ÄĒan object; not evaluated.

Description:
The quote special operator just returns object.

The consequences are undefined if literal objects (including quoted objects) are destructively modified.

Ok. This may seem trivial for anybody else, but it was not for me.

This is the same thing that happens in other languages.

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
#include <stdio.h>
 
void foo() {
  char string[] = "Fresh new at every call";
 
  printf("%s\n", string);
  string[0]++;
  printf("%s\n", string);
}
 
void bar() {
  char* string = "I could be in read-only memory";
 
  printf("%s\n", string);
  string[0]++; // Possible segmentation fault
  printf("%s\n", string);
}
 
int main(int argc, char **argv) {
  foo();
  foo();
  foo();
 
  bar();
  bar();
  bar();
 
  return 0;
}

This is what happens with gcc:

dom@dom-laptop:~/Progetti/c$ gcc -o test test.c && ./test
Fresh new at every call
Gresh new at every call
Fresh new at every call
Gresh new at every call
Fresh new at every call
Gresh new at every call
I could be in read-only memory
Errore di segmentazione
dom@dom-laptop:~/Progetti/c$

So if you need to define a data structure the way I did, use list or just copy-tree the literal data:

(defun prime-points (deck)
  (let ((scores (copy-tree '((denari 0) (coppe 0) (bastoni 0) (spade 0)))))
    (loop for card across deck do
         (let ((suit (card-suit card)))
           (setf (cadr (assoc suit scores)) (max (cadr (assoc suit scores))
                                                 (prime-points-of-card card)))))
    (apply #'+ (mapcar #'cadr scores))))

I need to thank people at comp.lang.lisp for always being friendly and very didactic to lurk at.

Programmare con le Raw Socket

When I was 16, I used to write articles under the nicknames Esorcista and XpTerminator.

The following is an article I translated from English to Italian, that got published on the 7th issue of OndaQuadra, an Italian e-zine.

 

+--------------------------------------------------------------------------+
| ONDAQUADRA ~ [MiSC]                                     #06 - 25/04/2002 |
| PR0GRAMMARE LE REW S0CKET (TRADUZi0NE)          [XpTerminator] 0x11/0x1D |
+--------------------------------------------------------------------------+
|                                                                          |
|                       -==============================-                   |
|                        | Programmare le raw socket  |                    |
|                        |                   Nitr0gen |                    |
|                       =/____________________________\=                   |
|                       | traduzione  by  XpTerminator |                   |
|                       -==============================-                   |
|                                                                          |
| Premetto innanzi tutto  che questo testo  non e` di  mia fattura, io  ho |
| effettuato la traduzione   dalla lingua  inglese  e  delle modifiche  ed |
| aggiunte  per  rendere il   testo  pi√Ļ chiaro;   visto   che in   lingua |
| italiana    non  si   trovano  documenti   del   genere,    ed  essendo  |
| interessante,  ho   ritenuto   utile  effettuarne  la traduzione.        |
|                                                                          |
|                         Exile 2000 International Coding Team             |
|                              (http://www.exile2k.org)                    |
|                    Documentation about native raw socket programming     |
|                            All rights reserved Exile Team                |
|                                                                          |
|                 Free to distribute this text just keep it's integrity    |
|                            Ripping is lame remember this                 |
|                                                                          |
|                                                                          |
|         Per domande e commenti:  (in english! ;)                         |
|                                                                          |
|                                     Nitr0gen                             |
|                              nitr0gen@hackersnews.com                    |
|                                                                          |
|         oppure:   (in italiano:)                                         |
|                                                                          |
|                                    XpTerminator                          |
|                             xp_terminator@katamail.com                   |
|                                                                          |
|                                                                          |
|                                                                          |
| -----[ Prefazione ]---                                                   |
|                                                                          |
|                                                                          |
|         A differenza di  come pensano  molte  persone,                   |
| programmare   le  raw  socket  non  è annoiante ed una                   |
| perdita  di tempo, anzi  è una  buona  esperienza  per                   |
| imparare  ed  a  volte è  molto utile. Programmando le                   |
| raw  socket  si ha molta pi√Ļ  flessibilit√† rispetto ai                   |
| programmi che utilizzano socket  con librerie standard                   |
| e quindi diventa facile implementare  nuovi protocolli                   |
| e  controllare cosa  sta realmente  accadendo anche al                   |
| pi√Ļ basso dei livelli.                                                   |
| Costruire pacchetti tramite una libreria è efficiente,                   |
| ma immagina quanto lo sia tramite  una  TUA  libreria.                   |
| Non  mi  trovo  qui  per  spiegare  quanto  sia figo o                   |
| potente   programmare   le  raw  socket,  quindi  vado                   |
| direttamente   al   dunque.  Prima   di  tutto, voglio                   |
| avvertire  che per poter comprendere al  meglio questo                   |
| testo bisogna avere una buona conoscenza del C e della                   |
| struttura della rete.                                                    |
| Nella  prima  parte del  testo introdurrò l'header ip,                   |
| l'header tcp, quello udp ed infine quello icmp, ultimo                   |
| non per importanza.                                                      |
|                                                                          |
| La seconda parte di  questa prefazione è  dedicata ai                    |
| lamer:  per favore  abbiate  rispetto dell'autore del                    |
| testo (Nitr0gen) e non rippate queso testo per vostri                    |
| scopi!                                                                   |
|                                                                          |
| Nitr0gen and Exile 2000 International Coding Team:                       |
| don't worry! i've  only  translated your document,                       |
| and i've riported this!                                                  |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| -----[ Indice ]---                                                       |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| [ Header Ip ]                                                            |
|         - Teoria                                                         |
|         - Frammentazione                                                 |
|         - Checksum                                                       |
|         - Esempi                                                         |
|                                                                          |
| [ Header Tcp ]                                                           |
|         - Teoria                                                         |
|         - Esempi                                                         |
|                                                                          |
| [ Header Udp ]                                                           |
|         - Teoria                                                         |
|         - Esempi                                                         |
|                                                                          |
| [ Header Icmp ]                                                          |
|         - Teoria                                                         |
|         - Esempi                                                         |
|                                                                          |
| [ Implementazione ]                                                      |
|                                                                          |
| [ Conclusioni ]                                                          |
|                                                                          |
| [ Appendice A ]                                                          |
|         - Strutture e Funzioni                                           |
|         - Codici sorgente                                                |
|                                                                          |
| [ Riferimenti ]                                                          |
|                                                                          |
| [ Ringraziamenti ]                                                       |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                         [ CAPITOLO 1 ]                                   |
|                           (HEADER IP)                                    |
|                                                                          |
|                                                                          |
| ---[ Teoria                                                              |
|                                                                          |
|                                                                          |
|       Bene, se sei interessato nella programmazione delle                |
| raw  socket  presumo  che  tu conosca le basi del tcp/ip.                |
| L'header IP  fa parte  del layer  di rete della  suite di                |
| protocolli tcp/ip.  Fondamentalmente  l'header ip è usato                |
| per routare i pacchetti attraverso una rete,come internet                |
| una wan o una lan.  Il metodo di  trasmissione  di questo                |
| header è inaffidabile poichè non hai garanzia dell'arrivo                |
| a  destinazione  del  pacchetto, o  meglio,  quando invii                |
| dei pacchetti, non hai la certezza che questi  arrivino a                |
| destinazione nel giusto ordine in cui li hai inviati.                    |
| Prendi per esempio i pacchetti A B. A viene inviato prima                |
| di B, ma non è garantito che A prenderà la stessa  strada                |
| (routing) di B per arrivare a destinazione.  Il risultato                |
| di ciò  è  quello che  ho detto prima,  i  pacchetti  non                |
| vengono ricevuti nello stesso ordine di partenza. Come ho                |
| ho detto dalla partenza,  questo testo non è  un corso di                |
| tcp/ip  ma  un  testo  sulla  programmazione,  quindi, mi                |
| limiterò alla programmazione.  A titolo  di informazione,                |
| quando costruisci un pacchetto  non dimenticare htons() o                |
| htonl() per rispettare il giusto ordine dei byte.                        |
| Dei lettori si staranno sicuramente  chiedendo perchè sto                |
| dicendo questo,  rispondo  dicendo  che io ho  passato un                |
| mese per risolvere questo piccolo problema.                              |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| Questa è una rappresentazione ascii dell'header ip:                      |
|                                                                          |
|                                                                          |
| 0                     15-16                    31                        |
| +-----+-----+-----------+-----------------------+  \                     |
| | Ver | IHL |    TOS    |      Total Length     |   \                    |
| | (4) | (4) |    (8)    |         (16 )         |    |                   |
| +-----+-----+-----------+--------+--------------+    |                   |
| |    Identification     |  Flags |  Frag Offset |    |                   |
| |        (16)           |   (3)  |     (13)     |    |                   |
| +-----------+-----------+--------+--------------+    |                   |
| |    TTL    |  Protocol |    Header Checksum    |   20 Bytes             |
| |    (8)    |    (8)    |         (16)          |    |                   |
| +-----------+-----------+-----------------------+    |                   |
| |               Source Ip Address               |    |                   |
| |                      (32)                     |    |                   |
| +-----------------------------------------------+    |                   |
| |             Destination Ip Address            |    |                   |
| |                      (32)                     |   /                    |
| +-----------------------------------------------+  /                     |
| <                     Options                   >                        |
| >                     (if any)                  <                        |
| +-----------------------------------------------+                        |
| >                                               <                        |
| <                      Data                     >                        |
| >                                               <                        |
|                                                                          |
|                                                                          |
|                                                                          |
| Version (4 bits):                                                        |
|                 Il campo version è usato per  indicare  la               |
|         versione del IP (Internet Protocol), quindi o IpV4               |
|          o IpV6.                                                         |
|                                                                          |
|                                                                          |
| IHL (Internet Header Length, 4 bits):                                    |
|                 Il  campo ihl indica la lunghezza dell'header            |
|         Ip. Quando non si usano opzioni, il valore di default            |
|         dovrebbe essere 5.                                               |
|                                                                          |
|                                                                          |
| TOS (Type Of Service, 8 bits):                                           |
|                 Tos è utilizzato per specificare le necessità            |
|         del servizio.                                                    |
|                                                                          |
|         Vi sono 4 opzioni per TOS:                                       |
|                                                                          |
|                 *NOME*              *Valore esadecimale*                 |
|                                                                          |
|         1- Minimize delay                   0x10                         |
|         2- Maximize throughput              0x08                         |
|         3- Maximize reliability             0x04                         |
|         4- Minimize monatary cost           0x02                         |
|                                                                          |
|          1: Questa opzione è utilizzata  da  applicazioni                |
|             che trasmettono piccole quantità  di  dati  e                |
|             necessitano di una risposta veloce.                          |
|                                                                          |
|          2: Caso opposto:  questo  è usato da  applicazioni              |
|             che trasmettono grandi quantità di dati.                     |
|                                                                          |
|          3: Non ne parlerò in questo testo.                              |
|                                                                          |
|          4: Non ne parlerò in questo testo.                              |
|                                                                          |
|         Dato che TOS è  una  caratteristica  sperimentale                |
|         dell'ip, non ci dilungheremo su di esso in questo                |
|         testo.                                                           |
|                                                                          |
|                                                                          |
| Total Length (8 bits):                                                   |
|                 Questo specifica la grandezza del datagramma,            |
|         (header + dati). Per esempio:                                    |
|         Prendiamo  un  pacchetto (ip header +  tcp header[syn])          |
|         senza dati. La  grandezza dell'header  ip è 20 e quella          |
|         dell'header tcp anche, quindi il campo tot_len sarà 40.          |
|                                                                          |
|                                                                          |
| Identification (16 bits):                                                |
|                 Id è utilizzato per identificare i frammenti.            |
|         Quando  un  pacchetto non  è frammentato questo campo            |
|         è inutile.  L'Id solitamente aumenta da  datagramma a            |
|         datagramma;  ogni  frammento  ha  lo  stesso  id  del            |
|         datagramma a cui appartiene.                                     |
|                                                                          |
|                                                                          |
| Flags (3 bits):                                                          |
|                 Questo campo dell'header ip è utilizzato dalla           |
|                 frammentazione. Ci sono 4 flag:                          |
|                                                                          |
|               *NOME*               *Valore esadecimale*                  |
|                                                                          |
|          No flags                          0x00                          |
|          More fragment                     0x01                          |
|          Don't fragment                    0x02                          |
|          More and Dont't frag              0x03                          |
|                                                                          |
|         More fragment significa che ci sono ancora frammenti             |
|         dopo questo datagramma, don't fragment  dice che il              |
|         pacchetto non è frammentato.  Quando un datagramma è             |
|         frammentato,l'ultimo frammento non ha mai il flag MF             |
|         (More Fragment) settato.                                         |
|                                                                          |
|                                                                          |
| Fragment Offset (13 bits):                                               |
|               Questo è l'offset con  il  quale  il pacchetto             |
|       è stato calcolato.  Il primo  datagramma ha  offset 0.             |
|       Questo campo è calcolato a 64 bits.  Quando si calcola             |
|       l'offset, l'ultimo offset sarà uguale a tot_len.                   |
|                                                                          |
|                                                                          |
| TTL (Time To Live, 8 bits):                                              |
|                 Questo  campo  specifica  quanti  hop  potrà             |
|         effettuare il datagramma.  Esso è  decrementato ogni             |
|         volta che viene rispedito (durante il routing:  ogni             |
|         router decrementa di 1 questo valore). Quando il TTL             |
|         raggiunge 0,  il datagramma viene ignorato  e  viene             |
|         inviato al mittente un messaggio icmp di TIME EXCEED.            |
|         Questo  avviene  per evitare che un  datagramma giri             |
|         all'infinito per la rete.                                        |
|                                                                          |
|                                                                          |
| Protocol (8 bits):                                                       |
|                 Questo campo specifica il protocollo per il              |
|         layer di trasmissione.  Il valore può essere:                    |
|                                                                          |
|           *NOME*                    *Valore esadecimale*                 |
|                                                                          |
|         IPPROTO_TCP                         0x06                         |
|         IPPROTO_UDP                         0x11                         |
|         IPPROTO_ICMP                        0x01                         |
|                                                                          |
|         Vi sono anche altri protocolli ma non saranno trattati           |
|         in questo testo.  Per maggiori informazioni osserva il           |
|         seguente file header che definisce tutte le costanti.            |
|         '/usr/include/linux/in.h'                                        |
|                                                                          |
|                                                                          |
| Header CheckSum (16 bits):                                               |
|                 Il checksum è utilizzato per verificare                  |
|         l'integrità di un datagramma. Se i dati durante                  |
|         il trasporto si sono corrotti o modificati,esso                  |
|         è in grado di capirlo. Se il checksum non viene                  |
|         specificato   nel   datagramma,   questo  viene                  |
|         scartato  senza  alcun  tipo di avvertenza. Dal                  |
|         punto  di  vista  del programmatore ciò risulta                  |
|         annoiante.Osserva l'appendice A per la funzione                  |
|         del checksum ( in_cksum() ).                                     |
|                                                                          |
|                                                                          |
| Source Ip (32 bits):                                                     |
|                 L'indirizzo ip dell'host che ha inviato il               |
|         datagramma.                                                      |
|                                                                          |
| Destination Ip (32 bits):                                                |
|                 L'indirizzo ip della  macchina a cui dovrà               |
|         essere "recapitato" questo datagramma.                           |
|                                                                          |
|                                                                          |
| Options (Variable):                                                      |
|                 Il  campo  options  non  sarà  trattato in               |
|         questo testo.                                                    |
|                                                                          |
|                                                                          |
|                                                                          |
|         Dal punto di  vista della programmazione,  costruire             |
| un header ip significa semplicemente riempire una struttura.             |
| Dato che sto utilizzando Linux, tutti i riferimenti che farò             |
| a file di sistema saranno basati su kernel 2.2.13.                       |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ Frammentazione                                                      |
|                                                                          |
|                                                                          |
|         In parole povere,  la  frammentazione   avviene                  |
| quando il MTU  (Maximum Transfert Unit)  è minore della                  |
| lunghezza   totale  del   datagramma,  quindi,  dovremo                  |
| dividere il datagramma  in  piccoli  pezzi, ed inviarli                  |
| uno alla  volta;  quando i pacchetti  saranno ricevuti,                  |
| il datagramma originale sarà ricostruito.                                |
| Quando effettuiamo la frammentazione,abbiamo bisogno di                  |
| settare campi specifici dell'header Ip.                                  |
| Il flag MF deve  essere  settato  a  tutti i frammenti,                  |
| tranne l'ultimo.L'offset del primo pacchetto sarà zero.                  |
| L'Id  dovrà essere  lo stesso  per ogni  frammento, per                  |
| identificare  a  quale  serie  di pezzi  di  datagramma                  |
| appartiene.Se l'header Ip è modificato anche in un solo                  |
| frammento  il  checksum  dovrà  essere  ricalcolato. La                  |
| lunghezza  totale dei frammenti  prenderà il valore del                  |
| MTU.                                                                     |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ Checksum                                                            |
|                                                                          |
|                                                                          |
|         Calcolare  il  checksum  di  un  header  non  è                  |
| difficile, osserva l'appendice A per vedere la funzione                  |
| responsabile di questa operazione.                                       |
| Questo è il prototipo della funzione:                                    |
|                                                                          |
| unsigned short in_cksum(unsigned short *addr, int len);                  |
|                                                                          |
|     - unsigned short *addr : E' un puntatore  all'header ip.             |
|     - int len              : E' la lunghezza dell'header ip.             |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ Esempi                                                              |
|                                                                          |
|                                                                          |
| Il nome della  sezione  dice esplicitamente  cosa                        |
| troverai qui.                                                            |
|                                                                          |
|                                                                          |
|                                                                          |
| /*******************************************************************/    |
| /*                Exile 2000 International Coding Team             */    |
| /*                     (http://www.exile2k.org)                    */    |
| /*                   All rights reserved Exile Team                */    |
| /*                    Copyright 2000 (C) Nitr0gen                  */    |
| /*                                                                 */    |
| /*             Questa funzione costruisce un header IP             */    |
| /*                      SENZA FRAMMENTAZIONE                       */    |
| /*                                                                 */    |
| /*******************************************************************/    |
|                                                                          |
| void buildip_nf(){ /*** Funzione che costruisce un Header Ip ***/        |
|                                                                          |
|         struct iphdr *ip;                                                |
|          /*** A little step for a man, a big step for human kind ***/    |
|                                                                          |
|         ip = (struct iphdr *) malloc(sizeof(struct iphdr));              |
|                 /*** Alloca la memoria dinamica ***/                     |
|                                                                          |
|  ip->ihl     = 5;    /*** Lunghezza in byte dell'Header IP ***/          |
|  ip->version = 4;    /*** Versione del protocollo IP ***/                |
|  ip->tos     = 0;    /*** Sperimentale (Vedi sopra per i dettagli) ***/  |
|  ip->tot_len = sizeof(struct iphdr) + 452 /*** Lunghezza totale del ***/ |
|                                          /***       pacchetto      ***/  |
|                                                                          |
|                                                                          |
|  ip->id      = htons(getuid());                                          |
|   /*** ID (identification) del pacchetto, inutile nel nostro caso ***/   |
|                                                                          |
|  ip->ttl      = 255;                /*** Il pacchetto può effettuare     |
|                                                           255 hop ***/   |
|  ip->protocol = IPPROTO_TCP; /*** Utilizziamo il tcp come protocollo     |
|                                                  di trasmissione ***/    |
|  ip->saddr    = inet_addr("127.0.0.1");  /*** Ip sorgente  ***/          |
|  ip->daddr    = inet_addr("127.0.0.1");  /*** Ip di destinazione ***/    |
|                                                                          |
|  ip->check    = in_cksum((unsigned short *)ip, sizeof(struct iphdr));    |
|                            /*** Checksum ***/                            |
|                                                                          |
| }                                                                        |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| /*****************************************************************/      |
| /*                Exile 2000 International Coding Team           */      |
| /*                     (http://www.exile2k.org)                  */      |
| /*                   All rights reserved Exile Team              */      |
| /*                    Copyright 2000 (C) Nitr0gen                */      |
| /*                                                               */      |
| /*                Questa funzione costruisce un header IP        */      |
| /*                    FRAMMENTAZIONE del pacchetto               */      |
| /*                           in 2 frammenti                      */      |
| /*                           MTU = 280 byte                      */      |
| /*                                                               */      |
| /*****************************************************************/      |
|                                                                          |
|                                                                          |
|                                                                          |
| void buildip_f(){                                                        |
|      /*** Funzione che costruisce un header IP frammentato ***/          |
|                                                                          |
| struct iphdr *ipf;                                                       |
|                                                                          |
| ipf = (struct iphdr *) malloc(sizeof(struct iphdr));                     |
|                                                                          |
| /**** PRIMO FRAMMENTO ***/                                               |
| ipf->ihl     = 5; /*** Lunghezza dell'header in 32 bit */                |
| ipf->version = 4; /*** Versione del protocollo IP */                     |
| ipf->tos     = 0; /*** TOS (Type of service), inutilizzato */            |
| ipf->tot_len = sizeof(struct iphdr) + 256; /* Lunghezza del              |
|                                               primo frammento */         |
| ipf->id      = htons(1); /*** Per identificare i nostri 2 frammenti */   |
| ipf->ttl     = 255;        /*** Il datagramma può effettuare 255 hop */  |
| ipf->protocol = IPPROTO_TCP; /*** uso il protocollo TCP */               |
| ipf->saddr    = inet_addr("127.0.0.1"); /*** Ip sorgente (localhost) */  |
| ipf->daddr    = inet_addr("127.0.0.1"); /*** Ip di destinazione          |
|                                                          (localhost) */  |
| ipf->frag_off = htons(0x2000); /*** Offset 0 e MF */                     |
| ipf->check  = in_cksum((unsigned short *)ipf,sizeof(struct iphdr)+256);  |
|         /*** Checksum */                                                 |
|                                                                          |
|                                                                          |
| /**** Qui dovremmo inviare il primo frammento ***/                       |
|                                                                          |
|                                                                          |
| /**** SECONDO FRAMMENTO ***/                                             |
| ipf->tot_len = sizeof(struct iphdr) + 196; /*** Aggiorno la lunghezza    |
|                                                    dei datagrammi */     |
| ipf->frag_off = htons(32); /*** Offset del frammento ***/                |
| ipf->check = in_cksum((unsigned short *)ipf,sizeof(struct iphdr)+196);   |
| /*** Ricalcoliamo il checksum dato che abbiamo cambiato dei campi */     |
|                                                                          |
|   /**** Qui dovremmo inviare il secondo frammento ***/                   |
|                                                                          |
| }                                                                        |
|                                                                          |
|                                                                          |
|                                 [ CAPITOLO 2 ]                           |
|                                  (HEADER TCP)                            |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ Teoria                                                              |
|                                                                          |
|                                                                          |
|        Diamo  ora  un'occhiata all'header tcp. Dato                      |
| he  esso fa utilizzo  di un  metodo di trasmissione                      |
| ffidabile,  prima di  effettuare lo  streaming  dei                      |
| ati c'è bisogno di creare una connessione.  Quindi,                      |
| os'è una connessione? Con il tcp noi  la  chiamiamo                      |
| hree-way-handshake ("stretta di mano" in tre fasi).                      |
| on il  primo passo  il client  invia  al  server un                      |
| acchetto  tcp SYN per  sincronizzare  (SYNchronize)                      |
| l   numero  di acknowledgment; con il secondo passo                      |
| l  server  "riconosce" (ACKnowledge) il  syn,  cioè                      |
| onferma  la sua  ricezione,  tramite  un  pacchetto                      |
| YN_ACK. Se il SYN_ACK non è ricevuto dal  client lo                      |
| tato  della connessione  tcp  rimane  in SYN_SENT e                      |
| l client  continua  l'invio   di  SYN   al  server,                      |
| inchè  esso  non lo  riceverà  e quindi  confermerà                      |
| on SYN_ACK.Dopo la conferma dell'avvenuta ricezione                      |
| el   SYN,   il  client  risponde  con  un  ACK  per                      |
| onfermare  l'avvenuta ricezione del SYN_ACK.                             |
| eoricamente  una connessione è creata tra due host,                      |
| a se il server si disconnette  prima di ricevere il                      |
| ostro  ultimo  pacchetto  (ACK),  noi  crederemo di                      |
| ssere connessi, ma in realtà non lo siamo. Questo è                      |
| no dei  problemi  del tcp. Il Tcp (Transfer control                      |
| rotocol)  come  l'Ip  ( Internet protocol )  ha  un                      |
| hecksum per  il controllo  dell'integrità  dei dati                      |
| he   fa  utilizzo  di   uno pseudo-header   di  cui                      |
| arleremo dopo.  Per essere  sicuri che un pacchetto                      |
| rovenga  realmente  dal source ip  specificato  nel                      |
| uo header, il tcp ha aggiunto la funzionalità di un                      |
| equence   number,   ciò   significa   che   durante                      |
| 'handshake, prima il client invia un Seq Number,poi                      |
| l server effettua l'acknowledgement del SYN  con il                      |
| roprio seq number. Il server attende nel successivo                      |
| acchetto del client  il seq number come specificato                      |
| el  campo ACK  dell'ultimo  pacchetto  inviato. Ciò                      |
| reviene   l'hijacking   o   lo   spoofing   di  una                      |
| onnessione da parte di utenti malintenzionati.                           |
| cco un esempio:                                                          |
|                                                                          |
|        Host A < ---- TCP CONNECTION ----> HOST B                         |
|                                                                          |
|                   ^---- HOST X (utente malintenzionato)                  |
|                                                                          |
|        Se  non  ci fosse il  sequence number,  HOST X                    |
|        potrebbe  inviare  pacchetti  a HOST B facendo                    |
|        credere  in realtà  che questi  provenghino da                    |
|        HOST A. Oggi giorno,  con la  generazione  del                    |
|        sequence number ormai casuale questa tecnica è                    |
|        quasi impossibile.                                                |
|                                                                          |
| uesto protocollo ha ancora altre  opzioni in  ambito                     |
| i  sicurezza  aggiunte  a  quelle  dell'IP,  ma  non                     |
| erranno  trattate  in  questo testo. Il Tcp permette                     |
| noltre un  buon  managing  dei pacchetti  in entrata                     |
| d in uscita. Grazie   alla   specifica nei pacchetti                     |
| elle porte sorgente e destinazione,  molti  processi                     |
| ossono  comunicare contemporaneamente.  Tutte queste                     |
| pzioni, incluse quelle  non trattate, però  hanno lo                     |
| vantaggio di diminuire la velocità di trasmissione.                      |
| i sei  mai domandato  cosa sia un socket? Il termine                     |
| ocket  nel  mondo  tcp  è  usato  spesso.  Questo  è                     |
| emplicemente un indirizzo ip combinato con un numero                     |
| i  porta, ed  una coppia di socket è la combinazione                     |
| ndirizzo Ip Sorgente + Porta Sorgente + Indirizzo Ip                     |
| i Destinazione + Porta di Destinazione.                                  |
|                                                                          |
|        Il Tcp ha 6 funzioni principali:                                  |
|                                                                          |
|                                                                          |
|        URG:        Invia  dei  dati  urgenti,  cioè  con                 |
|                    maggiore   priorità,   all'host    di                 |
|                    destinazione.                                         |
|                                                                          |
|        ACK:        "Acknowledgement" dei  dati ricevuti.                 |
|                    Come visto sopra.                                     |
|                                                                          |
|        PSH:        Invia i dati all'host di destinazione.                |
|                                                                          |
|        RST:        Resetta una connessione.                              |
|                                                                          |
|        SYN:        Sincronizza il Seq Number.                            |
|                                                                          |
|        FIN:        Nessun altro dato da  inviare da parte                |
|                    dell'host.                                            |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| chema dell'header TCP:                                                   |
|                                                                          |
|                      15-16                    31                         |
| -----------------------+-----------------------+ \                       |
|       Source Port      |    Destination Port   |  \                      |
|         (16b)          |         (16b)         |  |                      |
| -----------------------+-----------------------+  |                      |
|                 Sequence Number                |  |                      |
|                      (32b)                     |  |                      |
| -----------------------------------------------+  |                      |
|                  Acknowledgement               |  |                      |
|                      (32b)                     |  |                      |
| -------+------+--------+-----------------------+  20 Bytes               |
|  D_Off | Res  | Flags  |       Windows         |  |                      |
|   (4b) | (6b) |  (6b)  |        (16b)          |  |                      |
| -------+------+--------+-----------------------+  |                      |
|        Checksum        |    Urgent Pointer     |  |                      |
|          (16b)         |        (16b)          |  |                      |
| -----------------------+------------+----------+  |                      |
|                Options              | Padding  |  |                      |
|                 (24b)               |  (8b)    |  /                      |
| ------------------------------------+----------+ /                       |
|                       DATA                     <                         |
|                                                >                         |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ource Port (16 bits):                                                    |
|                La porta sorgente  del  pacchetto.                        |
|        I pacchetti di ritorno saranno ricevuti su                        |
|        questa porta.                                                     |
|                                                                          |
| estination Port (16 bits):                                               |
|                La  porta   di   destinazione  del                        |
|        pacchetto. Il pacchetto  sarà  ricevuto su                        |
|        questa porta dall'host di destinazione.                           |
|                                                                          |
| equence number (32bits):                                                 |
|                Il Sequence  number è una  buona                          |
|        caratteristica della sicurezza del  tcp.                          |
|        Quando un pacchetto viene  ricevuto,  il                          |
|        modulo  tcp del  kernel  verifica  se il                          |
|        numero  è   giusto.  Se  non  lo  è,  il                          |
|        pacchetto viene scartato.                                         |
|                                                                          |
|                                                                          |
|                                                                          |
| cknowledgment (32 bits):                                                 |
|                Quando il flag ACK è settato, il                          |
|        valore  di  questo  campo  è  settato al                          |
|        valore del Seq number che ci si  aspetta                          |
|        di  ricevere  nel prossimo  pacchetto da                          |
|        parte   dell'altro   peer   (capo  della                          |
|        connessione).                                                     |
|                                                                          |
|                                                                          |
| ata Offset (4 bits):                                                     |
|                L'offset dei dati espresso  a  32                         |
|        bit. Se non vi sono opzioni, il valore di                         |
|        default è 5.                                                      |
|                                                                          |
|                                                                          |
| eserved (6 bits):                                                        |
|                Riservato per un uso futuro, deve                         |
|        essere settato a 0.                                               |
|                                                                          |
| lags (6 bits):                                                           |
|                Ci sono 6 flag possibili nel tcp.                         |
|        Come visto sopra, questi sono:                                    |
|                                                                          |
|                                                                          |
|        URG:        Indicatore di urgenza                                 |
|        ACK:        Acknowledge                                           |
|        PSH:        Push                                                  |
|        RST:        Reset                                                 |
|        SYN:        Sincronizza il Seq Number                             |
|        FIN:        Nessun altro dato da inviare                          |
|                                                                          |
|                                                                          |
| indows (16 bits):                                                        |
|                Questo  specifica  il  MSS  (maximum                      |
|        segment  size) del prossimo pacchetto. Se un                      |
|        pacchetto supera  questo valore,  esso dovrà                      |
|        essere frammentato.                                               |
|                                                                          |
|                                                                          |
| hecksum (16 bits):                                                       |
|                Il    checksum     per    verificare                      |
|        l'integrità dei dati.Il checksum è calcolato                      |
|        con uno Pseudo-Header che  spiegherò. Questa                      |
|        è la  struttura,  tratta da Tcp/Ip  Volume 1                      |
|        (The  protocol)  di  W. Richard Stevens. Per                      |
|        favore  dedica  un  minuto  di  silenzio per                      |
|        questo incredibile uomo che è morto, è stato                      |
|        uno straordinario scrittore.                                      |
|                                                                          |
|        Questa è la struttura:                                            |
|                                                                          |
|                struct pseudohdr {                                        |
|                        unsigned long saddr;                              |
|                        unsigned long daddr;                              |
|                        char useless;                                     |
|                        unsigned char protocol;                           |
|                        unsigned short length;                            |
|                };                                                        |
|                                                                          |
|        L'header contiene  l'indirizzo  ip  sorgente e                    |
|        destinazione per evitare pacchetti mal-routati                    |
|        (saddr, daddr). Il carattere "useless"  esiste                    |
|        solo  per  rispettare il  limite  dei  32  bit                    |
|        (per questo "useless" = "inutile"). "protocol"                    |
|        contiene  il  protocollo,   in   questo   caso                    |
|        IPPROTO_TCP,  e  "lenght", la   lunghezza  del                    |
|        pacchetto.                                                        |
|                                                                          |
|        Il checksum è calcolato come per l'header Ip:                     |
|                                                                          |
|                                                                          |
| -------------- CUT HERE -----------------                                |
|                                                                          |
|   #define PSEUDO sizeof(struct pseudohdr)                                |
|   #define TCPHDR sizeof(struct tcphdr)                                   |
|                                                                          |
|    struct pseudohdr pseudo;                                              |
|    struct tcphdr tcp;                                                    |
|                                                                          |
|    pseudo.saddr    = inet_addr("127.0.0.1");                             |
|    pseudo.daddr    = inet_addr("127.0.0.1");                             |
|    pseudo.useless  = htons(0);                                           |
|    pseudo.protocol = IPPROTO_TCP;                                        |
|    pseudo.length   = TCPHDR + data;                                      |
|                                                                          |
|    tcp->check    = in_cksum((unsigned short *)&pseudo, PSEUDO+TCPHDR);   |
|                                                                          |
| -------------- CUT HERE ----------------                                 |
|                                                                          |
|                                                                          |
|                                                                          |
|  Urgent Pointer (16 bits):                                               |
|                  Questo campo è significante solo se il flag             |
|          URG è settato.  Esso  punta  ad un'area  dati e ciò             |
|          rende i dati urgenti dal punto di vista dei peer.               |
|                                                                          |
|                                                                          |
|  Options (24 bits):                                                      |
|                  Il  campo  options  non  verrà  trattato in             |
|          questo testo.                                                   |
|                                                                          |
|                                                                          |
|  Padding (8 bits):                                                       |
|                  Il campo padding è riempito con 0. Questo               |
|          avviene per rispettare il limite dei 32 bit: esso               |
|          parte con 32 bit e finisce con 32 bit.                          |
|                                                                          |
|                                                                          |
| ---[ Esempi                                                              |
|                                                                          |
|                                                                          |
|                                                                          |
| /******************************************************************/     |
| /*              Exile 2000 International Coding Team              */     |
| /*                   (http://www.exile2k.org)                     */     |
| /*                 All rights reserved Exile Team                 */     |
| /*                  Copyright 2000 (C) Nitr0gen                   */     |
| /*                                                                */     |
| /*                Questa funzione costruisce un header TCP        */     |
| /*                       col flag SYN settato                     */     |
| /*            e richiede una connessione telnet su localhost      */     |
| /*                                                                */     |
| /******************************************************************/     |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| #define TCPHDR                sizeof(struct tcphdr)                      |
| #define PSEUHDR                sizeof(struct iphdr)                      |
|                                                                          |
|                                                                          |
| void build_tcp(){                                                        |
|                                                                          |
| struct tcphdr *tcp;           /*** Header tcp ***/                       |
| struct pseudohdr *pseudo;  /*** Pseudo header ***/                       |
|                                                                          |
| if ((tcp = (struct tcphdr *) malloc(TCPHDR)) == NULL){                   |
|         perror("malloc()");   /*** Alloca la memoria dinamica ***/       |
|         return -1;                                                       |
| }                                                                        |
|                                                                          |
| if ((pseudo = (struct pseudohdr *) malloc(PSEUDOHDR)) == NULL){          |
|         perror("malloc()");   /*** Alloca la memoria dinamica ***/       |
|         return -1;                                                       |
| }                                                                        |
|                                                                          |
| memset(tcp,'\0',TCPHDR);     /*** Inizializza la memoria                 |
|                                             al carattere \0 ***/         |
| memset(pseudo,'\0',PSEUDOHDR);                                           |
|                                                                          |
|                                                                          |
| pseudo->saddr    = inet_addr("127.0.0.1"); /*** Ip sorgente ***/         |
| pseudo->daddr    = inet_addr("127.0.0.1"); /*** Ip di destinazione ***/  |
| pseudo->useless  = 0;      /*** Spazio riservato per rispettare il       |
|                                                          limite ***/     |
| pseudo->protocol = IPPROTO_TCP; /*** Utilizziamo tcp ***/                |
| pseudo->length   = htons(TCPHDR); /*** Dato che non abbiamo nessun       |
|                                        dato,  la  lunghezza è solo       |
|                                        quella dell'header tcp.     ***/  |
|                                                                          |
|                                                                          |
| tcp->source  = htons(5000); /*** Utilizziamo la 5000                     |
|                                         come porta sorgente ***/         |
| tcp->dest    = htons(23);   /*** Inviamo al demone telnet ***/           |
| tcp->seq     = htonl(31337); /*** Initial sequence number ***/           |
| tcp->ack_seq = htonl(0);     /*** E' significante solo se è settato      |
|                                                     il flag ack ***/     |
| tcp->doff    = 5; /*** Offset dell'header tcp a 32 bit ***/              |
| tcp->fin     = 0; /*** Flag FIN non settato durante l'handshake ***/     |
| tcp->syn     = 1; /*** Flag SYN settato, primo passo dell'handshake ***/ |
| tcp->rst     = 0; /*** Flag RST non settato durante l'handshake ***/     |
| tcp->psh     = 0; /*** Flag PSH non settato durante l'handshake ***/     |
| tcp->ack     = 0; /*** Flag ACK non settato durante l'handshake ***/     |
| tcp->urg     = 0; /*** Flag URG non settato durante l'handshake ***/     |
| tcp->window  = htons(4000); /*** Lunghezza massima del prossimo          |
|                                                       pacchetto ***/     |
| tcp->urg_ptr = htons(0);  /*** E' significativo solo se il flag URG      |
|                                                         è settato ***/   |
|                                                                          |
| tcp->check   = in_cksum((unsigned short *)pseudo,TCPHDR+PSEUDOHDR);      |
|   /*** Calcolo del checksum tcp per evitare corruzione dei dati ***/     |
| }                                                                        |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                 [ CAPITOLO 3 ]                           |
|                                  (HEADER UDP)                            |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ Teoria                                                              |
|                                                                          |
|                                                                          |
|         Arrivato fin qui, hai  superato la  parte  pi√Ļ                   |
| "difficile".                                                             |
| L'Udp   è   meno   complesso  del  tcp.  Esso  non  ha                   |
| caratteristiche di sicurezza e neanche di affidabilità                   |
| ma ha un maggiore transfert rate  che lo  rende utile.                   |
| Come il tcp, anche l'udp ha un checksum ed  ha bisogno                   |
| di uno pseudo header per calcolarlo.                                     |
|                                                                          |
|                                                                          |
| Schema dell'Header UDP:                                                  |
|                                                                          |
|                                                                          |
| 0                     15-16                    31                        |
| +-----------------------+-----------------------+                        |
| |     Source Port       |   Destination Port    |                        |
| |       (16 b)          |       (16 b)          |                        |
| +-----------------------+-----------------------+                        |
| |       Length          |       Checksum        |                        |
| |       (16 b)          |        (16 b)         |                        |
| +-----------------------+-----------------------+                        |
| >                     DATA                      <                        |
| <                                               >                        |
|                                                                          |
|                                                                          |
|                                                                          |
| Source Port (16 bits):                                                   |
|                 La porta sorgente  del datagramma.                       |
|         I pacchetti di ritorno saranno ricevuti su                       |
|         questa porta.                                                    |
|                                                                          |
|                                                                          |
| Destination Port (16 bits):                                              |
|              La porta destinazione del datagramma.                       |
|         Il datagramma  sarà  ricevuto  dal peer di                       |
|         destinazione su questa porta.                                    |
|                                                                          |
|                                                                          |
| Length (16 bits):                                                        |
|               Contiene la lunghezza dei datagrammi                       |
|         udp in ottetti, solitamente 8.                                   |
|                                                                          |
|                                                                          |
| Checksum (16 bits):                                                      |
|               Contiene il checksum  del  datagramma                      |
|         per   controllarne   l'integrità    e   per                      |
|         assicurare che non vi sono stati errori nel                      |
|         routing.                                                         |
|                                                                          |
|         Se  sei  curioso  circa  la  sua struttura,                      |
|         osserva l'appendice A.                                           |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ Esempi                                                              |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| /****************************************************************/       |
| /*              Exile 2000 International Coding Team            */       |
| /*                   (http://www.exile2k.org)                   */       |
| /*                 All rights reserved Exile Team               */       |
| /*                  Copyright 2000 (C) Nitr0gen                 */       |
| /*                                                              */       |
| /*                Questa funzione costruisce un header UDP      */       |
| /*                                                              */       |
| /****************************************************************/       |
|                                                                          |
|                                                                          |
| void build_udp(){                                                        |
|                                                                          |
| struct udphdr *udp;        /*** Dichiarazione delle variabili ***/       |
| struct pseudohdr pseudo;                                                 |
|                                                                          |
| if ((udp = (struct udphdr *) malloc(sizeof(struct udphdr))) == NULL){    |
|         perror("Memory exhausted"); /*** Allocazione memoria             |
|                                                          dinamica ***/   |
|         return ;                                                         |
| }                                                                        |
|                                                                          |
|                                                                          |
| /*** Pseudo-Header, utilizzato per evitare datagrammi "mal-routati" ***/ |
|                                                                          |
| pseudo.saddr    = inet_addr("127.0.0.1"); /* Inviamo da localhost **/    |
| pseudo.daddr    = inet_addr("127.0.0.1"); /* Inviamo a localhost **/     |
| pseudo.useless  = htons(0);         /* Per rispettare il limite          |
|                                                         di 32 bit*/      |
| pseudo.protocol = IPPROTO_UDP;      /* Utilizziamo il protocollo UDP */  |
| pseudo.length   = sizeof(struct udphdr); /* sizeof della                 |
|                                                    struttura udphdr  */  |
|                                                                          |
| udp->source = htons(5000);  /** Inviamo dalla porta 5000 */              |
| udp->dest   = htons(7);     /** Inviamo al server echo (porta=7) */      |
| udp->len    = htons(sizeof(struct udphdr)); /* Lunghezza di udphdr.      |
|                                                 Utilizziamo htons()      |
|                                                 per il giusto            |
|                                                 ordinamento dei byte */  |
|                                                                          |
| udp->check  = in_cksum((unsigned short *)&pseudo,sizeof(struct udphdr)); |
|                 /*** Calcoliamo il checksum ***/                         |
|                                                                          |
| }                                                                        |
|                                                                          |
|                                                                          |
|                                 [ CAPITOLO 4 ]                           |
|                                 (HEADER ICMP)                            |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ Teoria                                                              |
|                                                                          |
|                                                                          |
|         Fondamentalmente l'Internet Control Message                      |
| Protocol  (ICMP)  è utilizzato per riportare errori                      |
| come l'irraggiungibilità di un host,la scadenza del                      |
| TTL (Time to live) o "source quench" (letteralmente                      |
| "spegnimento" dell'host sorgente) che significa che                      |
| non c'è abbastanza memoria  per  proseguire l'invio                      |
| del   datagramma  in  questione.  Non   esiste   un                      |
| messaggio  icmp  per  evitare  cicli infiniti di un                      |
| pacchetto in una rete.                                                   |
|                                                                          |
|                                                                          |
|                                                                          |
|         Schema dell'Header ICMP:                                         |
|                                                                          |
|                                                                          |
| 0                     15-16                    31                        |
| +-----------+-----------+-----------------------+                        |
| |   Type    |   Code    |       Checksum        |                        |
| |   (8 b)   |   (8 b)   |        (16 b)         |                        |
| +-----------+-----------+-----------------------+                        |
| |                     UNUSED                    |                        |
| |                     (32 b)                    |                        |
| +-----------------------------------------------+                        |
| |       Internet Header + 64 bits di dati       |                        |
| |                     (32 b)                    |                        |
| +-----------------------------------------------+                        |
| Questo è il formato standard dell'header icmp.                           |
| Se però cambiano i valori dei  campi "Type"  e  "Code"                   |
| il  campo  "unused" (inutilizzato) viene  utilizzato.                    |
| Se  "unused"   rimane  inutilizzato,  settalo  a  0. A                   |
| seconda del tipo  di  messaggio icmp, alcuni campi del                   |
| header Ip possono cambiare.                                              |
|                                                                          |
|                                                                          |
|                                                                          |
|  ECHO REQUEST o ECHO REPLY                                               |
|  -------------------------                                               |
|                                                                          |
| L'Echo  viene  comunemente  chiamato  PING.  Per                         |
| generare  la  reply,  lo  stack  inverte  l'indirizzo Ip                 |
| sorgente   e   destinazione   nell'header  Ip. Il  campo                 |
| "UNUSED" è diviso  in  campi da 8 bit ciascuno, chiamati                 |
| Identifier e Sequence number, che  descriverò qui sotto.                 |
|                                                                          |
|                                                                          |
| TYPE (8 bits):                                                           |
|                 0        Per echo reply                                  |
|                 8        Per echo request                                |
|                                                                          |
| CODE (8 bits):                                                           |
|                 0        Campo inutilizzato per questo tipo              |
|                          di messaggi                                     |
|                                                                          |
| CHECKSUM (16 bits):                                                      |
|                 Il checksum è calcolato come per gli altri               |
|         header, ma il campo  checksum  deve essere 0 prima               |
|         di averlo calcolato. Per rispettare il  limite dei               |
|         32 bit, il kernel può "imbottire" il  messaggio se               |
|         la sua lunghezza totale è inaspettata, cioè minore               |
|         dei 32 bit.                                                      |
|                                                                          |
| Identifier (16 bits):                                                    |
|                 Questo campo si comporta allo  stesso modo               |
|         dell'ID nell'headers ip, ma  per gli echo e reply.               |
|         Esso aiuta a capire  quale echo reply appartiene a               |
|         quale  echo request  (come per la frammentazione).               |
|                                                                          |
| Sequence Number (16 bits):                                               |
|                 Questo campo si comporta allo  stesso modo               |
|         dell'ID nell'headers ip, ma  per gli echo e reply.               |
|         Esso aiuta a capire  quale echo reply appartiene a               |
|         quale  echo request  (come per la frammentazione).               |
|                                                                          |
|                                                                          |
| Negli  echo  request possono essere inseriti anche i dati,               |
| questi   poi  saranno rispediti dall'host  di destinazione               |
| nell'echo reply.                                                         |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| DESTINATION UNREACHABLE                                                  |
| -----------------------                                                  |
|                                                                          |
| Questo messaggio è utilizzato  per indicare                              |
| che un host o una rete è down, che un  servizio non                      |
| è  in  funzione,  che  lo  stack  non  supporta  il                      |
| protocollo, che c'è bisogno della frammentazione ma                      |
| "don't fragment" (DF) è settato, o che c'è stato un                      |
| errore durante il routing del pacchetto.  Il  campo                      |
| "UNUSED"  rimane  inutilizzato  e  dovrebbe  essere                      |
| settato a 0.                                                             |
|                                                                          |
|                                                                          |
| TYPE (8 bits):                                                           |
|         3        Destination Unreachable                                 |
|                                                                          |
|                                                                          |
| CODE (8 bits):                                                           |
|         0        Rete irraggiungibile                                    |
|         1        Host irraggiungibile                                    |
|         2        Protocollo irraggiungibile                              |
|         3        Porta irraggiungibile                                   |
|         4        Frammentazione necessaria ma DF settato.                |
|         5        Routing fallito                                         |
|                                                                          |
|                                                                          |
|                                                                          |
| CHECKSUM (16 bits):                                                      |
|                 Il  checksum  è  calcolato  come                         |
|         l'ultimo messaggio.                                              |
|                                                                          |
|                                                                          |
| UNUSED (32 bits):                                                        |
|         Rimane inutilizzato.                                             |
|                                                                          |
|                                                                          |
| INTERNET HEADER + 64 BIT DI DATI DEL DATAGRAMMA:                         |
|                 Il titolo è esplicativo.E' usato                         |
|         dai  protocolli di  livello pi√Ļ alto, se                         |
|         c'è una  porta  da  identificare o altri                         |
|         campi.                                                           |
|                                                                          |
|                                                                          |
|                                                                          |
| SOURCE QUENCH                                                            |
| -------------                                                            |
|                                                                          |
| Questo   messaggio   d'errore  viene                                     |
| inviato quando un host  o  un gateway non ha                             |
| abbastanza  memoria  per  mettere in coda il                             |
| pacchetto ricevuto per inoltrarlo.                                       |
|                                                                          |
|                                                                          |
| TYPE (8 bits):                                                           |
|         4        Source Quench                                           |
|                                                                          |
|                                                                          |
| CODE (8 bits):                                                           |
|         0        Inutilizzato                                            |
|                                                                          |
|                                                                          |
| CHECKSUM (16 bits):                                                      |
|                 Il checksum viene calcolato come                         |
|         l'ultimo messaggio.                                              |
|                                                                          |
|                                                                          |
| UNUSED (32 bits):                                                        |
|         Rimane inutilizzato.                                             |
|                                                                          |
|                                                                          |
| INTERNET HEADER + 64 BIT DI DATI DEL DATAGRAMMA:                         |
|                 Il titolo è esplicativo.E' usato                         |
|         dai  protocolli di  livello pi√Ļ alto, se                         |
|         c'è una  porta  da  identificare o altri                         |
|         campi.                                                           |
|                                                                          |
|                                                                          |
|                                                                          |
| REDIRECT                                                                 |
| --------                                                                 |
|                                                                          |
| Un  messaggio  redirect  (di redirezione) è                              |
| inviato  quando  esiste  una  strada  pi√Ļ corta per                      |
| arrivare alla destinazione.                                              |
| Esempio:                                                                 |
|                                                                          |
|         Johnny invia un pacchetto alla rete R. La sua                    |
|         route  table  (tabella  di  routing) dice per                    |
|         default di inviarlo al Gateway #1, ma  quando                    |
|         il Gateway #1 riceve il pacchetto  esso trova                    |
|         una  via   pi√Ļ   corta   per  arrivare   alla                    |
|         destinazione. Esso  quindi  invia un REDIRECT                    |
|         all'ip sorgente  specificando  l'indirizzo Ip                    |
|         del nuovo gateway nel campo UNUSED.                              |
|                                                                          |
|                                                                          |
| Vi  è  una  eccezione  quando l'"IP source routing" è                    |
| abilitato,ma di questa opzione dell'ip non ho parlato                    |
| in questo testo quindi mi fermo qui.                                     |
|                                                                          |
|                                                                          |
| TYPE (8 bits):                                                           |
|         5        Redirect                                                |
|                                                                          |
|                                                                          |
| CODE (8 bits):                                                           |
|         0        Redirige i datagrammi destinati ad una Rete             |
|         1        Redirige i datagrammi destinati ad un Host              |
|         2        Redirige i datagrammi destinati ad un TOS e             |
|                  ad una Rete                                             |
|         3        Redirige i datagrammi destinati ad un TOS e             |
|                  ad un Host                                              |
|                                                                          |
|                                                                          |
| CHECKSUM (16 bits):                                                      |
|                 Il checksum viene calcolato come                         |
|         l'ultimo messaggio.                                              |
|                                                                          |
|                                                                          |
|                                                                          |
| GATEWAY INTERNET ADDRESS (32 bits):                                      |
|                 Indirizzo Ip del gateway pi√Ļ vicino                      |
|         al quale inviare il pacchetto.                                   |
|                                                                          |
|                                                                          |
| INTERNET HEADER + 64 BIT DI DATI DEL DATAGRAMMA:                         |
|                 Il titolo è esplicativo. E' usato                        |
|           dai  protocolli  di  livello pi√Ļ alto, se                      |
|         c'è  una  porta  da  identificare o altri                        |
|         campi.                                                           |
|                                                                          |
|                                                                          |
|                                                                          |
| TIME EXCEED                                                              |
| -----------                                                              |
|                                                                          |
| Questo messaggio viene inviato quando il Time To                         |
| Live (TTL)(tempo di vita) di un pacchetto scade o quando                 |
| scade il tempo per riassemblare il pacchetto.                            |
|                                                                          |
|                                                                          |
| TYPE (8 bits):                                                           |
|         11        Time Exceed                                            |
|                                                                          |
|                                                                          |
| CODE (8 bits):                                                           |
|         0        Time To Live Scaduto (TTL)                              |
|         1        Tempo per il riassemblaggio dei frammenti               |
|                  scaduto                                                 |
|                                                                          |
|                                                                          |
| CHECKSUM (16 bits):                                                      |
|                 Il checksum viene calcolato come                         |
|         l'ultimo messaggio.                                              |
|                                                                          |
|                                                                          |
| UNUSED (32 bits):                                                        |
|         Rimane inutilizzato.                                             |
|                                                                          |
|                                                                          |
| INTERNET HEADER + 64 BIT DI DATI DEL DATAGRAMMA:                         |
|                 Il titolo è esplicativo. E' usato                        |
|         dai  protocolli di  livello  pi√Ļ alto, se                        |
|         c'è una  porta  da  identificare  o altri                        |
|         campi.                                                           |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| PARAMETER PROBLEM                                                        |
| -----------------                                                        |
|                                                                          |
| Il  messaggio  "Parameter  problem"                                      |
| (problemi di parametri) è inviato quando un                              |
| datagramma ha valori  errati nelle opzioni,                              |
| TOS o un campo non valido.  Il campo UNUSED                              |
| viene  riempito con  un puntatore  al campo                              |
| errato.                                                                  |
|                                                                          |
|                                                                          |
| TYPE (8 bits):                                                           |
|         12        Parameter problem                                      |
|                                                                          |
|                                                                          |
| CODE (8 bits):                                                           |
|         0        Rende il campo POINTER significativo,                   |
|                  cioè non viene ignorato                                 |
|                                                                          |
|                                                                          |
| CHECKSUM (16 bits):                                                      |
|                 Il checksum viene calcolato come                         |
|         l'ultimo messaggio.                                              |
|                                                                          |
|                                                                          |
| POINTER (8 bits):                                                        |
|                 Viene preso in considerazione  solo                      |
|         se  CODE = 0. Esso punta  all'area  dove si                      |
|         trova l'errore.                                                  |
|                                                                          |
|                                                                          |
| UNUSED (24 bits):                                                        |
|                 Rimane inutilizzato.                                     |
|                                                                          |
|                                                                          |
| INTERNET HEADER + 64 BIT DI DATI DEL DATAGRAMMA:                         |
|                 Il titolo è esplicativo. E' usato                        |
|         dai  protocolli di  livello  pi√Ļ alto, se                        |
|         c'è  una  porta  da  identificare o altri                        |
|         campi.                                                           |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|  TIMESTAMP REQUEST e TIMESTAMP REPLY                                     |
|  -----------------------------------                                     |
|                                                                          |
| Tramite questi messaggi  si comunica l'orario in                         |
| secondi in  cui il pacchetto è stato modificato l'ultima                 |
| volta dalla  mezzanotte UT (Universal Time).  Quando  il                 |
| pacchetto  viene  inviato,  l'orario  viene  inserito, e                 |
| quando viene inviata la risposta a questo,viene inserito                 |
| l'orario  affianco a  quello  precedente. Tramite questo                 |
| metodo possiamo calcolare  quando sia distante da noi un                 |
| host.                                                                    |
|                                                                          |
|                                                                          |
| TYPE (8 bits):                                                           |
|         13        Timestamp Request                                      |
|         14        Timestamp Reply                                        |
|                                                                          |
|                                                                          |
| CODE (8 bits):                                                           |
|         0        Rende l'ID e il Seq Num significativi                   |
|                  (non vengono ignorati)                                  |
|                                                                          |
|                                                                          |
| CHECKSUM (16 bits):                                                      |
|                 Il checksum viene calcolato come                         |
|         l'ultimo messaggio.                                              |
|                                                                          |
|                                                                          |
| IDENTIFIER (16 bits):                                                    |
|                 Significativo solo se Code = 0.  Esso                    |
|         aiuta  a determinare la  giusta  combinazione                    |
|         reply / request.                                                 |
|                                                                          |
|                                                                          |
| SEQUENCE NUMBER (16 bits):                                               |
|                 Significativo solo se Code = 0.  Esso                    |
|         aiuta  a determinare la  giusta  combinazione                    |
|         reply / request.                                                 |
|                                                                          |
|                                                                          |
|                                                                          |
|  NETMASK REQUEST e NETMASK REPLY                                         |
|  -------------------------------                                         |
|                                                                          |
| Questo   messaggio   icmp  restituisce  la                               |
| maschera di rete dell'host che invia il messaggio.                       |
| Per generare la reply, gli indirizzi Ip sorgente e                       |
| destinazione vengono invertiti, viene  inserito la                       |
| maschera di rete  nel campo, viene  ricalcolato il                       |
| checksum  e  viene  spedito  al  mittente.  Se  il                       |
| mittente non conosce il proprio Ip, egli inserisce                       |
| 0 nel campo del source ip adress, e la risposta al                       |
| pacchetto   verrà   inviata  all'indirizzo  Ip  di                       |
| broadcast.                                                               |
|                                                                          |
|                                                                          |
|                                                                          |
| TYPE (8 bits):                                                           |
|         17        Netmask Request                                        |
|         18        Netmaks Reply                                          |
|                                                                          |
|                                                                          |
| CODE (8 bits):                                                           |
|         0        Rende l'ID e il Seq Num significativi                   |
|                                                                          |
|                                                                          |
| CHECKSUM (16 bits):                                                      |
|                 Il checksum viene calcolato come                         |
|         l'ultimo messaggio.                                              |
|                                                                          |
|                                                                          |
| IDENTIFIER (16 bits):                                                    |
|                 Significativo solo se Code = 0.  Esso                    |
|         aiuta  a determinare la  giusta  combinazione                    |
|         reply / request.                                                 |
|                                                                          |
|                                                                          |
| SEQUENCE NUMBER (16 bits):                                               |
|                 Significativo solo se Code = 0.  Esso                    |
|         aiuta  a determinare la  giusta  combinazione                    |
|         reply / request.                                                 |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ Esempi                                                              |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| /****************************************************************/       |
| /*                                                              */       |
| /*           Exile 2000 International Coding Team               */       |
| /*                (http://www.exile2k.org)                      */       |
| /*              All rights reserved Exile Team                  */       |
| /*               Copyright 2000 (C) Nitr0gen                    */       |
| /*                                                              */       |
| /*         Questa funzione costruisce un header ICMP (PING)     */       |
| /*                                                              */       |
| /****************************************************************/       |
|                                                                          |
|                                                                          |
|                                                                          |
| void icmp_build(){                                                       |
|                                                                          |
| struct icmphdr *icmp;                                                    |
|                                                                          |
| icmp = (struct icmphdr *) malloc(sizeof(struct icmphdr));                |
|                                                                          |
| icmp->type = ICMP_ECHO;        /*** ECHO REQUEST */                      |
| icmp->code = 0;                /*** Campi Id e Sequence significativi */ |
| icmp->un.echo.id = 0;        /*** Per identificare la risposta al ping */|
| icmp->un.echo.sequence = 0; /*** Per identificare la risposta al ping */ |
| icmp->checksum = 0;        /*** Il campo checksum deve essere 0          |
|                                                   prima del calcolo */   |
|                                                                          |
| icmp->checksum =in_cksum((unsigned short *)icmp,sizeof(struct icmphdr)); |
|         /*** Checksum */                                                 |
|                                                                          |
| }                                                                        |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                 [ CAPITOLO 5 ]                           |
|                                (IMPLEMENTAZIONE)                         |
|                                                                          |
|                                                                          |
| ---[ Teoria                                                              |
|                                                                          |
| Dopo  questa  teoria sui vari header                                     |
| dei protocolli, dobbiamo ora  abbandonare la                             |
| teoria per passare alla implementazione vera                             |
| e propria. Fondamentalmente ciò che descrivo                             |
| in  questo  testo è  come creare  un  socket                             |
| utilizzando il  livello  raw, come  riempire                             |
| la struttura del socket e come comunicare ad                             |
| un livello così basso.                                                   |
|                                                                          |
|         Per prima cosa  osserveremo man mano                             |
| un   codice  sorgente   e   per  ogni  linea                             |
| spiegherò il suo significato. Andiamo:                                   |
|                                                                          |
|                                                                          |
|         int sock, optval;        /***  Descrittore del socket  ***/      |
|         struct sockaddr_in peer; /*** Struttura usata da sendto() ***/   |
|                                                                          |
|                                                                          |
| Se  non  capisci  qualcosa, credo sia meglio                             |
| che tu prenda un libro  sulla programmazione                             |
| dei socket su sistemi unix.                                              |
|                                                                          |
|         if ((sock = socket(AF_INET,SOCK_RAW,IPPROTO_TCP)) == -1){        |
|                 perror("Errore nella creazione del socket");             |
|                 return -1;                                               |
|         }                                                                |
|                                                                          |
|                                                                          |
|  Queste linee creano  un socket utilizzando                              |
|  il  TCP  come  protocollo di trasporto. Il                              |
|  socket è SOCK_RAW per permettere l'accesso                              |
|  raw.   E'  utilizzato  AF_INET  poichè  ci                              |
|  troviamo su internet. Da  ora, se socket()                              |
|  restituisce     un      errore,   perror()                              |
|  visualizzerà il contenuto di errno  e  ciò                              |
|  che ha restituito la funzione.                                          |
|                                                                          |
|         setsockopt(sock,IPPROTO_IP,IP_HDRINCL,&optval,sizeof(int));      |
|                                                                          |
|                                                                          |
|                                                                          |
| Questa  funzione dice  al  socket  sock che                              |
| lavoriamo al livello IPPROTO_IP e  che  noi                              |
| includeremo  l'header ip  (IP_HDRINCL)  nei                              |
| pacchetti inviati. optval  e    sizeof(int)                              |
| non sono  importanti  per  questa  opzione,                              |
| quindi non parlerò di loro.                                              |
|                                                                          |
|                                                                          |
|         peer.sin_family      = AF_INET;                                  |
|         peer.sin_port        = htons(23);                                |
|         peer.sin_addr.s_addr = inet_addr("127.0.0.1");                   |
|                                                                          |
|                                                                          |
| Qui  riempiamo  la   struttura  sockaddr_in                              |
| (peer) utilizzata da sendto().Diciamo che è                              |
| un protocollo di famiglia Internet(AF_INET).                             |
| La   porta   di   destinazione   è   la  23.                             |
| Utilizziamo htons() per la  giusta sequenza                              |
| dei  byte,  come  detto   all'inizio. Nella                              |
| linea  successiva  settiamo  l'indirizzo di                              |
| destinazione  utilizzando  inet_addr()  per                              |
| convertire l'indirizzo in formato binario.                               |
|                                                                          |
| A questo punto dovremmo costruire il nostro                              |
| pacchetto.  Prenderò  per scontato le  cose                              |
| di cui ho parlato nella teoria.                                          |
|                                                                          |
|                                                                          |
|         sendto(sock, packet, strlen(packet),0,                           |
|         (struct sockaddr *)&peer,sizeof(struct sockaddr));               |
|                                                                          |
|                                                                          |
|                                                                          |
| Inviamo il   pacchetto packet  sul socket sock                           |
| per la lunghezza strlen(packet). Nel parametro                           |
| successivo settiamo 0, poichè  non  indichiamo                           |
| alcun flag. Vi sono 4 flag:                                              |
|                                                                          |
|                 MSG_OOB                Questo  invia  un pacchetto       |
|                                 Out  Of  Bound,  aumentando la sua       |
|                                 priorità.                                |
|                                                                          |
|                 MSG_DONTROUTE        Non osserva  la  tabella di         |
|                                 routing   e  invia  direttamente         |
|                                 all'interfaccia.                         |
|                                                                          |
|                 MSG_DONTWAIT        Normalmente   sendto()  può          |
|                                 trattenere un pacchetto, ma con          |
|                                 questo  flag,  non  lo  farà  e          |
|                                 restituirà EAGAIN.                       |
|                                                                          |
|                 MSG_NONSIGNAL        Chiede  di  non  inviare  il        |
|                                 segnale SIGPIPE quando uno stream        |
|                                 orientato     alla    connessione        |
|                                 fallisce cioè genera  un errore o        |
|                                 si disconnette.                          |
|                                                                          |
|                                                                          |
| Poi, con ((struct sockaddr *)&peer), chiediamo                           |
| al   peer   di   specificare  la   famiglia di                           |
| protocolli,  e  la  porta   e  l'indirizzo  di                           |
| destinazione  poichè  sendto  si   aspetta  di                           |
| avere  un  puntatore  alla struttura sockaddr.                           |
| Infine  specifichiamo   la   lunghezza   della                           |
| struttura          sockaddr            tramite                           |
| (sizeof(struct sockaddr))  e  il  datagramma è                           |
| inviato!!                                                                |
|                                                                          |
| Per essere sicuro  di  aver  capito, scrivi                              |
| questo  esempio  e  prova  a   ricevere  il                              |
| pacchetto  e  stamparne  il  risultato.  Ho                              |
| creato  dei  programmini   nella   seguente                              |
| sezione in modo che tu possa  verificare di                              |
| aver capito bene.                                                        |
|                                                                          |
| Suggerimento:     man recv                                               |
|                                                                          |
|         buona fortuna                                                    |
|                                                                          |
|                                                                          |
| -----[ Conclusioni ]---                                                  |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| Ho fatto il meglio  che  potevo  per  creare                             |
| un testo completo e buono sulla  programmazione delle                    |
| raw socket. Spero che il testo ti sia piaciuto e sono                    |
| sicuro che ti abbia aiutato  nel capire  come  codare                    |
| con le raw socket.  Questo  documento  mi  ha aiutato                    |
| a capire delle  cose  di cui  non  ero  sicuro  e  ad                    |
| imparare delle cose che non avevo  mai sentito prima.                    |
| Infine, vorrei  approfittare  di  questo momento  per                    |
| dire ufficialmente  che in breve  tempo  rilascerò un                    |
| portscanner simile a nmap. Sto provando a migliorarne                    |
| la velocit√† e lo stile di codifica  per  renderlo pi√Ļ                    |
| leggibile  a  persone  "ordinarie"  come  me.  Questo                    |
| progetto è chiamato ESCAN ed include  molte  funzioni                    |
| come:  connect  scan,  stealth,  half  open,  decoys,                    |
| logging. Una versione beta dovrebbe essere rilasciata                    |
| il prima possibile. Per seguire lo sviluppo:                             |
|         http://www.exile2k.org                                           |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                         [ Appendice A ]                                  |
|                      (Strutture e Funzioni)                              |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ STRUTTURA HEADER IP                                                 |
|                                                                          |
|                                                                          |
|                                                                          |
| struct iphdr {                                                           |
|                                                                          |
| #if __BYTE_ORDER == __LITTLE_ENDIAN                                      |
|     unsigned int ihl:4;                                                  |
|     unsigned int version:4;                                              |
| #elif __BYTE_ORDER == __BIG_ENDIAN                                       |
|     unsigned int version:4;                                              |
|     unsigned int ihl:4;                                                  |
| #else                                                                    |
| # error        "Please fix <bits/endian.h>"                              |
| #endif                                                                   |
|     u_int8_t tos;                                                        |
|     u_int16_t tot_len;                                                   |
|     u_int16_t id;                                                        |
|     u_int16_t frag_off;                                                  |
|     u_int8_t ttl;                                                        |
|     u_int8_t protocol;                                                   |
|     u_int16_t check;                                                     |
|     u_int32_t saddr;                                                     |
|     u_int32_t daddr;                                                     |
|     /*The options start here. */                                         |
| };                                                                       |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ STRUTTURA PSEUDO HEADER                                             |
|                                                                          |
|                                                                          |
|                                                                          |
| struct pseudohdr {                                                       |
|         unsigned long saddr;                                             |
|         unsigned long daddr;                                             |
|         char useless;                                                    |
|         unsigned char protocol;                                          |
|         unsigned short length;                                           |
| };                                                                       |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ STRUTTURA HEADER TCP                                                |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| struct tcphdr {                                                          |
|         __u16        source;                                             |
|         __u16        dest;                                               |
|         __u32        seq;                                                |
|         __u32        ack_seq;                                            |
| #if defined(__LITTLE_ENDIAN_BITFIELD)                                    |
|         __u16        res1:4,                                             |
|                 doff:4,                                                  |
|                 fin:1,                                                   |
|                 syn:1,                                                   |
|                 rst:1,                                                   |
|                 psh:1,                                                   |
|                 ack:1,                                                   |
|                 urg:1,                                                   |
|                 res2:2;                                                  |
| #elif defined(__BIG_ENDIAN_BITFIELD)                                     |
|                 __u16        doff:4,                                     |
|                 res1:4,                                                  |
|                 res2:2,                                                  |
|                 urg:1,                                                   |
|                 ack:1,                                                   |
|                 psh:1,                                                   |
|                 rst:1,                                                   |
|                 syn:1,                                                   |
|                 fin:1;                                                   |
| #else                                                                    |
| #error        "Adjust your <asm/byteorder.h> defines"                    |
| #endif                                                                   |
|         __u16        window;                                             |
|         __u16        check;                                              |
|         __u16        urg_ptr;                                            |
| };                                                                       |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ STRUTTURA HEADER UDP                                                |
|                                                                          |
|                                                                          |
|                                                                          |
| struct udphdr {                                                          |
|         __u16        source;                                             |
|         __u16        dest;                                               |
|         __u16        len;                                                |
|         __u16        check;                                              |
| };                                                                       |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ STRUTTURA HEADER ICMP                                               |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| struct icmphdr {                                                         |
|   __u8          type;                                                    |
|   __u8          code;                                                    |
|   __u16         checksum;                                                |
|   union {                                                                |
|         struct {                                                         |
|                 __u16   id;                                              |
|                 __u16   sequence;                                        |
|         } echo;                                                          |
|         __u32   gateway;                                                 |
|         struct {                                                         |
|                 __u16   __unused;                                        |
|                 __u16   mtu;                                             |
|         } frag;                                                          |
|   } un;                                                                  |
| };                                                                       |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ---[ FUNZIONE PER IL CALCOLO DEL CHECKSUM                                |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| /*                                                                       |
|  * in_cksum --                                                           |
|  *      Checksum routine for Internet Protocol                           |
|  *        family headers (C Version)                                     |
|  */                                                                      |
| unsigned short in_cksum(unsigned short *addr, int len)                   |
| {                                                                        |
|     register int sum = 0;                                                |
|     u_short answer = 0;                                                  |
|     register u_short *w = addr;                                          |
|     register int nleft = len;                                            |
|                                                                          |
|     /*                                                                   |
|      * Our algorithm is simple, using a 32 bit accumulator (sum), we add |
|      * sequential 16 bit words to it, and at the end, fold back all the  |
|      * carry bits from the top 16 bits into the lower 16 bits.           |
|      */                                                                  |
|     while (nleft > 1)                                                    |
|       {                                                                  |
|           sum += *w++;                                                   |
|           nleft -= 2;                                                    |
|       }                                                                  |
|                                                                          |
|     /* mop up an odd byte, if necessary */                               |
|     if (nleft == 1)                                                      |
|       {                                                                  |
|           *(u_char *) (&answer) = *(u_char *) w;                         |
|           sum += answer;                                                 |
|       }                                                                  |
|     /* add back carry outs from top 16 bits to low 16 bits */            |
|     sum = (sum >> 16) + (sum & 0xffff);  /* add hi 16 to low 16 */       |
|     sum += (sum >> 16);                /* add carry */                   |
|     answer = ~sum;                /* truncate to 16 bits */              |
|     return (answer);                                                     |
| }                                                                        |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| ----[ Codici sorgente                                                    |
|                                                                          |
|                                                                          |
| /********************************************************************/   |
| /*                                                                  */   |
| /*           Exile 2000 International Coding Team                   */   |
| /*                (http://www.exile2k.org)                          */   |
| /*              All rights reserved Exile Team                      */   |
| /*               Copyright 2000 (C) Nitr0gen                        */   |
| /*                                                                  */   |
| /*         Questa funzione costruisce un pacchetto ICMP (PING)      */   |
| /*                     includendo l'header IP                       */   |
| /*                                                                  */   |
| /*                                                                  */   |
| /*                                                                  */   |
| /*                                                                  */   |
| /********************************************************************/   |
|                                                                          |
|                                                                          |
| #include <stdio.h>                                                       |
|                                                                          |
| #include <linux/ip.h>                                                    |
| #include <linux/icmp.h>                                                  |
| #include <netinet/in.h>                                                  |
| #include <sys/types.h>                                                   |
| #include <sys/socket.h>                                                  |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| unsigned short in_cksum(unsigned short *addr, int len);                  |
|                                                                          |
|                                                                          |
| int main(){                                                              |
|                                                                          |
| int sock, optval;                                                        |
| char *packet, *buffer;                                                   |
|                                                                          |
| struct icmphdr *icmp;                                                    |
|                                                                          |
| struct sockaddr_in peer;                                                 |
| struct iphdr *ip;                                                        |
|                                                                          |
|                                                                          |
| ip = (struct iphdr *) malloc(sizeof(struct iphdr));                      |
| icmp     = (struct icmphdr *) malloc(sizeof(struct icmphdr));            |
| packet= (char *) malloc(sizeof(struct iphdr) + sizeof(struct icmphdr));  |
| buffer= (char *) malloc(sizeof(struct iphdr) + sizeof(struct icmphdr));  |
|                                                                          |
|                                                                          |
| ip = (struct iphdr *) packet;                                            |
| icmp = (struct icmphdr *) (packet + sizeof(struct iphdr));               |
|                                                                          |
|                                                                          |
| ip->ihl     = 5;                                                         |
| ip->version = 4;                                                         |
| ip->tos     = 0;                                                         |
| ip->tot_len = sizeof(struct iphdr) + sizeof(struct icmphdr);             |
| ip->id      = htons(getuid());                                           |
| ip->ttl      = 255;                                                      |
| ip->protocol = IPPROTO_ICMP;                                             |
| ip->saddr    = inet_addr("127.0.0.1");                                   |
| ip->daddr    = inet_addr("127.0.0.1");                                   |
|                                                                          |
|                                                                          |
| sock = socket(AF_INET,SOCK_RAW,IPPROTO_ICMP);                            |
| setsockopt(sock,IPPROTO_IP,IP_HDRINCL,&optval,sizeof(int));              |
|                                                                          |
| icmp->type = ICMP_ECHO;                                                  |
| icmp->code = 0;                                                          |
| icmp->un.echo.id = 0;                                                    |
| icmp->un.echo.sequence = 0;                                              |
| icmp->checksum = 0;                                                      |
|                                                                          |
| icmp->checksum = in_cksum((unsigned short *)icmp,sizeof                  |
|      (struct icmphdr));                                                  |
|                                                                          |
| ip->check    = in_cksum((unsigned short *)ip, sizeof(struct iphdr));     |
|                                                                          |
|                                                                          |
|                                                                          |
| peer.sin_family = AF_INET;                                               |
| peer.sin_addr.s_addr = inet_addr("127.0.0.1");                           |
|                                                                          |
| sendto(sock,packet,ip->tot_len,0,(struct sockaddr *)&peer,sizeof         |
|       (struct sockaddr));                                                |
|                                                                          |
| recv(sock,buffer,sizeof(struct iphdr)+sizeof(struct icmphdr),0);         |
| printf("Ricevuto l'ECHO REPLY\n");                                       |
|                                                                          |
| close(sock);                                                             |
| return 0;                                                                |
| }                                                                        |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| /********************************************************************/   |
| /*                                                                  */   |
| /*            Exile 2000 International Coding Team                  */   |
| /*                 (http://www.exile2k.org)                         */   |
| /*               All rights reserved Exile Team                     */   |
| /*                Copyright 2000 (C) Nitr0gen                       */   |
| /*                                                                  */   |
| /*              Questa funzione csotruisce un pacchetto UDP         */   |
| /*     includendo l'header IP ed inviandlo al server echo locale    */   |
| /*                                                                  */   |
| /*  Per far funzionare il programma abilita il server echo:         */   |
| /*                                                                  */   |
| /*     - pico /etc/inetd.conf                                       */   |
| /*     - Elimina i simboli del commento dalla riga                  */   |
| /*       dell'echo server (udp one)                                 */   |
| /*     - killall -HUP inetd                                         */   |
| /*                                                                  */   |
| /*                                                                  */   |
| /*                                                                  */   |
| /*                                                                  */   |
| /********************************************************************/   |
|                                                                          |
|                                                                          |
| #include <stdio.h>                                                       |
|                                                                          |
| #include <linux/ip.h>                                                    |
| #include <linux/udp.h>                                                   |
| #include <netinet/in.h>                                                  |
| #include <sys/types.h>                                                   |
| #include <sys/socket.h>                                                  |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
| unsigned short in_cksum(unsigned short *addr, int len);                  |
|                                                                          |
|                                                                          |
|                                                                          |
| int main(){                                                              |
|                                                                          |
| int sock, optval;                                                        |
| char *packet, *buffer;                                                   |
|                                                                          |
| struct udphdr *udp;                                                      |
| struct pseudohdr {                                                       |
|         unsigned long saddr;                                             |
|         unsigned long daddr;                                             |
|         char useless;                                                    |
|         unsigned char protocol;                                          |
|         unsigned short length;                                           |
| }pseudo;                                                                 |
|                                                                          |
| struct sockaddr_in peer;                                                 |
| struct iphdr *ip;                                                        |
|                                                                          |
|                                                                          |
| ip = (struct iphdr *) malloc(sizeof(struct iphdr));                      |
| udp     = (struct udphdr *) malloc(sizeof(struct udphdr));               |
| packet  = (char *) malloc(sizeof(struct iphdr) +                         |
|           sizeof(struct udphdr) + 12);                                   |
| buffer  = (char *) malloc(sizeof(struct iphdr) +                         |
|           sizeof(struct udphdr) + 12);                                   |
|                                                                          |
|                                                                          |
| ip = (struct iphdr *) packet;                                            |
| udp = (struct udphdr *) (packet + sizeof(struct iphdr));                 |
|                                                                          |
|                                                                          |
| ip->ihl     = 5;                                                         |
| ip->version = 4;                                                         |
| ip->tos     = 0;                                                         |
| ip->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) +12;          |
| ip->id      = htons(getuid());                                           |
| ip->ttl      = 255;                                                      |
| ip->protocol = IPPROTO_UDP;                                              |
| ip->saddr    = inet_addr("127.0.0.1");                                   |
| ip->daddr    = inet_addr("127.0.0.1");                                   |
|                                                                          |
|                                                                          |
| sock = socket(AF_INET,SOCK_RAW,IPPROTO_UDP);                             |
| setsockopt(sock,IPPROTO_IP,IP_HDRINCL,&optval,sizeof(int));              |
|                                                                          |
| pseudo.saddr    = inet_addr("127.0.0.1");                                |
| pseudo.daddr    = inet_addr("127.0.0.1");                                |
| pseudo.useless  = htons(0);                                              |
| pseudo.protocol = IPPROTO_UDP;                                           |
| pseudo.length   = sizeof(struct udphdr) + 12;                            |
|                                                                          |
|                                                                          |
| udp->source = htons(5000);                                               |
| udp->dest   = htons(7);                                                  |
| udp->len    = htons(sizeof(struct udphdr) + 12);                         |
| udp->check  = in_cksum((unsigned short *)&pseudo,sizeof(struct udphdr)   |
|      + sizeof(struct pseudohdr) + 12);                                   |
|                                                                          |
| ip->check    = in_cksum((unsigned short *)ip, sizeof(struct iphdr));     |
|                                                                          |
|                                                                          |
| strcpy((packet+sizeof(struct iphdr) + sizeof(struct udphdr)),            |
|         "Hello World");                                                  |
|                                                                          |
| peer.sin_family = AF_INET;                                               |
| peer.sin_addr.s_addr = inet_addr("127.0.0.1");                           |
| peer.sin_port = htons(7);                                                |
|                                                                          |
| sendto(sock,packet,ip->tot_len,0,(struct sockaddr *)&peer,sizeof         |
|       (struct sockaddr));                                                |
|                                                                          |
| recv(sock,buffer,sizeof(struct iphdr)+sizeof(struct udphdr)+13,0);       |
|                                                                          |
| buffer += (sizeof(struct iphdr)+sizeof(struct udphdr));                  |
| printf("Reply from Echo server:\t%s\n",buffer);                          |
|                                                                          |
| close(sock);                                                             |
| return 0;                                                                |
| }                                                                        |
|                                                                          |
|                                 [ Riferimenti ]                          |
|                                                                          |
|                                                                          |
|                                                                          |
| Tcp/Ip Illustrated Volume 1 (The Protocol)                               |
| By W. Richard Stevens (Addison Wesley)                                   |
|                                                                          |
| Tcp/Ip Illustrated Volume 2 (The implementation)                         |
| By Gary R. Wright and W. Richard Stevens (Addition Wesley)               |
|                                                                          |
| Dai un'occhiata qui:                                                     |
|                                                                          |
|         http://www.exile2k.org                Exile Team home page       |
|         http://www.hexedit.com                HNS home page              |
|         http://www.eEyes.com                  eEyes home page            |
|                                                                          |
|                                                                          |
|                                                                          |
|                                 [ Ringraziamenti ]                       |
|                                                                          |
|                                                                          |
|                                                                          |
| Special thanx to:                                                        |
|         My Exile team bro's: Mayhem(Tutu rose emulator),                 |
|                                    Rix(Assembly wh0re),                  |
|                                    Kraken(Saleter dhypee),               |
|                                    Ehoba(Pas toi!!!),                    |
|                                    Liks(Erm...)                          |
|                                                                          |
|                 or Europeen wh0res kinda synonyms =]                     |
|                  ---> keep it kool guys!                                 |
|                                                                          |
|         #rhino9 peeps: Colonwq(Gotta learn you howto drink),             |
|                        Hexedit(Lucky to be yourself),                    |
|                        Binf(Mon mentor de hacking y0),                   |
|                        Klog(Bleh j00),                                   |
|                        zorkeres(Still sickshit addict?),                 |
|                        RcLocal(The french skill0rz),                     |
|                        and others                                        |
|                                                                          |
|         People who supported me even if i was newbie: Utopiste,          |
|                                                       Wyzeman...         |
|                                                                          |
| ~ My parents who made it possible during 1982's night... ~               |
|                                                                          |
|                 God bless people i forget...                             |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|                                                                          |
|         Nitr0gen     Exile Team 2000     Rock on!                        |
|                  nitr0gen@hackersnews.com                                |
|                                                                          |
|                                                                          |
| Tradotto da XpTerminator:                                                |
|                                                                          |
|     spero  proprio  di  aver  tradotto bene...                           |
| per  qualunque  genere  di  errore  segnalate  a:                        |
|                                                                          |
|                                   xp_terminator@katamail.com             |
|                                   http://xpterminator.cjb.net            |
|                                                                          |
| Ciao a tutti!                                                            |
|                                                                          |
|                                                                          |
+--------------------------------------------------------------------------+

Gabole in IRC

When I was 16, I used to write articles under the nicknames Esorcista and XpTerminator.

The following is an article on how to spoof nicknames in IRC DCC chats, that got published on the 6th issue of OndaQuadra, an Italian e-zine.

 

+--------------------------------------------------------------------------+
| ONDAQUADRA ~ [L'APPRENDiSTA STREG0NE]                   #05 - 14/01/2002 |
| GAB0LE iN iRC                                  [Xp Terminator] 0x1C/0x23 |
+--------------------------------------------------------------------------+
|                                                                          |
|                     +++ Disclaimer +++                                   |
| Continuando  a  leggere  questo  testo  accetti le seguenti  condizioni: |
|                                                                          |
| tutte le azioni che  compirai durante e dopo  la lettura   di  questo    |
| testo saranno di tua completa responsabilita`,  nessuna  colpa  potra`   |
| essere quindi data ne all`autore del testo ne a chiunque altro citato.   |
|                            +++                                           |
|                                                                          |
|                                                                          |
|                        .: IRC :.                                         |
|                                                                          |
| Irc e` sicuramente uno dei protocolli di chat piu` utilizzati al mondo,  |
| ma  soprattutto  e`  stato  il  primo  protocollo di chat a tempo reale  |
| realizzato. L`Internet Relay Chat faceva la sua prima comparsa gia` nel  |
| 1988, poi, miglioratosi nel tempo, si e` sempre piu` diffuso,diventando  |
| cio`  che  e`  oggi. Questo sistema  di  chat  si basa su un server irc  |
| bindato solitamente sulla porta di default 6667 di un server,  al quale  |
| e` possibile connettersi tramite un client irc; appena connessi bisogna  |
| registrarsi, cioe' "presentarsi", (il client irc lo  fa automaticamente) |
| e  si  puo` iniziare a chattare joinando uno o piu` canali.              |
|                                                                          |
|                     .: Client IRC :.                                     |
|                                                                          |
| Il compito principale del client  irc  e`  quello  di un vero e proprio  |
| interprete dei comandi:  quando  inviamo  un  comando  come per esempio  |
| "/ping nickname", questo non viene inviato  cosi` com`e` al server irc,  |
| ma viene elaborato dal client:  la  stringa  inviata  al  server  e` in  |
| realta`  "PRIVMSG NICKNAME : PING 12345678 ",  dove  12345678 e' un      |
| numero  generato  dal  client  utilizzato come identificatore, cioe' che |
| aiuta a capire ad ogni ping quale pong appartiene, proprio come avviene  |
| nei veri ping con il campo Identifier dei pacchetti ICMP.                |
| Potete  verificare cio` sniffando la vostra connessione e osservando il  |
| pacchetto inviato per un ping, il risultato sara' simile al seguente:    |
|                                                                          |
| Source IP: xxx.xxx.xxx.xxx  Target IP: yyy.yyy.yyy.yyy                   |
| TCP Length:37 Source Port:1130 Target Port:6667 Seq:369FDEB6 Ack:        |
| E1CFF6F1                                                                 |
| Flags: PA  Window: 9112  TCP ChkSum: 63304  UrgPtr: 0                    |
|  00000000: 50 52 49 56 4D 53 47 20 70 72 65 73 69 64 65 6E  PRIVMSG      |
|  presiden                                                                |
|  00000010: 74 20 3A 01 50 49 4E 47 20 31 30 30 35 33 33 32  t :.PING     |
|  1005332                                                                 |
|  00000020: 38 38 38 01 0A                                   888..        |
|                                                                          |
| Lo  stesso naturalmente  vale  anche  per i  semplici messaggi inviati;  |
| quando  il  client  vede  che  la  stringa  non  inizia  con /  capisce  |
| che   e`   un messaggio    ed    invia    al    server    il    comando  |
| "PRIVMSG NICKNAME_O_#CHAN :MESSAGGIO",   dove  NICKNAME_O_#CHAN  e`  il  |
| nickname  della  persona a  cui vogliamo inviare il messaggio o il nome  |
| del canale a cui invarlo. Da  cio`  e`  facile capire che i comandi che  |
| digitiamo  non  sono  altro  che  dei comandi usati per convenzione dai  |
| client, col fine di semplificare la comunicazione col server ( cio` che  |
| avviene con tutti i client, questo e' il loro compito..).                |
| Un  modo  per  rendervi  piu`  chiare  le idee e` quello di telnettarvi  |
| sul  vostro  server  irc  preferito  e  di  provare ad inviare i soliti  |
| comandi che digitate nel client.                                         |
| Sia  il  protocollo  IRC  sia  i  vari  server  IRC  sono  in  continua  |
| evoluzione,  e  per  evitare  che  un  client  non  permetta  una certa  |
| operazione si puo` inviare  un  comando  direttamente al  server, senza  |
| l`elaborazione  del client, grazie  al  comando convenzionale "/quote "  |
| o "/raw ". Basta anteporre uno di questi due comandi al comando  che si  |
| vuole  inviare  al  server. Per  provare,  digitate  nel  vostro client  |
| "/raw PRIVMSG VOSTRO_NICK :Ciao :)": dopo un attimo  vi  si aprira` una  |
| query  e  vi arrivera` il messaggio "Ciao :)" da voi stessi (sempre che  |
| abbiate sostituito  VOSTRO_NICK  col vostro nickname :P),  naturalmente  |
| non rispondetegli :P.                                                    |
|                                                                          |
| Ok, l'introduzione  basilare  al  testo,  la  parte  piu`  teorica , e`  |
| finita, passiamo  ora  a  vedere qualcosa di  maggiormente interessante  |
| e curioso che ho scoperto utilizzando irc.                               |
|                                                                          |
| Poiche` i comandi reali inviati al server e quindi le opzioni di questi  |
| vengono trattati dal nostro client, e` improbabile poter  scoprire  bug  |
| o tricks del protocollo o di un server irc, proprio come,  per esempio,  |
| (esempio classico..)  non possiamo  inviare  fake  mail  utilizzando un  |
| client mail (almeno che non si modifichino le impostazioni).Per la fake  |
| mail  ricorriamo  all`utilizzo  di telnet, mentre, per irc, il tutto e`  |
| ancora  possibile  rimanendo  nell`ambito del client irc utilizzando il  |
| comando appena visto "/raw".                                             |
| Per  testare  i  vari  comandi  e  quindi poterne trovare pro e difetti  |
| dobbiamo conoscerne la sintassi, quindi  o  leggiamo l`RFC inerente irc  |
| oppure, piu`  facilmente,  sniffiamo  la  nostra   connessione  durante  |
| l`utilizzo del comando e osserviamo  i pacchetti che il client invia al  |
| server.                                                                  |
|                                                                          |
|                                                                          |
|                      .: uSO AltERNAtiVo DELLA dCC CHAt :.                |
|                                                                          |
| La  dcc  chat e` una chat privata che a differenza della query  avviene  |
| senza nessun tramite tra i due utenti (nella  query  il  tramite  e` il  |
| server irc) e quindi e` possibile visionare l`indirizzo ip  dell`utente  |
| con cui si sta parlando. Quindi, sniffiamo un po` ;) ed  osserviamo  la  |
| sintassi del comando:                                                    |
|                                                                          |
| Source IP: xxx.xxx.xxx.xxx  Target IP: yyy.yyy.yyy.yyy                   |
| TCP Length:54 Source Port:1300 Target Port:6667 Seq:70ECA4EC Ack:        |
| C64F6192                                                                 |
| Flags: PA  Window: 8841  TCP ChkSum: 56804  UrgPtr: 0                    |
|                                                                          |
|  00000000: 50 52 49 56 4D 53 47 20 58 70 54 65 72 6D 69 6E  PRIVMSG      |
|  XpTerminator                                                            |
|  00000010: 61 74 6F 72 20 3A 01 44 43 43 20 43 48 41 54 20  ator :.DCC   |
|  CHAT                                                                    |
|  00000020: 63 68 61 74 20 32 33 35 34 35 35 34 31 35 38 20  chat         |
|  2354554158                                                              |
|  00000030: 33 39 33 36 01 0A                                3936..       |
|                                                                          |
| Le prime tre righe  rappresentano l'header del pacchetto, quindi source  |
| ip,  target ip,  flag settati,  checksum, ecc., il resto e' il campo del |
| pacchetto riguardante i dati. I numeri  centrali  sono  i  codici ascii  |
| in  esadecimale  della  stringa della terza colonna, cioe` della nostra  |
| sintassi.  Come   vediamo   quindi   la   sintassi   e`                  |
| "PRIVMSG NICKNAME : DCC CHAT chat 12345 12345 "                          |
| Come  notate  nel  pacchetto  che  abbiamo  sniffato  al posto dei " "   |
| vi  sono  dei  punti (anche nel pacchetto visto precedentemente, quello  |
| del ping),pero` se osservate la colonna centrale e il rispettivo codice  |
| ascii  in  esadecimale  vedete  che  il valore e` 01 che in decimale e`  |
| sempre 01 ma  che  normalmente  in  un  normale editor  di testo non si  |
| riesce  a  visualizzare  come  codice  ascii (provate nel vostro editor  |
| ALT + 1),  e  neanche  lo  sniffer  riesce  a  visualizzarlo  quindi lo  |
| sostituisce con un punto. Per visualizzarlo e quindi poterlo utilizzare  |
| nel vostro client, esistono diversi metodi,che possono cambiare secondo  |
| il  sistema  operativo  e  il  client  irc  in utilizzo. Con X-Chat per  |
| visualizzarlo, basta cliccare sulla  freccetta  che  si  trova al  lato  |
| della text box dove si scrivono i messaggi, cliccare sul  tasto ASCII e  |
| quindi sul tasto relativo al carattere 1, questo sara' visualizzato come |
| un piccolo rombo (potrebbe essere diverso). Con mIRC  si puo' utilizzare |
| il comando "//echo $chr(1)" per visualizzare il carattere, questo verra' |
| rappresentato con un quadratino. Naturalmente non ho  potuto verificare  |
| con tutti i client, ma  per  visualizzare il carattere si puo' anche per |
| esempio utilizzare la funzione per visualizzare caratteri ascii,  quasi  |
| sempre chr,presente praticamente in tutti i linguaggi di programmazione  |
| "chr(1)" (naturalmente  e`  una  funzione  e  come  tale restituendo un  |
| valore   va   inserito   nella   procedura  per  visualizzare  a  video  |
| [per esempio in Pascal "writeln(chr(1));"])(questo e` un metodo che non  |
| sempre mi ha funzionato, sempre a causa dell'incapacita' di visualizzare |
| il  carattere). Esisteranno   sicuramente   anche   altri   metodi  per  |
| visualizzarlo ma io non ne conosco altri.                                |
| Il carattere ascii 1 e' questo "", se non vedete nessun  carattere tra |
| le virgolette significa che il vostro editor non ne ha la possibilita'.  |
| Detto  questo  continuiamo  l`analisi  della  sintassi. La  prima parte  |
| "PRIVMSG NICKNAME" specifica che  stiamo inviando un  messaggio privato  |
| al nickname, la  seconda  parte invece, che  si  trova  tra i caratteri  |
| ascii 1 ("DCC CHAT chat 1234 12345") va analizzata piu` a fondo.         |
| "DCC CHAT chat" specifica appunto che stiamo inviando una  richiesta di  |
| DCC CHAT, mentre i due numeri successivi sono rispettivamente il nostro  |
| indirizzo ip in formato long e la porta che abbiamo messo  in listening  |
| in  attesa  che l`utente  accetti  la  dcc chat e ci si connetti : cio`  |
| avviene  perche`  la  connessione  dcc chat  dalla  parte client e` una  |
| connessione passiva; e` facile capire il perche`: se sarebbe  stata una  |
| connessione attiva, il  client  sarebbe  stato in  grado  di  conoscere  |
| l`indirizzo ip dell`utente irc anche senza che questo  avesse accettato  |
| la dcc chat. Spiego meglio:  l`utente che ricevera` la richiesta di dcc  |
| chat, se accetta, dovra` conoscere  il  nostro ip  e  la  nostra  porta  |
| locale alla quale connettersi per la conversazione privata. Normalmente  |
| si pensa che sia direttamente il server  irc  a inviarlo all`utente, ma  |
| per diversi motivi, come per esempio quello che il server irc  non puo`  |
| sapere su che porta noi stiamo attendendo  la  connessione, lo  inviamo  |
| invece  noi. Il  fatto  che  noi  specifichiamo  a che ip e porta debba  |
| connettersi l`utente dovrebbe gia` farci  venire un paio  di belle idee  |
| in  testa, infatti, grazie  a  questo comando,  potremo  effettuare  un  |
| semplice ip spoofing (se cosi` lo si puo` definire..).                   |
| In  pratica  cambiando questi due dati, se il ricevente della richiesta  |
| accetta,  non  si  trovera` in dcc chat con noi, ma con il demone sulla  |
| porta 12345 della macchina 12345 che specificheremo, in parole povere :  |
| facciamo connettere la persona a cui inviamo la richiesta dove vogliamo, |
| trasformando la semplice dcc chat in un telnet;naturalmente la finestra  |
| della dcc chat (il nostro telnet ;)non fungera` anche come emulatore di  |
| terminale, quindi non potremo far connettere la persona  a  determinati  |
| servizi, o meglio, si connettera`, ma le risposte  che  gli inviera` il  |
| server saranno incomprensibili per lui. Nell`analisi  di  prima abbiamo  |
| visto che l`indirizzo ip da inviare si deve specificare in formato long, |
| quindi,prima di poter continuare,vediamo come sia possibile convertirlo  |
| in questo formato.                                                       |
| Per convertire un indirizzo ip dal formato normale a 32 bit al  formato  |
| long, si prosegue in questo modo: immaginiamo  che  l`indirizzo  ip  da  |
| convertire sia 100.20.30.40;sappiamo che l`indirizzo ip e` formato da 4  |
| numeri  da  8  bit  ciascuno, moltiplichiamo  il primo per 16777216, il  |
| secondo per 65536, il terzo per 256 ed il quarto per 1, quindi facciamo  |
| la somma di questi quattro prodotti.                                     |
| Nel nostro esempio:                                                      |
|                                                                          |
| (100 * 16777216) +                                                       |
| (20  *    65536) +                                                       |
| (30  *      256) +                                                       |
| (40  *        1) =                                                       |
| 1677721600 + 1310720 + 7680 + 40 = 1679040040                            |
|                                                                          |
| quindi                                                                   |
|  100.20.30.40  -> formato standard                                       |
|   =                                                                      |
|  1679040040    -> formato long                                           |
|                                                                          |
| Se  utilizzate come client irc  mirc, per  la  conversione  da  formato  |
| 32  bit  a  quello  long  e  viceversa,  si  puo'  utilizzare il comando |
| "//echo 2 $longip(IP)": se  forniamo  l`IP  in  formato  long ci verra`  |
| restituito in formato a 32 bit e se forniamo quello  a 32 bit ci verra`  |
| restituito in formato long.                                              |
| Spiegato  cio`  passiamo  alla  pratica. Esistono  diversi  scenari  di  |
| applicazione, vediamone qualcuno:                                        |
|                                                                          |
| In irc e` connesso  un  tizio con nickname NICKNAME (che fantasia :), e  |
| vogliamo farlo connettere per esempio  al server xxx.xxx.xxx.xxx  sulla  |
| porta 25. Per  prima  cosa  convertiamo  l`indirizzo xxx.xxx.xxx.xxx in  |
| formato long  ed otteniamo yyyyyyyyyyy, dopodiche`  scriviamo  in  irc:  |
| "/raw PRIVMSG NICKNAME : DCC CHAT chat yyyyyyyyyyy 25 "                  |
| oppure                                                                   |
| "/quote PRIVMSG NICKNAME : DCC CHAT chat yyyyyyyyyyy 25 "                |
| e NICKNAME ricevera` una richiesta DCC CHAT da parte vostra,  ma quando  |
| accettera` non sara` in chat  privata con voi, ma  sara`  connesso  sul  |
| server  da  noi  specificato  in  comunicazione  col  demone smtp sulla  |
| porta 25 (logicamente sempre se la porta sia aperta), e tutto  cio` che  |
| credera` di inviare a voi lo inviera` in realta` al server e tutto cio`  |
| che il server gli rispondera` gli sembrera` in realta` arrivare da voi.  |
|                                                                          |
|                                                                          |
| E` una giornata molto calda e siamo molto stanchi,  non  abbiamo voglia  |
| di  utilizzare  il  nostro  solito e monotono telnet (=P) e pensiamo di  |
| cambiare utilizzando la dcc chat ;). Quindi mettiamo caso che il nostro  |
| nick e` XpTerminator e ci vogliamo connettere al server xxx.xxx.xxx.xxx  |
| sulla  porta  25. Convertiamo  xxx.xxx.xxx.xxx in yyyyyyyyyy e  inviamo  |
| questo comando                                                           |
| "/quote PRIVMSG XpTerminator : DCC CHAT chat yyyyyyyyyy 25 ", ci         |
| arrivera` una richiesta di dcc chat da parte di noi stessi  e quando     |
| accetteremo saremo in chat privata con yyyyyyyyyy:25. I messaggi che ci  |
| arriveranno dal server ci appariranno come invati da  noi stessi, cioe`  |
| del tipo: "<XpTerminator> Server yyyyyyyyyy".                            |
|                                                                          |
| Se  riuscite  a  trovare  un  nuovo  utilizzo  o  scenario  per  questo  |
| piccolo   trick   contattatemi   all`indirizzo   email                   |
| xp_terminator@katamail.com , lo    pubblichero`    volentieri   in   un  |
| aggiornamento  di  questo  testo, con  naturalmente  un  ringraziamento  |
| riportato.                                                               |
|                                                                          |
|                                                                          |
|                      .: sCHERZETTi DEl MiRc :.                           |
|                                                                          |
| Il  client  Mirc  ha  due  funzioni  $encode  e  $decode che criptano e  |
| decriptano dei comandi usando Uuencode o Mime.                           |
| La sintassi di queste due funzioni e`:                                   |
|         $encode(msg[, mubt])                                             |
|         $decode(msg[, mubt])                                             |
|                                                                          |
| In realta` non e`  precisamente cosi`, ci sarebbe  un terzo  parametro,  |
| opzionale,  ma  che  non  ci  interessa  per  il nostro fine. Msg e` il  |
| messaggio  che  vogliamo  criptare  o  decriptare,  mentre  il  secondo  |
| parametro  puo`  avere   come   valori m , u , b , t.  M sta  per Mime,  |
| U sta per uucode(la scelta di default se si tralascia questo parametro)  |
| le altre due B e T le sorvoliamo non interessandoci.Proviamo a scrivere  |
| il comando "//echo $encode(/amsg Ciao)" (ricordo  che  naturalmente  il  |
| tutto   funziona   solo   con   mirc),  il   client   ci    restituira`  |
| "*+V%M<V<@0VEA;P``"  ovvero  "/amsg Ciao"  codificato  con uucode. Come  |
| vedete il secondo parametro l`abbiamo tralasciato ed il client ha quindi |
| utilizzato  come  default  U.  Proviamo   ora   il   comando "//echo     |
| $encode(/amsg Ciao,m)", questa  volta  mirc  ci rispondera` con          |
| "L2Ftc2cgQ2lhbw==", ovvero la codifica Mime. Proviamo ora invece a fare  |
| la cosa inversa, scriviamo "//echo $decode(L2Ftc2cgQ2lhbw==,m)" (notate  |
| la m come seconda opzione). Mirc ci restituira` "/amsg Ciao".            |
| Bene,abbiamo visto come funziona la codifica,ma ora passiamo alla parte  |
| piu`  interessante. Quel "//echo "  che   abbiamo  scritto  davanti  la  |
| funzione serve  a  far  stampare  in  locale cio` che essa ritorna come  |
| output, cioe` il messaggio criptato o decriptato. Ma se invece di farlo  |
| stampare il comando decriptato lo vogliamo eseguire?                     |
| Scriviamo il comando "//$decode(L2Ftc2cgQ2lhbw==,m)" e verra`  eseguito  |
| il comando "/amsg Ciao" cioe` verra` inviato in tutti  i  canali in cui  |
| ci troviamo il messaggio "Ciao". (per  fare  cio`  utilizzate sempre il  |
| mime come secondo parametro,naturalmente sia nella criptatura che nella  |
| decriptatura).Immaginate un attimo a quanta gente ingenua esiste in irc  |
| che utilizza mirc..praticamente quasi la meta` delle persone :).         |
| Vi  stupirete  vedendo  che  andando in query a molte persone e dicendo  |
| qualcosa tipo:                                                           |
| "Prova  a  scrivere  //$decode(messaggio_criptato,m) ,  ho scoperto che  |
| facendo cosi` diventi op del canale", quasi tutte lo faranno sul serio,  |
| ed  immaginate  tutte le possibilita` che  avrebbe  un  malintenzionato  |
| contro questi poveretti ;).                                              |
| Ecco vari esempi:                                                        |
|                                                                          |
| "/timer 0 0 /amsg Bye!" ripete infinitamente il comando "/amsg Bye!",se  |
| lo si esegue dopo qualche msg il server vi disconnette per flood.        |
| (proprio qualche tempo fa su azzurra in un paio di minuti si  e' diffusa |
| un'epidemia di questo comando :)))                                       |
| Criptiamolo col mime, viene fuori:                                       |
| "//echo $encode(/timer 0 0 /amsg Bye!,m)"                                |
|     |                                                                    |
|     v                                                                    |
| "L3RpbWVyIDAgMCAvYW1zZyBCeWUh"                                           |
|                                                                          |
| "//say $ip"  e`  un  comando  che  visualizza  il  proprio  numero  ip.  |
| Immaginate di voler sapere il numero ip di qualcuno abbastanza ingenuo,  |
| e non  volete  convincerlo  a fargli scrivere questo comando poiche` il  |
| suo significato e` troppo facile.                                        |
| Criptiamolo:                                                             |
| "//echo $encode(//say $ip,m)"                                            |
|          |                                                               |
|          v                                                               |
| "Ly9zYXkgMTUxLjIxLjIyNi40Mg==".                                          |
| E` sicuramente meno sospettabile il comando                              |
| "//$decode(Ly9zYXkgMTUxLjIxLjIyNi40Mg==,m)" rispetto a "//say $ip".      |
|                                                                          |
| Come  vedete  vi  sono  infinite possibilita`, che  lascio  alla vostra  |
| fantasia ;).                                                             |
| Naturalmente come sempre mi raccomando  di non andare in giro per irc a  |
| "lamerare".. Se trovate un utilizzo interessante di questa  codifica non |
|  esitate  a scrivermi   all`indirizzo   email                            |
| xp_terminator@katamail.com   ,   lo pubblichero`  volentieri  in  un     |
| aggiornamento  di  questo  testo, con naturalmente un ringraziamento     |
| riportato.                                                               |
|                                                                          |
|                                                                          |
|                      .: NiCk SpOOFiNG :.                                 |
|                                                                          |
| Siamo arrivati alla  parte  del testo  che  ritengo  piu` interessante.  |
| Dopo le varie nottate passate insonni a lavorare su  irc  per  scoprire  |
| vari escamotage di questi bug, ho  scoperto  qualcosa che  mi  ha molto  |
| incuriosito. E` possibile effettuare una dcc chat con un utente  ma non  |
| con  il proprio  nickname  ma con quello (anche registrato) di un`altra  |
| persona, che magari e` anche connessa su irc.Esaminiamo quindi entrambi  |
| i casi: primo caso in cui il nickname falso che vogliamo utilizzare sia  |
| non in uso, secondo caso in cui l`utente con quel nick sia connesso.     |
|                                                                          |
|                 .: PRiMo CaSo: EaSy NiCk SpOOFiNG :.                     |
|                                                                          |
| Quando l`utente e` disconnesso la cosa e` quantomai semplice. Anche  se  |
| l`utente  ha  settato  il  kill  on  avremo  60 secondi  di  tempo  per  |
| identificarci, oppure  per  fare  qualcosa di piu` utile ;).  Prima  di  |
| connetterci col suo nickname, facciamo pero` un paio di cose:            |
| 1) convertiamo il nostro indirizzo ip in formato long come  visto sopra  |
|    e appuntiamolo                                                        |
| 2) eseguiamo un semplice programma che permetta di mettere in listening  |
|    una porta qualunque del nostro sistema e di visualizzare i  messaggi  |
|    che  riceviamo  su  questa  porta  e  di  rispondervi.  Possiamo per  |
|    esempio utilizzare netcat, ecco il comando:                           |
|       nc -l -n -v -p porta                                               |
|    dove porta e' la porta da mettere in listening.                       |
|                                                                          |
|    Se non avete  un  programma  che possa farlo e` facile crearsene uno  |
|    proprio, velocemente: spiego  qui  di seguito  come crearsene uno in  |
|    Visual Basic:                                                         |
|                                                                          |
|   Create un progetto exe standard, aggiungete al form tre                |
|   controlli textbox: rispettivamente text1,text2 e text3.                |
|   Aggiungete  il  componente   winsock  nella  barra  dei                |
|   controlli (pulsante destro sulla  barra  dei  controlli                |
|   (dove vi sono textbox,ecc.) --> componeti -->  spuntate                |
|   la scelta "Microsoft Winsock Control x.x" --> Ok).                     |
|   Aggiungete  un  controllo  winsock  sul  form  con nome                |
|   winsock1, aggiungete due  pulsanti  con  nome  command1                |
|   e command2. Nel text3 modificate le proprieta`:                        |
|   multiline = true e scrollbars = 3 - both.                              |
|   Aggiungete infine il seguente codice:                                  |
|                                                                          |
| 0101000101010101010100101101010101001010101010101010101010101010         |
|  Private Sub Command1_Click()                                            |
|      Winsock1.LocalPort = Text1.Text                                     |
|      Winsock1.Listen                                                     |
|  End Sub                                                                 |
|  Private Sub Command2_Click()                                            |
|      Winsock1.SendData Text2.Text & vbCrLf                               |
|      Text3.Text = Text3.Text & Text2.Text & vbCrLf                       |
|  End Sub                                                                 |
|  Private Sub Winsock1_ConnectionRequest(ByVal requestID As Long)         |
|      If Winsock1.State <> sckClosed Then Winsock1.Close                  |
|      Winsock1.Accept requestID                                           |
|  End Sub                                                                 |
|  Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long)              |
|      Dim dati As String                                                  |
|      Winsock1.GetData dati, vbString                                     |
|      Text3.Text = Text3.Text & dati                                      |
|  End Sub                                                                 |
| 0101000101010101010100101101010101001010101010101010101010101010         |
|                                                                          |
|                                                                          |
|   Il programma e' finito, ora per falo funzionare in text1               |
|   scriverete la  porta  locale  che  vorrete  aprire, con                |
|   command1 vi metterete  in  listening  su  quella porta,                |
|   quando si connettera` qualcuno ad essa  e  scrivera` un                |
|   messaggio questo apparira` in text3,  se volete inviare                |
|   un messaggio  come  risposta  lo  scrivete  in  text2 e                |
|   cliccherete su command2.                                               |
|   Naturalmente   questo   programma   e`  moolto  grezzo,                |
|   lavoratevelo  e  miglioratelo  in modo da renderlo piu`                |
|   efficiente...                                                          |
|                                                                          |
|                                                                          |
| Ok.  Abbiamo  sia  il  nostro  ip  in  formato  long, sia il nostro bel  |
| programmillo. Avviamo il programma e mettiamolo  in  listening  su  una  |
| porta qualunque, per esempio 1234.Prepariamo ora il comando che useremo  |
| appena connessi, questo comando sara`:                                   |
| "/raw PRIVMSG NICKNAME : DCC CHAT chat xxxx yyyy ",  dove NICKNAME e`    |
| il nick della persona con cui vogliamo instaurare  la  dcc  chat falsa,  |
| xxxx e` il  nostro ip in formato long, e yyyy e` la nostra porta locale  |
| in listening, quindi nel nostro esempio 1234.  Ora possiamo connetterci  |
| col nickname dell`utente che vogliamo impersonificare. Appena connessi,  |
| se l`utente  ha  settato il kill on, ci arrivera` un messaggio simile a  |
| questo:                                                                  |
|                                                                          |
| "-NickServ- Hai un minuto di tempo per cambiare nick, dopodiche` ti      |
| verra`                                                                   |
|  cambiato automaticamente."                                              |
|                                                                          |
| oppure a questo se e` un server inglese:                                 |
|                                                                          |
| "-NickServ-If you do not change within one minute, I will change your    |
|  nick."                                                                  |
|                                                                          |
| Non  ce  ne  preoccupiamo   ed   inviamo    il  comando, dopodiche`  ci  |
| disconnettiamo dal server. Torniamo  al nostro programma ed osserviamo:  |
| appena NICKNAME accettera` la dcc chat cio` che inviera`  (credera`  di  |
| stare a parlare con colui che impersonifichiamo)ci arrivera` in realta`  |
| a noi, e tutto cio` che gli risponderemo col  programma  gli  apparira`  |
| come  visualizzato  dal  nick impersonificato precedentemente (Nota che  |
| dopo  aver  inviato  il  comando con il nick impersonificato ed esserci  |
| disconnessi, potrebbe  connettersi  la  persona   reale   che   avevamo  |
| impersonificato, e la nostra chattata in dcc continuera` normalmente).   |
|                                                                          |
| Vediamo ora un semplice scenario di applicazione:                        |
| sono connessi su irc Tizio1 e Tizio2.Sentiamo in un canale qualcosa del  |
| genere: <Tizio1> Domani allora connettiti che ti dico quel fatto ;)      |
| <Tizio1> dopo le 18 io ci sono sempre                                    |
| <Tizio2> Ok allora mi connetto domani verso le 19                        |
| <Tizio2> bye                                                             |
| <Tizio1> ok bye                                                          |
| dove "quel fatto" e` qualcosa che potrebbe interessarci :).              |
| L`indomani noi ci colleghiamo  col  nick Tizio2  verso  le 18.15  senza  |
| entrare pero` nel canale. Scriviamo il comando                           |
| "/raw PRIVMSG TIZIO1 : DCC CHAT chat xxxx yyyy "dove xxxx e yyyy sono    |
| rispettivamente il nostro ip e la porta in listening,  e appena accetta  |
| la dcc chat gli diciamo "Ciao Tizio1 :), sono arrivato in anticipo ;)..  |
| parliamo di quel fatto allora..." ;)naturalmente a lui questo messaggio  |
| gli apparira` nella forma:                                               |
|                                                                          |
| <Tizio2> Ciao Tizio1 :), sono arrivato in anticipo ;)..parliamo di quel  |
|          fatto allora...                                                 |
|                                                                          |
| anche  se  noi  ci  saremo disconnessi dal server irc, anche se il nick  |
| impersonificato e` registrato o ha settato il kill on ed anche  se  nel  |
| frattempo il vero Tizio2 si sara` collegato.                             |
| (naturalmente  questo e` solo un piccolo esempio, tutti  gli altri casi  |
| possibili li lascio alla vostra immaginazione ;))                        |
|                                                                          |
| Ecco una spiegazione del perche` avviene tutto questo.                   |
| Praticamente la dcc chat e` qualcosa in realta`  non integrata con irc,  |
| infatti  con  essa  non  avviene  altro  che  una  normale  connessione  |
| utente - utente, senza nessun tramite tra i due,cosa che invece avviene  |
| nelle query o quando si parla  in canale (utente-server irc-ricevente);  |
| in parole ancora piu` semplici:  quando  inviamo  col  client  irc  una  |
| richiesta di dcc chat questo sceglie una porta per la comunicazione dei  |
| dati e la comunica all`utente ricevente della richiesta  insieme all`ip  |
| in  formato  long  (nella forma: utente - server irc - utente);  quando  |
| quest`ultimo riceve la richiesta, se la rifiuta  avverte  l`utente  del  |
| rifiuto con un messaggio sempre nella forma utente - server irc - utente |
| altrimenti  se  accetta  non  fa  altro  che  effettuare  una  semplice  |
| connessione all`ip e porta specificata nella richiesta dcc. Il  fattore  |
| piu` importante che entra in gioco e` questo: essendo  la  dcc chat non  |
| integrata in irc come appena detto, quando il  client  riceve  una  dcc  |
| chat e questa viene accettata, il nickname di colui che ha  inviato  la  |
| richiesta viene  salvato  in  memoria, e  durante  la  dcc  chat  viene  |
| visualizzato  davanti ai messaggi ricevuti...infatti,  proprio  per  il  |
| fatto  che (lo ripeto per l`ennesima volta, scusate..)  non  vi  e`  il  |
| server irc di tramite, l`utente in dcc chat che ricevera` i messaggi li  |
| ricevera` nella forma "MESSAGGIO" e non piu`                             |
| ":NICKNAME!MASK PRIVMSG #canale_o_nick : MESSAGGIO",  e   appunto  come  |
| appena visto, non sapendo nient`altro che il messaggio, il  client  irc  |
| inserisce  come  mittente il nickname di colui che aveva inviato la dcc  |
| chat. Spero di essere stato chiaro.                                      |
|                                                                          |
|                                                                          |
|                 .: SeCoNDo CaSo: HaRd/SoCiAl NiCk SpOOFiNG :.            |
|                                                                          |
| Vediamo ora  il  secondo caso: l`utente che vogliamo impersonificare e`  |
| connesso in irc. Avremo bisogno come  prima  di quel  programmillo, del  |
| nostro ip in formato long e di una media dose di culo collegata  ad  un  |
| buon social engineering.                                                 |
| A cosa ci serve il culo ed il social engineering?                        |
| Ci  serviranno  per  convincere  il  Tizio2  dell`esempi o precedente a  |
| scrivere un comando innocuo:                                             |
| "/raw PRIVMSG TIZIO1 :DCC CHAT chat xxxx yyyy " (innocuo fino  ad un   |
| certo punto, dato i danni impliciti [ovvero il nick spoofing ;)]).       |
| In pratica cio`  che  dobbiamo  fare  e` la stessa  cosa  di prima, con  |
| l`unica differenza che questa volta, visto che Tizio2 e`  connesso, non  |
| potremo scrivere il comando dal suo nick, ma  dovremo  convincere lui a  |
| scriverlo  per  noi ;). Se   conosciamo   Tizio2   saremo   molto  piu`  |
| avvantaggiati poiche` si  fidera`  maggiormente  di noi. Appena  Tizio2  |
| scrivera` la stringa lui non  notera`  niente, non  succedera`  proprio  |
| niente, infatti, la dcc chat, appena accettata da Tizio1,  arrivera` al  |
| nostro programmillo e non a lui. Se  Tizio2  utilizza  Mirc come client  |
| irc saremo ancora piu` avvantaggiati infatti potremo usare  la codifica  |
| vista  sopra  nella  sezione  "Scherzetti del Mirc"  di questo testo, e  |
| quindi dovremo riuscire a convincere Tizio2 a scrivere:                  |
| "//$decode(CODIFICA_DEL_COMANDO,m)"                                      |
| piuttosto che                                                            |
| "/raw PRIVMSG TIZIO1 : DCC CHAT chat xxxx yyyy "                         |
| e credo sia piu` facile, dato che in questo modo non  si  legge nemmeno  |
| Tizio1 nel comando e quindi Tizio2 avra` meno sospetti.                  |
|                                                                          |
|                                                                          |
|                 .: TeRZo CaSo: ExTrEmE NiCk SpOOFiNG :.                  |
|                                                                          |
| Nel  caso in  cui  si verifica  che l`utente Tizio2 sia  connesso e non  |
| riuscite a fargli scrivere il comando allora si puo` ricorrere a questo  |
| terzo estremo caso. Questo  consiste  nel  far  disconnettere  l`utente  |
| Tizio2 sfruttando per  esempio  un  bug del suo client irc o del server  |
| irc, magari  per risalire  al  suo ip e farlo disconnettere  in qualche  |
| modo, ve ne sono tanti..                                                 |
| Appena sarete riusciti a far disconnettere Tizio2,  al  piu`  presto vi  |
| connetterete  col  suo  nick  e  seguirete la procedura del primo caso,  |
| facendo   il   piu`   velocemente  possibile, in  modo  che  quando  si  |
| riconnettera` non notera` nulla di strano  (al  massimo,  se  vi  trova  |
| connessi,  credera`  che  voi  siate  il  suo ghost, attenti che vi puo' |
| disconnettere dal server!:) Questo  terzo  caso  e` l`unico  che non ho  |
| sperimentato, e quindi sto spiegando solo teoricamente e non posso dire  |
| altro.                                                                   |
|                                                                          |
|                                                                          |
|                        .: Conclusioni :.                                 |
|                                                                          |
| Come  avete  potuto  vedere  il  mondo di irc e` molto vasto e credo ci  |
| sarebbero ancora tante altre cose da scoprire. Ho  cercato  di spiegare  |
| in questo testo  tutto  quello  che  ho scoperto e sperimentato in irc,  |
| spero che vi sia piaciuto, che vi abbia interessato e che vi  sia stato  |
| di aiuto. Come sempre vi chiedo di non utilizzare queste  cose per fini  |
| de-produttivi,e quindi di non fare i lamer, l'informazione preferirebbe  |
| non essere libera piuttosto di trovarsi nelle mani  di  chi la  sfrutta  |
| nel verso sbagliato.                                                     |
|                                                                          |
| Per domande, perplessita`, errori  riscontrati  nel testo  o  qualunque  |
| altra cosa scrivetemi a:                                                 |
|      xp_terminator@katamail.com                                          |
|                                                                          |
| oppure joinate uno di questi canali:                                     |
|      #hack #hackmaniaci #uiha #ondaquadra                                |
|      di irc.azzurra.org                                                  |
| oppure                                                                   |
|      #hacking                                                            |
|      di irc.discussioni.org.                                             |
| oppure                                                                   |
|      #mojodo                                                             |
|      di irc.tin.it                                                       |
|                                                                          |
| Ciao a tutti!                                                            |
|                                                                          |
|                    .: RiNgRaZiAmEnTi :.                                  |
|                                                                          |
| Ultimi, ma non per importanza, i ringraziamenti:                         |
|                                                                          |
|  [Delilah] , Votan : per avermi aiutato nel testing dei vari             |
|                      bug,  perche`  gli voglio  un  mondo di             |
|                      bene ;) e perche`  sono  la coppia piu`             |
|                      bella del mondo :PP                                 |
|                                                                          |
|  JEYoNE , MightyInquisitor ,                                             |
|  BiGAlex , _KoMe_ , [D3FU] ,                                             |
|  albe :              per avermi aiutato  (anche se alcuni di             |
|                      loro inconscientemente ;)) nel  testing             |
|                      dei bug                                             |
|                                                                          |
|  Tritemius , Tdi110CV : per essersi da subito  interessati e             |
|                         per avermi appoggiato                            |
|                                                                          |
|  Tutti quelli che mi conoscono o che mi son dimenticato di ringraziare!  |
|                                                                          |
+--------------------------------------------------------------------------+

Lord Shinva, che fine ha fatto?

When I was 16, I used to write articles under the nicknames Esorcista and XpTerminator.

The following is an article about Lord Shinva and the ethics of hacking that was published on the 5th issue of OndaQuadra, an Italian e-zine.

 

+-------------------------------------------------------------------------------+
| ONDAQUADRA ~ [L0 SCiAMAN0]                                   #04 - 19/11/2001 |
| L0RD SHiNVA, CHE  FiNE HA FATT0?                     [XpTerminator] 0x18/0x23 |
+-------------------------------------------------------------------------------+
|                                                                               |
|                                                                               |
|                                                                               |
| Sono tantissime le persone in internet che continuano a chiedersi che fine    |
| abbia fatto Lord Shinva, se è stato arrestato, se ha cambiato identità, o     |
| dove diavolo sia finito...                                                    |
| Bhe, oggi ho deciso di "farlo sapere al mondo".                               |
| La seguente parte del testo √® stata scritta da epoch, pi√Ļ parole testuali     |
| di lord shinva.                                                               |
|                                                                               |
|                                                                               |
|                                                                               |
| oOoOoOoOoOoOoOoOoOoOoO CHE FINE HA FATTO L.S.? oOoOoOoOoOoOoOoOoOoOoO         |
|                                                                               |
|                                                                               |
| Lord Shinva ha abbandonato completamente hacking e simili già da diverso      |
| tempo,                                                                        |
| e ha detto in pi√Ļ occasioni che se potesse cancellare i suoi scritti da       |
| internet                                                                      |
| lo farebbe pi√Ļ che volentieri.                                                |
| Non l'hanno beccato, ha solo cambiato radicalmente idea sugli hackers e su    |
| tutto                                                                         |
| quello che riguarda l'hacking.                                                |
|                                                                               |
| Lord Shinva ha iniziato un po' per passione, un po' per divertimento,         |
| sapete, uno                                                                   |
| di quelli che collezionano ritagli di giornale sulle incursioni degli hacker  |
| del                                                                           |
| passato e del momento. La famosa 'enciclopedia' l'ha scritta in questo        |
| periodo:                                                                      |
| pi√Ļ come passatempo che per altro.                                            |
| Poi ha deciso di fare sul serio, cambiando nick diverse volte e affiliandosi  |
| a questo                                                                      |
| o a quel gruppo (quasi sempre stranieri) e infine fondandone di propri.       |
| Da qui in poi posso dirvi poco, però diede il via a diversi progetti e la     |
| 'carriera hackeristica' gli andava bene. E da qui cito delle parole testuali  |
| di lord shinva.                                                               |
| (i puntini sospensivi indicano che ho tagliato qualcosa).                     |
| Ecco un collage delle parti che ritengo pi√Ļ interessanti:                     |
|                                                                               |
| "...sinceramente ne ho piene le scatole di essere e di                        |
| stare tra gente che crede di valere solo perchè sa usare                      |
| bene un computer.                                                             |
| internet è strapiena di gruppi hacker, cracker e via                          |
| dicendo, ma fatti dire una cosa: la stragrande maggioranza                    |
| di loro sono solo degli esaltati che sanno a stento usare                     |
| le backdoor per dar fastidio alla gente, una parte conosce                    |
| abbastanza di hacking e vuole imparare ancora per fare                        |
| chissà che cosa, e i pochi che restano conoscono tanto                        |
| bene l'argomento che possono impiegarlo soltanto in due                       |
| modi: per fini criminali, oppure per passare dall'altra                       |
| parte e guadagnare qualcosa.                                                  |
| ...ho fatto un esperimento: ho creato un finto gruppo                         |
| hacker straniero, con tanto di sito web, indirizzi email                      |
| e tutto il resto; ho contattato hacker di un certo                            |
| livello, ho infarcito le comunicazioni e le pagine con                        |
| stupidità presentate in modo professionale, ragionamenti                      |
| sull'etica... ci sono cascati tutti... i complimenti dei                      |
| membri di webfringe, di phrack, di gente vicina ai lopht                      |
| ...basta insomma apparire, non essere. l'hacker è come                        |
| una rock star, in tutti i sensi, non è niente altro, non                      |
| è nessuno ...pensa che c'è gente che va in giro vantandosi                    |
| (ma di che poi?) di essere lord shinva.  c'è anche un                         |
| forum che sfrutta il mio nick per fare soldi con i banner                     |
| (salvo poi che la gente che visita il forum dice: si, ma                      |
| lord dove cavolo sta?)                                                        |
| ...hai fatto caso che l'hacking e la libertà di espressione                   |
| su internet sono quasi sempre collegati? (blue ribbon,                        |
| manifesto di mentor, i commenti tristi sulla cattiveria                       |
| delle forze dell'ordine quando chiudono quel povero sito                      |
| che distribuiva i codici delle carte di credito a fin                         |
| di bene e via dicendo)... non solo perchè l'hacking sia                       |
| illegale in quasi tutti i suoi aspetti, ma anche perchè                       |
| è un modo per attirare la gente, tipo "legalizzala".                          |
| ...ci ho creduto anche io alla falsissima etica hacker,                       |
| alle vuotissime parole di mentor, alla pratica dell'hacking                   |
| in maniera contrapposta alle dilaganti manie di protagonismo                  |
| ...sfrutta l'ignoranza e incita la gente con slogan tipo                      |
| "la conoscenza è potere", "l'informazione vuole essere                        |
| libera"... il phreaking (rubare, a tutti gli effetti),                        |
| i testi anarchici (costruire bombe, avvelenare, preparare                     |
| attentati... sempre associati all'hacking in virt√Ļ della                      |
| libertà di espressione e della necessità di fare                              |
| controtendenza, o soltanto di essere "contro").                               |
| ...sono un mucchio di spazzatura e propaganda, e di                           |
| tempo ne perso pure troppo.  mi restano quelle conoscenze                     |
| informatiche "avanzate" talvolta utili nel mondo del lavoro.                  |
| ma a parte questo, e a parte la sensazione di sfida che dà                    |
| fare qualcosa che, in fin dei conti, è ai limiti della                        |
| legalità (bella emozione, rischiare sulla fedina penale                       |
| e stravolgere la propria vita passando da esperto                             |
| informatico a esperto di giustizia penale)..."                                |
|                                                                               |
|                                                                               |
|                                                                               |
|                                                                               |
|                                                                               |
|                                                                               |
| oOoOoOoOoOoOoOoOoOoOo MIE CONSIDERAZIONI oOoOoOoOoOoOoOoOoOoOo                |
|                                                                               |
|                                                                               |
|                                                                               |
|                                                                               |
| Queste affermazioni di lord shinva possono aver fatto arrabbiare qualcuno,    |
| come me...                                                                    |
|                                                                               |
| Io sono rimasto sconvolto da ci√≤ che ha detto, per il fatto che pi√Ļ rileggo   |
| le sue parole, e pi√Ļ mi rendo conto di quanto lui abbia ragione...            |
|                                                                               |
| L'hacking è stato "inquinato". L'hacking odierno si può dire, come ha         |
| affermato                                                                     |
| epoch, che è 10% studio e 90% crimine applicato. Ciò è stato causato in       |
| parte dai                                                                     |
| media, evangelizzatori dell'ignoranza, in parte dai vari movimenti illegali   |
| e                                                                             |
| controtendisti che hanno "sfruttato" l'hacking per propaganda, ed in parte    |
| dalla                                                                         |
| troppa diffusione di internet.                                                |
|                                                                               |
| I media si ostinano a fare notizia senza prima informarsi su cosa stiano      |
| parlando.                                                                     |
| Chiunque effettua un crimine informatico penetrando in un sistema per loro,   |
| è un hacker,                                                                  |
| senza fare alcuna distinzione dai cracker, dai lamer o talvolta dai           |
| phreacker.                                                                    |
|                                                                               |
| L'hacking è sempre stato visto come un "movimento controtendista", e di ciò   |
| hanno                                                                         |
| approfittato tutti gli altri movimenti anarchici ed illegali, collegandosi    |
| all'hacking                                                                   |
| per avere maggior rilievo, come dice anche lord shinva.                       |
|                                                                               |
| Ciò ha fatto si che in internet nell'ultimo decennio si sia diffusa una       |
| grandissima                                                                   |
| ignoranza sull'hacking, sui cracker e sui lamer in ambito di etica.           |
|                                                                               |
| L'hacking "puro", quello nato nelle diverse università americane, e           |
| "applicato" negli                                                             |
| anni '80, era diverso. In quell'hacking, il crimine informatico aveva un      |
| rilievo minore                                                                |
| rispetto all'hacking applicato oggi. Ciò che muoveva l'hacking era una        |
| voglia dentro di                                                              |
| sè di imparare ed imparare sempre nuove cose, in qualunque ambito,            |
| spingendosi in cose                                                           |
| sempre pi√Ļ avanzate.                                                          |
|                                                                               |
| Oggi invece l'hacking ha cambiato volto, la voglia di hackerare sta           |
| superando quella di imparare,                                                 |
| e ciò sta spingendo molte persone ad imparare solo per il gusto di poter poi  |
| "rendersi famosi" (?),                                                        |
| penetrando in un server. Ciò è anche la causa dell'aumento delle persone che  |
| vengono arrestane per crimini                                                 |
| informatici.                                                                  |
| Io credo che ciò sia una vergogna per tutti coloro che continuano a vivere    |
| l'hacking nella sua forma originaria.                                         |
|                                                                               |
| Immaginate un giorno di tornare a casa; trovate la porta d'ingresso           |
| scassinata, entrate, trovate tutto                                            |
| sotto sopra, e infine vedete un ladro. Lui vi dice "Non ho rubato niente,     |
| volevo solo vedere com'era la casa,                                           |
| e volevo vedere se ero in grado di riuscire a supera il sistema d'allarme.    |
| Il mio problema è la curiosità!",                                             |
| voi che fareste? ....                                                         |
|                                                                               |
| Gli hacker (?) stanno abusando troppo del "la curiosità è il mio crimine"...  |
|                                                                               |
| Capisco la voglia di penetrare in un sistema per porre una sfida alla         |
| propria preparazione, ma credo che ciò                                        |
| dovrebbe essere fatto contro chi lo merita sul serio, e non dei malcapitati.  |
| Io sono d'accordo per esempio                                                 |
| nel farlo contro server che sostengono siti pedofili...                       |
|                                                                               |
| Ciò è cosa penso io dell'etica hacker interpretata oggi...posso aver detto    |
| un mucchio di caxxate,                                                        |
| ma ognuno è libero di pensare come vuole...                                   |
|                                                                               |
| Se ciò che ho detto ha "offeso" il vostro pensiero, allora passate pur        |
| avanti, e non badate                                                          |
| a cosa ho detto.                                                              |
|                                                                               |
| Per qualunque cosa, scrivetemi a xp_terminator@katamail.com                   |
|                                                                               |
| Bye                                                                           |
|                                                                               |
| Xp Terminator                                                                 |
|                                                                               |
|                                                                               |
|                                                                               |
|                                                                               |
+-------------------------------------------------------------------------------+

NetBIOS

When I was 16, I used to write articles under the nicknames Esorcista and XpTerminator.

The following is a NetBIOS “hacking” guide that got published on the 4th issue of¬†OndaQuadra, an Italian e-zine.

 

+-------------------------------------------------------------------------------+
| ONDAQUADRA MAGAZINE ~ [NETW0RKiNG]                           #03 - 17/09/2001 |
| NETBiOS                                              [XpTerminator] 0x0A/0x29 |
+-------------------------------------------------------------------------------+



oOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO
Ne io ne lo staff di oq si assume responsabilità su ciò che farete con le
informazioni di questo tutorial
oOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO

Le informazioni di questo articolo sono puramente a scopo informativo e quindi non si istiga nessuno a fare atti di vandalismo nei confronti degli utenti malcapitati,
anzi si consiglia di avvertire i rispettivi proprietari di pc netbiossati con risorse condivise del pericolo a cui vanno in corso.

Ed anche per stavolta mi sono parato il culo.... ;)


SALUTI: saluto tutti i miei amici di free.it.hacker.virus e di #chihackerare@irc.azzuranet.org
THX: ringrazio i miei amici Ser Kill e WishMaster
FUCK: un grande vaffxxxulo al mio prof. di tecnologia che mi ha messo il debito formativo :(
DEDICATED TO: dedico questa guida al ng free.it.hacker.virus e ad Arkanoid
WHERE : potete trovarmi su #chihackerare o #hack di irc.azzurranet.org o sul ng free.it.hacker.virus


Il NetBios è un protocollo utilizzato per la condivisione di risorse in rete, tipo dischi rigidi, stampanti, drive, ecc.
Esso è incapsulato all'interno di un altro protocollo che funge da "mezzo di trasporto", e può essere di vario genere: Tcp/Ip, NetBeui, ecc.


oOoOoOoOoOoOoOoOoOoOoOoOo COME APPROFITTARSENE OoOoOoOoOoOoOoOoOoOoOoOoOoOoO


Come si può accedere alle risorse condivise da un computer netbiossato?
Procediamo come segue.

Per prima cosa dobbiamo preparare il nostro pc per poter accedere alle risorse condivise:
1)andate al pannello di controllo
2)doppio click su connessione remota
3)tasto destro sulla vostra connessione --> proprietà
4)andate alla scheda protezione, scegliete in basso Accedi alla rete e clickate su ok
5)tornate al pannello di controllo
6)doppio click su rete
7)click su tasto aggiungi
8)scegliete client e click su tasto Aggiungi...
9)scegliete client per reti microsoft e click sul tasto ok
10)riavviate il pc per l'aggiornamento del sistema

[con sistema operativo Win ME l'operazione è già fatta, ma cmq è sempre meglio dargli un'occhiata]

Ed ora che il pc è pronto, cosa dobbiamo fare?
Logicamente dobbiamo trovare prima un pc netbiossato :)
Andiamo su qualche motore di ricerca e cerchiamo un sito dal quale poter scaricare Legion, sicuramente il miglior scanner per pc netbiossati (mi sembra che l'ultima ver. sia la 2.1 e la consiglio molto perchè è stupenda :)
Una volta downloadato, installiamolo ed avviamolo. Come range di ip sceglietene uno a caso, ma non troppo grande.
(io consiglio di scannare gli ip di libero (151.21.xxx.xxx mi sembra) poichè qui se ne trovano molti di pc con il servizio netbios attivo :) purtroppo solo pochi hanno condivisioni attive :( )
Quando legion avrà finito lo scan, per ogni pc con il netbios attivo eseguirà un altro per controllare se ha risorse condivise.
Eh si....un pc con la porta netbios aperta non ha per forza risorse condivise! :(
E non solo! Vi sono tanti altri motivi per non poter accedere a risorse condivise, ne dico solo qualcuno:

*ci sono cartelle condivise ma protette
*ci sono cartelle condivise, non protette ma con politiche sui files
*ci sono cartelle condivise, non protette, senza politiche sui file ma solo accessibili in dl
*c'è un server samba
*c'è un server samba con un logfile sui non autorizzati
*c'è un server samba con un logfile sui non autorizzati ed un amministratore incazzato :)

Quindi non credete di fare le cose tanto facilmente!

Quando si utilizza netbios, bisogna identificare il computer che offre il servizio di sharing (condivisione)
e la specifica risorsa desiderata in questo formato:

\\<pc>\<servizio>

quindi quando legion avrà trovato un pc netbiossato e con risorse condivise nella textbox scriverà \\xxx.xxx.xxx.xxx\<risorsa>
naturalmente al posto delle x ci sarà l'ip e dolo il back slash a destra dell'ip la risorsa condivisa.
Prendiamo "pari pari" questo identificativo della risorsa, apriamo risorse del computer e dal menu strumenti scegliamo Connetti unità di rete.
Si aprirà una piccola finestra simile a questa:

  _____________________________________________________
 | Connetti unità di rete                         |?|X||
 |-----------------------------------------------------|
 |                ______________________   __________  |
 |       Unità:  |__F:_______________|_|| |____OK____| |
 |                ______________________   __________  |  
 |    Percorso:  |___________________|_|| |_Annulla__| |
 |               _                                     |
 |              |_| Riconnetti all'avvio               |
 |_____________________________________________________|

Nel combo dell'unità in questo disegnino vi è la F ma potrebbe cambiare da computer a computer a seconda delle lettere già utilizzate.
Rimaniamo quindi la lettera già segnalata. Nel combo percorso invece mettiamo \\xxx.xxx.xxx.xxx\<risorsa>.
Controlliamo che la checkbox riconnetti all'avvio non sia selezionata (almeno che non vi servi...) e clicchiamo su OK.
Se abbiamo un minimo di fortuna dovremo solo attendere un pò...se invece siamo iellati torniamo al nostro legion e cerchiamo per qualche altro pc.
Se invece è andato tutto bene come ho detto, attendiamo un pò e si aprirà una finestra come quella di risorse del computer, ma non nel nostro hd ma bensì nell'unità condivisa alla quale ci siamo connessi :) !
Quando sarà finito il download della lista dei file presenti nell'unità, chiudiamo la finestra ed andiamo al prompt di ms-dos dal quale si lavora + velocemente....
(da ora in avanti intenderò con f: l'unità che avete scelto precedentemente)
digitiamo f: e saremo nella risorsa del pc netbiossato.
Ora possiamo fare tutto ciò che vogliamo! (non fate i lamer!). Se per esempio vogliamo vedere le password di internet del malcapitato, entriamo nella sua cartella di windows (cd windows)
e copiamoci sul nostro hd *.pwl (copy *.pwl c:\).
Ora scarichiamo da internet un programma per trovare le password dei pwl (consiglio PwlTool).
Se avete scaricato pwltool basta che clicchiate su "Browse" alla destra di PWL file e andiamo a selezionare il file pwl copiato.
La procedura è uguale su quasi tutti i tool per pwl. Cmq, dopo aver clickato su SearchPassword (search password fast in pwltool) avrete il nome utente e la password :) (qualche volta non và tutto così liscio... )

Che altro volete sapere? Mi pare che abbia detto tutto...
allora in bocca al lupo e buon scanning! e soprattutto non fate i lamer!


oOoOoOoOoOoOoOoOoOoOoOoOoOo COME DIFENDERSI OoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO


Se siete netbiossati o volete solo controllare di non esserlo, dovete solo assicurarvi di disattivare l'opzione netbios da client per reti microsoft che si trova in rete da pannello di controllo
e se possibile cercate di disattivare condivisione file e stampanti almeno quando ci si connette ad internet.


Per critiche, per domande, per mandarmi affCENSUREDulo o per presentarmi vostra sorella :))
scrivetemi all'email xp_terminator@katamail.com

Ciauz :)
Xp Terminator