EIP
/
classes-simplesniffer
Watch 2
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

Como en el libro

Luis Albertorio 8 years ago
parent
3d383718e5
commit
deead063ef
2 changed files with 69 additions and 158 deletions
Unified View Show Diff Stats
  1. 13
    12
      README-en.md
  2. 56
    146
      README-es.md

+ 13
- 12
README-en.md View File

1 
-
2 
 # Classes - Simple Sniffer
 1 
 # Classes - Simple Sniffer
3
2
4 
 ##Objectives
 3 
 ##Objectives
9
8
10 
 Before you get to the laboratory you should have:
 9 
 Before you get to the laboratory you should have:
11
10
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
11 
+1. Reviewed C++ classes and structures
12 
+2. Studied the concepts and instructions for this laboratory session.
13 
+3. Taken the Pre-Lab quiz in Moodle
15
14
16 
 ## Simple Sniffer
 15 
 ## Simple Sniffer
17
16
32
31
33 
 The packets captured by this program follow the following packet structure:
 32 
 The packets captured by this program follow the following packet structure:
34
33
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.
34 
+1. first an Ethernet header which contains the source and destination MAC addresses
35 
+2. second a IP header that contains the source and destination IP addresses
36 
+3. third a header that contains the source and destination port numbers.
38
37
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.
 38 
 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
39
51
50
52 
 ## Exercise 1: Familiriaze your self with the application
 51 
 ## Exercise 1: Familiriaze your self with the application
53
52
54 
-Instructions
53 
+####Instructions
55
54
56 
-    1. To load this project you need to run qt creator with root privileges.
55 
+1. To load this project you need to run qt creator with root privileges.
57 
         ```sudo qtcreator Documents/eip/simplesniffer/SimpleSniffer.pro```
 56 
         ```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`
57 
+
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 
+
60 
+3. 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
61
62
62 
 ## Exercise 2: Complete the class ethernet_packet
 63 
 ## Exercise 2: Complete the class ethernet_packet
129
130
130 
 ### References
 131 
 ### References
131
132
132 
-[1]http://en.wikipedia.org/wiki/Packet_analyzer
133 
+[1]http://en.wikipedia.org/wiki/Packet_analyzer

+ 56
- 146
README-es.md View File

1 
+# Clases - Sniffer Simple
1
2
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:
3 
+##Objetivos
15
4
16 
 1. Practicar la declaración e implementación de clases en C++.
 5 
 1. Practicar la declaración e implementación de clases en C++.
17
6
18 
-2. Implementar métodos de una clase.
19 
-
20
7
21 
 ## Pre-Lab:
 8 
 ## Pre-Lab:
22
9
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 
-
10 
+Antes de llegar al laboratorio debes:
62
11
12 
+1. Haber repasado la declaración e implementación de clases en C++.
13 
+2. Haber estudiado los conceptos e instrucciones para la sesión de laboratorio.
14 
+3. Haber tomado el quiz Pre-Lab que se encuentra en Moodle.
63
15
64 
----
16 
+## Sniffer Simple
65
17
66 
-![figure1.png](images/figure1.png)
18 
+Las computadoras se comunican con otras a través del protocolo de Internet (IP).  Cuando una computadora envia información a otra computadora es via paquetes de Internet que contienen la dirección de Internet de la computadora que envia (computadora fuente), el puerto fuente de la aplicación que está enviando el mensaje, la dirección de Internet de la computadora que recibe (computadora destino), y el puerto de la aplicación que va a recibir el mensaje.
67
19
68 
-**Figura 1.** Estructura de cada paquete de Ethernet capturado por un *sniffer*.
20 
+Podemos comparar las direcciones de Internet a las direcciones de una casa, y las aplicaciones a los miembros de una casa.  Cuando se envia una carta de una casa a otra, la dirección en la carta identifica la casa destino, y el nombre en la carta identifica al miembro de la casa al que se le envía.
69
21
70 
----
22 
+Por ejemplo cuando tu computadora de laboratorio esta contactactando al servidor de web del departamento, los paquetes que cargan la informacion de tu computadora al servidor de web contienen la dirección fuente de la computadora del laboratorio y la dirección destino del servidor de web; y el puerto fuente del tu buscador de web (browser) y el puerto destino del servidor de web.
71
23
24 
+Las direcciones de Internet son representados usando 4 bytes (32 bits), y comunmente son presentadas a los usuarios como cadenas de caracteres de 4 valores decimales.  Cada valor decimal es la representacion decimal de uno de los 4 bytes: "(0-255).(0-255).(0-255).(0-255)". Por ejemplo, las siguientes son tres direcciones IP  10.0.1.10, 192.168.10.11, 136.145.54.10.
72
25
26 
+Los números de los puertos son enteros sin signo en el rango de [0-65535]. Se representan usando 2 bytes (16 bits). Hay números de puertos que son asignados a servicios de aplicaciones comúnes tales como el número 22 para ssh, 23 para telnet, 25 smtp, y el 80 para http.
73
27
74 
-Dentro de la  estructura estructura mostrada en la Figura 1 se encuentra:
28 
+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 usarios como una cadena de caracteres de 6 pares de dígitos hexadecimales (cada par de dígitos hexadecimal corresponde a 1 byte). Por ejemplo, los siguientes son direcciones MAC:  `e0:f8:47:01:e9:90` y  `70:ad:60:ff:fe:dd:79:d8`.
75
29
30 
+Un sniffer de paquetes (también conocido como analizador de paquetes, analizador de protocolos, o analizador de red) es un programa de computadora que puede interceptar y registrar tráfico pasando 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 paquet, y si es necesario decodifica los datos crudos del paquete[1].
76
31
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).
32 
+Cada paquete capturado por este programa tiene la siguiente estructura:
80
33
81 
-Dentro del payload, el paquete de IP contiene varios campos, entre ellos:
34 
+1. un encabezado de Ethernet que contiene las direcciones MAC fuente y destino
35 
+2. un encabezado de IP que contiene las direcciones IP fuente y destino
36 
+3. un encabezado que contiene los números de puerto fuente y destino
82
37
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.
38 
+En esta experiencia de laboratorio completaremos 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 imagenes en la web, y despliega las imágenes en el GUI.
86
39
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
40
89 
----
90
41
91 
----
92
42
43 
+----
93
44
94 
-## Sesión de laboratorio:
45 
+![](images/ss.png)
95
46
47 
+**Figura 1** - La aplicación corriendo.
96
48
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.
49 
+----
98
50
51 
+La Figura 1 muestra una foto 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 en ASCII del paquete seleccionado en la tabla, y la lista en el lado derecho presenta las imagenes que han sido solicitadas y se han visto en la tarjeta de red.
99
52
100 
----
53 
+La aplicación que tu estas a punto de completar le da a los usuarios la habilidad de analizar el tráfico de red y monitorear imagenes que estan siendo vistas en tu red.
101
54
102 
-![figure2.png](images/figure2.png)
103
55
104 
-**Figura 2.** Interface de la aplicación *Simple Packet Sniffer*.
56 
+## Sesión de laboratorio
105
57
106 
----
58 
+Para crear un sniffer de paquetes puedes usar la librería de *pcap* que provee una interface para accesar la data que está pasando a través de tu tarjeta de red.  Esta librería contiene una función que devuelve un torrente crudo de los bytes de cada paquete capturado.
107
59
60 
+Es la tarea del programador del sniffer 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 abajo para que puedas proveerle al sniffer los objetos necesarios (Clases) para procesar los paquetes.
108
61
62 
+## Ejercicio 1: Familiriarizate con la aplicación
109
63
64 
+**Instrucciones**
110
65
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.
66 
+1. Para cargar este proyecto necesitas correr qt creator con privilegios de administrador (root).
67 
+        ```sudo qtcreator Documents/eip/simplesniffer/SimpleSniffer.pro```
112
68
69 
+2. El proyecto `SimpleSniffer` está en el directorio `Documents/eip/simplesniffer` de tu computadora.  Alternativamente puedes crear un clon del repositorio git `http://bitbucket.org/eip-uprrp/classes-simplesniffer` para descargar el directorio `classes-simplesniffer` a tu computadora.
113
70
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.
71 
+3. Configura el proyecto. El proyecto consiste de varios archivos.  En este laboratorio trabajarás con los archivos `ethernet_hdr.h`, `ethernet_packet.h`, `ethernet_packet.cpp`, `ip_packet.h` and `ip_packet.cpp`.
115
72
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.
73 
+## Ejercicio 2: Completa la clase ethernet_packet
117
74
118 
-### Ejercicio 1: Familiriarizate con la aplicación
75 
+Lee el archivo `ethernet_hdr.h`, este contiene la definición de la estructura de datos que representa un encabezado de Ethernet. A continuación mostramos esa definición:
119
76
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
77 
+```
134 
 #define ETHER_ADDR_LEN 6
 78 
 #define ETHER_ADDR_LEN 6
135
79
136 
 struct sniff_ethernet {
 80 
 struct sniff_ethernet {
140 
 };
 84 
 };
141 
 ```
 85 
 ```
142
86
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.
87 
+El encabezado de Ethernet 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
88
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.
89 
+Como puedes ver, no es una buena idea enseñar este formato de información a un usario regular.  Tu primer tarea es definir las funciones de la clase de C++ que define las funciones para traducir la información de las direcciones MAC a cadenas de caracteres legibles por humanos.
146
90
147 
-El siguiente código es la definición de la clase `ethernet_packet`, que se encuentra en el archivo `ethernet_packet.h`:
91 
+El encabezado de la clase está en el archivo `ethernet_packet.h` y también la mostramos a continuación:
148
92
149 
-```cpp
93 
+```
150 
 class ethernet_packet
 94 
 class ethernet_packet
151 
 {
 95 
 {
152
96
153 
     sniff_ethernet ethernet ;
 97 
     sniff_ethernet ethernet ;
154 
-
155 
     // Devuelve una direccion de 6 bytes MAC en una cadena de caracteres.
 98 
     // Devuelve una direccion de 6 bytes MAC en una cadena de caracteres.
156 
     string mac2string(u_char []) ;
 99 
     string mac2string(u_char []) ;
157
100
158 
 public:
 101 
 public:
159 
     ethernet_packet();  // Constructor por defecto
 102 
     ethernet_packet();  // Constructor por defecto
160
103
161 
-    // Ajusta la variable miembro ether_dhost a los valores
104 
+    // Ajusta la variable miembro ether_host a los valores
162 
     // recibidos en el arreglo
 105 
     // recibidos en el arreglo
163 
     void setEtherDHost(u_char []) ;
 106 
     void setEtherDHost(u_char []) ;
164 
-
165 
-    // Ajusta la variable miembro  ether_shost a los valores
166 
-    // recibidos en el arreglo
107 
+    // Lo mismo que arriba pero al  ether_shost
167 
     void setEtherSHost(u_char []) ;
 108 
     void setEtherSHost(u_char []) ;
168
109
169 
     // Ajusta el ethernet type al valor recibido.
 110 
     // Ajusta el ethernet type al valor recibido.
178 
     u_short getEtherType() ;
 119 
     u_short getEtherType() ;
179
120
180 
 };
 121 
 };
181 
-
182 
-
183 
-
184 
 ```
 122 
 ```
185
123
186 
-Nota que cada objeto de clase `ethernet_packet` solo tiene el siguiente atributo:
187 
-* una estructura tipo `sniff_ethernet` llamada `ethernet`
124 
+Implementa las funciones en el archivo `ethetnet_packet.cpp`.
188
125
189 
-El resto son métodos que actúan como interfaz al atributo:
126 
+**[Rafa] Puedes sugerir una forma para que validen si han implementado bien la función.**
190
127
191 
-* `void setEtherDHost(u_char [])`: es un *setter* para el campo `ether_dhost` del atributo `ethernet`
128 
+## Ejercicio 3: Construye el encabezado de ip_packet
192
129
193 
-* `void setEtherSHost(u_char [])`: es un *setter* para el campo `ether_shost` del atributo `ethernet`
130 
+Para el Ejercicio 3 debes estudiar las definiciones de las funciones de la clase `ip_packet` que se encuentra en el archivo `ip_packet.cpp`
194
131
195 
-* `void setEtherType(u_short)`:  es un *setter* para el campo `ether_type` del atributo `ethernet`
132 
+Tu tarea es definir el **encabezado** de la clase siguiendo las funciones en ese archivo.  Las variables miembro son:
196
133
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
134 
+* dos variables  `string` para almacenar las direcciones de IP fuente y destino
135 
+* una variable de un byte (`char`) para almacenar el typo de protocolo IP
213 
 * dos variables `unsigned short` para almacenar el puerto fuente y destino
 136 
 * dos variables `unsigned short` para almacenar el puerto fuente y destino
214 
-* un objeto de clase `string` para almacenar la carga (*payload*) del paquete.
137 
+* una variable `string` para almacenar la carga del paquete.
215
138
216 
-En la declaración de la clase `ip_packet` debes especificar que es una **clase derivada** de la clase `ethernet_packet`.
139 
+En la declaración de la clase `ip_packet` debes especificar que es una clase derivada de la clase `ethernet_packet`.
217
140
218 
----
141 
+### Entregas
219
142
220 
----
143 
+Utiliza "Entrega" en Moodle para entregar los archivos `ethernet_packet.cpp` y `ip_packet.h` que definistes.
221
144
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
145 
+### Referencias
231
146
232 
 [1]http://en.wikipedia.org/wiki/Packet_analyzer
 147 
 [1]http://en.wikipedia.org/wiki/Packet_analyzer
233
148
234
149
235 
----
236 
-
237 
----
238 
-
239 
----
240 
-
150 
+----