Categoría: Notas

  • Mini Taller de Sockets en Python: Uso de Sockets para Internet

    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.

  • Cómo preparar un servidor DNS en Debian

    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)