🔐 Messagerie Sécurisée Terminal - Chiffrement End-to-End

Auteur : [𝕹𝖎𝖓_𝕾𝖍𝖎𝖓𝖔𝖇𝖎🥷🏾] | GitHub : @Nin-Shinobi

• 🎯 Description
• ✨ Fonctionnalités
• 🔧 Installation
• 🚀 Utilisation
• 🏗️ Architecture
• 🔐 Sécurité
• 📊 Performances
• 🛠️ Configuration
• 🧪 Tests
• 📚 Documentation
• 🤝 Contribution
• 📄 Licence

MessagerCrypt est une application de messagerie sécurisée en ligne de commande qui offre une communication chiffrée de bout en bout. Conçue pour les utilisateurs soucieux de leur vie privée, elle combine une interface terminal moderne et responsive avec des protocoles de chiffrement militaires.

• 🔒 Chiffrement AES-256-GCM + RSA-4096
• 🎨 Interface terminal responsive et moderne
• ⚡ Performances optimisées avec lazy loading
• 🛡️ Sécurité renforcée avec validation des entrées
• 📱 Adaptation automatique à toutes les tailles de terminal
• 🗄️ Base de données SQLite chiffrée
• 🔐 Authentification par mot de passe sécurisé

• Chiffrement hybride : AES-256-GCM pour les messages + RSA-4096 pour les clés
• Hachage des mots de passe avec Argon2id
• Signatures numériques pour l'authentification
• Protection anti-replay avec nonces et timestamps
• Base de données chiffrée avec SQLite

• ASCII Art animé avec logo MessagerCrypt
• Menus interactifs avec Rich et Colorama
• Interface responsive qui s'adapte à toutes les tailles de terminal
• Animations de chargement et notifications visuelles
• Thème cyberpunk avec couleurs personnalisables

• Envoi de messages chiffrés en temps réel
• Réception instantanée avec notifications
• Historique des messages avec recherche
• Messages multilignes avec gestion des retours à la ligne
• Statut de lecture des messages

• Lazy loading des modules pour un démarrage rapide
• Cache intelligent des clés et validations
• Pool de connexions pour la base de données
• Compression des messages avec gzip
• Requêtes préparées pour optimiser les performances

• Python 3.8+ installé sur votre système
• pip (gestionnaire de paquets Python)
• Terminal compatible (Windows, macOS, Linux)

# 1. Cloner le repository
git clone https://github.com/Nin-Shinobi/MessagerCrypt.git
cd MessagerCrypt

# 2. Installer les dépendances
pip install -r requirements.txt

# 3. Lancer l'application
python src/main.py

# Vérifier Python
python --version

# Installer les dépendances
pip install colorama cryptography argon2-cffi click rich pytest psutil

# Lancer l'application
python src/main.py

# Vérifier Python
python3 --version

# Installer les dépendances
pip3 install -r requirements.txt

# Rendre exécutable (optionnel)
chmod +x src/main.py

# Lancer l'application
python3 src/main.py

python src/main.py

L'application affichera :

1. Animation de démarrage avec logo MessagerCrypt
2. Menu principal avec options disponibles
3. Interface responsive adaptée à votre terminal

╔══════════════════════════════════════════════════════════════════════════════╗
║                                                                              ║
                     MESSAGERCRYPT v1.0 — Sécurisé                            
║                                                                              ║
╚══════════════════════════════════════════════════════════════════════════════╝

[1] 🖥️  Démarrer le serveur
[2] 👤  S'inscrire
[3] 🔐  Se connecter
[4] 💬  Consulter l'historique
[5] ⚙️  Configuration
[6] 🚪  Quitter

1. Démarrer le serveur (Option 1)
2. Configurer l'adresse et le port
3. Démarrer l'écoute des connexions
4. Gérer les clients connectés

1. Démarrer le serveur :

   python src/main.py

2. Choisir : "Démarrer le serveur"
3. Le serveur écoute sur : 0.0.0.0:8888 (toutes les interfaces)

1. Démarrer l'application :

   python src/main.py

2. Choisir : "Se connecter"
3. Remplir le formulaire de connexion :
   • Adresse IP du serveur : IP_DU_PC_SERVEUR (ex: 192.168.1.100)
   • Port du serveur : 8888 (ou Entrée pour utiliser 8888)
   • Nom d'utilisateur : Votre nom d'utilisateur
   • Mot de passe : Votre mot de passe

Option 1 - Automatique (Windows) :

# Exécuter en tant qu'administrateur
python configure_firewall.py

Option 2 - Manuelle :

1. Panneau de configuration > Pare-feu Windows Defender
2. Paramètres avancés > Règles de trafic entrant
3. Nouvelle règle > Port > TCP > 8888
4. Autoriser la connexion > Tous les profils
5. Nom : "MessagerCrypt"

• ✅ Les deux PC sont sur le même réseau
• ✅ Le firewall autorise le port 8888
• ✅ Les routeurs permettent la communication
• ✅ Le serveur écoute sur 0.0.0.0:8888

1. Sélectionner "S'inscrire" (Option 2)
2. Saisir le nom d'utilisateur (3-20 caractères)
3. Choisir un mot de passe sécurisé
4. Confirmer l'inscription

1. Sélectionner "Se connecter" (Option 3)
2. Remplir le formulaire de connexion :

   ╔══════════════════════════════════════════════════════════════════════════════╗
                              🔐 CONNEXION                            
   ╚══════════════════════════════════════════════════════════════════════════════╝
   
   Configuration du serveur:
   
   Adresse IP du serveur (Entrée pour localhost): [IP_DU_SERVEUR]
   Port du serveur (Entrée pour 8888): [8888]
   
   Identifiants:
   
   Nom d'utilisateur: [VOTRE_NOM_UTILISATEUR]
   Mot de passe: [VOTRE_MOT_DE_PASSE]
   

3. Accéder à l'interface de messagerie

• IP par défaut : 127.0.0.1 (localhost) si vous appuyez sur Entrée
• Port par défaut : 8888 si vous appuyez sur Entrée
• Pour connexion locale : Laissez les valeurs par défaut
• Pour connexion réseau : Saisissez l'IP du PC serveur

╔══════════════════════════════════════════════════════════════════════════════╗
                         💬 MESSAGERIE - USERNAME                            
╚══════════════════════════════════════════════════════════════════════════════╝

[1] 📤 Envoyer un message
[2] 📥 Messages reçus
[3] 📜 Historique
[4] 🔍 Rechercher
[5] ⚙️  Paramètres
[6] 🔙 Déconnexion

1. Sélectionner "Envoyer un message" (Option 1)
2. Saisir le destinataire
3. Composer le message (multiligne)
4. Appuyer sur Entrée pour nouvelle ligne
5. Double Entrée pour envoyer

• Notifications instantanées lors de la réception
• Affichage automatique des nouveaux messages
• Sauvegarde automatique dans l'historique

Solutions :

1. Vérifier l'IP du serveur :

   # Sur le PC serveur, récupérer l'IP
   ipconfig  # Windows
   ifconfig  # Linux/Mac

2. Tester la connectivité :

   # Sur le PC client
   ping IP_DU_SERVEUR
   telnet IP_DU_SERVEUR 8888

3. Vérifier le firewall :

   • Exécuter python configure_firewall.py en tant qu'administrateur
   • Ou configurer manuellement le port 8888

4. Vérifier la configuration réseau :

   • Les deux PC doivent être sur le même réseau
   • Vérifier les paramètres du routeur/switch

Solutions :

1. Vérifier que le port n'est pas utilisé :

   netstat -an | findstr 8888  # Windows
   netstat -tulpn | grep 8888  # Linux

2. Changer le port si nécessaire :

   • Modifier DEFAULT_PORT dans config/settings.py

3. Vérifier les permissions :

   • Exécuter en tant qu'administrateur si nécessaire

Solutions :

1. Vérifier l'authentification :

   • S'assurer que les deux utilisateurs sont connectés
   • Vérifier les identifiants

2. Vérifier les logs :

   • Consulter logs/server.log et logs/client.log

3. Redémarrer les connexions :

   • Déconnecter et reconnecter les clients

MessagerCrypt/
├── 📁 config/
│   └── settings.py          # Configuration globale
├── 📁 src/
│   ├── main.py              # Point d'entrée principal
│   ├── server.py            # Serveur TCP sécurisé
│   ├── client.py            # Client de messagerie
│   ├── 📁 crypto/
│   │   ├── encryption.py     # Gestionnaire de chiffrement
│   │   ├── auth.py          # Authentification
│   │   └── keys.py          # Gestion des clés
│   ├── 📁 storage/
│   │   ├── database.py      # Base de données chiffrée
│   │   └── messages.py      # Gestion des messages
│   ├── 📁 ui/
│   │   ├── ascii.py         # ASCII art et animations
│   │   └── menu.py          # Interface utilisateur
│   └── 📁 utils/
│       └── helpers.py       # Utilitaires
├── 📁 data/
│   ├── messagercrypt.db     # Base de données
│   └── user_keys.json       # Clés utilisateurs
├── 📁 logs/
│   ├── client.log           # Logs client
│   └── server.log           # Logs serveur
├── 📁 tests/
│   ├── test_crypto.py       # Tests chiffrement
│   ├── test_database.py     # Tests base de données
│   ├── test_network.py      # Tests réseau
│   └── test_integration.py  # Tests d'intégration
├── requirements.txt         # Dépendances
├── README.md               # Documentation
└── LICENSE                 # Licence MIT

graph TD
    A[Client] --> B[Chiffrement AES-256]
    B --> C[Signature RSA-4096]
    C --> D[Envoi TCP]
    D --> E[Serveur]
    E --> F[Vérification Signature]
    F --> G[Déchiffrement AES-256]
    G --> H[Base de Données]
    H --> I[Notification Client]

• EncryptionManager : Chiffrement AES-GCM et RSA
• AuthManager : Authentification et signatures
• KeyManager : Génération et gestion des clés

• EncryptedDatabase : Base de données SQLite chiffrée
• MessageManager : Gestion des messages et cache

• ASCIIArt : Animations et logo
• MenuManager : Interface utilisateur responsive

• Algorithme : AES-256-GCM
• Mode : Galois/Counter Mode (authentification intégrée)
• Clé : 256 bits générée aléatoirement
• Nonce : 96 bits unique par message

• Algorithme : RSA-4096
• Taille : 4096 bits
• Usage : Chiffrement des clés de session AES
• Rotation : Clés régénérées périodiquement

• Hachage : Argon2id
• Sel : 32 bytes aléatoire
• Itérations : 100,000
• Mémoire : 64 MB

• Chiffrement : AES-256 en mode CBC
• Clé : Dérivée du mot de passe maître
• Intégrité : HMAC-SHA256
• Sauvegarde : Chiffrée automatiquement

• Protocole : TCP sécurisé
• Authentification : Certificats RSA
• Protection : Anti-replay avec timestamps
• Validation : Signatures numériques

• ✅ Validation des entrées utilisateur
• ✅ Protection contre les injections SQL
• ✅ Gestion sécurisée des mots de passe
• ✅ Nettoyage automatique des données sensibles
• ✅ Logs sécurisés sans informations sensibles

• Lazy Loading : Modules chargés à la demande
• Cache intelligent : Mise en cache des validations
• Pool de connexions : Réutilisation des connexions DB
• Requêtes préparées : Optimisation des requêtes SQL

• Cache limité : Taille maximale configurable
• Nettoyage automatique : Libération mémoire
• Compression : Messages compressés avec gzip
• Pool de ressources : Réutilisation des objets

# config/settings.py
PERFORMANCE_CONFIG = {
    "cache_size": 1000,           # Taille du cache
    "max_connections": 10,         # Connexions max
    "compression_enabled": True,   # Compression messages
    "lazy_loading": True,         # Chargement différé
    "query_timeout": 30           # Timeout requêtes
}

# config/settings.py
DEBUG = False                    # Mode debug
DEFAULT_HOST = "localhost"       # Adresse par défaut
DEFAULT_PORT = 8888              # Port par défaut
MAX_CONNECTIONS = 50             # Connexions simultanées
BUFFER_SIZE = 4096               # Taille du buffer

# Base de données
DATABASE_PATH = "data/messagercrypt.db"
DATABASE_KEY = "your-secret-key"

# Sécurité
SALT_SIZE = 32
AES_KEY_SIZE = 32
RSA_KEY_SIZE = 4096

# Personnaliser les couleurs
COLORS = {
    'primary': '\033[91m',      # Rouge principal
    'secondary': '\033[94m',    # Bleu secondaire
    'success': '\033[92m',      # Vert succès
    'warning': '\033[93m',      # Jaune avertissement
    'error': '\033[91m'         # Rouge erreur
}

# Configuration responsive
RESPONSIVE_CONFIG = {
    "min_width": 60,            # Largeur minimale
    "max_width": 120,           # Largeur maximale
    "optimal_width": 80,        # Largeur optimale
    "spacing_small": 1,         # Espacement petit terminal
    "spacing_normal": 3         # Espacement normal
}

# Tests unitaires
python -m pytest tests/

# Tests avec couverture
python -m pytest --cov=src tests/

# Tests spécifiques
python -m pytest tests/test_crypto.py -v

• Chiffrement/Déchiffrement : Vérification des algorithmes
• Authentification : Validation des tokens
• Validation : Tests des entrées utilisateur
• Gestion des clés : Rotation et stockage

• Opérations CRUD : Création, lecture, mise à jour, suppression
• Intégrité : Vérification des contraintes
• Performance : Tests de charge
• Sauvegarde : Récupération des données

• Connexions : Tests de connectivité
• Messages : Envoi/réception
• Concurrence : Clients multiples
• Résilience : Gestion des erreurs

Name                     Stmts   Miss  Cover   Missing
-----------------------------------------------------
src/crypto/encryption.py    45      2    96%   23, 45
src/crypto/auth.py          38      1    97%   42
src/crypto/keys.py          52      3    94%   15, 28, 41
src/storage/database.py     89      4    96%   67, 78, 89, 102
src/storage/messages.py     67      2    97%   34, 67
src/ui/menu.py             124      5    96%   23, 45, 67, 89, 102
src/ui/ascii.py             78      3    96%   23, 45, 67
src/main.py                 45      2    96%   23, 45
-----------------------------------------------------
TOTAL                      538     22    96%

from src.crypto.encryption import EncryptionManager

# Initialisation
encryption = EncryptionManager()

# Chiffrement AES
encrypted_data = encryption.encrypt_with_aes(data, key, nonce)

# Chiffrement RSA
encrypted_key = encryption.encrypt_with_rsa(key, public_key)

from src.storage.database import EncryptedDatabase

# Initialisation
db = EncryptedDatabase()

# Sauvegarde d'un message
success = db.save_message(sender, recipient, message, hash)

# Récupération des messages
messages = db.get_user_messages(username, limit=50)

from src.ui.menu import MenuManager

# Initialisation
menu = MenuManager()

# Affichage du menu principal
choice = menu.show_main_menu()

# Affichage responsive
width = menu.get_responsive_width()

# Client
client = MessagerCryptClient()
client.connect("localhost", 8888)
client.login("username", "password")

# Envoi de message
success = client.send_message("recipient", "Hello World!")

# Serveur
server = MessagerCryptServer("localhost", 8888)
server.start()

# Gestion des connexions
while server.running:
    server.handle_connections()

1. Fork le repository
2. Créer une branche pour votre fonctionnalité
3. Commiter vos changements
4. Pousser vers la branche
5. Ouvrir une Pull Request

• PEP 8 : Respect des conventions Python
• Docstrings : Documentation des fonctions
• Type Hints : Annotations de types
• Tests : Couverture de code > 90%

• Validation : Toutes les entrées utilisateur
• Chiffrement : Données sensibles uniquement
• Logs : Aucune information sensible
• Tests : Validation des protocoles de sécurité

• Responsive : Adaptation à tous les terminaux
• Accessibilité : Support des lecteurs d'écran
• Couleurs : Thème cohérent
• Animations : Fluides et non intrusives

Utilisez le template d'issue avec :

• Description détaillée du problème
• Étapes pour reproduire
• Environnement (OS, Python, etc.)
• Logs d'erreur si disponibles

Utilisez le template de feature request avec :

• Description de la fonctionnalité
• Cas d'usage concrets
• Mockups ou exemples si applicable
• Impact sur la sécurité

Ce projet est sous licence MIT. Voir le fichier LICENSE pour plus de détails.

MIT License

Copyright (c) 2024 [𝕹𝖎𝖓_𝕾𝖍𝖎𝖓𝖔𝖇𝖎🥷🏾]

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

• Cryptography.io pour les primitives de chiffrement
• Rich pour l'interface terminal moderne
• SQLite pour la base de données légère
• Python pour l'écosystème robuste

• Signal pour les protocoles de sécurité
• Telegram pour l'interface utilisateur
• Matrix pour l'architecture décentralisée
• Terminal pour l'esthétique rétro