Para ocultar nuestras comunicaciones de nuestros dispositivos IOT, no es necesario utilizar complejos métodos de encriptación. En la actualidad se dispone de diversos métodos de codificación para que las comunicaciones entre nuestros dispositivos IOT, ya sean creados con arduino o con el ESP32, y los sistemas centrales, no tengan que hacerse en texto plano.

Una de las premisas que suelen usar los ciberdelincuentes es la de, esfuerzo/recompensa.

Si están intentando vulnerar un sistema bancario, el esfuerzo que les puede llevar sera muy grande, pero la recompensa también lo es.

Pero si lo que están vulnerando es el sistema de riego de mi jardín, la recompensa es muy baja. Con lo que aumentando el grado de esfuerzo necesario para la vulneración, podemos eliminar una gran mayoría de amenazas.

Recordatorio: Esto no es un sistema para asegurar las comunicaciones de la Nasa o del FBI. Solo es un sistema para darle una capa más de seguridad a nuestros pequeños proyectos.

Teniendo en cuenta esta premisa, para ocultar nuestras comunicaciones no hace falta desplegar un gran sistema criptográfico para hacer que los crackers desistan con el ataque a nuestro sistema.

Para ello solo tenemos que utilizar los métodos de codificación que tenemos a nuestro alcance, como puede ser la codificación en Base64.

Un poco de teoría

La codificación base64 se define como:

Base64 es un grupo de esquemas de codificación de binario a texto que representa los datos binarios mediante una cadena ASCII, traduciéndolos en una representación radix-64. El término Base64 se origina de un sistema de codificación de transmisión de contenido MIME específico.

https://developer.mozilla.org/es/docs/Web/API/WindowBase64/Base64_codificando_y_decodificando

Este tipo de codificación la tenemos disponible en cualquier lenguaje de programación. Lo que la hace muy fácil de usar.

Una de las formas más fáciles de identificar que una cadena esta codificada en base64, es, si la cadena termina en uno o dos símbolos de igual. Esto se debe a que base64 usa 6 bits de los 8 de los normales. Para cubrir ese hueco el algoritmo de base64 lo rellena con 1 o con dos símbolos de igual.

Otra forma que se puede usar para identificar la codificación, es que la cadena solo está compuesta por letras de la «a» a la «z», tanto en mayúsculas, como en minúsculas, números del 0 al 9 y los símbolos, normalmente, «+» y «/». Ya que la suma de letras y número es 62, y se usan eso dos símbolos para completar los 64.

¿Pero solo con eso puedo ocultar mis comunicaciones?

Pero, ¿si base64, está implementado en todos los lenguajes?, ¿es fácil de identificar?, el esfuerzo de un malo, más bien es poco ¿no?. Pues si, pero ya tenemos la base de nuestro sistema.

Si ya sabemos los puntos débiles del sistema, podemos detectarlos y reforzarlos.

Por ejemplo, sabemos que base64, nos pone en ocasiones, símbolos de igual si la cadena no tiene la longitud deseada. Pues vamos a controlar que la cadena tenga la longitud necesaria para que no incluya los símbolos de igual.

Esto es fácil, solo tenemos que controlar que el tamaño sea múltiplo de 3. Si no es múltiplo añadiremos tantos caracteres como sean necesarios.

Para el tema de los caracteres usados, es más compleja su solución. Pero podemos aplicar un método fácil para dificultar la codificación. Para ello solo tenemos que invertir la cadena en base64, por ejemplo, antes de su envió. Podría ser una forma de ofuscar. Se podrían aplicar otras.

Código, que es lo que mola

Un código de ejemplo que nos permite ocultar nuestras comunicaciones de lo explicado anteriormente en python sería el siguiente.

#!/usr/bin/env python

"""
    Encode base64
"""
import base64

def encode(encode):
    # Calculamos si la cadena es múmtiplo de 3
    rest_message = len(encode.encode('utf-8')) % 3
    if rest_message == 0:
        temp_message = encode
    else:
        # Si no es múltiplo de 3, le añadimos tantos caracteres
        # como necesitemos    
        temp_message = encode + (" " * (3 - rest_message))
    # Lo codificamos en utf-8
    message_byte = temp_message.encode('utf-8')
    # Lo codificamos en base64
    codec_base64 = base64.b64encode(message_byte)
    # Decodificamos el utf-8e invertimos la cadena
    string_codec_base64 = codec_base64.decode('utf-8')[::-1]

    print(f'encode: {string_codec_base64}')

if __name__ == "__main__":
    string_encode = "Esto es una prueba más"
    encode(encode=string_encode)

Para calcular si la cadena es múltiplo de 3 usamos la siguiente linea

rest_message = len(encode.encode('utf-8')) % 3

Si el resto es cero, la longitud de la cadena es múltiplo de 3, por lo que no tenemos que añadir nada. Si fuera distinto de 0, es decir 1 o 2. El valor nos valdría para calcular cuantos caracteres nos hacen faltan.

if rest_message == 0:
    temp_message = encode
else:
    # Si no es múltiplo de 3, le añadimos tantos caracteres
    # como necesitemos    
    temp_message = encode + (" " * (3 - rest_message))

Una vez que ya tenemos ajustado el tamaño solo nos queda codificarla en base64

# Lo codificamos en utf-8
message_byte = temp_message.encode('utf-8')
# Lo codificamos en base64
codec_base64 = base64.b64encode(message_byte)

Para darle la vuelta solo tenemos que añadir [::-1] a la cadena con la codificación en base64

string_codec_base64 = codec_base64.decode('utf-8')[::-1]

Y con esto ya tenemos un sistema fácil de implementar, todos los lenguajes tiene librerías para trabajar con ello. Y que a los malos no le resulte tan fácil.

Vuelta el recordatorio: Esto no es un sistema para proteger información delicada, si no, un método para darle una capa mayor de seguridad a nuestros pequemos proyectos.