024_密码学基础实战：简单替换密码全解析与破解技术指南

密钥: QWERTYUIOPASDFGHJKLZXCVBNM

class SimpleSubstitutionCipher:
    def __init__(self, key=None):
        # 定义明文字母表
        self.plain_alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        
        if key:
            # 使用提供的密钥
            self.key = key.upper()
        else:
            # 默认密钥（恒等映射）
            self.key = self.plain_alphabet
        
        # 创建加密和解密映射
        self.encrypt_map = {p: c for p, c in zip(self.plain_alphabet, self.key)}
        self.decrypt_map = {c: p for p, c in zip(self.plain_alphabet, self.key)}
    
    def encrypt(self, plaintext):
        """加密明文"""
        ciphertext = []
        for char in plaintext.upper():
            if char in self.encrypt_map:
                ciphertext.append(self.encrypt_map[char])
            else:
                # 非字母字符保持不变
                ciphertext.append(char)
        return ''.join(ciphertext)
    
    def decrypt(self, ciphertext):
        """解密密文"""
        plaintext = []
        for char in ciphertext.upper():
            if char in self.decrypt_map:
                plaintext.append(self.decrypt_map[char])
            else:
                # 非字母字符保持不变
                plaintext.append(char)
        return ''.join(plaintext)
    
    def generate_key_from_phrase(self, phrase):
        """从密钥短语生成密钥"""
        # 移除短语中的非字母字符并转换为大写
        phrase = ''.join(char.upper() for char in phrase if char.isalpha())
        
        # 移除重复字母
        unique_chars = []
        seen = set()
        for char in phrase:
            if char not in seen:
                unique_chars.append(char)
                seen.add(char)
        
        # 添加剩余字母
        for char in self.plain_alphabet:
            if char not in seen:
                unique_chars.append(char)
                seen.add(char)
        
        # 更新密钥和映射
        self.key = ''.join(unique_chars)
        self.encrypt_map = {p: c for p, c in zip(self.plain_alphabet, self.key)}
        self.decrypt_map = {c: p for p, c in zip(self.plain_alphabet, self.key)}
        
        return self.key

# 使用示例
if __name__ == "__main__":
    # 示例1：使用自定义密钥
    cipher = SimpleSubstitutionCipher("QWERTYUIOPASDFGHJKLZXCVBNM")
    plaintext = "HELLO WORLD"
    ciphertext = cipher.encrypt(plaintext)
    print(f"明文: {plaintext}")
    print(f"密钥: {cipher.key}")
    print(f"密文: {ciphertext}")
    print(f"解密: {cipher.decrypt(ciphertext)}")
    
    # 示例2：使用密钥短语
    cipher = SimpleSubstitutionCipher()
    key = cipher.generate_key_from_phrase("SECURITY IS IMPORTANT")
    plaintext = "HELLO WORLD"
    ciphertext = cipher.encrypt(plaintext)
    print(f"\n明文: {plaintext}")
    print(f"密钥: {key}")
    print(f"密文: {ciphertext}")
    print(f"解密: {cipher.decrypt(ciphertext)}")

class SimpleSubstitutionCipher {
    constructor(key = null) {
        // 定义明文字母表
        this.plainAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
        
        if (key) {
            // 使用提供的密钥
            this.key = key.toUpperCase();
        } else {
            // 默认密钥（恒等映射）
            this.key = this.plainAlphabet;
        }
        
        // 创建加密和解密映射
        this.encryptMap = {};
        this.decryptMap = {};
        for (let i = 0; i < this.plainAlphabet.length; i++) {
            this.encryptMap[this.plainAlphabet[i]] = this.key[i];
            this.decryptMap[this.key[i]] = this.plainAlphabet[i];
        }
    }
    
    encrypt(plaintext) {
        """加密明文"""
        let ciphertext = '';
        for (let char of plaintext.toUpperCase()) {
            if (this.encryptMap[char]) {
                ciphertext += this.encryptMap[char];
            } else {
                // 非字母字符保持不变
                ciphertext += char;
            }
        }
        return ciphertext;
    }
    
    decrypt(ciphertext) {
        """解密密文"""
        let plaintext = '';
        for (let char of ciphertext.toUpperCase()) {
            if (this.decryptMap[char]) {
                plaintext += this.decryptMap[char];
            } else {
                // 非字母字符保持不变
                plaintext += char;
            }
        }
        return plaintext;
    }
    
    generateKeyFromPhrase(phrase) {
        """从密钥短语生成密钥"""
        // 移除短语中的非字母字符并转换为大写
        phrase = phrase.toUpperCase().replace(/[^A-Z]/g, '');
        
        // 移除重复字母
        let uniqueChars = [];
        let seen = new Set();
        for (let char of phrase) {
            if (!seen.has(char)) {
                uniqueChars.push(char);
                seen.add(char);
            }
        }
        
        // 添加剩余字母
        for (let char of this.plainAlphabet) {
            if (!seen.has(char)) {
                uniqueChars.push(char);
                seen.add(char);
            }
        }
        
        // 更新密钥和映射
        this.key = uniqueChars.join('');
        this.encryptMap = {};
        this.decryptMap = {};
        for (let i = 0; i < this.plainAlphabet.length; i++) {
            this.encryptMap[this.plainAlphabet[i]] = this.key[i];
            this.decryptMap[this.key[i]] = this.plainAlphabet[i];
        }
        
        return this.key;
    }
}

// 使用示例
// 示例1：使用自定义密钥
let cipher = new SimpleSubstitutionCipher("QWERTYUIOPASDFGHJKLZXCVBNM");
let plaintext = "HELLO WORLD";
let ciphertext = cipher.encrypt(plaintext);
console.log(`明文: ${plaintext}`);
console.log(`密钥: ${cipher.key}`);
console.log(`密文: ${ciphertext}`);
console.log(`解密: ${cipher.decrypt(ciphertext)}`);

// 示例2：使用密钥短语
cipher = new SimpleSubstitutionCipher();
let key = cipher.generateKeyFromPhrase("SECURITY IS IMPORTANT");
plaintext = "HELLO WORLD";
ciphertext = cipher.encrypt(plaintext);
console.log(`\n明文: ${plaintext}`);
console.log(`密钥: ${key}`);
console.log(`密文: ${ciphertext}`);
#### 4.2.3 Java实现

Java是一种广泛使用的编程语言，也可以用于实现简单替换密码。

```java
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class SimpleSubstitutionCipher {
    private final String plainAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private String key;
    private Map<Character, Character> encryptMap;
    private Map<Character, Character> decryptMap;
    
    public SimpleSubstitutionCipher(String key) {
        if (key != null) {
            this.key = key.toUpperCase();
        } else {
            this.key = plainAlphabet;
        }
        
        // 初始化映射
        initializeMaps();
    }
    
    public SimpleSubstitutionCipher() {
        this(null);
    }
    
    private void initializeMaps() {
        encryptMap = new HashMap<>();
        decryptMap = new HashMap<>();
        
        for (int i = 0; i < plainAlphabet.length(); i++) {
            encryptMap.put(plainAlphabet.charAt(i), key.charAt(i));
            decryptMap.put(key.charAt(i), plainAlphabet.charAt(i));
        }
    }
    
    public String encrypt(String plaintext) {
        StringBuilder ciphertext = new StringBuilder();
        
        for (char c : plaintext.toUpperCase().toCharArray()) {
            if (encryptMap.containsKey(c)) {
                ciphertext.append(encryptMap.get(c));
            } else {
                // 非字母字符保持不变
                ciphertext.append(c);
            }
        }
        
        return ciphertext.toString();
    }
    
    public String decrypt(String ciphertext) {
        StringBuilder plaintext = new StringBuilder();
        
        for (char c : ciphertext.toUpperCase().toCharArray()) {
            if (decryptMap.containsKey(c)) {
                plaintext.append(decryptMap.get(c));
            } else {
                // 非字母字符保持不变
                plaintext.append(c);
            }
        }
        
        return plaintext.toString();
    }
    
    public String generateKeyFromPhrase(String phrase) {
        // 移除短语中的非字母字符并转换为大写
        String cleanPhrase = phrase.toUpperCase().replaceAll("[^A-Z]", "");
        
        // 移除重复字母
        Set<Character> seen = new HashSet<>();
        StringBuilder uniqueChars = new StringBuilder();
        
        for (char c : cleanPhrase.toCharArray()) {
            if (!seen.contains(c)) {
                uniqueChars.append(c);
                seen.add(c);
            }
        }
        
        // 添加剩余字母
        for (char c : plainAlphabet.toCharArray()) {
            if (!seen.contains(c)) {
                uniqueChars.append(c);
                seen.add(c);
            }
        }
        
        // 更新密钥和映射
        this.key = uniqueChars.toString();
        initializeMaps();
        
        return this.key;
    }
    
    public String getKey() {
        return key;
    }
    
    public static void main(String[] args) {
        // 示例1：使用自定义密钥
        SimpleSubstitutionCipher cipher = new SimpleSubstitutionCipher("QWERTYUIOPASDFGHJKLZXCVBNM");
        String plaintext = "HELLO WORLD";
        String ciphertext = cipher.encrypt(plaintext);
        System.out.println("明文: " + plaintext);
        System.out.println("密钥: " + cipher.getKey());
        System.out.println("密文: " + ciphertext);
        System.out.println("解密: " + cipher.decrypt(ciphertext));
        
        // 示例2：使用密钥短语
        cipher = new SimpleSubstitutionCipher();
        String key = cipher.generateKeyFromPhrase("SECURITY IS IMPORTANT");
        plaintext = "HELLO WORLD";
        ciphertext = cipher.encrypt(plaintext);
        System.out.println("\n明文: " + plaintext);
        System.out.println("密钥: " + key);
        System.out.println("密文: " + ciphertext);
        System.out.println("解密: " + cipher.decrypt(ciphertext));
    }
}

import re
from collections import Counter

class SimpleSubstitutionCracker:
    def __init__(self):
        # 英语中字母的平均频率（从高到低）
        self.english_frequency = 'ETAOINSHRDLCUMWFGYPBVKJXQZ'
        # 常见的英语单词（用于验证）
        self.common_words = {'THE', 'AND', 'THAT', 'HAVE', 'FOR', 'NOT', 'WITH', 'YOU', 'THIS', 'BUT', 
                             'HIS', 'FROM', 'THEY', 'SHE', 'WILL', 'SAID', 'THERE', 'THEIR', 'WHAT', 'ALL'}
    
    def count_letter_frequency(self, ciphertext):
        """统计密文中字母的频率"""
        # 只考虑大写字母
        ciphertext = ciphertext.upper()
        # 过滤非字母字符
        letters = re.sub(r'[^A-Z]', '', ciphertext)
        # 统计频率
        frequency = Counter(letters)
        # 按频率排序
        sorted_letters = sorted(frequency.keys(), key=lambda x: frequency[x], reverse=True)
        return ''.join(sorted_letters)
    
    def create_initial_mapping(self, ciphertext):
        """基于频率分析创建初始映射"""
        # 获取密文字母频率排序
        cipher_frequency = self.count_letter_frequency(ciphertext)
        # 创建映射
        mapping = {}
        for i, cipher_char in enumerate(cipher_frequency):
            if i < len(self.english_frequency):
                mapping[cipher_char] = self.english_frequency[i]
        return mapping
    
    def decrypt_with_mapping(self, ciphertext, mapping):
        """使用给定的映射解密"""
        plaintext = []
        for char in ciphertext.upper():
            if char in mapping:
                plaintext.append(mapping[char])
            else:
                # 非字母字符或未映射字符保持不变
                plaintext.append(char)
        return ''.join(plaintext)
    
    def score_decryption(self, plaintext):
        """评估解密结果的质量"""
        # 提取所有单词
        words = re.findall(r'[A-Z]+', plaintext)
        # 计算匹配的常见单词数量
        match_count = sum(1 for word in words if word in self.common_words)
        # 返回得分（匹配的常见单词数量）
        return match_count
    
    def crack(self, ciphertext, max_attempts=1000):
        """破解简单替换密码"""
        # 创建初始映射
        best_mapping = self.create_initial_mapping(ciphertext)
        best_plaintext = self.decrypt_with_mapping(ciphertext, best_mapping)
        best_score = self.score_decryption(best_plaintext)
        
        # 简单的启发式调整（交换两个字母的映射）
        cipher_frequency = self.count_letter_frequency(ciphertext)
        attempts = 0
        
        # 尝试不同的映射调整
        # 注意：这只是一个简化的示例，实际的破解算法会更复杂
        for i in range(len(cipher_frequency)):
            for j in range(i + 1, len(cipher_frequency)):
                if attempts >= max_attempts:
                    break
                
                # 创建新的映射（交换两个字母的映射）
                new_mapping = best_mapping.copy()
                if cipher_frequency[i] in new_mapping and cipher_frequency[j] in new_mapping:
                    # 交换映射
                    new_mapping[cipher_frequency[i]], new_mapping[cipher_frequency[j]] = \
                    new_mapping[cipher_frequency[j]], new_mapping[cipher_frequency[i]]
                    
                    # 解密并评估
                    new_plaintext = self.decrypt_with_mapping(ciphertext, new_mapping)
                    new_score = self.score_decryption(new_plaintext)
                    
                    # 更新最佳结果
                    if new_score > best_score:
                        best_mapping = new_mapping
                        best_plaintext = new_plaintext
                        best_score = new_score
                
                attempts += 1
            
            if attempts >= max_attempts:
                break
        
        return best_plaintext, best_mapping, best_score

# 使用示例
if __name__ == "__main__":
    # 示例密文（使用QWERTYUIOPASDFGHJKLZXCVBNM作为密钥加密"HELLO WORLD THIS IS A TEST MESSAGE"）
    ciphertext = "ITSSG VGKSR XWQH XS B XPQT BIQTQXG"
    
    cracker = SimpleSubstitutionCracker()
    plaintext, mapping, score = cracker.crack(ciphertext)
    
    print(f"密文: {ciphertext}")
    print(f"解密结果: {plaintext}")
    print(f"得分: {score}")
    print(f"映射: {mapping}")