# CrackMe2

**Catégorie:** Reverse\
**Difficulté:** -\
**Flag:** CTFREI{x0r\_1s\_l1f3}

## Challenge

{% file src="https://2344605990-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5vTwbgJFy6k3bN4a9ntp%2Fuploads%2FeYPJNQN7G99ypAogVUQ0%2Fcrackme2.zip?alt=media&token=1646acd9-c921-4692-9b34-12d954dfb9f2" %}

{% hint style="info" %}
#### Description

***

Deuxième challenge d'introduction, introduisant un élément très connu (le **xor**).

Retrouve le flag qui est caché dans ce binaire !
{% endhint %}

## Solution

Décompilation du binaire avec GHIDRA, ensuite, il faut simplement prendre son temps pour renommer les variables et les retyper avec ce qui semble logique.

Ici le binaire demande un input qui doit faire 19 caractères, puis XOR chaque caractère avec une clé et vérifie que le résultat correspond au flag chiffré. Comme le XOR est réversible, il suffit de XOR le flag chiffré avec la clé pour le déchiffrer.

```c

int main(void) {
  size_t taille_de_notre_input;
  byte notre_input [112];
  char key [20];
  int flag_chiffre [20];
  int i;
  bool bon_flag;
  
  flag_chiffre[0] = 0x2d;
  flag_chiffre[1] = 0x64;
  flag_chiffre[2] = 0x32;
  flag_chiffre[3] = 0x67;
  flag_chiffre[4] = 0x75;
  flag_chiffre[5] = 0x3b;
  flag_chiffre[6] = 0x4f;
  flag_chiffre[7] = 0x16;
  flag_chiffre[8] = 0x54;
  flag_chiffre[9] = 0x42;
  flag_chiffre[10] = 0x32;
  flag_chiffre[11] = 0x72;
  flag_chiffre[12] = 0x1b;
  flag_chiffre[13] = 0x6b;
  flag_chiffre[14] = 0x1e;
  flag_chiffre[15] = 0x4;
  flag_chiffre[16] = 0xe;
  flag_chiffre[17] = 0x46;
  flag_chiffre[18] = 0x15;
  
  key[0] = 'n';
  key[1] = '0';
  key[2] = 't';
  key[3] = '5';
  key[4] = '0';
  key[5] = 'r';
  key[6] = '4';
  key[7] = 'n';
  key[8] = 'd';
  key[9] = '0';
  key[10] = 'm';
  key[11] = 'C';
  key[12] = 'h';
  key[13] = '4';
  key[14] = 'r';
  key[15] = '5';
  key[16] = 'h';
  key[17] = 'u';
  key[18] = 'h';
  key[19] = '\0';
  
  printf("Rentre le flag: ");
  __isoc99_scanf(&DAT_00102015,notre_input);
  taille_de_notre_input = strlen((char *)notre_input);
  if (taille_de_notre_input == 0x13) {
    bon_flag = true;
    for (i = 0; i < 19; i = i + 1) {
      if ((int)(char)(key[i] ^ notre_input[i]) != flag_chiffre[i]) {
        bon_flag = false;
        break;
      }
    }
    if (bon_flag) {
      puts("Bon flag!");
    }
    else {
      puts("Mauvais flag!");
    }
  }
  else {
    puts("Mauvais flag!");
  }
  return 0;
}
```

Voici un script python dans lequel on a juste recopié les valeurs et xor char par char le flag chiffré et la clé :

```python
flag_chiffre = [0x2d, 0x64, 0x32, 0x67, 0x75, 0x3b, 0x4f, 0x16, 0x54, 0x42, 0x32, 0x72, 0x1b, 0x6b, 0x1e, 0x4, 0xe, 0x46, 0x15]
key = b'n0t50r4nd0mCh4r5huh'
flag = ''.join([chr(a^b) for a, b in zip(flag_chiffre, key)])
print(flag)
# CTFREI{x0r_1s_l1f3}
```
