瀏覽代碼

Splitted READMEs

root 8 年之前
父節點
當前提交
3d383718e5
共有 3 個文件被更改,包括 374 次插入374 次删除
  1. 132
    0
      README-en.md
  2. 240
    0
      README-es.md
  3. 2
    374
      README.md

+ 132
- 0
README-en.md 查看文件

@@ -0,0 +1,132 @@
1
+
2
+# Classes - Simple Sniffer
3
+
4
+##Objectives
5
+
6
+1. Practice Data Structures, Classes and Inheritance
7
+
8
+## Pre-Lab:
9
+
10
+Before you get to the laboratory you should have:
11
+
12
+    1. Reviewed C++ classes and structures
13
+    2. Studied the concepts and instructions for this laboratory session.
14
+    3. Taken the Pre-Lab quiz in Moodle
15
+
16
+## Simple Sniffer
17
+
18
+Computers communicate with each other through the Internet Protocol (IP).  When a computer sends information to another computer it is sent via Internet packets that contain the Internet address of the sender computer (source address), the source port of the application that is sending the message, the Internet address of the receiving computer(destination address), and the port of the application that will receive the message.
19
+
20
+We can compare the Internet address to the address of a house, and the applications to the members of the house. When sending a letter from one house to another, the address on the letter identifies the destination house, and the name on the letter identifies the house member to who it is sent.
21
+
22
+For instance when your lab computer is contacting the department's web server, the packets that carry the information from your computer to the web server contains the source address of the lab computer and the destination address of the web server;  and the source port of your web browser and the destination port of the web server.
23
+
24
+Internet addresses are represented on 4 bytes (32 bits) normally presented to users as strings of 4 decimal values. Each decimal value is the decimal representation of one of the 4 bytes:  "(0-255).(0-255).(0-255).(0-255)". Examples of IP addresses are: 10.0.1.10, 192.168.10.11, 136.145.54.10, and so on.
25
+
26
+Port numbers are composed of 2 bytes or 16 bits.  Therefore port numbers range from 0-65535. There are ports numbers assigned to known application services such as number 22 for ssh, 23 for telnet, 25 smtp, 80 for http, and so on.
27
+
28
+To complicate things a little bit, each computer network card has an unique identifier that is used for the communication between you computer and the network device that routes the network traffic from the Internet and local network to your computer and vice-versa (Ethernet protocol).  This unique identifier is known as the Hardware address (a.k.a Multiple Access Controll (MAC) addres), is represented on 6 bytes (48 bits), and is presented to users as strings of 6 hexadecimal values. Each hex value is the hex representation of the 6 bytes: "(00-ff):(00-ff):(00-ff):(00-ff):(00-ff):(00-ff)".  Examples of MAC addresses are: e0:f8:47:01:e9:90, 70:ad:60:ff:fe:dd:79:d8 , and so on.
29
+
30
+A packet sniffer (a.k.a packet analyzer, protocol analyzer, or network analyzer) is a computer program that can intercept and log traffic passing over a digital network, or network device.  As data flow across the network, the sniffer captures each packet and, if needed decodes the packet's raw data[1].
31
+
32
+
33
+The packets captured by this program follow the following packet structure:
34
+
35
+    * first an Ethernet header which contains the source and destination MAC addresses
36
+    * second a IP header that contains the source and destination IP addresses
37
+    * third a header that contains the source and destination port numbers.
38
+
39
+In this application we create a simple packet sniffer that captures all the IP packets that flow across your lab computer, and for each packet, decodes the IP addresses, the port numbers, and some additional information of the packets.  Additionaly it detects the unencrypted request of images in the web, and displays the images in the GUI.
40
+
41
+See the following snapshot of the application:
42
+![](images/ss.png)
43
+
44
+Each row in the table is the information of each captured packet, the text box under the table presents a ASCII summary of a selected packet from the table, and the list in the right presents the images that have been requested and are seen in you network card.  
45
+
46
+The application that you are about to complete gives the user the ability to analyze the network traffic and monitor the images that are being watched in your network.  
47
+
48
+## Laboratory session:
49
+
50
+To create a packet sniffer you can use the *pcap* library that provides an interface to access the data passing across your network card.  This library contains a function that returns a raw stream of bytes of each packet captured.  It is the task of the sniffer programmer to decode the raw stream into human readable information.  Fortunately this is not your task, but you can learn how to do it, if you want, by reading the source code of this laboratory.  Your task is to follow the exercises below so you provide the packet sniffer with the needed objects (Classes) to process the packets.
51
+
52
+## Exercise 1: Familiriaze your self with the application
53
+
54
+Instructions
55
+
56
+    1. To load this project you need to run qt creator with root privileges.
57
+        ```sudo qtcreator Documents/eip/simplesniffer/SimpleSniffer.pro```
58
+    2.The project `SimpleSniffer` is in the directory `Documents/eip/simplesniffer` of your computer. You can also go to `http://bitbucket.org/eip-uprrp/classes-simplesniffer` to download the folder `classes-simplesniffer` to your computer.
59
+    2. Configure the project.  The project consists of several files.  In this laboratory you will be working with the files `ethernet_hdr.h`, `ethernet_packet.h`, `ethernet_packet.cpp`, `ip_packet.h` and `ip_packet.cpp`
60
+
61
+
62
+## Exercise 2: Complete the class ethernet_packet
63
+
64
+Read the file `ethernet_hdr.h`, it contains the definition of the data structure that represents an Ethernet header.  It is also shown below:
65
+
66
+```
67
+#define ETHER_ADDR_LEN 6
68
+
69
+struct sniff_ethernet {
70
+        u_char  ether_dhost[ETHER_ADDR_LEN];    /* destination host address */
71
+        u_char  ether_shost[ETHER_ADDR_LEN];    /* source host address */
72
+        u_short ether_type;                     /* IP? ARP? RARP? etc */
73
+};
74
+```
75
+
76
+The Ethernet header above is used to decode the ethernet part of the raw data in each packet.  It is composed of the source MAC address (ether_shost, 6 bytes), the destiantion MAC address (ether_dhost, 6 bytes), and the type of Ethernet packet (ether_type, 2 bytes) which is used to determine if the packet is an IP packet.
77
+
78
+As you can see, it is not a good idea to show this information format to a regular user.  Your first task is to define the functions of the C++ class that defines the functions to translate the MAC address information into human readable strings.
79
+
80
+The class header is in file `ethernet_packet.h` and is also shown below:
81
+
82
+```
83
+class ethernet_packet
84
+{
85
+
86
+    sniff_ethernet ethernet ;
87
+    // Returns a 6 bytes MAC address in string representation.
88
+    string mac2string(u_char []) ;
89
+
90
+public:
91
+    ethernet_packet();  // Default constructor
92
+
93
+    // Set the ethernet variable member ether_dhost to the values
94
+    // received in the array
95
+    void setEtherDHost(u_char []) ;
96
+    // Same as above but to the ether_shost
97
+    void setEtherSHost(u_char []) ;
98
+
99
+    // Set the ethernet type to the value received.
100
+    void setEtherType(u_short) ;
101
+
102
+    // returns the string representation of the ethernet addresses
103
+    string getEtherDHost() ;
104
+    string getEtherSHost() ;
105
+
106
+    // Return the ethernet type
107
+    u_short getEtherType() ;
108
+
109
+};
110
+```
111
+
112
+Define the functions in file `ethetnet_packet.cpp`
113
+
114
+## Exercise 3: Construct the header of class ip_packet  
115
+
116
+For Exercise 3 see the definitions of the functions of the class ip_packet found in file `ip_packet.cpp`
117
+
118
+Your task is to define the class header following the functions inside the file.  The member variables are:
119
+* two `string`s to store the source and destination IP addresses
120
+* a one byte (`char`) variable to store the IP protocol
121
+* two `unsigned short` variables to store the source and destination port
122
+* one `string` to store the packet payload.
123
+
124
+This class header that you are defining inherits from the class that you defined in Exercise 2.
125
+
126
+### Deliverables
127
+
128
+Use "Deliverables" in Moodle to upload the files `ethernet_packet.cpp` y `ip_packet.h` that you defined.
129
+
130
+### References
131
+
132
+[1]http://en.wikipedia.org/wiki/Packet_analyzer

+ 240
- 0
README-es.md 查看文件

@@ -0,0 +1,240 @@
1
+
2
+
3
+# Clases - Analizador de redes simple
4
+
5
+![header.png](images/header.png)  
6
+
7
+
8
+La *programación orientada a objetos* (object oriented programming, OOP) es un paradigma de programación que promueve el diseño de programas en el que distintos objetos interactúan entre sí para resolver un problema.   C++ es uno de los lenguajes de programación que promueve la programación orientada a objetos, permitiendo que los programadores creen sus propias clases desde cero o derivadas de otras clases existentes. Algunos otros lenguajes que promueven OOP son Java, Python, javascript y PHP.   
9
+
10
+En OOP, cada objeto encapsula dentro de él ciertas propiedades sobre el ente que está modelando (por ejemplo, un objeto que modela un *punto* encapsula dentro de sí las coordenadas *x* y *y* del punto que representa). Además, cada objeto permite realizar ciertas acciones sobre sí, i.e. contiene sus *métodos*. Por ejemplo, un objeto de clase *punto* puede realizar la acción de cambiar el valor de su coordenada *x*.
11
+
12
+Cuando la clase de objetos que necesitamos utilizar en nuestro programa no ha sido predefinida en el alguna librería, necesitamos declarar e implementar nuestra propia clase. Para esto definimos *clases* que contengan datos con ciertas *propiedades* o *atributos* y acciones que queremos hacer con esos datos por medio de *métodos* o *funciones miembro*. De esta manera, podremos organizar la información y procesos en *objetos* que tienen las propiedades y métodos de una clase. En la experiencia de laboratorio de hoy practicarás el definir una clase e implementar algunos de sus métodos completando analizador de redes (*sniffer*) simple. El sniffer captura todos los paquetes de protocolo de internet (IP) que fluyen a través de tu computadora en el laboratorio, y alguna información adicional de los paquetes.
13
+
14
+## Objetivos:
15
+
16
+1. Practicar la declaración e implementación de clases en C++.
17
+
18
+2. Implementar métodos de una clase.
19
+
20
+
21
+## Pre-Lab:
22
+
23
+Antes de llegar al laboratorio debes haber:
24
+
25
+
26
+1. Repasado la declaración e implementación de clases en C++.
27
+
28
+2. Estudiado los conceptos e instrucciones para la sesión de laboratorio.
29
+
30
+3. Tomado el quiz Pre-Lab que se encuentra en Moodle.
31
+
32
+
33
+---
34
+
35
+---
36
+
37
+
38
+## Comunicación entre computadoras
39
+
40
+Las computadoras se comunican por medio del Internet utilizando el *Protocolo de Internet* (IP, por sus siglas en inglés). Cuando una computadora envía información (o mensaje) a otra computadora, la información se envía por *Paquetes de Internet* que contienen la *dirección fuente* ("source address"), que es la dirección de Internet de la computadora que está enviando la información, y la *dirección del destino* ("destination address"), que es dirección de Internet de la computadora que debe recibir el mensaje. Las direcciones de Internet se usan para guiar la información de una computadora a otra, pero, una vez el paquete llega a su destino, ?quién se supone que reciba la información? ?Cuál aplicación debe recibir la información?
41
+
42
+Los paquetes de internet también deben especificar la aplicación que envía la información y la aplicación que debe recibirla. Podemos pensar que las direcciones de Internet son las direcciones de correo de una casa, y que las aplicaciones que envían y reciben la información son las personas que envían y reciben la correspondencia. Para enviar una carta por correo, hay que especificar a qué persona se le está enviando la carta. Esto corresponde a especificar la aplicación que recibe la información. Para identificar la aplicación fuente y la aplicación del destino, el protocolo de Internet usa lo que se conoce como *números de puerto*. De este modo, mirando la información del paquete, se puede identificar las direcciones y puertos de la fuente y del destino.
43
+
44
+Por ejemplo, cuando la computadora que usas en un laboratorio se comunica con el servidor donde se encuentra el programa  Moodle, los paquetes que llevan la información de tu computadora al servidor contienen la dirección de la fuente, que es la computadora del laboratorio, y la dirección del destinatario, que es el servidor de Moodle. El puerto fuente es el de tu buscador web y el puerto destinatario es el del servidor de Moodle.
45
+
46
+Las direcciones de internet ocupan 4 bytes (32 bits) y usualmente se presentan al usuario como cadenas de 4 valores decimales. Cada valor decimal entre 0 y 255 es la representación decimal  de uno de los 4 bytes:
47
+ "(0-255).(0-255).(0-255).(0-255)". Algunos ejemplos de direcciones de IP son:
48
+ `10.0.1.10`, `192.168.10.11`, `136.145.54.10`.
49
+
50
+Para complicar las cosas un poco, cada tarjeta de red de computadoras tiene un identificador único que es usado para la comunicación entre tu computadora y el dispositivo de la red que enruta el tráfico de red de Internet y la red local a tu computadora y vice-versa (*protocolo Ethernet*). Este identificador único es conocido como la dirección de Hardware (también conocido como *dirección MAC*), es representado usando 6 bytes (48 bits), y es presentado a los usuarios como una cadena de caracteres de 6 pares de dígitos hexadecimales (cada par de dígitos hexadecimal corresponde a 1 byte). Por ejemplo, las siguientes son direcciones MAC:  `e0:f8:47:01:e9:90` y  `70:ad:60:ff:fe:dd`.
51
+
52
+---
53
+
54
+---
55
+
56
+## Analizador de redes simple
57
+
58
+Un *sniffer* de paquetes (también conocido como analizador de paquetes, analizador de protocolos, o analizador de redes) es un programa de computadora que puede interceptar y registrar el tráfico que pasa a través de una red digital, o dispositivo de red.  Mientras los datos fluyen a través de la red, el sniffer captura cada paquete, y si es necesario lo descifra para obtener los datos crudos del paquete [1].
59
+
60
+Cada paquete capturado por un sniffer tiene una estructura como la que ilustra la Figura 1.
61
+
62
+
63
+
64
+---
65
+
66
+![figure1.png](images/figure1.png)
67
+
68
+**Figura 1.** Estructura de cada paquete de Ethernet capturado por un *sniffer*.
69
+
70
+---
71
+
72
+
73
+
74
+Dentro de la  estructura estructura mostrada en la Figura 1 se encuentra:
75
+
76
+
77
+1. **Destination MAC Address** y **Source Mac Address**: son las direcciones MAC de la fuente y el destino.
78
+3. **Ether Type**: se utiliza para indicar el tipo de de protocolo utilizado en el **payload**. Uno de los **payloads** posibles es un paquete de IP.
79
+4. **Payload**: contiene un paquete de IP (en realidad puede contener otras cosas, pero para esta experiencia de laboratorio asumiremos que contiene solo IP).
80
+
81
+Dentro del payload, el paquete de IP contiene varios campos, entre ellos:
82
+
83
+1. Las direcciones **IP fuente y destino**
84
+2. Los números de **puerto fuente y destino**
85
+3. El **payload** del paquete IP. Dentro de este payload estarían los datos que se desean comunicar de una computadora a otra.
86
+
87
+En esta experiencia de laboratorio completarás un sniffer de paquetes sencillo que captura todos los paquetes de IP que fluyen a través de tu computadora de laboratorio, y alguna información adicional de los paquetes.  Adicionalmente detecta las solicitudes no encriptadas de imágenes en la web, y despliega las imágenes en el GUI.
88
+
89
+---
90
+
91
+---
92
+
93
+
94
+## Sesión de laboratorio:
95
+
96
+
97
+La aplicación que completarás hoy permite a los usuarios analizar el tráfico de red y monitorear las imágenes que están siendo transferidas a través de tu red.
98
+
99
+
100
+---
101
+
102
+![figure2.png](images/figure2.png)
103
+
104
+**Figura 2.** Interface de la aplicación *Simple Packet Sniffer*.
105
+
106
+---
107
+
108
+
109
+
110
+
111
+La Figura 2 muestra una foto de la interfaz de la aplicación. Cada fila en la tabla es la información de un paquete capturado. La caja de texto bajo la tabla presenta un resumen del paquete seleccionado en la tabla. La lista en el lado derecho presenta las imágenes que han sido capturadas por el sniffer.
112
+
113
+
114
+Para crear un sniffer de paquetes puedes usar la librería de *pcap* que provee una interfaz para accesar la data que está pasando a través de la tarjeta de red de tu computadora.  Esta librería contiene una función que devuelve un torrente crudo de los bytes de cada paquete capturado.
115
+
116
+La tarea del programador del sniffer es decodificar el torrente en crudo a información legible por humanos.  Afortunadamente esta no va a ser tu tarea, pero tu puedes aprender a hacerlo, si quieres, leyendo el código fuente de este laboratorio.  Tu tarea es seguir los ejercicios de abajo para que puedas proveerle al sniffer los objetos necesarios (Clases) para procesar los paquetes.
117
+
118
+### Ejercicio 1: Familiriarizate con la aplicación
119
+
120
+#### Instrucciones
121
+
122
+1. Descarga la carpeta `Classes-SimpleSniffer` a tu computadora escribiendo `git clone http://bitbucket.org/eip-uprrp/classes-simplesniffer` en el terminal.
123
+
124
+2. Para cargar este proyecto necesitas correr `Qt Creator` con privilegios de administrador (root). Para lograr esto, escribe lo siguiente en el terminal:
125
+`sudo qtcreator Documents/eip/classes-simplesniffer/Classes-SimpleSniffer.pro`.
126
+
127
+3. Configura el proyecto.  El proyecto consiste de varios archivos.  En esta experiencia de laboratorio trabajarás con los archivos `ethernet_hdr.h`, `ethernet_packet.h`, `ethernet_packet.cpp`, `ip_packet.h` y `ip_packet.cpp`.
128
+
129
+### Ejercicio 2: Completar la clase `ethernet_packet`
130
+
131
+Estudia el archivo `ethernet_hdr.h`. Este archivo contiene la siguiente definición de la estructura de datos que representa un encabezado de Ethernet:
132
+
133
+```cpp
134
+#define ETHER_ADDR_LEN 6
135
+
136
+struct sniff_ethernet {
137
+        u_char  ether_dhost[ETHER_ADDR_LEN];    /* direccion destino */
138
+        u_char  ether_shost[ETHER_ADDR_LEN];    /* direccion fuente */
139
+        u_short ether_type;                     /* IP? ARP? RARP? etc */
140
+};
141
+```
142
+
143
+El encabezado de Ethernet de arriba es usado para decodificar la parte Ethernet de los datos crudos en cada paquete.  Este se compone de la dirección MAC fuente (`ether_shost`, 6 bytes), la dirección MAC destino (`ether_dhost`, 6 bytes), y el tipo de paquete de Ethernet (`ether_type`, 2 bytes) que es usado para determinar si el paquete es un paquete de IP.
144
+
145
+Como sabes, no es una buena idea enseñar este formato de información a un usuario regular.  Tu primer tarea es definir los métodos de la clase de C++ que traducen la información de las direcciones MAC a cadenas de caracteres legibles por humanos.
146
+
147
+El siguiente código es la definición de la clase `ethernet_packet`, que se encuentra en el archivo `ethernet_packet.h`:
148
+
149
+```cpp
150
+class ethernet_packet
151
+{
152
+
153
+    sniff_ethernet ethernet ;
154
+
155
+    // Devuelve una direccion de 6 bytes MAC en una cadena de caracteres.
156
+    string mac2string(u_char []) ;
157
+
158
+public:
159
+    ethernet_packet();  // Constructor por defecto
160
+
161
+    // Ajusta la variable miembro ether_dhost a los valores
162
+    // recibidos en el arreglo
163
+    void setEtherDHost(u_char []) ;
164
+
165
+    // Ajusta la variable miembro  ether_shost a los valores
166
+    // recibidos en el arreglo
167
+    void setEtherSHost(u_char []) ;
168
+
169
+    // Ajusta el ethernet type al valor recibido.
170
+    void setEtherType(u_short) ;
171
+
172
+    // Devuelve la representación en cadenas de caracteres de las direcciones
173
+    // Ethernet
174
+    string getEtherDHost() ;
175
+    string getEtherSHost() ;
176
+
177
+    // Devuelve el tipo de ethernet.
178
+    u_short getEtherType() ;
179
+
180
+};
181
+
182
+
183
+
184
+```
185
+
186
+Nota que cada objeto de clase `ethernet_packet` solo tiene el siguiente atributo:
187
+* una estructura tipo `sniff_ethernet` llamada `ethernet`
188
+
189
+El resto son métodos que actúan como interfaz al atributo:
190
+
191
+* `void setEtherDHost(u_char [])`: es un *setter* para el campo `ether_dhost` del atributo `ethernet`
192
+
193
+* `void setEtherSHost(u_char [])`: es un *setter* para el campo `ether_shost` del atributo `ethernet`
194
+
195
+* `void setEtherType(u_short)`:  es un *setter* para el campo `ether_type` del atributo `ethernet`
196
+
197
+* `getEtherDHost()` y `getEtherSHost()` son *getters* que devuelven los valores de `ether_dhost` y `ether_shost` en formato legible por humanos, i.e. 6 pares de dígitos hexadecimales (por ejemplo, `e0:f8:47:01:e9:90`).
198
+
199
+* `getEtherType()` es un *getter*  que devuelve el valor de `ether_type` como *unsigned char*.
200
+
201
+* el método privado `string mac2string(u_char [])` recibe un arreglo de seis *unsigned characters* y devuelve el string correspondiente a su representación hexadecimal. Por ejemplo, si recibe `{ 0x8A, 0x11, 0xAB, 0xFF, 0x12, 0x34}` debe devolver el string `"8A:11:AB:FF:12:34"`.
202
+
203
+Tu tarea en este ejercicio es implementar las siete funciones listadas arriba en el archivo `ethetnet_packet.cpp`. Los encabezados de algunas de la funciones están provistos en el archivo.
204
+
205
+### Ejercicio 3: Construir la declaración de `ip_packet`
206
+
207
+Estudia las definiciones de las funciones de la clase `ip_packet` que se encuentra en el archivo `ip_packet.cpp`
208
+
209
+Tu tarea es crear la *declaración* de la clase `ip_packet` en el archivo `ip_packet.h` tomando como  base  los métodos que aparecen en el archivo `ip_packet.cpp`.  Los atributos de la clase `ip_packet` deben ser:
210
+
211
+* dos objetos de clase `string` para almacenar las direcciones de IP fuente y destino
212
+* una variable de un byte (`char`) para almacenar el tipo de protocolo IP
213
+* dos variables `unsigned short` para almacenar el puerto fuente y destino
214
+* un objeto de clase `string` para almacenar la carga (*payload*) del paquete.
215
+
216
+En la declaración de la clase `ip_packet` debes especificar que es una **clase derivada** de la clase `ethernet_packet`.
217
+
218
+---
219
+
220
+---
221
+
222
+## Entregas
223
+
224
+1. Utiliza "Entrega" en Moodle para entregar los archivos `ethernet_packet.cpp` y `ip_packet.h` que completaste. Recuerda utilizar buenas prácticas de programación, incluir el nombre de los programadores y documentar tu programa.
225
+
226
+---
227
+
228
+---
229
+
230
+## Referencias
231
+
232
+[1]http://en.wikipedia.org/wiki/Packet_analyzer
233
+
234
+
235
+---
236
+
237
+---
238
+
239
+---
240
+

+ 2
- 374
README.md 查看文件

@@ -1,374 +1,2 @@
1
-[English](#markdown-header-classes-simple-sniffer) | [Español](#markdown-header-clases-analizador-de-redes-simple)
2
-
3
-
4
-# Clases - Analizador de redes simple
5
-
6
-![header.png](images/header.png)  
7
-
8
-
9
-La *programación orientada a objetos* (object oriented programming, OOP) es un paradigma de programación que promueve el diseño de programas en el que distintos objetos interactúan entre sí para resolver un problema.   C++ es uno de los lenguajes de programación que promueve la programación orientada a objetos, permitiendo que los programadores creen sus propias clases desde cero o derivadas de otras clases existentes. Algunos otros lenguajes que promueven OOP son Java, Python, javascript y PHP.   
10
-
11
-En OOP, cada objeto encapsula dentro de él ciertas propiedades sobre el ente que está modelando (por ejemplo, un objeto que modela un *punto* encapsula dentro de sí las coordenadas *x* y *y* del punto que representa). Además, cada objeto permite realizar ciertas acciones sobre sí, i.e. contiene sus *métodos*. Por ejemplo, un objeto de clase *punto* puede realizar la acción de cambiar el valor de su coordenada *x*.
12
-
13
-Cuando la clase de objetos que necesitamos utilizar en nuestro programa no ha sido predefinida en el alguna librería, necesitamos declarar e implementar nuestra propia clase. Para esto definimos *clases* que contengan datos con ciertas *propiedades* o *atributos* y acciones que queremos hacer con esos datos por medio de *métodos* o *funciones miembro*. De esta manera, podremos organizar la información y procesos en *objetos* que tienen las propiedades y métodos de una clase. En la experiencia de laboratorio de hoy practicarás el definir una clase e implementar algunos de sus métodos completando analizador de redes (*sniffer*) simple. El sniffer captura todos los paquetes de protocolo de internet (IP) que fluyen a través de tu computadora en el laboratorio, y alguna información adicional de los paquetes.
14
-
15
-## Objetivos:
16
-
17
-1. Practicar la declaración e implementación de clases en C++.
18
-
19
-2. Implementar métodos de una clase.
20
-
21
-
22
-## Pre-Lab:
23
-
24
-Antes de llegar al laboratorio debes haber:
25
-
26
-
27
-1. Repasado la declaración e implementación de clases en C++.
28
-
29
-2. Estudiado los conceptos e instrucciones para la sesión de laboratorio.
30
-
31
-3. Tomado el quiz Pre-Lab que se encuentra en Moodle.
32
-
33
-
34
----
35
-
36
----
37
-
38
-
39
-## Comunicación entre computadoras
40
-
41
-Las computadoras se comunican por medio del Internet utilizando el *Protocolo de Internet* (IP, por sus siglas en inglés). Cuando una computadora envía información (o mensaje) a otra computadora, la información se envía por *Paquetes de Internet* que contienen la *dirección fuente* ("source address"), que es la dirección de Internet de la computadora que está enviando la información, y la *dirección del destino* ("destination address"), que es dirección de Internet de la computadora que debe recibir el mensaje. Las direcciones de Internet se usan para guiar la información de una computadora a otra, pero, una vez el paquete llega a su destino, ?quién se supone que reciba la información? ?Cuál aplicación debe recibir la información?
42
-
43
-Los paquetes de internet también deben especificar la aplicación que envía la información y la aplicación que debe recibirla. Podemos pensar que las direcciones de Internet son las direcciones de correo de una casa, y que las aplicaciones que envían y reciben la información son las personas que envían y reciben la correspondencia. Para enviar una carta por correo, hay que especificar a qué persona se le está enviando la carta. Esto corresponde a especificar la aplicación que recibe la información. Para identificar la aplicación fuente y la aplicación del destino, el protocolo de Internet usa lo que se conoce como *números de puerto*. De este modo, mirando la información del paquete, se puede identificar las direcciones y puertos de la fuente y del destino.
44
-
45
-Por ejemplo, cuando la computadora que usas en un laboratorio se comunica con el servidor donde se encuentra el programa  Moodle, los paquetes que llevan la información de tu computadora al servidor contienen la dirección de la fuente, que es la computadora del laboratorio, y la dirección del destinatario, que es el servidor de Moodle. El puerto fuente es el de tu buscador web y el puerto destinatario es el del servidor de Moodle.
46
-
47
-Las direcciones de internet ocupan 4 bytes (32 bits) y usualmente se presentan al usuario como cadenas de 4 valores decimales. Cada valor decimal entre 0 y 255 es la representación decimal  de uno de los 4 bytes:
48
- "(0-255).(0-255).(0-255).(0-255)". Algunos ejemplos de direcciones de IP son:
49
- `10.0.1.10`, `192.168.10.11`, `136.145.54.10`.
50
-
51
-Para complicar las cosas un poco, cada tarjeta de red de computadoras tiene un identificador único que es usado para la comunicación entre tu computadora y el dispositivo de la red que enruta el tráfico de red de Internet y la red local a tu computadora y vice-versa (*protocolo Ethernet*). Este identificador único es conocido como la dirección de Hardware (también conocido como *dirección MAC*), es representado usando 6 bytes (48 bits), y es presentado a los usuarios como una cadena de caracteres de 6 pares de dígitos hexadecimales (cada par de dígitos hexadecimal corresponde a 1 byte). Por ejemplo, las siguientes son direcciones MAC:  `e0:f8:47:01:e9:90` y  `70:ad:60:ff:fe:dd`.
52
-
53
----
54
-
55
----
56
-
57
-## Analizador de redes simple
58
-
59
-Un *sniffer* de paquetes (también conocido como analizador de paquetes, analizador de protocolos, o analizador de redes) es un programa de computadora que puede interceptar y registrar el tráfico que pasa a través de una red digital, o dispositivo de red.  Mientras los datos fluyen a través de la red, el sniffer captura cada paquete, y si es necesario lo descifra para obtener los datos crudos del paquete [1].
60
-
61
-Cada paquete capturado por un sniffer tiene una estructura como la que ilustra la Figura 1.
62
-
63
-
64
-
65
----
66
-
67
-![figure1.png](images/figure1.png)
68
-
69
-**Figura 1.** Estructura de cada paquete de Ethernet capturado por un *sniffer*.
70
-
71
----
72
-
73
-
74
-
75
-Dentro de la  estructura estructura mostrada en la Figura 1 se encuentra:
76
-
77
-
78
-1. **Destination MAC Address** y **Source Mac Address**: son las direcciones MAC de la fuente y el destino.
79
-3. **Ether Type**: se utiliza para indicar el tipo de de protocolo utilizado en el **payload**. Uno de los **payloads** posibles es un paquete de IP.
80
-4. **Payload**: contiene un paquete de IP (en realidad puede contener otras cosas, pero para esta experiencia de laboratorio asumiremos que contiene solo IP).
81
-
82
-Dentro del payload, el paquete de IP contiene varios campos, entre ellos:
83
-
84
-1. Las direcciones **IP fuente y destino**
85
-2. Los números de **puerto fuente y destino**
86
-3. El **payload** del paquete IP. Dentro de este payload estarían los datos que se desean comunicar de una computadora a otra.
87
-
88
-En esta experiencia de laboratorio completarás un sniffer de paquetes sencillo que captura todos los paquetes de IP que fluyen a través de tu computadora de laboratorio, y alguna información adicional de los paquetes.  Adicionalmente detecta las solicitudes no encriptadas de imágenes en la web, y despliega las imágenes en el GUI.
89
-
90
----
91
-
92
----
93
-
94
-
95
-## Sesión de laboratorio:
96
-
97
-
98
-La aplicación que completarás hoy permite a los usuarios analizar el tráfico de red y monitorear las imágenes que están siendo transferidas a través de tu red.
99
-
100
-
101
----
102
-
103
-![figure2.png](images/figure2.png)
104
-
105
-**Figura 2.** Interface de la aplicación *Simple Packet Sniffer*.
106
-
107
----
108
-
109
-
110
-
111
-
112
-La Figura 2 muestra una foto de la interfaz de la aplicación. Cada fila en la tabla es la información de un paquete capturado. La caja de texto bajo la tabla presenta un resumen del paquete seleccionado en la tabla. La lista en el lado derecho presenta las imágenes que han sido capturadas por el sniffer.
113
-
114
-
115
-Para crear un sniffer de paquetes puedes usar la librería de *pcap* que provee una interfaz para accesar la data que está pasando a través de la tarjeta de red de tu computadora.  Esta librería contiene una función que devuelve un torrente crudo de los bytes de cada paquete capturado.
116
-
117
-La tarea del programador del sniffer es decodificar el torrente en crudo a información legible por humanos.  Afortunadamente esta no va a ser tu tarea, pero tu puedes aprender a hacerlo, si quieres, leyendo el código fuente de este laboratorio.  Tu tarea es seguir los ejercicios de abajo para que puedas proveerle al sniffer los objetos necesarios (Clases) para procesar los paquetes.
118
-
119
-### Ejercicio 1: Familiriarizate con la aplicación
120
-
121
-#### Instrucciones
122
-
123
-1. Descarga la carpeta `Classes-SimpleSniffer` a tu computadora escribiendo `git clone http://bitbucket.org/eip-uprrp/classes-simplesniffer` en el terminal.
124
-
125
-2. Para cargar este proyecto necesitas correr `Qt Creator` con privilegios de administrador (root). Para lograr esto, escribe lo siguiente en el terminal:
126
-`sudo qtcreator Documents/eip/classes-simplesniffer/Classes-SimpleSniffer.pro`.
127
-
128
-3. Configura el proyecto.  El proyecto consiste de varios archivos.  En esta experiencia de laboratorio trabajarás con los archivos `ethernet_hdr.h`, `ethernet_packet.h`, `ethernet_packet.cpp`, `ip_packet.h` y `ip_packet.cpp`.
129
-
130
-### Ejercicio 2: Completar la clase `ethernet_packet`
131
-
132
-Estudia el archivo `ethernet_hdr.h`. Este archivo contiene la siguiente definición de la estructura de datos que representa un encabezado de Ethernet:
133
-
134
-```cpp
135
-#define ETHER_ADDR_LEN 6
136
-
137
-struct sniff_ethernet {
138
-        u_char  ether_dhost[ETHER_ADDR_LEN];    /* direccion destino */
139
-        u_char  ether_shost[ETHER_ADDR_LEN];    /* direccion fuente */
140
-        u_short ether_type;                     /* IP? ARP? RARP? etc */
141
-};
142
-```
143
-
144
-El encabezado de Ethernet de arriba es usado para decodificar la parte Ethernet de los datos crudos en cada paquete.  Este se compone de la dirección MAC fuente (`ether_shost`, 6 bytes), la dirección MAC destino (`ether_dhost`, 6 bytes), y el tipo de paquete de Ethernet (`ether_type`, 2 bytes) que es usado para determinar si el paquete es un paquete de IP.
145
-
146
-Como sabes, no es una buena idea enseñar este formato de información a un usuario regular.  Tu primer tarea es definir los métodos de la clase de C++ que traducen la información de las direcciones MAC a cadenas de caracteres legibles por humanos.
147
-
148
-El siguiente código es la definición de la clase `ethernet_packet`, que se encuentra en el archivo `ethernet_packet.h`:
149
-
150
-```cpp
151
-class ethernet_packet
152
-{
153
-
154
-    sniff_ethernet ethernet ;
155
-
156
-    // Devuelve una direccion de 6 bytes MAC en una cadena de caracteres.
157
-    string mac2string(u_char []) ;
158
-
159
-public:
160
-    ethernet_packet();  // Constructor por defecto
161
-
162
-    // Ajusta la variable miembro ether_dhost a los valores
163
-    // recibidos en el arreglo
164
-    void setEtherDHost(u_char []) ;
165
-
166
-    // Ajusta la variable miembro  ether_shost a los valores
167
-    // recibidos en el arreglo
168
-    void setEtherSHost(u_char []) ;
169
-
170
-    // Ajusta el ethernet type al valor recibido.
171
-    void setEtherType(u_short) ;
172
-
173
-    // Devuelve la representación en cadenas de caracteres de las direcciones
174
-    // Ethernet
175
-    string getEtherDHost() ;
176
-    string getEtherSHost() ;
177
-
178
-    // Devuelve el tipo de ethernet.
179
-    u_short getEtherType() ;
180
-
181
-};
182
-
183
-
184
-
185
-```
186
-
187
-Nota que cada objeto de clase `ethernet_packet` solo tiene el siguiente atributo:
188
-* una estructura tipo `sniff_ethernet` llamada `ethernet`
189
-
190
-El resto son métodos que actúan como interfaz al atributo:
191
-
192
-* `void setEtherDHost(u_char [])`: es un *setter* para el campo `ether_dhost` del atributo `ethernet`
193
-
194
-* `void setEtherSHost(u_char [])`: es un *setter* para el campo `ether_shost` del atributo `ethernet`
195
-
196
-* `void setEtherType(u_short)`:  es un *setter* para el campo `ether_type` del atributo `ethernet`
197
-
198
-* `getEtherDHost()` y `getEtherSHost()` son *getters* que devuelven los valores de `ether_dhost` y `ether_shost` en formato legible por humanos, i.e. 6 pares de dígitos hexadecimales (por ejemplo, `e0:f8:47:01:e9:90`).
199
-
200
-* `getEtherType()` es un *getter*  que devuelve el valor de `ether_type` como *unsigned char*.
201
-
202
-* el método privado `string mac2string(u_char [])` recibe un arreglo de seis *unsigned characters* y devuelve el string correspondiente a su representación hexadecimal. Por ejemplo, si recibe `{ 0x8A, 0x11, 0xAB, 0xFF, 0x12, 0x34}` debe devolver el string `"8A:11:AB:FF:12:34"`.
203
-
204
-Tu tarea en este ejercicio es implementar las siete funciones listadas arriba en el archivo `ethetnet_packet.cpp`. Los encabezados de algunas de la funciones están provistos en el archivo.
205
-
206
-### Ejercicio 3: Construir la declaración de `ip_packet`
207
-
208
-Estudia las definiciones de las funciones de la clase `ip_packet` que se encuentra en el archivo `ip_packet.cpp`
209
-
210
-Tu tarea es crear la *declaración* de la clase `ip_packet` en el archivo `ip_packet.h` tomando como  base  los métodos que aparecen en el archivo `ip_packet.cpp`.  Los atributos de la clase `ip_packet` deben ser:
211
-
212
-* dos objetos de clase `string` para almacenar las direcciones de IP fuente y destino
213
-* una variable de un byte (`char`) para almacenar el tipo de protocolo IP
214
-* dos variables `unsigned short` para almacenar el puerto fuente y destino
215
-* un objeto de clase `string` para almacenar la carga (*payload*) del paquete.
216
-
217
-En la declaración de la clase `ip_packet` debes especificar que es una **clase derivada** de la clase `ethernet_packet`.
218
-
219
----
220
-
221
----
222
-
223
-## Entregas
224
-
225
-1. Utiliza "Entrega" en Moodle para entregar los archivos `ethernet_packet.cpp` y `ip_packet.h` que completaste. Recuerda utilizar buenas prácticas de programación, incluir el nombre de los programadores y documentar tu programa.
226
-
227
----
228
-
229
----
230
-
231
-## Referencias
232
-
233
-[1]http://en.wikipedia.org/wiki/Packet_analyzer
234
-
235
-
236
----
237
-
238
----
239
-
240
----
241
-
242
-[English](#markdown-header-classes-simple-sniffer) | [Español](#markdown-header-clases-analizador-de-redes-simple)
243
-
244
-# Classes - Simple Sniffer
245
-
246
-##Objectives
247
-
248
-1. Practice Data Structures, Classes and Inheritance
249
-
250
-## Pre-Lab:
251
-
252
-Before you get to the laboratory you should have:
253
-
254
-    1. Reviewed C++ classes and structures
255
-    2. Studied the concepts and instructions for this laboratory session.
256
-    3. Taken the Pre-Lab quiz in Moodle
257
-
258
-## Simple Sniffer
259
-
260
-Computers communicate with each other through the Internet Protocol (IP).  When a computer sends information to another computer it is sent via Internet packets that contain the Internet address of the sender computer (source address), the source port of the application that is sending the message, the Internet address of the receiving computer(destination address), and the port of the application that will receive the message.
261
-
262
-We can compare the Internet address to the address of a house, and the applications to the members of the house. When sending a letter from one house to another, the address on the letter identifies the destination house, and the name on the letter identifies the house member to who it is sent.
263
-
264
-For instance when your lab computer is contacting the department's web server, the packets that carry the information from your computer to the web server contains the source address of the lab computer and the destination address of the web server;  and the source port of your web browser and the destination port of the web server.
265
-
266
-Internet addresses are represented on 4 bytes (32 bits) normally presented to users as strings of 4 decimal values. Each decimal value is the decimal representation of one of the 4 bytes:  "(0-255).(0-255).(0-255).(0-255)". Examples of IP addresses are: 10.0.1.10, 192.168.10.11, 136.145.54.10, and so on.
267
-
268
-Port numbers are composed of 2 bytes or 16 bits.  Therefore port numbers range from 0-65535. There are ports numbers assigned to known application services such as number 22 for ssh, 23 for telnet, 25 smtp, 80 for http, and so on.
269
-
270
-To complicate things a little bit, each computer network card has an unique identifier that is used for the communication between you computer and the network device that routes the network traffic from the Internet and local network to your computer and vice-versa (Ethernet protocol).  This unique identifier is known as the Hardware address (a.k.a Multiple Access Controll (MAC) addres), is represented on 6 bytes (48 bits), and is presented to users as strings of 6 hexadecimal values. Each hex value is the hex representation of the 6 bytes: "(00-ff):(00-ff):(00-ff):(00-ff):(00-ff):(00-ff)".  Examples of MAC addresses are: e0:f8:47:01:e9:90, 70:ad:60:ff:fe:dd:79:d8 , and so on.
271
-
272
-A packet sniffer (a.k.a packet analyzer, protocol analyzer, or network analyzer) is a computer program that can intercept and log traffic passing over a digital network, or network device.  As data flow across the network, the sniffer captures each packet and, if needed decodes the packet's raw data[1].
273
-
274
-
275
-The packets captured by this program follow the following packet structure:
276
-
277
-    * first an Ethernet header which contains the source and destination MAC addresses
278
-    * second a IP header that contains the source and destination IP addresses
279
-    * third a header that contains the source and destination port numbers.
280
-
281
-In this application we create a simple packet sniffer that captures all the IP packets that flow across your lab computer, and for each packet, decodes the IP addresses, the port numbers, and some additional information of the packets.  Additionaly it detects the unencrypted request of images in the web, and displays the images in the GUI.
282
-
283
-See the following snapshot of the application:
284
-![](images/ss.png)
285
-
286
-Each row in the table is the information of each captured packet, the text box under the table presents a ASCII summary of a selected packet from the table, and the list in the right presents the images that have been requested and are seen in you network card.  
287
-
288
-The application that you are about to complete gives the user the ability to analyze the network traffic and monitor the images that are being watched in your network.  
289
-
290
-## Laboratory session:
291
-
292
-To create a packet sniffer you can use the *pcap* library that provides an interface to access the data passing across your network card.  This library contains a function that returns a raw stream of bytes of each packet captured.  It is the task of the sniffer programmer to decode the raw stream into human readable information.  Fortunately this is not your task, but you can learn how to do it, if you want, by reading the source code of this laboratory.  Your task is to follow the exercises below so you provide the packet sniffer with the needed objects (Classes) to process the packets.
293
-
294
-## Exercise 1: Familiriaze your self with the application
295
-
296
-Instructions
297
-
298
-    1. To load this project you need to run qt creator with root privileges.
299
-        ```sudo qtcreator Documents/eip/simplesniffer/SimpleSniffer.pro```
300
-    2.The project `SimpleSniffer` is in the directory `Documents/eip/simplesniffer` of your computer. You can also go to `http://bitbucket.org/eip-uprrp/classes-simplesniffer` to download the folder `classes-simplesniffer` to your computer.
301
-    2. Configure the project.  The project consists of several files.  In this laboratory you will be working with the files `ethernet_hdr.h`, `ethernet_packet.h`, `ethernet_packet.cpp`, `ip_packet.h` and `ip_packet.cpp`
302
-
303
-
304
-## Exercise 2: Complete the class ethernet_packet
305
-
306
-Read the file `ethernet_hdr.h`, it contains the definition of the data structure that represents an Ethernet header.  It is also shown below:
307
-
308
-```
309
-#define ETHER_ADDR_LEN 6
310
-
311
-struct sniff_ethernet {
312
-        u_char  ether_dhost[ETHER_ADDR_LEN];    /* destination host address */
313
-        u_char  ether_shost[ETHER_ADDR_LEN];    /* source host address */
314
-        u_short ether_type;                     /* IP? ARP? RARP? etc */
315
-};
316
-```
317
-
318
-The Ethernet header above is used to decode the ethernet part of the raw data in each packet.  It is composed of the source MAC address (ether_shost, 6 bytes), the destiantion MAC address (ether_dhost, 6 bytes), and the type of Ethernet packet (ether_type, 2 bytes) which is used to determine if the packet is an IP packet.
319
-
320
-As you can see, it is not a good idea to show this information format to a regular user.  Your first task is to define the functions of the C++ class that defines the functions to translate the MAC address information into human readable strings.
321
-
322
-The class header is in file `ethernet_packet.h` and is also shown below:
323
-
324
-```
325
-class ethernet_packet
326
-{
327
-
328
-    sniff_ethernet ethernet ;
329
-    // Returns a 6 bytes MAC address in string representation.
330
-    string mac2string(u_char []) ;
331
-
332
-public:
333
-    ethernet_packet();  // Default constructor
334
-
335
-    // Set the ethernet variable member ether_dhost to the values
336
-    // received in the array
337
-    void setEtherDHost(u_char []) ;
338
-    // Same as above but to the ether_shost
339
-    void setEtherSHost(u_char []) ;
340
-
341
-    // Set the ethernet type to the value received.
342
-    void setEtherType(u_short) ;
343
-
344
-    // returns the string representation of the ethernet addresses
345
-    string getEtherDHost() ;
346
-    string getEtherSHost() ;
347
-
348
-    // Return the ethernet type
349
-    u_short getEtherType() ;
350
-
351
-};
352
-```
353
-
354
-Define the functions in file `ethetnet_packet.cpp`
355
-
356
-## Exercise 3: Construct the header of class ip_packet  
357
-
358
-For Exercise 3 see the definitions of the functions of the class ip_packet found in file `ip_packet.cpp`
359
-
360
-Your task is to define the class header following the functions inside the file.  The member variables are:
361
-* two `string`s to store the source and destination IP addresses
362
-* a one byte (`char`) variable to store the IP protocol
363
-* two `unsigned short` variables to store the source and destination port
364
-* one `string` to store the packet payload.
365
-
366
-This class header that you are defining inherits from the class that you defined in Exercise 2.
367
-
368
-### Deliverables
369
-
370
-Use "Deliverables" in Moodle to upload the files `ethernet_packet.cpp` y `ip_packet.h` that you defined.
371
-
372
-### References
373
-
374
-[1]http://en.wikipedia.org/wiki/Packet_analyzer
1
+## [\[English\]](README-en.md) - for README in English
2
+## [\[Spanish\]](README-es.md) - for README in Spanish