仿射與替換密碼技術解析與程式實作

import cryptomath

def affine_encrypt(plain_text, key_a, key_b):
    """仿射密碼加密函式"""
    cipher_text = ""
    for char in plain_text:
        if char.isalpha():
            # 將字元轉換為數值（A=0, B=1, ...）
            num = ord(char.upper()) - ord('A')
            # 進行仿射加密
            encrypted_num = (key_a * num + key_b) % 26
            # 轉換回字元
            encrypted_char = chr(encrypted_num + ord('A'))
            cipher_text += encrypted_char
        else:
            cipher_text += char
    return cipher_text

def affine_decrypt(cipher_text, key_a, key_b):
    """仿射密碼解密函式"""
    # 計算a的模逆元
    mod_inverse_a = cryptomath.find_mod_inverse(key_a, 26)
    plain_text = ""
    for char in cipher_text:
        if char.isalpha():
            num = ord(char.upper()) - ord('A')
            # 進行仿射解密
            decrypted_num = (mod_inverse_a * (num - key_b)) % 26
            decrypted_char = chr(decrypted_num + ord('A'))
            plain_text += decrypted_char
        else:
            plain_text += char
    return plain_text

# 主程式執行範例
if __name__ == "__main__":
    plain_text = "ATTACKATDAWN"
    key_a = 5
    key_b = 8
    
    # 加密過程
    cipher_text = affine_encrypt(plain_text, key_a, key_b)
    print(f"加密結果: {cipher_text}")
    
    # 解密過程
    decrypted_text = affine_decrypt(cipher_text, key_a, key_b)
    print(f"解密結果: {decrypted_text}")

# 仿射密碼破解程式
def hackAffineCipher(message):
    # 暴力破解所有可能的金鑰
    for keyA in range(len(SYMBOLS)):
        for keyB in range(len(SYMBOLS)):
            # 檢查金鑰是否有效
            if gcd(keyA, len(SYMBOLS)) == 1:
                # 解密訊息
                decryptedMessage = decryptMessage(keyA, keyB, message)
                # 檢查解密結果是否合理
                if isEnglish(decryptedMessage):
                    return decryptedMessage, (keyA, keyB)
    return None, None

# 主要函式
def main():
    message = "your encrypted message here"
    decryptedMessage, key = hackAffineCipher(message)
    if decryptedMessage:
        print("解密成功！")
        print("金鑰：", key)
        print("解密訊息：", decryptedMessage)
    else:
        print("解密失敗！")

if __name__ == "__main__":
    main()

import pprint
import re

def get_word_pattern(word):
    # 將單詞轉換為模式
    pattern = []
    letter_map = {}
    next_letter = 0
    
    for letter in word:
        if letter not in letter_map:
            letter_map[letter] = str(next_letter)
            next_letter += 1
        pattern.append(letter_map[letter])
    
    return '.'.join(pattern)

def main():
    # 建立詞彙模式字典
    word_patterns = {}
    with open('dictionary.txt') as f:
        for line in f:
            word = line.strip().lower()
            pattern = get_word_pattern(word)
            if pattern not in word_patterns:
                word_patterns[pattern] = [word]
            else:
                word_patterns[pattern].append(word)
    
    # 測試詞彙模式匹配
    test_word = 'hello'
    pattern = get_word_pattern(test_word)
    print(f'詞彙模式：{pattern}')
    print(f'可能的單詞：{word_patterns.get(pattern, [])}')

#### 內容解密：
1. **`get_word_pattern`函式實作**：該函式負責將輸入的單詞轉換為對應的模式，透過建立字母對映表來確保相同的字母對應相同的代號。
2. **詞彙模式字典建立**：程式讀取字典檔案並建立詞彙模式字典，用於後續的密碼破解。
3. **測試與驗證**：透過測試單詞來驗證詞彙模式匹配的效果，確保程式正確運作。

### 技術選型與設計考量

在簡單替換密碼破解程式的設計中，採用了以下關鍵技術：
- **詞彙模式匹配**：透過計算單詞的模式來進行比對，有效縮小可能的明文範圍。
- **正規表示式應用**：利用正規表示式進行字串處理，提升程式的靈活性。
- **字典查詢最佳化**：建立高效的詞彙模式字典，加速破解過程。

### 破解策略與實務挑戰

簡單替換密碼的破解依賴於對密鑰的深入分析，主要挑戰包括：
1. **密鑰字母頻率分析**：透過分析字母出現頻率來推測可能的明文字母。
2. **詞彙模式匹配**：利用已知的詞彙模式來進行比對，逐步還原明文。
3. **逐步迭代最佳化**：不斷最佳化字母對映關係，直到完全破解。