Codage Base64 et Obfuscation

L'examen du code source révèle que la flag est cachée et peut être obtenue par un simple décodage Base64.

Injection par Entête HTTP

L'analyse du code source mène à un identifiant et un mot de passe. L'utilisation d'un navigateur spécifique, tel que 'ctf-show-brower', est requise. En modifiant l'en-tête User-Agent pour simuler ce navigateur, la flag est révélée.

Décodage Base64 Imbricé

En examinant la logique de validation du mot de passe dans le code source, on constate un processus de transformation en plusieurs étapes avant la comparaison finale avec une valeur de référence.

const motDePasseCorrect = "SXpVRlF4TTFVelJtdFNSazB3VTJ4U1UwNXFSWGRVVlZrOWNWYzU=";

function validerMotDePasse(entree) {
   let encode = btoa(entree);
   encode = btoa(encode + 'xH7jK').slice(3);
   encode = btoa(encode.split('').reverse().join(''));
   encode = btoa('aB3' + encode + 'qW9').substr(2);
   return btoa(encode) === motDePasseCorrect;
}
 

Le processus implique les étapes suivantes :

1. Encodage Base64 de l'entrée utilisateur.
2. Concaténation avec 'xH7jK', nouvel encodage Base64, puis troncature à partir du 4ème caractère.
3. Inversion de la chaîne résultante, suivie d'un encodage Base64.
4. Préfixage avec 'aB3', suffixage avec 'qW9', encoadge Base64, puis troncature à partir du 3ème caractère.
5. Encodage Base64 final pour la comparaison avec motDePasseCorrect.

Pour retrouver le mot de passe, il faut inverser ces étapes :

1. Décodage Base64 de motDePasseCorrect pour obtenir une partie de la chaîne intermédiaire.
2. L'étape 4, impliquant l'ajout de 'aB3' et 'qW9' et une troncature, nécessite un décodage parteil et une reconstruction pour isoler la chaîne avant cette transformation.
3. L'inversion de l'étape 3 (inversion et décodage Base64).
4. Un script est nécessaire pour tester les combinaisons possibles afin de trouver l'entrée originale qui satisfait la chaîne intermédiaire après toutes les transformations.

Un script Python peut être utilisé pour tenter de retrouver l'entrée originale en considérant les permutations possibles.

import string
import base64
import itertools

# Chaîne obtenue après une partie de l'inversion
chaine_inversee_partielle = "FM016RTJ4SDdqSw=="
caracteres_possibles = string.digits + string.ascii_letters
permutations = itertools.permutations(caracteres_possibles, r=3)
elements_potentiels = ["".join(p) for p in permutations]

for element in elements_potentiels:
   temp = element + chaine_inversee_partielle
   try:
       # Tentative de décodage inverse pour vérifier la validité
       partie_decodee = base64.b64decode(base64.b64decode(temp))
       if partie_decodee.endswith(b'qW9') and len(partie_decodee) > 5:
            # Logique pour aller plus loin dans l'inversion
            pass # Il faudrait implémenter la logique complète d'inversion ici
   except Exception:
       pass
 

Après avoir identifié une entrée valide, le système demande à nouveau la modification de l'en-tête User-Agent pour obtenir la flag.

Attaque de l'Homme du Milieu sur HTTPS

Les paquets de trafic chiffrés par le protocole SSL peuvent être déchiffrés en important le fichier sslkey.log, ce qui permet de visualiser la flag.

Falsification de Cookie

L'accès initial est possible avec le compte 'guest'. Après avoir découvert que le mot de passe est également 'guest', une connexion réussie est établie. L'analyse des requêtes et réponses HTTP révèle un paramètre clé dans la réponse : role=guest. Pour obtenir les privilèges d'administrateur, il suffit de modifier le cookie dans la requête sortante pour inclure role=admin.