Red (Networking)

Ejemplo en Ruby para construir un mensaje version (con funciones auxiliares para formatear los datos):

require 'digest' # necesario para crear checksums

# Funciones auxiliares para dejar los datos en el formato correcto para los mensajes
def hexadecimal(number)
    return number.to_s(16)
end

def size(data, size)
    return data.rjust(size*2, '0') # rellena a la izquierda con ceros hasta un nº de bytes (2 chars hex = 1 byte)
end

def reversebytes(bytes)
    return bytes.scan(/../).reverse.join() # toma cada 2 chars (1 byte), invierte y vuelve a unir
end

def ascii2hex(string)
    # Convierte cada carácter de la cadena a su representación en bytes hexadecimales
    bytes = string.each_byte.map {|c| c.to_s(16) }.join()

    # Rellena hasta 12 bytes (manteniendo los bytes de la cadena ASCII a la izquierda)
    return bytes.ljust(24, '0')
end

def checksum(bytes)
    # Hace hash de los datos dos veces
    hash = Digest::SHA256.digest(Digest::SHA256.digest([bytes].pack("H*"))).unpack("H*")[0]

    # Devuelve los primeros 4 bytes (8 caracteres)
    return hash[0...8]
end

# Crea el payload de un mensaje version
payload  = reversebytes(size(hexadecimal(70014), 4))         # versión del protocolo
payload += reversebytes(size(hexadecimal(0), 8))             # servicios (ej.: 1<<3 | 1<<2 | 1<<0)
payload += reversebytes(size(hexadecimal(1640961477), 8))    # tiempo
payload += reversebytes(size(hexadecimal(0), 8))             # servicios del nodo remoto
payload += "00000000000000000000ffff2e13894a"                # ipv6 del nodo remoto
payload += size(hexadecimal(8333), 2)                        # puerto del nodo remoto
payload += reversebytes(size(hexadecimal(0), 8))             # servicios del nodo local
payload += "00000000000000000000ffff7f000001"                # ipv6 del nodo local
payload += size(hexadecimal(8333), 2)                        # puerto del nodo local
payload += reversebytes(size(hexadecimal(0), 8))             # nonce
payload += "00"                                              # user agent (compact_size + bytes ascii)
payload += reversebytes(size(hexadecimal(0), 4))             # último bloque

# Crea la cabecera del mensaje
magic_bytes = 'f9beb4d9'
command     = ascii2hex('version')                                 # 76 65 72 73 69 6F 6E 00 00 00 00 00
size        = reversebytes(size(hexadecimal(payload.length/2), 4)) # 55 00 00 00
checksum    = checksum(payload)
header      = magic_bytes + command + size + checksum

# Junta cabecera y payload
message = header + payload

El programa completo de este tutorial: se conecta a un nodo, hace el handshake y sigue leyendo mensajes (respondiendo a ping e inv). Los comentarios del código están en inglés (como en el original).

# Los sockets están en la librería estándar de Ruby
require 'socket'

# Abre una conexión TCP a una IP y un puerto
socket = TCPSocket.open("127.0.0.1", 8333) # computadora local = 127.0.0.1

require 'digest' # necesario para crear checksums

# Funciones útiles para obtener datos en el formato correcto para los mensajes
def hexadecimal(number)
    return number.to_s(16)
end

def size(data, size)
    return data.rjust(size*2, '0') # rellena a la izquierda con ceros hasta un nº específico de bytes (2 chars hex = 1 byte)
end

def reversebytes(bytes)
    return bytes.scan(/../).reverse.join() # toma cada 2 caracteres (1 byte) en un array, invierte el array y vuelve a unir
end

def ascii2hex(string)
    # Convierte cada carácter de la cadena a su representación hexadecimal en bytes
    bytes = string.each_byte.map {|c| c.to_s(16) }.join()

    # Rellena hasta 12 bytes (manteniendo los bytes de la cadena ASCII a la izquierda)
    return bytes.ljust(24, '0')
end

def checksum(bytes)
    # Hace hash de los datos dos veces
    hash = Digest::SHA256.digest(Digest::SHA256.digest([bytes].pack("H*"))).unpack("H*")[0]

    # Devuelve los primeros 4 bytes (8 caracteres)
    return hash[0...8]
end

# Crea el payload de un mensaje version
payload  = reversebytes(size(hexadecimal(70014), 4))         # versión del protocolo
payload += reversebytes(size(hexadecimal(0), 8))             # servicios, por ejemplo (1<<3 | 1<<2 | 1<<0)
payload += reversebytes(size(hexadecimal(1640961477), 8))    # hora
payload += reversebytes(size(hexadecimal(0), 8))             # servicios del nodo remoto
payload += "00000000000000000000ffff2e13894a"                # ipv6 del nodo remoto (https://dnschecker.org/ipv4-to-ipv6.php)
payload += size(hexadecimal(8333), 2)                        # puerto del nodo remoto
payload += reversebytes(size(hexadecimal(0), 8))             # servicios del nodo local
payload += "00000000000000000000ffff7f000001"                # ipv6 del nodo local
payload += size(hexadecimal(8333), 2)                        # puerto del nodo local
payload += reversebytes(size(hexadecimal(0), 8))             # nonce
payload += "00"                                              # user agent (compact_size, seguido de bytes ascii)
payload += reversebytes(size(hexadecimal(0), 4))             # último bloque

# Crea la cabecera del mensaje
magic_bytes = 'f9beb4d9'
command     = ascii2hex('version')                                 # 76 65 72 73 69 6F 6E 00 00 00 00 00
size        = reversebytes(size(hexadecimal(payload.length/2), 4)) # 55 00 00 00
checksum    = checksum(payload)
header      = magic_bytes + command + size + checksum

# Combina la cabecera y el payload
message = header + payload

# 1. Enviar mensaje Version

# Prepara el mensaje version
version = message

# Escribe el mensaje en el socket (el protocolo envía y recibe mensajes en bytes crudos)
socket.write [version].pack("H*")
puts "version->"
puts version
puts


# 2. Recibir mensaje Version

# Lee la respuesta de la cabecera del mensaje desde el socket
magic_bytes = socket.read(4)
command     = socket.read(12)
size        = socket.read(4)
checksum    = socket.read(4)

# Muestra la cabecera del mensaje
puts "<-version"
puts "magic_bytes: " + magic_bytes.unpack("H*").join  # convierte bytes crudos a caracteres hexadecimales
puts "command:     " + command.to_s                   # to_s convierte automáticamente bytes crudos a ASCII
puts "size:        " + size.unpack("V").join          # V = entero sin signo de 32 bits, little-endian
puts "checksum:    " + checksum.unpack("H*").join

# Lee el payload del mensaje
size = size.unpack("V").join.to_i
payload = socket.read(size)

# Muestra el payload
puts "payload:     " + payload.unpack("H*").join
puts


# 3. Recibir mensaje Verack (verack = version acknowledged)

# Lee la respuesta de la cabecera del mensaje desde el socket
magic_bytes = socket.read(4)
command     = socket.read(12)
size        = socket.read(4)
checksum    = socket.read(4)

# Muestra la cabecera del mensaje
puts "<-verack"
puts "magic_bytes: " + magic_bytes.unpack("H*").join  # convierte bytes crudos a caracteres hexadecimales
puts "command:     " + command.to_s                   # to_s convierte automáticamente bytes crudos a ASCII
puts "size:        " + size.unpack("V").join          # V = entero sin signo de 32 bits, little-endian
puts "checksum:    " + checksum.unpack("H*").join

# Lee el payload del mensaje (no debería haber ninguno)
size = size.unpack("V").join.to_i
payload = socket.read(size)

# Muestra el payload del mensaje (no debería haber ninguno)
puts "payload:     " + payload.unpack("H*").join
puts

# 4. Enviar mensaje Verack

# Crea el mensaje verack
payload     = '' # verack no tiene payload, solo una cabecera de mensaje
magic_bytes = 'f9beb4d9'
command     = ascii2hex('verack')
size        = reversebytes(size(hexadecimal(payload.size/2), 4))
checksum    = checksum(payload)
verack      = magic_bytes + command + size + checksum + payload

# Escribe el mensaje en el socket
socket.write [verack].pack("H*")
puts "verack->"
puts "magic_bytes: " + magic_bytes
puts "command:     " + 'verack'
puts "size:        " + size.to_i(16).to_s
puts "checksum:    " + checksum
puts "payload:     " + payload
puts

# Sigue leyendo mensajes
loop do

    # Crea un buffer vacío para ayudarnos a encontrar el siguiente flujo de bytes mágicos (el inicio de un nuevo mensaje)
    buffer = ''

    # Sigue leyendo bytes del socket
    loop do

        # Lee un byte a la vez
        byte = socket.read(1)

        # Verifica que no nos hayan desconectado del nodo.
        if byte.nil?
            puts "Leí un byte nulo desde el socket. Parece que el nodo remoto se desconectó de nosotros. Probablemente fallamos el handshake demasiadas veces o no respondimos a suficientes pings. No pasa nada, prueba conectarte a otro nodo por ahora."
            exit
        end

        # Agrega cada byte al buffer temporal
        buffer += byte.unpack("H*").join unless byte.nil? # no hagas nada si por alguna razón obtuvimos un byte nulo

        # Revisa el buffer cuando alcance 4 bytes
        if (buffer.size == 8) # 8 caracteres hexadecimales = 4 bytes

            # Comprueba si el buffer coincide con los bytes mágicos
            if (buffer == 'f9beb4d9')

                # Si tenemos los bytes mágicos que buscamos, leemos el mensaje completo del socket
                command     = socket.read(12).to_s.delete("\x00")  # convierte a ASCII y elimina bytes vacíos
                size        = socket.read(4).unpack("V").join.to_i   # convierte a entero
                checksum    = socket.read(4).unpack("H*").join       # convierte a string hexadecimal de bytes
                payload     = socket.read(size).unpack("H*").join    # usa el tamaño de la cabecera para leer el payload, luego convierte a string hexadecimal

                # Imprime el mensaje
                puts "<-#{command}"
                puts "magic_bytes: " + buffer
                puts "command:     " + command
                puts "size:        " + size.to_s
                puts "checksum:    " + checksum
                puts "payload:     " + payload
                puts

                # Responde a todos los mensajes inv con mensajes getdata
                if command == "inv"

                    # Define el nuevo nombre del comando
                    command = "getdata"

                    # Usa el mismo payload que recibimos del mensaje inv
                    payload = payload

                    # Crea el mensaje
                    magic_bytes = 'f9beb4d9'
                    command_hex = ascii2hex(command)
                    size        = reversebytes(size(hexadecimal(payload.size/2), 4))
                    checksum    = checksum(payload)
                    message     = magic_bytes + command_hex + size + checksum + payload

                    # Imprime la cabecera y el payload del mensaje
                    puts "#{command}->"
                    puts "magic_bytes: " + magic_bytes
                    puts "command:     " + command
                    puts "size:        " + (payload.size/2).to_s
                    puts "checksum:    " + checksum
                    puts "payload:     " + payload
                    puts

                    # Envía el mensaje (convierte primero de cadena hexadecimal a bytes crudos)
                    socket.write [message].pack("H*")

                end

                # Responde a todos los mensajes ping con mensajes pong
                if command == "ping"

                    # Define el nuevo nombre del comando
                    command = "pong"

                    # Usa el mismo payload que recibimos del mensaje ping
                    payload = payload

                    # Crea el mensaje
                    magic_bytes = 'f9beb4d9'
                    command_hex = ascii2hex(command)
                    size        = reversebytes(size(hexadecimal(payload.size/2), 4))
                    checksum    = checksum(payload)
                    message     = magic_bytes + command_hex + size + checksum + payload

                    # Imprime la cabecera y el payload del mensaje
                    puts "#{command}->"
                    puts "magic_bytes: " + magic_bytes
                    puts "command:     " + command
                    puts "size:        " + (payload.size/2).to_s
                    puts "checksum:    " + checksum
                    puts "payload:     " + payload
                    puts

                    # Envía el mensaje (convierte primero de cadena hexadecimal a bytes crudos)
                    socket.write [message].pack("H*")

                end

                # Sale del bucle de lectura de un único mensaje
                break

            end

            # Reinicia el buffer y sigue buscando una secuencia de bytes mágicos
            buffer = ''

        end

    end

end