<- REVERSING

Secured Transfer

7 minutos de lectura

Se nos proporciona un archivo binario llamado securetransfer:

$ file securetransfer
securetransfer: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=0457997eda987eb100de85a2954fc8b8fc660a53, for GNU/Linux 3.2.0, stripped

También tenemos un archivo de captura de red llamado trace.pcap.

Análisis de tráfico

Comenzando por trace.pcap, podemos usar Wireshark para analizar la captura de red:

Secured Transfer 1

Solamente hay un segmento TCP que contiene datos:

17275a3d9163b2798392813bf5e6826657bd11426076c910a38b68c2bcbbd3a5

Ingeniería inversa

Podemos usar Ghidra para leer el código descompilado en C. Esta es la función main:

int main(int param_1, long param_2) {
  OPENSSL_init_crypto(2,0);
  OPENSSL_init_crypto(0xc, 0);
  OPENSSL_init_crypto(0x80, 0);

  if (param_1 == 3) {
    printf("Sending File: %s to %s\n", *(undefined8 *) (param_2 + 0x10), *(undefined8 *) (param_2 + 8));  
    send_encrypt(*(undefined8 *) (param_2 + 8), *(undefined8 *) (param_2 + 0x10));
  } else if (param_1 == 1) {
    puts("Receiving File");
    recv_decrypt();
  } else {
    puts("Usage ./securetransfer [<ip> <file>]");
  }

  return 0;
}

Básicamente, ofrece dos opciones: cifrar un archivo y enviarlo, o recibir un archivo y descifrarlo. También vemos que utiliza OpenSSL para construir el cifrado.

Función de cifrado

Vamos a echar un vistazo a send_encrypt:

undefined8 send_encrypt(char *param_1, char *param_2) {
  int __fd;
  int iVar1;
  undefined8 uVar2;
  size_t sVar3;
  long in_FS_OFFSET;
  size_t local_50;
  FILE *local_48;
  ulong local_40;
  void *local_38;
  void *local_30;
  undefined local_28[4];
  undefined local_24[20];
  long local_10;
  
  local_10 = *(long *) (in_FS_OFFSET + 0x28);
  __fd = socket(2, 1, 0);

  if (__fd == -1) {
    puts("ERROR: Socket creation failed");
    uVar2 = 0;
  } else {
    memset(local_28, 0, 0x10);
    local_28._0_2_ = 2;
    iVar1 = inet_pton(2, param_1, local_24);

    if (iVar1 == 0) {
      printf("ERROR: Invalid input address \'%s\'\n", param_1);
      uVar2 = 0;
    } else {
      local_28._2_2_ = htons(0x539);
      iVar1 = connect(__fd, (sockaddr *) local_28, 0x10);

      if (iVar1 == 0) {
        local_48 = fopen(param_2, "rb");

        if (local_48 == NULL) {
          printf("ERROR: Can\'t open the file \'%s\'\n", param_2);
          close(__fd);
          uVar2 = 0;
        } else {
          fseek(local_48, 0, 2);
          local_40 = ftell(local_48);
          fseek(local_48, 0, 0);

          if (local_40 < 0x10) {
            puts("ERROR: File too small");
            fclose(local_48);
            close(__fd);
            uVar2 = 0;
          } else if (local_40 < 0x1001) {
            local_38 = malloc(local_40);
            local_30 = malloc(local_40 * 2);
            sVar3 = fread(local_38, 1, local_40, local_48);

            if (local_40 == sVar3) {
              iVar1 = encrypt(local_38, local_40 & 0xffffffff, local_30);  
              local_50 = (size_t) iVar1;
              write(__fd, &local_50, 8);
              write(__fd, local_30, local_50);
              puts("File send...");
              free(local_30);
              free(local_38);
              fclose(local_48);
              close(__fd);
              uVar2 = 1;
            } else {
              puts("ERROR: Failed reading the file");
              free(local_30);
              free(local_38);
              fclose(local_48);
              close(__fd);
              uVar2 = 0;
            }
          } else {
            puts("ERROR: File too large");
            fclose(local_48);
            close(__fd);
            uVar2 = 0;
          }
        }
      } else {
        puts("ERROR: Connection failed");
        uVar2 = 0;
      }
    }
  }

  if (local_10 != *(long *) (in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }

  return uVar2;
}

Esta función lee un archivo de entrada, lo cifra y lo envía a través de un socket TCP. Esta es la función encrypt:

int encrypt(uchar *param_1, int param_2, uchar *param_3) {
  int iVar1;
  EVP_CIPHER *cipher;
  long in_FS_OFFSET;
  int local_50;
  int local_4c;
  char *local_48;
  EVP_CIPHER_CTX *local_40;
  uchar local_38;
  undefined local_37;
  undefined local_36;
  undefined local_35;
  undefined local_34;
  undefined local_33;
  undefined local_32;
  undefined local_31;
  undefined local_30;
  undefined local_2f;
  undefined local_2e;
  undefined local_2d;
  undefined local_2c;
  undefined local_2b;
  undefined local_2a;
  undefined local_29;
  undefined local_28;
  undefined local_27;
  undefined local_26;
  undefined local_25;
  undefined local_24;
  undefined local_23;
  undefined local_22;
  undefined local_21;
  undefined local_20;
  undefined local_1f;
  undefined local_1e;
  undefined local_1d;
  undefined local_1c;
  undefined local_1b;
  undefined local_1a;
  undefined local_19;
  long local_10;
  
  local_10 = *(long *) (in_FS_OFFSET + 0x28);
  local_38 = 's';
  local_2f = 0x65;
  local_2e = 0x74;
  local_2d = 0x6b;
  local_1d = 0x74;
  local_1c = 0x69;
  local_37 = 0x75;
  local_36 = 0x70;
  local_22 = 0x6e;
  local_21 = 99;
  local_1b = 0x6f;
  local_32 = 0x65;
  local_31 = 99;
  local_33 = 0x73;
  local_20 = 0x72;
  local_1f = 0x79;
  local_30 = 0x72;
  local_26 = 0x66;
  local_25 = 0x6f;
  local_24 = 0x72;
  local_1a = 0x6e;
  local_2c = 0x65;
  local_2b = 0x79;
  local_2a = 0x75;
  local_29 = 0x73;
  local_28 = 0x65;
  local_27 = 100;
  local_23 = 0x65;
  local_35 = 0x65;
  local_34 = 0x72;
  local_1e = 0x70;
  local_19 = 0x21;
  local_48 = "someinitialvalue";
  local_40 = EVP_CIPHER_CTX_new();

  if (local_40 == NULL) {
    iVar1 = 0;
  } else {
    cipher = EVP_aes_256_cbc();
    iVar1 = EVP_EncryptInit_ex(local_40, cipher, NULL, &local_38, (uchar *) local_48);  

    if (iVar1 == 1) {
      iVar1 = EVP_EncryptUpdate(local_40, param_3, &local_50, param_1, param_2);

      if (iVar1 == 1) {
        local_4c = local_50;
        iVar1 = EVP_EncryptFinal_ex(local_40,param_3 + local_50, &local_50);

        if (iVar1 == 1) {
          local_4c = local_4c + local_50;
          EVP_CIPHER_CTX_free(local_40);
          iVar1 = local_4c;
        } else {
          iVar1 = 0;
        }
      } else {
        iVar1 = 0;
      }
    } else {
      iVar1 = 0;
    }
  }

  if (local_10 != *(long *) (in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }

  return iVar1;
}

Es una función un tanto larga, pero lo único que hace es configurar una clave byte por byte, y un valor inicial (IV) para crear un cifraro AES CBC. En este punto, cogí todos los valores local_xx y creé la clave AES. Traté de usar esta clave AES con el IV para descifrar los datos del segmento TCP, pero no era correcto.

Función de descifrado

Entonces eché un vistazo a la función decrypt (llamada por recv_decrypt):

int decrypt(uchar *param_1, int param_2, uchar *param_3) {
  int iVar1;
  EVP_CIPHER *cipher;
  long in_FS_OFFSET;
  int local_50;
  int local_4c;
  char *local_48;
  EVP_CIPHER_CTX *local_40;
  uchar local_38;
  undefined local_37;
  undefined local_36;
  undefined local_35;
  undefined local_34;
  undefined local_33;
  undefined local_32;
  undefined local_31;
  undefined local_30;
  undefined local_2f;
  undefined local_2e;
  undefined local_2d;
  undefined local_2c;
  undefined local_2b;
  undefined local_2a;
  undefined local_29;
  undefined local_28;
  undefined local_27;
  undefined local_26;
  undefined local_25;
  undefined local_24;
  undefined local_23;
  undefined local_22;
  undefined local_21;
  undefined local_20;
  undefined local_1f;
  undefined local_1e;
  undefined local_1d;
  undefined local_1c;
  undefined local_1b;
  undefined local_1a;
  undefined local_19;
  long local_10;
  
  local_10 = *(long *) (in_FS_OFFSET + 0x28);
  local_38 = 's';
  local_2f = 0x65;
  local_37 = 0x75;
  local_36 = 0x70;
  local_26 = 0x66;
  local_25 = 0x6f;
  local_24 = 0x72;
  local_21 = 99;
  local_2e = 0x74;
  local_2d = 0x6b;
  local_1d = 0x74;
  local_1b = 0x6f;
  local_32 = 0x65;
  local_31 = 99;
  local_33 = 0x73;
  local_20 = 0x72;
  local_2b = 0x79;
  local_2a = 0x75;
  local_29 = 0x73;
  local_1c = 0x69;
  local_28 = 0x65;
  local_27 = 100;
  local_23 = 0x65;
  local_1f = 0x79;
  local_30 = 0x72;
  local_34 = 0x72;
  local_1e = 0x70;
  local_19 = 0x21;
  local_1a = 0x6e;
  local_2c = 0x65;
  local_35 = 0x65;
  local_22 = 0x6e;
  local_48 = "someinitialvalue";
  local_40 = EVP_CIPHER_CTX_new();

  if (local_40 == NULL) {
    iVar1 = 0;
  } else {
    cipher = EVP_aes_256_cbc();
    iVar1 = EVP_DecryptInit_ex(local_40, cipher, NULL, &local_38, (uchar *) local_48);  

    if (iVar1 == 1) {
      iVar1 = EVP_DecryptUpdate(local_40, param_3, &local_50, param_1, param_2);

      if (iVar1 == 1) {
        local_4c = local_50;
        iVar1 = EVP_DecryptFinal_ex(local_40, param_3 + local_50, &local_50);

        if (iVar1 == 1) {
          local_4c = local_4c + local_50;
          EVP_CIPHER_CTX_free(local_40);
          iVar1 = local_4c;
        } else {
          iVar1 = 0;
        }
      } else {
        iVar1 = 0;
      }
    } else {
      iVar1 = 0;
    }
  }

  if (local_10 != *(long *) (in_FS_OFFSET + 0x28)) {
                    /* WARNING: Subroutine does not return */
    __stack_chk_fail();
  }

  return iVar1;
}

Se parece bastante a encrypt. De hecho, AES es un algoritmo de cifrado simétrico, por lo que la clave AES es la misma para cifrar que para descifrar.

Si comparamos las funciones encrypt y decrypt, veremmos que los valores local_xx no están en el mismo orden, pero sabemos que ambas claves AES son iguales. Entonces, me di cuenta de que los valoes local_xx simplemente estaban desordenados y tenemos que ordenarlos para construir la clave AES. Este sería el orden correcto:

  local_19 = 0x21;  
  local_1a = 0x6e;
  local_1b = 0x6f;
  local_1c = 0x69;
  local_1d = 0x74;
  local_1e = 0x70;
  local_1f = 0x79;
  local_20 = 0x72;
  local_21 = 99;
  local_22 = 0x6e;
  local_23 = 0x65;
  local_24 = 0x72;
  local_25 = 0x6f;
  local_26 = 0x66;
  local_27 = 100;
  local_28 = 0x65;
  local_29 = 0x73;
  local_2a = 0x75;
  local_2b = 0x79;
  local_2c = 0x65;
  local_2d = 0x6b;
  local_2e = 0x74;
  local_2f = 0x65;
  local_30 = 0x72;
  local_31 = 99;
  local_32 = 0x65;
  local_33 = 0x73;
  local_34 = 0x72;
  local_35 = 0x65;
  local_36 = 0x70;
  local_37 = 0x75;
  local_38 = 's';

Flag

En este punto, podemos coger estos valores y ponerlos en Python. También, nótese que el orden anterior es inverso debido al endianness (little-endian):

$ python3 -q
>>> from Crypto.Cipher import AES
>>> key = bytes([
...     0x21,
...     0x6e,
...     0x6f,
...     0x69,
...     0x74,
...     0x70,
...     0x79,
...     0x72,
...     99,
...     0x6e,
...     0x65,
...     0x72,
...     0x6f,
...     0x66,
...     100,
...     0x65,
...     0x73,
...     0x75,
...     0x79,
...     0x65,
...     0x6b,
...     0x74,
...     0x65,
...     0x72,
...     99,
...     0x65,
...     0x73,
...     0x72,
...     0x65,
...     0x70,
...     0x75,
...     ord('s'),
... ])[::-1]
>>> iv = b'someinitialvalue'
>>> cipher = AES.new(key, AES.MODE_CBC, iv)
>>> data = bytes.fromhex('17275a3d9163b2798392813bf5e6826657bd11426076c910a38b68c2bcbbd3a5')  
>>> cipher.decrypt(data)
b'HTB{3ncRyPt3d_F1LE_tr4nSf3r}\x04\x04\x04\x04'