⚠️ Avertissement important : Ce script est destiné exclusivement à la récupération de votre propre portefeuille Cove Wallet. Toute utilisation non autorisée sur un portefeuille appartenant à autrui est illégale et passible de poursuites judiciaires.

Introduction

Cove Wallet est un portefeuille de cryptomonnaies non dépositaire (non-custodial) qui permet aux utilisateurs de garder le contrôle total de leurs clés privées. Si vous avez oublié votre mot de passe et que vous ne disposez pas de votre phrase de récupération (seed phrase), un script de récupération par attaque par dictionnaire peut vous aider à retrouver l'accès à vos fonds, à condition que le mot de passe soit présent dans votre dictionnaire. Ce tutoriel vous explique comment développer un tel script en Python, en s'appuyant sur les mécanismes de chiffrement de Cove Wallet.

Prérequis techniques

Avant de commencer, assurez-vous de disposer des éléments suivants :

  • Connaissances de base en programmation Python
  • Connaissances élémentaires en cryptographie symétrique
  • Un fichier de portefeuille Cove Wallet valide, auquel vous avez le droit d'accéder légalement
  • Un fichier de dictionnaire de mots de passe (format .txt, un mot de passe par ligne)
  • Python 3.8 ou version supérieure installé sur votre machine
  • La bibliothèque pycryptodome pour les opérations cryptographiques

Étape 1 : Analyse du format de stockage de Cove Wallet

Par défaut, Cove Wallet stocke les fichiers de portefeuille dans les répertoires suivants selon votre système d'exploitation :

  • Windows : %APPDATA%\CoveWallet\wallets\
  • macOS : ~/Library/Application Support/CoveWallet/wallets/
  • Linux : ~/.config/CoveWallet/wallets/

Les fichiers de portefeuille sont au format JSON et contiennent les champs de chiffrement suivants :

  • salt : Sel aléatoire utilisé pour la dérivation de la clé
  • iv : Vecteur d'initialisation pour le chiffrement AES
  • ciphertext : Données du portefeuille chiffrées (y compris la clé privée)
  • tag : Balise d'authentification pour le mode GCM
  • iterations : Nombre d'itérations pour la dérivation de clé PBKDF2 (200 000 par défaut selon la documentation officielle)

Étape 2 : Préparation de l'environnement de développement

Commencez par installer la bibliothèque pycryptodome nécessaire aux opérations de chiffrement et de déchiffrement :

pip install pycryptodome

Créez ensuite un dossier de projet, par exemple cove-wallet-recovery, et un fichier de script nommé recovery.py.

Étape 3 : Écriture de la fonction de dérivation de clé

Cove Wallet utilise l'algorithme PBKDF2-HMAC-SHA256 pour dériver une clé de chiffrement de 32 octets à partir du mot de passe utilisateur et du sel stocké dans le fichier de portefeuille. Ajoutez la fonction suivante à votre script :


![récupération de mot de passe](/media/upload/13/ca619b60723c32db0ad932995dce96ce_800_600.jpg)

from Crypto.Protocol.KDF import PBKDF2
from Crypto.Hash import SHA256
from Crypto.Cipher import AES
import json
import os

def derive_key(password: str, salt: bytes, iterations: int = 200000) -> bytes:
    """
    Dérive une clé de chiffrement de 32 octets à partir du mot de passe et du sel
    en utilisant l'algorithme PBKDF2-HMAC-SHA256.
    """
    return PBKDF2(
        password.encode('utf-8'),
        salt,
        dkLen=32,
        count=iterations,
        hmac_hash_module=SHA256
    )

Étape 4 : Implémentation de la fonction de déchiffrement

La fonction suivante tente de déchiffrer le fichier de portefeuille avec un mot de passe fourni, et renvoie les données déchiffrées si le mot de passe est valide, ou None sinon :

def decrypt_wallet(wallet_path: str, password: str) -> dict | None:
    """Tente de déchiffrer le portefeuille Cove Wallet avec le mot de passe fourni."""
    try:
        # Chargement des données chiffrées du portefeuille
        with open(wallet_path, 'r', encoding='utf-8') as f:
            encrypted_data = json.load(f)
        
        # Extraction des paramètres de chiffrement
        salt = bytes.fromhex(encrypted_data['salt'])
        iv = bytes.fromhex(encrypted_data['iv'])
        ciphertext = bytes.fromhex(encrypted_data['ciphertext'])
        tag = bytes.fromhex(encrypted_data['tag'])
        iterations = encrypted_data.get('iterations', 200000)
        

![récupération de mot de passe](/media/upload/13/377c9d83b832f7cd9d37d3458ca0dcb5_800_600.jpg)

        # Dérivation de la clé et déchiffrement
        key = derive_key(password, salt, iterations)
        cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
        decrypted_bytes = cipher.decrypt_and_verify(ciphertext, tag)
        
        # Conversion des données déchiffrées en dictionnaire JSON
        return json.loads(decrypted_bytes.decode('utf-8'))
    except (ValueError, KeyError, json.JSONDecodeError, UnicodeDecodeError):
        # Le mot de passe est incorrect ou le fichier est invalide
        return None

Étape 5 : Ajout de la fonction d'attaque par dictionnaire

L'attaque par force brute étant irréaliste pour des mots de passe complexes, nous utilisons une attaque par dictionnaire : le script teste chaque mot de passe du fichier de dictionnaire jusqu'à trouver le bon. Ajoutez la fonction suivante :

def dictionary_attack(wallet_path: str, dict_path: str) -> str | None:
    """
    Effectue une attaque par dictionnaire sur le portefeuille Cove Wallet.
    Renvoie le mot de passe si trouvé, sinon None.
    """
    if not os.path.exists(wallet_path):
        raise FileNotFoundError(f'Le fichier de portefeuille {wallet_path} n\'existe pas.')
    if not os.path.exists(dict_path):
        raise FileNotFoundError(f'Le fichier de dictionnaire {dict_path} n\'existe pas.')
    
    with open(dict_path, 'r', encoding='utf-8', errors='ignore') as f:
        tested_count = 0
        for line in f:
            password = line.strip()
            if not password:
                continue
            tested_count += 1
            # Affichage du progrès toutes les 100 tentatives
            if tested_count % 100 == 0:
                print(f'Tentatives effectuées : {tested_count}')
            
            result = decrypt_wallet(wallet_path, password)

![récupération de mot de passe](/media/upload/13/1ab703704dff96fad862ced312122550_800_600.jpg)

            if result is not None:
                print(f'\nMot de passe trouvé après {tested_count} tentatives : {password}')
                return password
    
    print(f'\nAucun mot de passe correspondant trouvé après {tested_count} tentatives.')
    return None

Étape 6 : Test du script complet

Ajoutez le bloc d'exécution principal à la fin de votre script, en adaptant les chemins des fichiers :

if __name__ == '__main__':
    # Chemin vers votre fichier de portefeuille Cove Wallet
    CHEMIN_PORTEFEUILLE = 'chemin/vers/votre/portefeuille.cove.json'
    # Chemin vers votre fichier de dictionnaire de mots de passe
    CHEMIN_DICTIONNAIRE = 'chemin/vers/votre/dictionnaire.txt'
    
    try:
        mot_de_passe_trouve = dictionary_attack(CHEMIN_PORTEFEUILLE, CHEMIN_DICTIONNAIRE)
        if mot_de_passe_trouve:
            print(f'\n✅ Récupération réussie ! Votre mot de passe est : {mot_de_passe_trouve}')
            print('💡 Pensez à sauvegarder votre phrase de récupération pour éviter ce problème à l\'avenir.')
        else:
            print('\n❌ Récupération échouée. Essayez un dictionnaire plus complet ou vériez le fichier de portefeuille.')
    except FileNotFoundError as e:
        print(f'Erreur : {e}')

Avertissements éthiques et légaux

Il est essentiel de respecter les règles suivantes lors de l'utilisation de ce type d'outil :

  1. Ce script ne doit être utilisé que sur des portefeuilles dont vous êtes le propriétaire légal.
  2. Toute tentative d'accès non autorisé à un portefeuille appartenant à autrui constitue un délit de piratage informatique, passible de peines de prison et d'amendes importantes.
  3. L'efficacité de l'attaque par dictionnaire dépend entièrement de la qualité du dictionnaire et de la complexité du mot de passe : un mot de passe long et aléatoire ne pourra pas être retrouvé par cette méthode.
  4. Nous vous recommandons vivement de sauvegarder votre phrase de récupération (seed phrase) dans un endroit sûr, c'est la méthode la plus fiable pour récupérer l'accès à votre portefeuille.

Conclusion

Dans ce tutoriel, vous avez appris à développer un script Python de récupération de mot de passe pour Cove Wallet, basé sur une attaque par dictionnaire et les mécanismes de chiffrement AES-256-GCM et PBKDF2. N'oubliez pas de n'utiliser cet outil que dans un cadre légal et éthique, et de toujours sauvegarder votre phrase de récupération pour éviter toute perte d'accès à vos fonds.