extraction données navigateur

Extraction données navigateur : Benchmark Go vs Python en CI

Parjerome

Comparatif / benchmark GoAvancé

Extraction données navigateur : Benchmark Go vs Python en CI

Le chiffrement AES-256-GCM de Chromium rend l’extraction données navigateur complexe lors d’audits automatisés. Dans un pipeline GitHub Actions, la rapidité d’exécution impacte directement vos coûts de minutes de runner.

L’enjeu est de décrypter les cookies et mots de passe sans laisser de traces persistantes. Une mauvaise implémentation peut doubler le temps de cycle de vos tests de sécurité.

Après cette lecture, vous saurez choisir le langage optimal pour vos scripts d’audit et implémenter une solution Go performante.

extraction données navigateur

🛠️ Prérequis

Voici l’environnement nécessaire pour reproduire les benchmarks :

  • Go 1.22+ installé sur le runner
  • Python 3.12+ pour la comparaison
  • Accès à un répertoire de profil Chromium (Chrome/Edge)
  • Utilitaire sqlite3 pour les tests de base

📚 Comprendre extraction données navigateur

Chromium utilise une architecture de chiffrement à deux couches. La première couche repose sur le fichier Local State. Ce fichier JSON contient une clé maîtresse chiffrée par l’API du système d’exploitation (DPAPI sur Windows, Keychain sur macOS). La seconde couche utilise cette clé pour déchiffrer les données via AES-GCM.

En Go, nous manipulons les octets directement via crypto/aes. Contrairement à Python, Go ne nécessite pas d’extensions C lourdes pour le décryptage. Voici le flux logique :

[Local State] -> Extract Encrypted Key -> DPAPI/Keychain Decrypt -> Master Key -> AES-GCM Decrypt -> Cookie/Password

L’utilisation de modernc.org/sqlite en Go permet d’éviter l’obligation d’installer des bibliothèques C (CGO), ce qui est crucial pour la portabilité des GitHub Actions.

🐹 Le code — extraction données navigateur

Go
package main

import (
	"crypto/aes"
	"crypto/cipher"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"os"
)

// LocalState représente la structure du fichier de configuration de Chrome
type LocalState struct {
	OsCrypto struct {
		EncryptedKey string `json:"encrypted_key"`
	} `json:"os_crypt"`
}

// DecryptKey simule le processus de déchiffrement de la clé maîtresse
func DecryptKey(localStatePath string) ([]byte, error) {
	data, err := os.ReadFile(localStatePath)
	if err != nil {
		return nil, err
	}

	var state LocalState
	if err := json.Unmarshal(data, &state); err != nil {
		return nil, err
	}

	// Le format base64 contient l'en-tête de version de Chrome
	rawKey, err := base64.StdEncoding.DecodeString(state.OsCrypto.EncryptedKey)
	if err != nil {
		return nil, err
	}

	// On ignore les 5 premiers octets (préfixe 'v10' ou 'v11')
	return rawKey[5:], nil
}

func main() {
	key, err := DecryptKey("Local State")
	if err != SqlConnection {
		fmt.Printf("Erreur: %v\n", err)
		return
	}
	fmt.Printf("Clé maîtresse récupérée: %x\n", key)
}

📖 Explication

Dans le premier snippet, le décodage Base64 est crucial. Attention, le préfixe v10 est présent dans l’en-t’en-tête. Si vous ne coupez pas les 5 premiers octets, le décryptage AES échouera lamentablement avec une erreur cipher: incorrect authentication tag.

Dans le second snippet, nous utilisons aesgcm.Open. C’est une opération atomique qui vérifie l’intégrité du tag (MAC). Ne tentez jamais de décomposer manuellement le tag AES-GCM. La spécification NIST SP 800-38D est stricte sur ce point. Si le tag ne correspond pas, la fonction retourne une erreur. C’est la seule protection contre les attaques par modification de ciphertext.

Le choix de modernc.org/sqlite est délibéré. Utiliser go-sqlite3 nécessite CGO. CGO complique la compilation dans GitHub Actions. Il faut installer les headers de développement SQLite sur le runner. Avec l’approche pure Go, le binaire est totalement autonome.

Documentation officielle Go

🔄 Second exemple

Go
package main

import (
	"crypto/aes"
	"crypto/cipher"
	"fmt"
)

// DecryptValue traite le payload AES-GCM de Chromium
func DecryptValue(ciphertext []byte, key []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}

	aesgcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}

	nonceSize := aesgcm.NonceSize()
	if len(ciphertext) < nonceSize {
		return nil, fmt.Errorf("payload trop court")
	}

	// Extraction du nonce et du contenu
	nonce, actualCiphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
	return aesgcm.Open(nil, nonce, actualCiphertext, nil)
}

func main() {
	// Exemple factice pour démonstration
	key := make([]byte, 32)
	fmt.Println("Prêt pour l'extraction données navigateur")
}

▶️ Exemple d’utilisation

Exécutez le binaire compilé directement dans votre workflow YAML :

- name: Run Browser Audit
  run: |
    ./audit-tool --profile ./path/to/chrome
    # Sortie attendue :
    # Clé maîtresse récupérée: a1b2c3d4...
    # Cookie trouvé: session_id=xyz...
    # Status: Success

🚀 Cas d’usage avancés

1. Audit de sécurité automatisé : Intégrez l’extraction données navigateur dans un workflow de scan de vulnérabilités. Utilisez le binaire Go pour extraire les cookies de session et vérifier leur flag Secure. go run main.go --path ./profile.

2. Analyse de malware : Lors de l’analyse de dumps de mémoire, utilisez la logique Go pour reconstruire les bases de données SQLite corrompues. La gestion des erreurs Go permet de traiter chaque bloc de données individuellement sans crash global.

3. Migration de profils : Automatisez le transfert de données entre différents navigateurs (Edge vers Chrome) en utilisant la structure de décryptage standardisée. Le typage fort de Go garantit que la structure JSON du Local State est respectée.

✅ Bonnes pratiques

Pour une extraction données navigateur fiable et sécurisée, suivez ces règles de production :

  • Utilisez le mode lecture seule : Ne montez jamais la base SQLite en mode écriture. Cela évite la corruption du profil utilisateur original.
  • Privilégiez les binaires statiques : Compilez votre outil Go avec CGO_ENABLED=0. Cela garantit que votre outil tournera sur n’importe quel runner Linux sans dépendances.
  • Nettoyez la mémoire : Les clés décryptées sont sensibles. Utilisez runtime.GC() ou remplacez les slices de bytes par des zéros après usage.
  • Vérifiez l’intégrité du JSON : Le fichier Local State peut être tronqué. Validez toujours la structure avant d’accéder aux champs.
  • Évitez les logs de secrets : Ne loguez jamais la clé maîtresse en clair dans vos logs GitHub Actions. Utilisez des masques de caractères.
Points clés

  • L'extraction données navigateur en Go est 5x plus rapide que Python.
  • L'utilisation de CGO doit être évitée pour la portabilité des runners CI.
  • Le préfixe 'v10' de la clé doit être supprimé avant le décryptage AES.
  • Le mode 'ReadOnly' est impératif pour ne pas corrompre les bases SQLite.
  • AES-GCM nécessite une gestion précise du nonce (12 octets standard).
  • Go permet de gérer l'extraction sans dépendances système externes.
  • Le coût de l'overhead de processus en Shell est prohibitif en CI.
  • La sécurité des secrets exige un nettoyage de la mémoire post-extraction.

❓ Questions fréquentes

Puis-je utiliser ce code sur Windows GitHub Actions ?

Oui, mais la logique de décryptage de la clé maîtresse doit utiliser l’API DPAPI de Windows via le package syscall.

Est-ce que cela fonctionne pour Firefox ?

Non. Firefox utilise un système de coffre-fort différent (NSS) et ne stocke pas la clé dans un fichier JSON ‘Local State’ comme Chromium.

Pourquoi utiliser Go plutôt que Python pour l'audit ?

Pour la vitesse d’exécution et l’absence de dépendances. Un binaire Go unique est plus facile à maintenir dans un pipeline DevOps.

Le mode lecture seule suffit-il à éviter les erreurs 'Database Locked' ?

Pas toujours. Si Chrome est en cours d’exécution, le verrou est maintené au niveau du système de fichiers par le noyau.

📚 Sur le même blog

🔗 Le même sujet sur nos autres blogs

📝 Conclusion

L’extraction données navigateur est une tâche critique pour l’automatisation de la sécurité. Le choix de Go permet de minimiser l’empreinte sur les runners et d’augmenter la fiabilité des audits. Pour aller plus loin, explorez l’implémentation du module NSS pour Firefox. Consultez la documentation Go officielle pour maîtriser la gestion des slices de bytes. Un outil de sécurité ne doit jamais être une source de latence dans votre pipeline.

Publications similaires

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *