Categoría: Notas

El Taller a resolver es éste:

Se pueden notar que nos permiten solo usar el módulo de Sockets, no podemos usar cosas como Requests 🙁

Introducción

Para esto necesitamos usar Python. Hay varias formas de prepararlo:

• Usar Colab, que tiene un intérprete Python online que podremos usar sin instalar nada. (OJO: leer la nota de Colab al final)
• Instalar Python para Windows, y como IDEs podemos usar VS Code, o PyCharm.
• Usar una imagen de Debian en Virtualbox. Una instalación de escritorio normal ya viene con Python preinstalado y listo para usar.

1. El programa debe recibir dominios de Internet y devolver la IP de cada uno.

En otras palabras, debemos resolver los dominios a su IP.

Tomen en cuenta que se pidió como argumento una lista de dominios, que pueden ser uno, dos, muchos o ninguno. Tendremos que iterar.

Cuando ejecutamos un programa, podemos pasarle argumentos (como cat programa.py). En Python leeremos los argumentos que el usuarios nos dé, con el módulo sys.

Código:

import socket # Importamos el módulo socket
import sys

# Ejecuta el programa como:
# python3 ej1_resolvedor.py www.google.com www.facebook.com www.youtube.com

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Creamos un objeto socket

for x in sys.argv: # Recorremos tooodos los argumentos pasados al programa
    if x != sys.argv[0]: # Ignoramos el primer argumento (que es el nombre del programa en sí)
        hostname = x
        try:
            ip_address = socket.gethostbyname(hostname) # Solicitamos al PC resolver el hostname a su dirección IP
            print(f"La IP de {hostname} es {ip_address}")
        except socket.gaierror as e:
            print(f"Error: {e}") # Si no se puede resolver el hostname, se imprime el error

client_socket.close() # Cerramos el socket

Esto usa una funcionalidad integrada del módulo de sockets, donde la parte de la resolución del dominio se lo delega al sistema.

También se puede armar una versión donde tú te comuniques directamente al DNS, y en «idioma DNS» tú le pidas que te resuelva el dominio. Hacer eso es una locura, pero si alguien lo quiere probar puede verlo.

2. Programa que dé la hora

Esto se puede hacer con Python, aperturando un puerto TCP/9876 y pueden usar código de ejemplos en Internet, de guías o de otros paralelos.

Cada vez que cualquiera se conecte, este debe devolver la hora y luego cerrar la conexión.

Para el programa cliente, se puede usar cualquiera que abra una conexión súper simple. Telnet es un protocolo que abre conexiones simples, y podremos aprovecharlo:

En Linux podemos conectarnos así: telnet localhost 9876.
En Windows o Linux podemos conectarnos con el programa Putty de esta manera:

3. Cliente HTML que reciba una dirección web y la abra.

Este programa usa un Socket TCP cliente.

El programa, a grandes rasgos, debe:
1) Resolver el dominio, tal como está en 1.
2) Abrir una conexión TCP cliente a la IP, puerto 80.
3) Enviarle una Petición
4) Recibir el contenido y mostrarlo con print().

La Petición la debemos hardcodear y sería algo parecido a esto:

GET / HTTP/1.1
HOST: google.com
Accept: */*

La primera línea pide el archivo
La segunda pide el dominio
La tercera le dice al server que aceptaremos todo lo que nos dé.

4. Servidor web de archivos

Lo que nos piden:

• Que el servidor corra continuamente
• Que se revise si algún archivo pedido exista, si es el caso, abrirlo

import socket # Importamos el módulo socket

# Declaramos la funcion Pedido
def pedido(conn):
    # Llega un pedido
    request = conn.recv(1024).decode() # Recibimos el pedido y lo ponemos en un string

    if 'GET ' in request: # Si el pedido es un GET
        file_name = request.split()[1][1:] # Obtenemos el nombre del archivo pedido
        print("Archivo pedido: "+file_name)
        try:
            with open(file_name, 'r') as f: # Abrimos el archivo pedido
                response_body = f.read()
                response = f"HTTP/1.1 200 OK\r\n\r\n{response_body}" # Respondemos
        except FileNotFoundError: # Si el archivo no existe, devolvemos un error
            response = "HTTP/1.1 404 Not Found\r\n\r\nFile Not Found"
    else: # Si nos piden algo que no es GET
        response = 'HTTP/1.1 405 Method Not Allowed\r\n\r\nMethod Not Allowed'

    conn.sendall(response.encode()) # Enviamos 
    conn.close()


# -------------------------
# Inicio del programa
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Creamos un objeto socket
server_socket.bind(('0.0.0.0', 8888)) # Asociamos el socket a un host y puerto
server_socket.listen(5) # Ponemos el socket en modo escucha
print('Servidor Funcionando.')

while True: # Bucle infinito, termina una peticion y esperamos otra
    client_socket, addr = server_socket.accept() # Si hay una conexion de entrada, la aceptamos y la mandamos a la funcion Pedido
    pedido(client_socket)

Este código da una idea de la funcionalidad más básica de un web server.

Faltan varias cosas:

• Cambiar número de puerto de escucha
• No implementa Content-Type, lo cual complica el usarlo con navegadores web
• No implementa Content-Length
• No genera un listado de páginas dentro de la carpeta, o sea para probarlo tendremos que escribir todo el URL a mano.
• No se valida lo que pide el cliente. Alguien podria intentar hackear el webserver con algo como http://localhost:8888/../../../../../etc/passwd

Sobre el uso de Colab

En la evaluación, necesitamos ejecutar el programa Python como un archivo «.py» y pasarle argumentos.
En Colab no se puede pasar argumentos, pero una forma de hacerlo sin tocar el código es:

import socket
import sys
sys.argv[1] = "google.com"
sys.argv[2] = "facebook.com"

(...)

Inicias desde el 1, y en el 2 o 3 puedes ir poniendo los dominios que quieras.
Esto es técnicamente «usar argumentos», pero esto no está probado si será válido en la defensa.

Tenemos una Guía en la materia y los ejercicios son estos:

Requerimientos para empezar

Instalar bind9, el server DNS. En la máquina virtual Debian, luego de entrar como root usando su, puedes instalarlo con estos comandos:

apt update; apt install bind9

El servidor DNS se instalará e iniciará solo 🙂

Inciso 1

Probar el bind9 como server caché y registrar el tiempo de consulta.

Editar el archivo named.conf.options. Descomentar y editar la sección de forwarders, poniendo una IP. Como ejemplo: 1.1.1.1

Recargar el servicio systemctl restart named

Probar con consultas dig:

dig @8.8.8.8 facebook.com
dig @127.0.0.1 facebook.com
dig @127.0.0.1 facebook.com

Una captura de la salida del comando dig:

(1) les muestra el TTL (time to live), o sea por cuántos segundos la respuesta será válida. Útil para la caché.
(2) les muestra la respuesta de la consulta DNS. Acá preguntamos por la IP de facebook.com, y ya nos dieron la respuesta.
(3) les muestra cuánto tiempo duró la consulta. Si instalaron la caché, la cifra debe ser muy pequeña, entre 0 o 2 ms.

Inciso 2

Configuraremos la zona primaria en bind9.

Editamos /etc/bind/named.conf.local y agregamos esto:

zone "ejemplo.com" {
type master;
file "/etc/bind/db.ejemplo.com";
};

Ahora agarramos una plantilla existente de la zona y la copiamos
cp /etc/bind/db.local /etc/bind/db.ejemplo.com

Editamos la zona
nano /etc/bind/db.ejemplo.com

Aparte de editar lo existente, podemos agregar algunos subdominios al final. Por ejemplo, puse

informatica    IN    A    12.34.56.78

siendo 12.34.56.78 una IP inventada.

Ojo que las IPs se componen de 4 números, cada uno de un valor entre 0-255.
Una IP como 456.789.999.999 no es válida.

Para aplicar los cambios, reiniciamos el servicio:
systemctl restart named

Antes de reiniciar, también podemos verificar la sintaxis con el comando
named-checkconf
Si todo está bien, no te dirá nada.
Si algo está mal, te lanzará un mensaje de error.

---

Inciso 3

Parte 1: Probar lo que hicimos

Usar dig @127.0.0.1 dominio.com

Luego verificamos que la respuesta es correcta.

Podemos hacer la prueba también con nslookup:

Parte 2: crearemos una zona inversa

Una zona normal, como vimos, administra un dominio entero, como «ejemplo.com» y podemos apuntar hacia IPs.

Una zona inversa administra un bloque de IPs tuyos (ej, si te armas una red con un router, puedes administrar todas las IPs en el rango 192.168.1.1-192.168.1.254). Ahora, a cada IP podemos apuntarle un dominio.

O sea, con una zona inversa podemos bautizar IPs y les pondremos los nombres que queramos!

Editamos /etc/bind/named.conf.local y agregamos

zone "1.168.192.in-addr.arpa" {
type master;
file "/etc/bind/db.192.168.1";
};

Usamos el bloque de IPs pero al revés (por eso está como 1.168.192) y le ponemos «in-addr.arpa».
Esto es una convención. O sea, los creadores de Internet le pusieron «in-addr.arpa» por que sí.

Ahora agarramos una plantilla existente de la zona y la copiamos
cp /etc/bind/db.local /etc/bind/db.ejemplo.com

El tipo de registro ya no es A, ahora es PTR.

Reiniciamos el servicio con systemctl restart .named

Ahora podemos hacer la prueba con dig:

Nótese que las consultas en dig las hacemos ahora con-x.

Inciso 4

Obtendremos el DNS actual de /etc/resolv.conf, que por defecto es el del router (y este suele apuntar al proveedor)

AXS tiene el DNS 200.105.128.40
Entel 200.87.100.10
Tigo 190.104.12.242

En mi máquina el DNS es 10.64.64.54.

Desde su conexión a internet deben probar los servicios de su ISP, de google y de Cloudflare, y comentar cuál es más rápido (revisando la salida del comando dig)