Exemples de chiffrement de mots clés et mise en oeuvre du code

Exemples de chiffrement de mots clés: Guide de programmation complet avec code

Ce guide complet fournit des exemples pratiques et complète la mise en œuvre de la programmation du chiffre-clé. Qu'il s'agisse d'apprendre la cryptographie, de mettre en œuvre des algorithmes de chiffrement ou d'étudier des méthodes de chiffrement historiques, ces exemples offrent une expérience pratique avec des chiffrements de substitution monoalphabétiques.

Exemples fondamentaux

Transformation simple des mots clés

Commençons par un exemple simple en utilisant le mot-clé "ZEBRA":

Mot-clé: ZEBRA ** Alphabet standard**: ABCDEFGHIJKLMNOPQRSTUVWXYZ ** Alphabet numérique**: ZEBRACKDFGHIJLMNOPQSTUVWXY

Processus de chiffrement:

• Plaintext: HELLO WORLD
• Cartographie: H→G, E→J, L→K, L→K, O→F
• Ciphertext: GJKKF VFEKX

** Transformation étape par étape**:

1. Supprimer les duplicata du mot clé: ZEBRA (pas de duplicata)
2. Ajouter les lettres restantes: ZEBRACKDFGHIJLMNOPQSTUVWXY
3. Carter chaque lettre en texte en clair à la lettre de chiffre correspondante
4. Préserver les espaces et la ponctuation

Exemple diplomatique historique

Mot-clé: MONARCHY Contexte: Chiffre diplomatique européen du XVIIe siècle Plaintext: THE TREATY IS SIGNED Ciphertext: TDO THIPTS YA AYGFOH

Cet exemple montre comment les communications diplomatiques ont été cryptées pendant l'ère des Lumières, où les chiffres à mots clés ont fourni une sécurité suffisante pour la correspondance politique.

Mise en œuvre de la programmation

Mise en œuvre de Python

Voici une classe complète de Python pour les opérations de chiffrement de mots clés:

class KeywordCipher:
    def __init__(self, keyword):
        """Initialize the cipher with a keyword."""
        self.keyword = keyword.upper()
        self.standard_alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        self.cipher_alphabet = self._generate_cipher_alphabet()
        self.encrypt_map = self._create_encrypt_map()
        self.decrypt_map = self._create_decrypt_map()
    
    def _generate_cipher_alphabet(self):
        """Generate cipher alphabet from keyword."""
        # Remove duplicates while preserving order
        seen = set()
        clean_keyword = ''.join(char for char in self.keyword 
                               if char.isalpha() and char not in seen 
                               and not seen.add(char))
        
        # Add remaining letters
        remaining = ''.join(char for char in self.standard_alphabet 
                          if char not in clean_keyword)
        
        return clean_keyword + remaining
    
    def _create_encrypt_map(self):
        """Create encryption mapping dictionary."""
        mapping = {}
        for i, char in enumerate(self.standard_alphabet):
            mapping[char] = self.cipher_alphabet[i]
            mapping[char.lower()] = self.cipher_alphabet[i].lower()
        return mapping
    
    def _create_decrypt_map(self):
        """Create decryption mapping dictionary."""
        mapping = {}
        for i, char in enumerate(self.cipher_alphabet):
            mapping[char] = self.standard_alphabet[i]
            mapping[char.lower()] = self.standard_alphabet[i].lower()
        return mapping
    
    def encrypt(self, plaintext):
        """Encrypt plaintext using the keyword cipher."""
        return ''.join(self.encrypt_map.get(char, char) for char in plaintext)
    
    def decrypt(self, ciphertext):
        """Decrypt ciphertext using the keyword cipher."""
        return ''.join(self.decrypt_map.get(char, char) for char in ciphertext)
    
    def get_alphabet_mapping(self):
        """Return the alphabet mapping for analysis."""
        return {
            'standard': self.standard_alphabet,
            'cipher': self.cipher_alphabet,
            'keyword': self.keyword
        }

# Example usage
def main():
    # Create cipher instance
    cipher = KeywordCipher('CRYPTOGRAPHY')
    
    # Test messages
    messages = [
        "Hello World",
        "The quick brown fox jumps over the lazy dog",
        "ATTACK AT DAWN"
    ]
    
    print(f"Keyword: {cipher.keyword}")
    print(f"Cipher Alphabet: {cipher.cipher_alphabet}")
    print("-" * 50)
    
    for message in messages:
        encrypted = cipher.encrypt(message)
        decrypted = cipher.decrypt(encrypted)
        
        print(f"Original:  {message}")
        print(f"Encrypted: {encrypted}")
        print(f"Decrypted: {decrypted}")
        print(f"Match: {message == decrypted}")
        print("-" * 30)

if __name__ == "__main__":
    main()

Mise en œuvre JavaScript

Version JavaScript compatible navigateur avec l'intégration DOM:

class KeywordCipher {
    constructor(keyword) {
        this.keyword = keyword.toUpperCase();
        this.standardAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
        this.cipherAlphabet = this.generateCipherAlphabet();
        this.encryptMap = this.createEncryptMap();
        this.decryptMap = this.createDecryptMap();
    }
    
    generateCipherAlphabet() {
        // Remove duplicates from keyword
        const uniqueKeyword = [...new Set(this.keyword.split(''))]
            .filter(char => /[A-Z]/.test(char))
            .join('');
        
        // Generate remaining letters
        const remaining = this.standardAlphabet
            .split('')
            .filter(char => !uniqueKeyword.includes(char))
            .join('');
        
        return uniqueKeyword + remaining;
    }
    
    createEncryptMap() {
        const map = new Map();
        for (let i = 0; i < this.standardAlphabet.length; i++) {
            const std = this.standardAlphabet[i];
            const cipher = this.cipherAlphabet[i];
            map.set(std, cipher);
            map.set(std.toLowerCase(), cipher.toLowerCase());
        }
        return map;
    }
    
    createDecryptMap() {
        const map = new Map();
        for (let i = 0; i < this.standardAlphabet.length; i++) {
            const std = this.standardAlphabet[i];
            const cipher = this.cipherAlphabet[i];
            map.set(cipher, std);
            map.set(cipher.toLowerCase(), std.toLowerCase());
        }
        return map;
    }
    
    encrypt(plaintext) {
        return plaintext
            .split('')
            .map(char => this.encryptMap.get(char) || char)
            .join('');
    }
    
    decrypt(ciphertext) {
        return ciphertext
            .split('')
            .map(char => this.decryptMap.get(char) || char)
            .join('');
    }
    
    // Utility methods for web integration
    static createFromForm() {
        const keyword = document.getElementById('keyword').value;
        return new KeywordCipher(keyword);
    }
    
    encryptFromDOM() {
        const plaintext = document.getElementById('plaintext').value;
        const result = this.encrypt(plaintext);
        document.getElementById('ciphertext').value = result;
        return result;
    }
    
    decryptFromDOM() {
        const ciphertext = document.getElementById('ciphertext').value;
        const result = this.decrypt(ciphertext);
        document.getElementById('plaintext').value = result;
        return result;
    }
}

// Web interface integration
document.addEventListener('DOMContentLoaded', function() {
    let cipher = null;
    
    // Initialize cipher when keyword changes
    document.getElementById('keyword').addEventListener('input', function() {
        const keyword = this.value;
        if (keyword) {
            cipher = new KeywordCipher(keyword);
            updateAlphabetDisplay();
        }
    });
    
    // Encrypt button handler
    document.getElementById('encryptBtn').addEventListener('click', function() {
        if (cipher) {
            cipher.encryptFromDOM();
        }
    });
    
    // Decrypt button handler
    document.getElementById('decryptBtn').addEventListener('click', function() {
        if (cipher) {
            cipher.decryptFromDOM();
        }
    });
    
    function updateAlphabetDisplay() {
        if (cipher) {
            document.getElementById('standardAlphabet').textContent = 
                cipher.standardAlphabet;
            document.getElementById('cipherAlphabet').textContent = 
                cipher.cipherAlphabet;
        }
    }
});

Exemples avancés

Algorithme de test de résistance

def analyze_keyword_strength(keyword):
    """Analyze the cryptographic strength of a keyword."""
    analysis = {
        'length': len(keyword),
        'unique_letters': len(set(keyword.upper())),
        'duplicates': [],
        'strength': 'weak'
    }
    
    # Find duplicate letters
    seen = set()
    for char in keyword.upper():
        if char in seen:
            analysis['duplicates'].append(char)
        seen.add(char)
    
    # Determine strength
    if analysis['length'] >= 8 and len(analysis['duplicates']) == 0:
        analysis['strength'] = 'strong'
    elif analysis['length'] >= 6 and len(analysis['duplicates']) <= 1:
        analysis['strength'] = 'medium'
    
    return analysis

# Usage example
keywords = ['SECRET', 'CRYPTOGRAPHY', 'ZEBRA', 'SUPERCALIFRAGILISTICEXPIALIDOCIOUS']
for keyword in keywords:
    strength = analyze_keyword_strength(keyword)
    print(f"{keyword}: {strength['strength']} "
          f"(Length: {strength['length']}, "
          f"Duplicates: {len(strength['duplicates'])})")

Outil d'analyse de fréquence

def frequency_analysis(text):
    """Perform frequency analysis on text."""
    from collections import Counter
    import string
    
    # Clean text (letters only)
    clean_text = ''.join(char.upper() for char in text if char.isalpha())
    
    # Count frequencies
    letter_counts = Counter(clean_text)
    total_letters = len(clean_text)
    
    # Calculate percentages
    frequencies = {}
    for letter in string.ascii_uppercase:
        count = letter_counts.get(letter, 0)
        frequencies[letter] = (count / total_letters) * 100 if total_letters > 0 else 0
    
    # Sort by frequency
    sorted_freq = sorted(frequencies.items(), key=lambda x: x[1], reverse=True)
    
    return sorted_freq, total_letters

# English language frequency reference
ENGLISH_FREQ = {
    'E': 12.7, 'T': 9.1, 'A': 8.2, 'O': 7.5, 'I': 7.0, 'N': 6.7,
    'S': 6.3, 'H': 6.1, 'R': 6.0, 'D': 4.3, 'L': 4.0, 'C': 2.8
}

def compare_with_english(text_frequencies):
    """Compare text frequencies with standard English."""
    comparison = []
    for letter, freq in text_frequencies[:12]:  # Top 12 letters
        english_freq = ENGLISH_FREQ.get(letter, 0)
        difference = abs(freq - english_freq)
        comparison.append((letter, freq, english_freq, difference))
    
    return comparison

Exemples d'apprentissage interactif

Exemples de difficultés progressives

Niveau débutant

Mot-clé: CAT Plaintext: I LOVE CATS Process: Mot-clé simple de 3 lettres, facile à comprendre

Niveau intermédiaire

Mot-clé: JAVASCRIPT Plaintext: La programmation est amusante et éducative Challenge: Mot-clé plus long avec lettres dupliquées à supprimer

Niveau avancé

Mot-clé: CRYPTANALYSIS Plaintext: L'analyse de fréquence révèle des patrons dans les chiffrements de substitution monoalphabétiques Complexité: vocabulaire technique et texte plus long pour une analyse réaliste

Études de cas historiques

Exemple 1: Mary Queen of Scots (1586)

** Contexte historique**: Babington Communications par lots Mot-clé: MARIE (simplifié par exemple) Message original: "L'acte sera fait jeudi" ** chiffré**: "Rdj kjjk vpmm yj kghj gh Rdqxakit"

Note historique: Le chiffre utilisé était plus complexe, mais la substitution par mot-clé était une composante du système nomenclateur qui a finalement conduit à la chute de Marie.

Exemple 2: Telegraph Era (1850s)

** Contexte commercial**: Communications d'affaires Mot-clé: TELEGRAPH Considération du coût: Des messages chiffrés plus courts économisent de l'argent Exemple: "PROFITS UP" → "QUHDITJ RQ"

Exercices pratiques

Exercice 1: Mise en œuvre de base

Créez un chiffrement de mot-clé en utilisant votre nom comme mot-clé et chiffrez un message personnel.

Exercice 2: Comparaison de la force

Comparez les alphabets de chiffrement générés par ces mots clés:

• SHORT
• MEDIUM
• VERYLONGKEYWORD

Analyser comment la longueur des mots clés affecte le modèle de substitution.

Exercice 3: Pratique de rupture

Essayez de briser ce chiffre clé: Ciphertext: "MJKKP VPEKX ! LPHJ YGPJFKXJ FP XJVJEHJFJ QGJ JFXEFJ GRA FPQGJHKJX HGJAKJ"

Aperçu:

• Texte anglais commun
• Mot-clé est un mot commun de 6 lettres
• Recherchez le modèle de la lettre la plus fréquente

Exercice 4: Optimisation de l'algorithme

Mettre en œuvre une version qui gère:

• Plusieurs mots clés (rotation entre eux)
• alphabets non anglais
• Options de conservation du nombre

Meilleures pratiques

Considérations en matière de sécurité

1. ** Sélection des mots clés**: Utilisez des mots-clés longs et aléatoires sans lettres répétées
2. ** Longueur du message**: Les messages plus courts sont plus difficiles à analyser
3. ** Sensibilisation au contexte**: Considérez quelles informations pourraient être disponibles pour les agresseurs

Directives de mise en œuvre

1. Validation d'entrée: Toujours valider et désinfecter les entrées de mots clés
2. ** Traitement des cas**: Décider de la façon de gérer la valise supérieure/lowercase de façon cohérente
3. Manipulation d'erreurs: Gérer les cas de bord comme des mots-clés vides ou des caractères spéciaux
4. Performance: Pour les grands textes, optimiser les recherches de cartographie

Applications pédagogiques

1. ** Apprentissage progressif**: Commencez par des exemples simples et augmentez la complexité
2. Aides visuelles: Afficher clairement les correspondances alphabétiques
3. ** Outils interactifs**: Permettre aux élèves d'expérimenter différents mots clés
4. Contexte historique: Connectez des exemples à un usage historique réel

Le chiffre de mots clés constitue une excellente introduction aux concepts cryptographiques tout en offrant des défis pratiques de programmation. Ces exemples montrent à la fois les détails de mise en oeuvre et les techniques analytiques nécessaires pour comprendre les chiffres de substitution classiques dans leur contexte historique et éducatif.