025_密码学基础实战：维吉尼亚密码全解析与破解指南

   A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
A  A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
B  B C D E F G H I J K L M N O P Q R S T U V W X Y Z A
C  C D E F G H I J K L M N O P Q R S T U V W X Y Z A B
D  D E F G H I J K L M N O P Q R S T U V W X Y Z A B C
E  E F G H I J K L M N O P Q R S T U V W X Y Z A B C D
...
Y  Y Z A B C D E F G H I J K L M N O P Q R S T U V W X
Z  Z A B C D E F G H I J K L M N O P Q R S T U V W X Y

class VigenereCipher:
    def __init__(self, key):
        """初始化维吉尼亚密码实例
        
        Args:
            key: 密钥词
        """
        # 将密钥转换为大写，并过滤掉非字母字符
        self.key = ''.join([c.upper() for c in key if c.isalpha()])
        
    def _process_text(self, text, encrypt=True):
        """处理文本（加密或解密）
        
        Args:
            text: 要处理的文本
            encrypt: True表示加密，False表示解密
            
        Returns:
            处理后的文本
        """
        result = []
        key_index = 0
        
        for char in text:
            if char.isalpha():
                # 确定字符的基础值（大写或小写）
                base = ord('A') if char.isupper() else ord('a')
                
                # 获取字符的数值表示
                char_num = ord(char) - base
                
                # 获取密钥字符的数值表示
                key_char = self.key[key_index % len(self.key)]
                key_num = ord(key_char) - ord('A')
                
                # 执行加密或解密操作
                if encrypt:
                    # 加密: (明文 + 密钥) % 26
                    processed_num = (char_num + key_num) % 26
                else:
                    # 解密: (密文 - 密钥) % 26
                    processed_num = (char_num - key_num) % 26
                
                # 将结果转换回字符
                result.append(chr(processed_num + base))
                
                # 更新密钥索引
                key_index += 1
            else:
                # 非字母字符保持不变
                result.append(char)
        
        return ''.join(result)
    
    def encrypt(self, plaintext):
        """加密明文
        
        Args:
            plaintext: 要加密的明文
            
        Returns:
            加密后的密文
        """
        return self._process_text(plaintext, encrypt=True)
    
    def decrypt(self, ciphertext):
        """解密密文
        
        Args:
            ciphertext: 要解密的密文
            
        Returns:
            解密后的明文
        """
        return self._process_text(ciphertext, encrypt=False)

# 使用示例
if __name__ == "__main__":
    # 创建维吉尼亚密码实例
    cipher = VigenereCipher("KEY")
    
    # 加密示例
    plaintext = "HELLO, WORLD!"
    ciphertext = cipher.encrypt(plaintext)
    print(f"明文: {plaintext}")
    print(f"密文: {ciphertext}")
    
    # 解密示例
    decrypted_text = cipher.decrypt(ciphertext)
    print(f"解密: {decrypted_text}")

class VigenereCipher {
  constructor(key) {
    // 将密钥转换为大写，并过滤掉非字母字符
    this.key = key.toUpperCase().replace(/[^A-Z]/g, '');
  }

  processText(text, encrypt = true) {
    let result = '';
    let keyIndex = 0;

    for (let i = 0; i < text.length; i++) {
      const char = text[i];
      
      if (/[A-Za-z]/.test(char)) {
        // 确定字符的基础值（大写或小写）
        const base = char >= 'A' && char <= 'Z' ? 'A'.charCodeAt(0) : 'a'.charCodeAt(0);
        
        // 获取字符的数值表示
        const charNum = char.charCodeAt(0) - base;
        
        // 获取密钥字符的数值表示
        const keyChar = this.key[keyIndex % this.key.length];
        const keyNum = keyChar.charCodeAt(0) - 'A'.charCodeAt(0);
        
        // 执行加密或解密操作
        let processedNum;
        if (encrypt) {
          // 加密: (明文 + 密钥) % 26
          processedNum = (charNum + keyNum) % 26;
        } else {
          // 解密: (密文 - 密钥) % 26
          processedNum = (charNum - keyNum + 26) % 26; // 加26确保结果为正
        }
        
        // 将结果转换回字符
        result += String.fromCharCode(processedNum + base);
        
        // 更新密钥索引
        keyIndex++;
      } else {
        // 非字母字符保持不变
        result += char;
      }
    }
    
    return result;
  }

  encrypt(plaintext) {
    return this.processText(plaintext, true);
  }

  decrypt(ciphertext) {
    return this.processText(ciphertext, false);
  }
}

// 使用示例
const cipher = new VigenereCipher("KEY");
const plaintext = "HELLO, WORLD!";
const ciphertext = cipher.encrypt(plaintext);
console.log(`明文: ${plaintext}`);
console.log(`密文: ${ciphertext}`);
const decryptedText = cipher.decrypt(ciphertext);
console.log(`解密: ${decryptedText}`);

public class VigenereCipher {
    private String key;
    
    public VigenereCipher(String key) {
        // 将密钥转换为大写，并过滤掉非字母字符
        this.key = key.toUpperCase().replaceAll("[^A-Z]", "");
    }
    
    private String processText(String text, boolean encrypt) {
        StringBuilder result = new StringBuilder();
        int keyIndex = 0;
        
        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);
            
            if (Character.isLetter(c)) {
                // 确定字符的基础值（大写或小写）
                char base = Character.isUpperCase(c) ? 'A' : 'a';
                
                // 获取字符的数值表示
                int charNum = c - base;
                
                // 获取密钥字符的数值表示
                char keyChar = key.charAt(keyIndex % key.length());
                int keyNum = keyChar - 'A';
                
                // 执行加密或解密操作
                int processedNum;
                if (encrypt) {
                    // 加密: (明文 + 密钥) % 26
                    processedNum = (charNum + keyNum) % 26;
                } else {
                    // 解密: (密文 - 密钥) % 26
                    processedNum = (charNum - keyNum + 26) % 26; // 加26确保结果为正
                }
                
                // 将结果转换回字符
                result.append((char) (processedNum + base));
                
                // 更新密钥索引
                keyIndex++;
            } else {
                // 非字母字符保持不变
                result.append(c);
            }
        }
        
        return result.toString();
    }
    
    public String encrypt(String plaintext) {
        return processText(plaintext, true);
    }
    
    public String decrypt(String ciphertext) {
        return processText(ciphertext, false);
    }
    
    public static void main(String[] args) {
        // 创建维吉尼亚密码实例
        VigenereCipher cipher = new VigenereCipher("KEY");
        
        // 加密示例
        String plaintext = "HELLO, WORLD!";
        String ciphertext = cipher.encrypt(plaintext);
        System.out.println("明文: " + plaintext);
        System.out.println("密文: " + ciphertext);
        
        // 解密示例
        String decryptedText = cipher.decrypt(ciphertext);
        System.out.println("解密: " + decryptedText);
    }
}

#include <iostream>
#include <string>
#include <cctype>

class VigenereCipher {
private:
    std::string key;
    
    // 辅助函数：将字符串转换为大写并过滤非字母字符
    std::string processKey(const std::string& k) {
        std::string result;
        for (char c : k) {
            if (std::isalpha(c)) {
                result += std::toupper(c);
            }
        }
        return result;
    }
    
public:
    VigenereCipher(const std::string& k) : key(processKey(k)) {}
    
    std::string processText(const std::string& text, bool encrypt) {
        std::string result;
        int keyIndex = 0;
        
        for (char c : text) {
            if (std::isalpha(c)) {
                // 确定字符的基础值（大写或小写）
                char base = std::isupper(c) ? 'A' : 'a';
                
                // 获取字符的数值表示
                int charNum = c - base;
                
                // 获取密钥字符的数值表示
                char keyChar = key[keyIndex % key.length()];
                int keyNum = keyChar - 'A';
                
                // 执行加密或解密操作
                int processedNum;
                if (encrypt) {
                    // 加密: (明文 + 密钥) % 26
                    processedNum = (charNum + keyNum) % 26;
                } else {
                    // 解密: (密文 - 密钥) % 26
                    processedNum = (charNum - keyNum + 26) % 26; // 加26确保结果为正
                }
                
                // 将结果转换回字符
                result += static_cast<char>(processedNum + base);
                
                // 更新密钥索引
                keyIndex++;
            } else {
                // 非字母字符保持不变
                result += c;
            }
        }
        
        return result;
    }
    
    std::string encrypt(const std::string& plaintext) {
        return processText(plaintext, true);
    }
    
    std::string decrypt(const std::string& ciphertext) {
        return processText(ciphertext, false);
    }
};

int main() {
    // 创建维吉尼亚密码实例
    VigenereCipher cipher("KEY");
    
    // 加密示例
    std::string plaintext = "HELLO, WORLD!";
    std::string ciphertext = cipher.encrypt(plaintext);
    std::cout << "明文: " << plaintext << std::endl;
    std::cout << "密文: " << ciphertext << std::endl;
    
    // 解密示例
    std::string decryptedText = cipher.decrypt(ciphertext);
    std::cout << "解密: " << decryptedText << std::endl;
    
    return 0;
}

class VigenereCracker:
    def __init__(self):
        # 英语字母频率表（百分比）
        self.english_freq = {
            'A': 8.2,
            'B': 1.5,
            'C': 2.8,
            'D': 4.3,
            'E': 12.7,
            'F': 2.2,
            'G': 2.0,
            'H': 6.1,
            'I': 7.0,
            'J': 0.2,
            'K': 0.8,
            'L': 4.0,
            'M': 2.4,
            'N': 6.7,
            'O': 7.5,
            'P': 1.9,
            'Q': 0.1,
            'R': 6.0,
            'S': 6.3,
            'T': 9.1,
            'U': 2.8,
            'V': 1.0,
            'W': 2.4,
            'X': 0.2,
            'Y': 2.0,
            'Z': 0.1
        }
    
    def calculate_ic(self, text):
        """计算重合指数
        
        Args:
            text: 要计算重合指数的文本
            
        Returns:
            重合指数
        """
        # 过滤出字母字符并转换为大写
        text = ''.join([c.upper() for c in text if c.isalpha()])
        N = len(text)
        
        if N < 2:
            return 0
        
        # 统计字母频率
        freq = {chr(65 + i): 0 for i in range(26)}
        for char in text:
            if char.isalpha():
                freq[char] += 1
        
        # 计算重合指数
        ic = sum(f * (f - 1) for f in freq.values()) / (N * (N - 1))
        return ic
    
    def find_key_length(self, ciphertext, max_length=20):
        """使用重合指数法找到可能的密钥长度
        
        Args:
            ciphertext: 密文
            max_length: 最大可能的密钥长度
            
        Returns:
            最可能的密钥长度
        """
        ics = []
        
        for m in range(1, max_length + 1):
            # 按照密钥长度m分组
            groups = ['' for _ in range(m)]
            for i, char in enumerate(ciphertext):
                if char.isalpha():
                    groups[i % m] += char
            
            # 计算每组的重合指数，并求平均值
            avg_ic = sum(self.calculate_ic(group) for group in groups) / m
            ics.append((m, avg_ic))
        
        # 找到平均重合指数最接近0.065的密钥长度
        # 0.065是英语文本的平均重合指数
        ics.sort(key=lambda x: abs(x[1] - 0.065))
        return ics[0][0]
    
    def calculate_freq_score(self, text):
        """计算文本的频率得分
        
        Args:
            text: 要计算频率得分的文本
            
        Returns:
            频率得分（与英语频率的相关性）
        """
        # 过滤出字母字符并转换为大写
        text = ''.join([c.upper() for c in text if c.isalpha()])
        N = len(text)
        
        if N == 0:
            return 0
        
        # 统计字母频率
        freq = {chr(65 + i): 0 for i in range(26)}
        for char in text:
            if char.isalpha():
                freq[char] += 1
        
        # 计算与英语频率的相关性
        score = 0
        for char in freq:
            observed_freq = freq[char] / N * 100
            expected_freq = self.english_freq[char]
            score += abs(observed_freq - expected_freq)
        
        # 得分越低，相关性越高
        return score
    
    def find_key(self, ciphertext, key_length):
        """使用频率分析找到密钥
        
        Args:
            ciphertext: 密文
            key_length: 密钥长度
            
        Returns:
            可能的密钥
        """
        # 按照密钥长度分组
        groups = ['' for _ in range(key_length)]
        for i, char in enumerate(ciphertext):
            if char.isalpha():
                groups[i % key_length] += char
        
        key = []
        
        # 对每组进行频率分析
        for group in groups:
            best_shift = 0
            best_score = float('inf')
            
            # 尝试所有可能的位移（0-25）
            for shift in range(26):
                # 模拟解密（假设当前位移是正确的）
                decrypted = ''
                for char in group:
                    if char.isalpha():
                        base = ord('A') if char.isupper() else ord('a')
                        decrypted_char = chr((ord(char) - base - shift) % 26 + base)
                        decrypted += decrypted_char
                
                # 计算频率得分
                score = self.calculate_freq_score(decrypted)
                
                if score < best_score:
                    best_score = score
                    best_shift = shift
            
            # 将最佳位移转换为密钥字符
            key_char = chr(best_shift + ord('A'))
            key.append(key_char)
        
        return ''.join(key)
    
    def crack(self, ciphertext, max_length=20):
        """破解维吉尼亚密码
        
        Args:
            ciphertext: 密文
            max_length: 最大可能的密钥长度
            
        Returns:
            可能的密钥和对应的明文
        """
        # 找到可能的密钥长度
        key_length = self.find_key_length(ciphertext, max_length)
        print(f"可能的密钥长度: {key_length}")
        
        # 找到可能的密钥
        key = self.find_key(ciphertext, key_length)
        print(f"可能的密钥: {key}")
        
        # 使用密钥解密
        from vigenere_cipher import VigenereCipher  # 假设我们有VigenereCipher类
        cipher = VigenereCipher(key)
        plaintext = cipher.decrypt(ciphertext)
        
        return key, plaintext

# 使用示例
if __name__ == "__main__":
    # 导入VigenereCipher类
    from vigenere_cipher import VigenereCipher
    
    # 创建测试数据
    plaintext = "THE SECRET MESSAGE IS ENCRYPTED USING VIGENERE CIPHER THIS IS A TEST FOR FREQUENCY ANALYSIS"
    key = "KEYWORD"
    cipher = VigenereCipher(key)
    ciphertext = cipher.encrypt(plaintext)
    
    print(f"原始明文: {plaintext}")
    print(f"密钥: {key}")
    print(f"密文: {ciphertext}")
    
    # 破解密文
    cracker = VigenereCracker()
    found_key, decrypted_text = cracker.crack(ciphertext)
    
    print(f"\n破解结果:")
    print(f"找到的密钥: {found_key}")
    print(f"解密后的文本: {decrypted_text}")