Forem: NULLX

Ingeniería inversa EXE

NULLX — Sat, 11 May 2024 10:44:49 +0000

Library Jailbreak

Durante el curso de varias asignaturas en la universidad hemos tenido ciertas restricciones. La mayoría de las veces, por la limitación de licencias de ciertos programas de ingeniería.

En este caso vamos a hablar sobre unas librerías que contenían funciones para la realización de diversos ejercicios. Estas librerías solo funcionaban en los ordenadores de un aula de la universidad y eran el medio para poder practicar y prepararse los exámenes. A título individual me causa curiosidad y me produce un reto el proceso de averiguar qué ocurre dentro de dicha librería para que funcione en un sitio, pero si lo intentas ejecutar en otro contexto deje de funcionar.

Impulsado por esta emoción vamos a investigar qué ocurre con estas librerías.

Vista general

En un ejercicio necesitaríamos por ejemplo las siguientes dos funciones:

int leeCelulaFotoelectrica(void);
void leeCodigoBarras(void *datos);

De tal forma que ambas funciones serán llamadas a lo largo de la solución propuesta al enunciado concreto de un ejercicio.

Si llamamos a estas funciones en el aula, estas se comportan tal y como se describen en el enunciado. Sin embargo, si las ejecutamos en un ordenador ajeno, estas no lo hacen de forma coherente.

Se hace una prueba para detectar si existe algún tipo de comunicación a nivel de red desde el equipo origen, pero no es así, por lo que directamente vamos a analizar el código.

Análisis del código fuente

En este caso el fichero a analizar es un ".lib", una librería estática de Windows para su uso en C/C++.

El programa seleccionado para realizar ingeniería inversa ha sido Ghidra, un kit de herramientas de ingeniería inversa desarrollado y mantenido por la NSA (National Security Agency de Estados Unidos).

Es importante entender que cuando un programa escrito en C es compilado para producir un archivo binario, el proceso de ingeniería inversa rara vez logra recrear el código fuente original de manera idéntica. En su lugar, el objetivo es generar un código equivalente que funcione de manera similar. Esto se debe a las transformaciones que ocurren durante la compilación, donde el código fuente es convertido en instrucciones que la máquina puede ejecutar directamente.

Al intentar analizar directamente una librería estática, como en este caso, nos encontramos con desafíos significativos. La principal dificultad es identificar la sección específica del código que contiene las condiciones que limitan el uso de la librería fuera del aula. La complejidad aumenta por el hecho de que la librería contiene una gran cantidad de componentes adicionales, no relacionados directamente con las funciones de interés. También el proceso de compilación introduce numerosos símbolos y referencias que pueden dificultar la búsqueda del fragmento de código relevante.

Una forma sencilla pero efectiva e ingeniosa para llegar al código a analizar es embebiendo dicha librería dentro de un ejecutable. De tal forma que dicho ejecutable será el producto de este código:

#include <stdio.h>

int leeCelulaFotoelectrica(void);
void leeCodigoBarras(void *datos);

int main() {
    int r = leeCelulaFotoelectrica();
    printf("num = %d\n", r);

    return 0;
}

Nota: A menudo los compiladores realizan optimizaciones complejas, es por ello que utilizamos la variable r de retorno de forma que se garantiza que el compilador no descarte la llamada a leeCelulaFotoelectrica() por considerarla innecesaria, manteniendo así la lógica deseada del programa.

Ahora cuando analicemos ejecutable derivado de este programa, solo tendremos que buscar el main, pues es ahí donde lo primero que se hace es llamar a la función que queremos inspeccionar.

Para encontrar el entrypoint del programa debemos empezar por encontrar la función entry, que es la función de entrada que define el compilador.

Esta imagen nos muestra el código ensamblador de la función entry. Esta realiza una operación MOV, SUB y luego hace una llamada a una función __scrt_common_main. Este ejecutable es un binario de debug, es decir que contiene símbolos y funciones de ayuda que Visual Studio inyecta para manejar el flujo del programa. Es por eso que de aquí en adelante vamos a ver diferentes fragmentos de código que no son de nuestro programa.

Se puede ver que __scrt_common_main llama a su vez a __scrt_common_main_seh.

Parece que nos vamos acercando: podemos ver la llamada a
invoke_main().

Podemos ver la recolección y elaboración de los parámetros típicos de un programa en C/C++: argc y argv.

int main(int argc, char *argv[]);

 #include <stdio.h>                                                    

 int main() {                                                          
     int r = leeCelulaFotoelectrica();                                 
     printf("num = %d\n", r);                                          

     return 0;                                                         
}

En este caso la función leeCelulaFotoelectrica se ha renombrado a FUN_1400010f0, y printf a FUN_140001070, al igual que la variable local r, que ahora es uVar1.

Ahora sabemos que dentro de la función FUN_1400010f0 está la guinda del pastel.

Aquí está la lógica de la función leeCelulaFotoelectrica. Un análisis rápido parece indicar que hay una serie de condiciones iniciales que, si no se cumplen, el flujo del programa salta (instrucción goto) a la etiqueta LAB_1400012f3. Ésta está declarada así:

Y como podemos ver, no hace nada en especial (la línea 75 forma parte de las funciones de ayuda mencionadas anteriormente), simplemente retorna de la función.

Analizando la última imagen más a fondo, debemos evitar la ejecución de las instrucciones goto de las líneas 29 y 38. Para ello tenemos que, de alguna forma, evitar que las condiciones que lo permiten lo hagan.

Iremos condición a condición analizando qué cambiar para que no se cumplan y poder llegar a la línea verde discontinua. A partir de dicha línea comienza la lógica real de la función y es la que nos interesa que se ejecute.

Primera condición

GetLocalTime(&local_250);
if ((0x7e7 < local_250.wYear) ||
    (((0x7e6 < local_250.wYear && (9 < local_250.wMonth)) ||
    (DVar2 = GetEnvironmentVariableW(L"JDIR",local_118,0x100), DVar2 == 0))))
goto LAB_1400012f3;

Teniendo en cuenta que la función GetLocalTime nos da información sobre
la fecha local del sistema, se puede traducir al siguiente pseudo
código:

Si el año es mayor a 2023
   o (el año es mayor a 2022 y el mes es mayor a 9)
   o (la variable de entorno JDIR no está definida)
entonces
   Ir a LAB_1400012f3

¿Qué hacer para que no lleguemos a cumplir esas condiciones? Al ser una sentencia de OR no debe de cumplirse ninguna de las condiciones; entonces:

Establecer la fecha del ordenador con fecha anterior a 2023, por
ejemplo, en 2021.
Crear la variable de entorno JDIR.

Aunque si nos damos cuenta, con que se cumpla la segunda de las propuestas, ya valdría (dependiendo del año en que se lea).

Segunda condición

hModule = GetModuleHandleW(L"ntdll");
pFVar4 = GetProcAddress(hModule,"RtlGetVersion");
if (pFVar4 != (FARPROC)0x0) {
    local_238 = 0x11c;
    (*pFVar4)(&local_238);
    if (0x2540c2e65 <
        (longlong)
        (((ulonglong)local_234 * 1000 + (ulonglong)local_230) * 1000000 + (ulonglong)local_22c))
    goto LAB_1400012f3;
}

Según la documentación oficial, la función GetProcAddress devuelve la dirección de la función que pedimos por parámetros (RtlGetVersion). Si la dirección pedida no se encuentra devuelve nulo47.

Para evitar que se cumpla el primer if, que evalúa la dirección descrita, es posible inducir un error en la búsqueda de la función deseada. Esto se puede conseguir con la modificación de un único carácter en la cadena literal L"RtlGetVersion", lo que resultaría en un fallo en la búsqueda y, por tanto, la devolución de NULL. El literal modificado sería L"RtlGetVersien".

Esta solución se ha escogido dado que la modificación de una cadena dentro de un binario en comparación con otras más complejas (inyección de código, desensamblado y modificación...) es una tarea relativamente sencilla y fácil de automatizar.

Ya hemos solucionado el problema de forma conceptual. Ahora tocaría crear un programa al que pudiéramos pasarle la librería y fuera capaz de devolvérnosla libre de restricciones.

Para poder visualizar de mejor forma cómo es el flujo del código véase la siguiente imagen.

Solución

En los binarios compilados, normalmente existen secciones dedicadas para alojar constantes y variables, entre ellas: .data, .rsrc, .text... pero nosotros no vamos a hacer distinción. Vamos a escanear el binario completo en búsqueda de una secuencia de bytes concreta (que representen RtlGetVersion), y de encontrarla vamos a reemplazar uno de esos bytes por otro.

En la primera condición que hemos resuelto antes, se ha propuesto crear la variable de entorno JDIR, pues necesita encontrarla para el correcto funcionamiento. En vez de hacer al usuario cambiar la variable de entorno, ¿por qué no cambiar también el literal JDIR por otro que exista en todos los ordenadores?

Procedimiento:

Búsqueda de los literales RtlGetVersion y cambiarlos por
RtlGetVersien.
Búsqueda de los literales JDIR y cambiarlos por PATH.

Este ejecutable viene en el formato PE (Portable Executable en inglés) y es común encontrarse literales string codificadas en UTF-16 debido a la naturaleza del ecosistema de Windows. Debido principalmente a que UTF-16 permite una representación estándar de caracteres para casi todos los sistemas de escritura, hace más fácil la internacionalización de aplicaciones.

Programación

Aunque la solución se pueda programar en cualquier lenguaje de propósito general, con el objetivo de seguir explorando las tecnologías web se propone hacerlo en TypeScript. Aunque dada la sencillez del código es fácilmente extrapolable a cualquier lenguaje.

function findMatches(buffer: Buffer, match: Buffer) {
    const matches = [];
    let matchIndex = 0;

    while (true) {
        const index = buffer.indexOf(match, matchIndex);
        if (index === -1) break;

        matches.push(index);
        matchIndex = index + 1;
    }

    return matches;
}

function replace(origBuff: Buffer, replBuff: Buffer, startIdx: number) {
    for (let i = 0; i < replBuff.length; i++) {
        origBuff[startIdx + i] = replBuff[i];
    }

    return origBuff;
}

Con la ayuda estas funciones, realizaremos el reemplazo de las cadenas de texto mencionadas previamente.

let matches = findMatches(libBuffer, Buffer.from("RtlGetVersion"));
for (const matchIndex of matches) {
    replace(libBuffer, Buffer.from("RtlGetVersien"), matchIndex);
}

matches = findMatches(libBuffer, Buffer.from("J\0D\0I\0R\0"));
for (const matchIndex of matches) {
    replace(libBuffer, Buffer.from("P\0A\0T\0H\0"), matchIndex);
}

Ingeniería inversa APK: Deusto App

NULLX — Sat, 11 May 2024 10:44:28 +0000

Sobre Deusto App

Deusto App es una aplicación de la Universidad de Deusto con la que además de otras diversas funciones, puedes consultar tus calificaciones finales como estudiante.

Se entiende que esta aplicación hace uso de las comunicaciones para obtener la información de un repositorio securizado.

Queremos llegar a saber cómo se comunica la aplicación con dicho repositorio a la hora de obtener las calificaciones de un usuario. Para hacer esto inicialmente tenemos dos opciones:

Analizar el tráfico de red
Investigar el propio código

Se empieza por el primero, ya que es el más sencillo. De no obtener información suficiente pasaremos al segundo método.

Análisis del tráfico de red

Utilizando una herramienta de análisis de tráfico http, como es Charles, podemos ver que las peticiones http se realizan de la siguiente manera:

Identificación:

POST /AdvancedProtocolRedirector/resources/identificacion HTTP/1.1
Host: <HOST>
Content-Type: application/x-www-form-urlencoded
Content-Length: <TAMAÑO DEL CONTENIDO DE LA PETICIÓN>

av=3.6.10&hash=00841f1b43tcc4dce4y7f26e2039827f&idioma=es&multi=true&os=iOS&pais=ES&password=<CONTRASEÑA>&time=<STAMPA DE TIEMPO>&usuario=<CORREO ELECTRÓNICO>&token=&sv=15.2

Obtención de calificaciones:

POST /academic-rest/resources-ext/obtenerCalificacionesExt HTTP/1.1
Host: <HOST>
Content-Type: application/x-www-form-urlencoded
Content-Length: <TAMAÑO DEL CONTENIDO DE LA PETICIÓN>

av=3.6.10&hash=7f99544ebfdb531bfd8586f7af09b592&idioma=es&multi=true&multicliente=N&os=iOS&pais=ES&perfilActivo=<PERFIL ACTIVO>&registrationID=18AB34A93C05AF04E54128EF3FD859DA97783D81107E98C881245E2DFAC566E9&sv=15.2&time=1640618821566&token=<TOKEN>

Las peticiones necesitan ciertos parámetros, de los que destacan:

CORREO ELECTRÓNICO
CONTRASEÑA
HASH
TOKEN (se entiende que será una forma de autenticarse tras el inicio de sesión)

De los campos anteriores, disponemos de todos ellos menos del hash. En un principio se puede intuir lo que significa el hash, pero no conocemos la manera de recrear su valor.

Si probamos a cambiar el hash por otro cualquiera la API devuelve un error, por lo que vemos que es necesario para poder realizar tanto el inicio de sesión como las siguientes peticiones.

Tras distintos intentos fallidos de adivinar cómo obtener dicho hash se decide inspeccionar el código para obtener el algoritmo que revela cómo calcular dicho hash.

Análisis del código fuente

No es nada trivial inspeccionar el código de una aplicación ya compilada puesta en producción ya que estas suelen estar preparadas para dificultar lo máximo posible su entendimiento. Dentro del proceso de compilación existe una fase denominada ofuscación, la cual se encarga de enrevesar de diversas formas el código (renombramiento de variables y funciones, alteración de la estructura, aparición de código muerto, uso de reflexión...) de forma que si alguien intenta analizarlo le sea muy difícil.

Haciendo uso de una herramienta de ingeniería inversa llamada jadx vamos a descompilar la aplicación para su posterior análisis.

❯ jadx -d AcademicMobileDEUSTO_4_0_19 AcademicMobileDEUSTO_4_0_19.apk

Ahora debemos buscar la zona del código donde se añade esa clave "hash" al contenido de la petición http. Para ello buscamos dentro del código java compilado por "hash". Parece que el código principal de la aplicación se encuentra dentro del paquete org.sigmaaie.mobile.* ya que el resto de los paquetes son librerías externas. Es dentro de este paquete donde buscaremos por "hash".

El único lugar de todo el código fuente donde se define "hash" es en siguiente nodo

Veamos en qué parte se utiliza esta variable que contiene la string "hash" ICON_HASH_KEY.

Hay varios resultados que pueden resultar interesantes, sin embargo, vamos a probar con la remarcada en la anterior imagen.

El método UtilRest.generarHash es el siguiente:

public static String generarHash(Map<String, String> map) {
    List<String> a = a(map);
    String str = "";
    int i = 0;
    while (i < a.size()) {
        if (i > 0) {
            str = str + "~";
        }
        String str2 = str + ((Object) a.get(i));
        i++;
        str = str2;
    }
    return a(str);
}

Parece que esta función hace uso de otra llamada
UtilRest.a(Map<String, String>):

private static List<String> a(Map<String, String> map) {
    ArrayList arrayList = new ArrayList();
    ArrayList arrayList2 = new ArrayList();
    for (String str : map.keySet()) {
        arrayList2.add(str);
    }
    Collections.sort(arrayList2);
    int i = 0;
    while (true) {
        int i2 = i;
        if (i2 >= arrayList2.size()) {
            return arrayList;
        }
        arrayList.add(map.get(arrayList2.get(i2)));
        i = i2 + 1;
    }
}

Y además necesita de otra función UtilRest.a(String), que a su vez
llama a otra UtilRest.a(byte[] bArr).

private static String a(String str) {
    try {
        MessageDigest messageDigest = MessageDigest.getInstance(CommonUtils.MD5_INSTANCE);
        messageDigest.reset;
        messageDigest.update(str.getBytes());
        return a(messageDigest.digest());
    } catch (NoSuchAlgorithmException e) {
        throw new RuntimeException(e);
    }
}

private static String a(byte[] bArr) {
    StringBuilder sb = new StringBuilder(bArr.length * 2);
    for (byte b : bArr) {
        int i = b & 255;
        if (i < 16) {
            sb.append('0');
        }
        sb.append(Integer.toHexString(i));
    }
    return sb.toString().toLowerCase();
}

Después de analizar su comportamiento y ejecutar el código de forma independiente y se concluye lo siguiente:

Parece que a(Map<String, String> map) ordena el mapa por orden
alfabético de sus claves.
generarHash(Map<String, String> map) genera una string que luego
es convertida a hash MD5 a través de a(String str).

Se necesita saber qué algoritmo es utilizado para formar dicha string previa a la conversión MD5 (a(String str)). Para esto podríamos detenernos a observar el código o directamente ejecutarlo para ver cómo reacciona:

Dado el siguiente HashMap:

Map<String, String> map = new HashMap<>();
map.put("clave2", "valor2");
map.put("clave1", "valor1");
map.put("clave3", "valor3");

Vamos a llamar a la función generarHash(map) para luego ver el valor de str:

public static String generarHash(Map<String, String> map) {
    List<String> a = a(map);
    String str = "";
    int i = 0;
    while (i < a.size()) {
        if (i > 0) {
            str = str + "~";
        }
        String str2 = str + ((Object) a.get(i));
        i++;
        str = str2;
    }

    System.out.println(str); // valor1~valor2~valor3
    return a(str); // e0a66defa6eb59967ead9d70868f7261
}

Esto es lo que sale por consola: valor1~valor2~valor3.

Según el análisis del código de generarHash(Map<String, String>) y el ejemplo de ejecución se concluye en una primera instancia:

Se han ordenado los ítems del mapa según las claves: clave1, clave2,
clave3
Se ha creado una string separando los valores (con el nuevo orden)
por el carácter '~': valor1~valor2~valor3
Se ha hecho la conversión de la string obtenida a un hash utilizando
el algoritmo de reducción criptográfico MD5:
e0a66defa6eb59967ead9d70868f7261

Ahora toca saber qué mapa inicial debe de ir en la llamada a la función padre generarHash(Map<String, String>).

La función que llama a la mencionada es la siguiente:

public static void b(Map<String, String> map, List<String> list, String str) {
    HashMap hashMap = new HashMap(map);
    if (list != null && !list.isEmpty()) {
        for (String str2 : list) {
            hashMap.remove(str2);
        }
    }
    hashMap.put("metodo", str);
    hashMap.put("secreto", ConnectionConfig.getInstance().getSecret());
    map.put(SettingsJsonConstants.ICON_HASH_KEY, UtilRest.generarHash(hashMap));
}

Esto nos sugiere que hay un mapa del que ciertas entradas son eliminadas dada una lista de claves. También vemos que a este mapa se le añade dos claves: "método" (que viene como parámetro) y "secreto", que si buscamos de nuevo encontramos:

Sigamos con el mapa, ¿de dónde viene? Encontramos una función create, que si tiramos del hilo...

public Map<String, String> create() {
    if (this.c == null) {
        throw new IllegalStateException("missing mainService");
    }
    if (this.e) {
        this.a.putAll(this.b.tokenDefaults());
        BaseClient.b(this.a, this.d, this.c);
        this.e = false;
        if (BaseClient.buildInfo.DEBUG) {
            Log.v("ParamBuilder", this.c + StringUtils.SPACE + this.a);
        }
        return this.a;
    }
    throw new IllegalStateException("already built");
}

protected final Map<String, String> tokenDefaults() {
    Map<String, String> defaults = this.b.getDefaults();
    String userToken = ConnectionConfig.getInstance().getUserToken();
    if (userToken != null) {
        defaults.put(UserContract.Users.COLUMN_TOKEN, userToken);
    }
    return defaults;
}

@Override // org.sigmaaie.mobile.sigmacore.rest.ParamProvider
@SuppressLint({"HardwareIds"})
public Map<String, String> getDefaults() {
    Locale locale = Locale.getDefault();
    HashMap hashMap = new HashMap();
    hashMap.put("multi", "true");
    hashMap.put("av", this.a);
    hashMap.put("avc", this.b);
    hashMap.put("sv", Build.VERSION.RELEASE);
    hashMap.put("os", "ANDROID");
    hashMap.put(PerfilIdCampos.PAIS, locale.getCountry());
    hashMap.put("idioma", locale.getLanguage());
    hashMap.put("nid", Build.SERIAL);
    String lastProfile = this.preferences.getLastProfile();
    if (lastProfile != null && !lastProfile.isEmpty()) {
        hashMap.put("perfilActivo", lastProfile);
    }
    ConnectionConfig connectionConfig = ConnectionConfig.getInstance();
    if (connectionConfig.EXTERNAL) {
        hashMap.put("pocket", "true");
        hashMap.put("pocket_id", connectionConfig.getUserID());
        hashMap.put("pocket_token", connectionConfig.getUserToken());
    }
    return hashMap;
}

Nos damos cuenta de que el mapa que va a pasar por el generarHash(Map<String, String>) es el contenido de la petición, previamente observada, sin la clave "hash".

Conclusiones

Para replicar el funcionamiento de inicio de sesión:

Generamos el hash con el contenido inicial de la petición

generarHash({
    "multi": true,
    "av": "...", // opcional
    "avc": "...", // opcional
    "sv": "...", // opcional
    "os": "...", // opcional: sistema operativo
    "idioma": "...", // opcional: idioma
    "nid": "...", // opcional: serial build
    "perfilActivo": "...", // opcional en login: ultimo perfil activo: nos servirá para las calificaciones
    "token": "...", // opcional en login: token de autenticación que nos devolverá el login
}) => <String: HASH MD5>

Formamos el contenido definitivo de la petición añadiéndole el hash MD5 calculado

{
  "multi": true,
  "av": "...", // opcional
  "avc": "...", // opcional
  "sv": "...", // opcional
  "os": "...", // opcional: sistema operativo
  "idioma": "...", // opcional: idioma
  "nid": "...", // opcional: serial build
  "perfilActivo": "...", // opcional en login: ultimo perfil activo: nos servirá para las calificaciones
  "token": "...", // opcional en login: token de autenticación que nos devolverá el login
  "hash": "<String: HASH MD5>"
}

Hemos descubierto cómo se comunica la aplicación con el servidor para obtener las calificaciones. Este proceso ha demostrado la importancia de un componente específico, el hash, cuyo valor correcto es crucial para la autenticación y la obtención de datos.

El análisis detallado ha permitido replicar la comunicación exitosamente, abriendo la puerta a la posibilidad de desarrollar una función de notificaciones que mejore la experiencia del usuario sin comprometer la seguridad ni la integridad del sistema original.

Ingeniería Inversa de software [desde cero]

NULLX — Sat, 11 May 2024 10:44:04 +0000

En este tutorial aprenderás los conceptos básicos de la ingeniería
inversa y cómo aplicarla de manera ética y responsable en el campo de la informática.

Introducción

En el ámbito gastronómico, hay ciertos platos o postres que nos llaman la atención por su sabor perfecto. Al no poder acceder a esas fórmulas culinarias, solo tenemos una opción: adquirir una muestra de, por ejemplo, una tarta de queso, y con observación y análisis descubrir tanto los ingredientes como el procedimiento de su elaboración.

Al igual que los ingredientes se convierten en una perfecta tarta de queso, el código fuente se convierte en un programa.

Durante toda la carrera de ingeniería informática invertimos mucho tiempo en construir para obtener el producto (ejecutable). En este proceso aprendemos técnicas y herramientas prácticas que nos permiten transformar ideas abstractas en soluciones concretas que pueden ser implementadas y utilizadas en el mundo real.

¿Pero cómo se hackea algo? Está muy bien programar para obtener un programa, pero ¿cómo alguien puede conseguir modificar el comportamiento
de dicho programa a partir de un ejecutable lleno de unos y ceros? Este proyecto viene a saciar dicha necesidad de curiosidad que cualquiera de nosotros, los informáticos, hemos tenido. Se pretende ofrecer un punto de vista educativo distinto al que estamos acostumbrados, explorando el
análisis de software desde una perspectiva más allá del desarrollo.

Motivación

Se realizará el análisis de dos productos del mundo real alejando la abstracción a la que estamos acostumbrados en los entornos educativos para acercarnos al mundo real.

En mi universidad, existe una aplicación oficial en la que se pueden visualizar las calificaciones finales de las asignaturas. Los alumnos como usuarios de ésta, echamos en falta un sistema de notificaciones que te avise cuándo se publica o cambia una calificación. Esta carencia de funcionalidad provoca que en época de exámenes estemos continuamente refrescando manualmente la aplicación para ver si hay alguna nota nueva.

No solo nos provoca cierto estrés tener que continuamente estar pendientes de "y si las han colgado ya" sino que el hecho de estar visitando la aplicación recurrentemente por todos los estudiantes sobrecargue el sistema innecesariamente. Se pretende descubrir de qué forma la aplicación se comunica con el servidor de calificaciones para hipotéticamente replicar dicho funcionamiento y detectar cambios en ellas.

En este mismo contexto de la universidad, hay ciertas asignaturas de informática que requieren de acceso y uso de librerías para realizar ejercicios prácticos. Dado que alguna de ellas está restringida para el uso exclusivo en los ordenadores del aula, surge la necesidad de buscar soluciones que permitan su utilización fuera del campus. Esta situación despierta nuestra curiosidad como programadores y nos empuja a investigar los principios de la ingeniería inversa como herramienta educativa, siempre dentro de un marco ético, respetando las políticas de la universidad.

Renuncia de responsabilidad

Generalmente, (dependiendo de cada país) aplicar el proceso de ingeniería inversa a un producto de software con motivos educativos o de mejora de seguridad, se considera justo siempre que no viole la propiedad intelectual o los derechos de autor del software en cuestión.
De esta misma forma hacer uso de este proceso para crear productos alternativos a la competencia, suele considerarse ilegal. Además, es importante destacar que incluso cuando la ingeniería inversa se realiza con fines legítimos, como la educación o la mejora de la seguridad, los investigadores deben actuar con precaución para asegurar que no compartan o utilicen el código fuente descubierto durante el proceso, especialmente si dicho código está protegido por derechos de autor.
Mientras que el conocimiento adquirido a través de la ingeniería inversa puede ser muy valioso para el aprendizaje, su aplicación debe hacerse siempre dentro del marco legal y ético adecuado, respetando las patentes y los derechos de autor.

Objetivos

Se busca ofrecer un punto de vista educativo alternativo mostrando que simplemente con la modificación de unos cuantos bytes el comportamiento de un programa puede cambiar.

También se busca quitar peso al concepto de "hackear" que cotidianamente asociamos a expertos en seguridad informática o a seres encerrados con malas intenciones. Conocer estas técnicas ayuda a formar una habilidad que, utilizada de forma éticamente correcta, puede contribuir significativamente al avance tecnológico.

Al enfocar este aprendizaje desde una perspectiva ética y responsable, se pretende concienciar a los futuros informáticos sobre la importancia de usar sus habilidades para el bien común.

¡Sigue la serie para descubrir la ingeniería inversa de dos soluciones del mundo real!

Cómo construir y gestionar un clúster de Kubernetes de Raspberry Pi con fines educativos

NULLX — Sun, 05 May 2024 18:27:05 +0000

Introducción

Esta guía está dirigida a estudiantes de ingeniería informática que tienen la intención de aprender a construir y gestionar un sistema de computación descentralizado como Kubernetes, con un ejemplo práctico de cómo crear un cluster utilizando dispositivos Raspberry Pi.

¿Qué es Kubernetes?

Kubernetes es una plataforma de código abierto que automatiza las operaciones de contenedores Linux. Elimina muchos de los procesos manuales involucrados en el despliegue y la escalabilidad de aplicaciones contenerizadas.

Objetivo

Al final de este tutorial, podrás:

Configurar varios Raspberry Pis para formar un cluster.
Instalar y configurar Kubernetes usando una herramienta ligera llamada k3s.
Desplegar y gestionar aplicaciones contenerizadas en el cluster.

Configuración del Hardware

Nuestro cluster, llamado clusperry, consiste en 6 unidades de Raspberry Pi 4B, cada una con 4GB de RAM.

Configuración Inicial

Crear Imágenes Linux:
- Usaremos una herramienta GUI desarrollada para generar imágenes de Linux, las cuales luego serán grabadas en tarjetas microSD.
- Herramienta disponible en: clusperry-installer.
Descargar y Configurar:
- Obtén la herramienta desde la página de lanzamientos.
- Elige el sistema operativo para los nodos y configura los ajustes de red y las llaves SSH.

Escribir y Cargar Imágenes del SO:
- Escribe las imágenes del SO descargadas en tarjetas microSD.
- Carga estas imágenes en tus Raspberry Pis.

Configuración del Software

Instalación de Kubernetes con k3s

k3s es una versión ligera de Kubernetes ideal para entornos de edge, IoT y CI que requieren un menor consumo de recursos, como en nuestro caso.

Preparación para la Instalación:

Utiliza Ansible para la automatización.
Clona el repositorio Ansible de k3s:

 git clone https://github.com/k3s-io/k3s-ansible.git
 cd k3s-ansible
 cp -R inventory/sample inventory/my-cluster
 nano inventory/my-cluster/hosts.ini

Configuración:
- Configura inventory/my-cluster/hosts.ini y inventory/my-cluster/group_vars/all.yml con detalles como la versión de Kubernetes, el usuario del sistema y la IP del nodo maestro.
Despliegue:
- Ejecuta el playbook de Ansible para instalar k3s en tus nodos:
```
 ansible-playbook site.yml -i inventory/my-cluster/hosts.ini
```
Instalar kubectl:
- Instala kubectl en tu máquina local para interactuar con el cluster.
```
 brew install kubectl
 scp ubuntu@192.168.1.100:~/.kube/config ~/.kube/config
```

Verificación de la Instalación

Asegúrate de que todos los nodos estén listos ejecutando:

kubectl get nodes

Despliegue de Aplicaciones

Desplegando una Aplicación de Prueba

Configurar DNS Local:
- Añade una entrada DNS a /etc/hosts para el dominio de prueba.

sudo echo "192.168.1.100 test.com" >> /etc/hosts

Desplegar una Aplicación:
- Crea un despliegue, servicio e ingreso para el servidor web Nginx.

YAML de Despliegue

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2 # indica al despliegue ejecutar 2 pods replicados
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
  labels:
    name: nginx-service
spec:
  ports:
    - port: 80
      name: http
  selector:
    name: nginx-deployment
--------

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: nginx-ingress
  annotations:
    kubernetes.io/ingress.class: traefik
spec:
  rules:
  - host: "test.com"
    http:
      paths:
      - path: /
        backend:
          serviceName: nginx-service
          servicePort: 80

Verifica el despliegue:

kubectl get pods
curl http://test.com

Limpieza y Aprendizaje Adicional

Recuerda eliminar cualquier configuración temporal como las entradas DNS.
Para soluciones de almacenamiento persistente, consulta esta guía.

Conclusión

Este ejercicio práctico introduce los conceptos básicos y los pasos para configurar un cluster de Kubernetes en Raspberry Pi. Esta configuración fomenta el aprendizaje mediante la experiencia práctica y es ideal para fines educativos en currículos de ingeniería informática.

TOP 4 free database hosting

NULLX — Mon, 15 Aug 2022 20:01:00 +0000

1. Amazon Relational Database Service (RDS)

They offer a a free usage during the first year.

Amazon Aurora
RDS for MySQL
RDS for PostgreSQL
RDS for MariaDB
RDS for Oracle
RDS for SQL Server
Amazon RDS Custom

2. MongoDB Atlas

They have free 512MB / project.

MongoDB database hosting

3. Filess

They have a free plan forever with free backups.

MySQL
MariaDB
MongoDB
Postgres

4. bit.io

Managed PostgreSQL database service. 1 database, 10GB storage, 1 CPU and 1GB Memory (burst).

Postgres

Pub/Sub: C implementation

NULLX — Tue, 22 Mar 2022 15:16:50 +0000

Note: this implementation is not optimized as:

Unsubscribing sets NULL on subscriptions array. Would be good to delete NULL subscriptions from there.
Publishing message is done sequentially. The messages will be delivered in order of subscription.

Persistent storage for raspberry pi k8s cluster

NULLX — Thu, 06 May 2021 22:07:21 +0000

If you want to check the setup of this cluster, check my last post.

As I said in that post, I installed kubernetes with the k3s tool.

It's cool to deploy stateless applications, but when you need something more complex, you'll need a persistent volume.

K3s comes with local-path-provisioner which is used to create local storages in each node of your cluster.
What is the problem? If we are running a simple deployment with multiple replicas and each node needs to store data, we will realize that each node will save its own data. No storage will be shared between nodes and we don't want that behavior.

I tried to mount a GlusterFS directly with k8s drivers but I could't make it work. It seems that is a k3s incompatibility problem. So in this tutorial I am going to try another way.

Cluster info

host	IP
master-01	192.168.1.100
node-01	192.168.1.101
node-02	192.168.1.102
node-03	192.168.1.103
node-04	192.168.1.104
node-05	192.168.1.105

Ansible `hosts.ini`

[master]
192.168.1.100

[node]
192.168.1.101
192.168.1.102
192.168.1.103
192.168.1.104
192.168.1.105

[k3s_cluster:children]
master
node

Install glusterfs

INSTALL IN ALL NODES DEPENDENCIES:

ansible all -i hosts.ini -a "sudo modprobe fuse" -b

ansible all -i hosts.ini -a "sudo apt-get install -y xfsprogs glusterfs-server" -b

** Add glusterd service to startup services **

ansible all -i hosts.ini -a "sudo systemctl enable glusterd" -b

ansible all -i hosts.ini -a "sudo systemctl start glusterd" -b

ONLY ON MASTER NODES:

Ping all slave nodes

sudo gluster peer probe 192.168.1.101

sudo gluster peer probe 192.168.1.102

sudo gluster peer probe 192.168.1.103

sudo gluster peer probe 192.168.1.104

sudo gluster peer probe 192.168.1.105

Check the connection status

sudo gluster peer status

Create folder in all master nodes

sudo mkdir -p /mnt/glusterfs/myvolume/brick1/

Create the volume

sudo gluster volume create brick1 192.168.1.100:/mnt/glusterfs/myvolume/brick1/ force

Start the volume

sudo gluster volume start brick1

Check the volume status

sudo gluster volume status

Final step: mount them

Create the folder in all nodes for mounting (it will create on masters also but wont mount)

ansible all -i hosts.ini -a "mkdir -p /mnt/general-volume" -b

Mount in all nodes

ansible all -i hosts.ini -a "mount -t glusterfs 192.168.1.100:/brick1 /mnt/general-volume" -b

Mount on reboot

/root/mount-volumes.sh: create this file in all slaves nodes

#!/bin/sh

function check_glusterd_running()
{
# Explanation of why ps command is used this way:
# https://stackoverflow.com/questions/9117507/linux-unix-command-to-determine-if-process-is-running
        if ! ps cax | grep -w '[g]lusterd' > /dev/null 2>&1
        then
                echo "ERROR: Glusterd is not running"
                exit 1
        fi
}

while [[ !  -z  $(check_glusterd_running)  ]]; do
  sleep 1s;
done

echo "Glusterd is running"

# =====> start volume mounts <======
mount -t glusterfs 192.168.1.100:/brick1 /mnt/general-volume

After creating this file on all slave nodes:

Create crontab line

sudo crontab -e

@reboot bash /root/mount-volumes.sh
# ^^^^^^^^^^^^ Add this line

k8s Manifest example

apiVersion: v1
kind: Pod
metadata:
  name: ubuntu
  labels:
    app: ubuntu
spec:
  volumes:
    - name: general-volume
      hostPath:
        path: "/mnt/general-volume/test"
  containers:
  - image: ubuntu
    command:
      - "sleep"
      - "604800"
    imagePullPolicy: IfNotPresent
    name: ubuntu
    volumeMounts:
      - mountPath: "/app/data"
        name: general-volume
        readOnly: false
  restartPolicy: Always

Create a file in the container

kubectl exec -it ubuntu -- mkdir -p /app/data && touch /app/data/hello-world

SSH to any node and check if the new file is there

ssh ubuntu@192.168.1.102

ubuntu@node-02:~$ ls /mnt/general-volume/test

You are ready to go!

Raspberry pi 4B kubernetes cluster

NULLX — Thu, 06 May 2021 11:47:20 +0000

I love decentralized computing. It’s beautiful. Just add a node to your cluster if you need more power! Just that. Restart the pods with no downtime, horizontal pod autoscaler...

To create a cluster, we can do it with services provided by google, amazon… or just manually installing it in each node.

I prefer to create my own mini cluster. My cluster is made of 6 raspberry pi 4B (4GB RAM each) and has it's own name: clusperry ⚡️

I created a simple gui tool to generate the linux images to flash into the mini-SD cards with the initial cloudconfig. You can check it here: https://github.com/nullxx/clusperry-installer.

Nodes setup

Download the release from https://github.com/nullxx/clusperry-installer/releases/ (its currently only compiled for macOS)

1. Select the nodes operating system

2. Configure each node with your configuration:

IP
WIFI (or ethernet)
hostname
SSH keys

3. Download OS images

4. Write images

5. Open generated images

Install kubernetes with k3s

For this I will use ansible. It makes it easier to do all the install work.
I will use the following repo: https://github.com/k3s-io/k3s-ansible

Clone the repo

git clone https://github.com/k3s-io/k3s-ansible.git

Get into the cloned repo

cd k3s-ansible

Create our inventory from the sample

cp -R inventory/sample inventory/my-cluster

Edit `inventory/my-cluster/hosts.ini`

nano inventory/my-cluster/hosts.ini

[master]
192.168.1.100

[node]
192.168.1.101
192.168.1.102
192.168.1.103
192.168.1.104
192.168.1.105

[k3s_cluster:children]
master
node

Edit `inventory/my-cluster/group_vars/all.yml`

In my case edit the ansible_user to ubuntu

---
k3s_version: v1.17.5+k3s1
ansible_user: ubuntu
systemd_dir: /etc/systemd/system
master_ip: "{{ hostvars[groups['master'][0]]['ansible_host'] | default(groups['master'][0]) }}"
extra_server_args: ""
extra_agent_args: ""

Be ready for the power!

Execute the ansible-playbook to install k8s in the nodes.

ansible-playbook site.yml -i inventory/my-cluster/hosts.ini

Install kubectl in your computer

In my case macOS

brew install kubectl

Get the kubectl config from any of your master nodes

scp ubuntu@192.168.1.100:~/.kube/config ~/.kube/config

Verify installation.

Check that all nodes are in STATUS 'Ready'

kubectl get nodes

Deploy test

Create a local DNS entry for the test

sudo echo "192.168.1.100 test.com" >> /etc/hosts

I'm going to use traefik because is installed by default with k3s.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2 # tells deployment to run 2 pods matching the template
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
  labels:
    name: nginx-service
spec:
  ports:
    - port: 80
      name: http
  selector:
    name: nginx-deployment
---

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: nginx-ingress
  annotations:
    kubernetes.io/ingress.class: traefik
spec:
  rules:
  - host: "test.com"
    http:
      paths:
      - path: /
        backend:
          serviceName: nginx-service
          servicePort: 80

Verify pods are up

kubectl get pods

Go to `http://test.com` on your browser

curl http://test.com

Its working!

Cleanup

Remember to remove the test.com line in /etc/hosts

Persistent storage

Part two available here

Forem: NULLX

Ingeniería inversa EXE

Library Jailbreak

Vista general

Análisis del código fuente

Primera condición

Segunda condición

Solución

Programación

Ingeniería inversa APK: Deusto App

Sobre Deusto App

Análisis del tráfico de red

Análisis del código fuente

Conclusiones

Ingeniería Inversa de software [desde cero]

Introducción

Motivación

Renuncia de responsabilidad

Objetivos

Cómo construir y gestionar un clúster de Kubernetes de Raspberry Pi con fines educativos

Introducción

¿Qué es Kubernetes?

Objetivo

Configuración del Hardware

Configuración Inicial

Configuración del Software

Instalación de Kubernetes con k3s

Verificación de la Instalación

Despliegue de Aplicaciones

Desplegando una Aplicación de Prueba

Limpieza y Aprendizaje Adicional

Conclusión

TOP 4 *free* database hosting

1. Amazon Relational Database Service (RDS)

2. MongoDB Atlas

3. Filess

4. bit.io

Pub/Sub: C implementation

Persistent storage for raspberry pi k8s cluster

Cluster info

Ansible hosts.ini

Install glusterfs

INSTALL IN ALL NODES DEPENDENCIES:

ONLY ON MASTER NODES:

Ping all slave nodes

Check the connection status

Create folder in all master nodes

Create the volume

Start the volume

Check the volume status

Final step: mount them

Create the folder in all nodes for mounting (it will create on masters also but wont mount)

Mount on reboot

k8s Manifest example

Create a file in the container

SSH to any node and check if the new file is there

Raspberry pi 4B kubernetes cluster

Nodes setup

1. Select the nodes operating system

2. Configure each node with your configuration:

3. Download OS images

4. Write images

5. Open generated images

Install kubernetes with k3s

Clone the repo

Get into the cloned repo

Create our inventory from the sample

Edit inventory/my-cluster/hosts.ini

Edit inventory/my-cluster/group_vars/all.yml

Be ready for the power!

Install kubectl in your computer

Get the kubectl config from any of your master nodes

Verify installation.

Deploy test

Create a local DNS entry for the test

Verify pods are up

Go to http://test.com on your browser

Cleanup

Persistent storage

TOP 4 free database hosting

Ansible `hosts.ini`

Edit `inventory/my-cluster/hosts.ini`

Edit `inventory/my-cluster/group_vars/all.yml`

Go to `http://test.com` on your browser