仿射密碼與簡單替換加密技術探討

仿射密碼根據模逆元與符號集大小的特性，其金鑰空間並非無限大，安全性相對較低。透過 Python 程式碼實作暴力破解法，可以有效地嘗試所有可能的金鑰組合，從而解密密鑰。相較之下，簡單替換加密法的金鑰空間更大，破解難度更高。其原理是建立字母的一對一對映關係，透過金鑰字串打亂字母順序，實作加密和解密。雖然金鑰空間較大，但仍可透過頻率分析等方法進行破解。程式碼範例中展示了金鑰的產生、加密和解密的過程，並分析了其安全性和破解的可能性。

仿射密碼（Affine Cipher）的金鑰空間探討

在密碼學中，仿射密碼是一種根據數學運算的替換密碼。在前面的章節中，我們已經實作了一個名為 affineCipher.py 的程式，用於加密和解密訊息。本章節將探討仿射密碼的金鑰空間，並分析其安全性。

解密函式的實作

在 affineCipher.py 中，解密函式 decryptMessage() 的實作與加密函式 encryptMessage() 非常相似。主要區別在於解密過程中，先將符號索引減去 Key B，然後乘以 Key A 的模逆元，最後對符號集大小取模。

def decryptMessage(key, message):
    # 省略其他程式碼...
    plaintext = ''
    for symbol in message:
        if symbol in SYMBOLS:
            # 取得符號在符號集中的索引
            symIndex = SYMBOLS.find(symbol)
            # 解密運算
            plaintext += SYMBOLS[(symIndex - keyB) * modInverse(keyA, len(SYMBOLS)) % len(SYMBOLS)]
        else:
            plaintext += symbol
    return plaintext

內容解密：

1. 解密函式遍歷輸入的 message 中的每個符號。
2. 如果符號存在於符號集 SYMBOLS 中，則進行解密運算。
3. 解密運算首先計算符號索引減去 Key B 的結果。
4. 然後，將結果乘以 Key A 的模逆元，確保解密過程正確逆轉加密過程。
5. 最後，對符號集大小取模，以確保結果在符號集範圍內。

隨機金鑰生成

為了方便使用者，getRandomKey() 函式被設計用來生成一個隨機且有效的金鑰。

def getRandomKey():
    while True:
        keyA = random.randint(2, len(SYMBOLS))
        keyB = random.randint(2, len(SYMBOLS))
        if cryptomath.gcd(keyA, len(SYMBOLS)) == 1:
            return keyA * len(SYMBOLS) + keyB

內容解密：

1. getRandomKey() 函式進入一個無限迴圈，直到找到有效的 Key A 和 Key B。
2. Key A 和 Key B 被隨機選取，但需確保 Key A 與符號集大小互質。
3. 當找到有效的 Key A 和 Key B 時，將它們組合成一個單一的金鑰並傳回。

仿射密碼的金鑰空間大小

理論上，Key B 的範圍是從 1 到符號集大小，而 Key A 的選擇則需要與符號集大小互質。我們可能會認為，由於 Key A 可以是任意與符號集大小互質的數，因此仿射密碼具有無限多個金鑰。

然而，事實並非如此。透過編寫一個簡單的程式 affineKeyTest.py，我們可以觀察到使用不同 Key A 值加密同一訊息的結果。

# affineKeyTest.py
for keyA in range(2, 100):
    key = keyA * len(affineCipher.SYMBOLS) + 1
    if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) == 1:
        print(keyA, affineCipher.encryptMessage(key, message))

內容解密：

1. 程式遍歷從 2 到 100 的 Key A 值。
2. 對每個有效的 Key A 值（即與符號集大小互質），計算出對應的金鑰並加密訊息。
3. 輸出結果顯示，即使用不同的 Key A 值，有些加密結果是相同的。

這表明仿射密碼的金鑰空間並不是無限的，其大小受限於符號集的大小。具體來說，金鑰空間的大小約為符號集大小的平方。

仿射密碼流程圖示

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

title 仿射密碼與簡單替換加密技術探討

package "安全架構" {
    package "網路安全" {
        component [防火牆] as firewall
        component [WAF] as waf
        component [DDoS 防護] as ddos
    }

    package "身份認證" {
        component [OAuth 2.0] as oauth
        component [JWT Token] as jwt
        component [MFA] as mfa
    }

    package "資料安全" {
        component [加密傳輸 TLS] as tls
        component [資料加密] as encrypt
        component [金鑰管理] as kms
    }

    package "監控審計" {
        component [日誌收集] as log
        component [威脅偵測] as threat
        component [合規審計] as audit
    }
}

firewall --> waf : 過濾流量
waf --> oauth : 驗證身份
oauth --> jwt : 簽發憑證
jwt --> tls : 加密傳輸
tls --> encrypt : 資料保護
log --> threat : 異常分析
threat --> audit : 報告生成

@enduml

此圖示說明：

1. 圖表展示了仿射密碼的主要流程，包括加密和解密兩條路徑。
2. 使用者首先選擇進行加密或解密操作。
3. 根據選擇，分別輸入明文或密鑰，以及對應的金鑰。
4. 經過仿射加密或解密演算法處理後，輸出相應的結果。

破解仿射密碼（Affine Cipher）

仿射密碼是一種簡單的加密技術，但其安全性有限。本章將探討如何使用暴力破解法來破解仿射密碼，並介紹相關的數學概念和程式實作。

仿射密碼的限制

仿射密碼的金鑰空間有限，主要受限於符號集的大小。以95個可列印的ASCII字元為例，金鑰A的有效值只有那些與95互質的整數。經過計算，總共有7,125個可能的金鑰組合，這使得暴力破解變得相對容易。

暴力破解法

暴力破解法是透過嘗試所有可能的金鑰來解密訊息。由於仿射密碼的金鑰空間不大，這種方法非常有效。

affineHacker.py 程式碼解析

# Affine Cipher Hacker 程式碼
import pyperclip, affineCipher, detectEnglish, cryptomath

SILENT_MODE = False

def main():
    myMessage = """U&'<3dJ^Gjx'-3^MS'Sj0jxuj'G3'%j'<mMMjS'g{GjMMg9j{G'g"'gG'<3^MS'Sj<jguj'm'P^dm{'g{G3'%jMgjug{9'GPmG'gG'-m0'P^dm{LU'5&Mm{'_^xg{9"""
    hackedMessage = hackAffine(myMessage)
    
    if hackedMessage != None:
        print('Copying hacked message to clipboard:')
        print(hackedMessage)
        pyperclip.copy(hackedMessage)
    else:
        print('Failed to hack encryption.')

def hackAffine(message):
    print('Hacking...')
    print('(Press Ctrl-C or Ctrl-D to quit at any time.)')
    
    for key in range(len(affineCipher.SYMBOLS) ** 2):
        keyA = affineCipher.getKeyParts(key)[0]
        if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) != 1:
            continue
        
        decryptedText = affineCipher.decryptMessage(key, message)
        if not SILENT_MODE:
            print('Tried Key %s... (%s)' % (key, decryptedText[:40]))
        
        if detectEnglish.isEnglish(decryptedText):
            print()
            print('Possible encryption hack:')
            print('Key: %s' % (key))
            print('Decrypted message: ' + decryptedText[:200])
            print()
            print('Enter D for done, or just press Enter to continue hacking:')
            response = input('> ')
            
            if response.strip().upper().startswith('D'):
                return decryptedText
    
    return None

if __name__ == '__main__':
    main()

程式碼重點解析：

1. hackAffine 函式：負責遍歷所有可能的金鑰，並嘗試解密訊息。
2. keyA 的計算：從金鑰中提取 keyA，並檢查其與符號集大小是否互質。
3. decryptMessage 函式：使用當前金鑰解密訊息。
4. detectEnglish.isEnglish 函式：檢查解密後的文字是否為英文。
5. 使用者互動：當找到可能的解密結果時，程式會提示使用者是否接受該結果。

程式執行結果

執行 affineHacker.py 後，程式會輸出嘗試的金鑰及其對應的解密結果。當找到正確的金鑰時，會顯示解密後的訊息，並詢問使用者是否完成破解。

破解仿射密碼的技術深度解析

在密碼學領域中，仿射密碼是一種常見的加密技術，但其安全性相對較低，容易被破解。本篇文章將探討如何利用Python程式語言破解仿射密碼，並提供詳細的技術分析。

仿射密碼破解程式的核心概念

仿射密碼的破解依賴於暴力破解法，即嘗試所有可能的金鑰組合，直到找到正確的解密金鑰。這個過程需要遍歷所有可能的金鑰空間，並對每個金鑰進行解密嘗試。

程式碼實作與解析

以下為仿射密碼破解程式的主要程式碼片段：

def hackAffine(message):
    print('Hacking...')
    print('(Press Ctrl-C or Ctrl-D to quit at any time.)')

    for key in range(len(affineCipher.SYMBOLS) ** 2):
        keyA = affineCipher.getKeyParts(key)[0]
        # ... 省略其他程式碼 ...

內容解密：

1. hackAffine函式：該函式負責執行仿射密碼的破解過程。首先，它會輸出提示訊息，告知使用者正在進行破解，並提示使用者可以隨時按下Ctrl-C或Ctrl-D來終止程式。
2. for迴圈：使用for迴圈遍歷所有可能的金鑰組合，金鑰的範圍是從0到符號集大小的平方。這是因為仿射密碼的金鑰由兩個部分組成（Key A和Key B），每個部分都有符號集大小個可能的取值，因此總共有符號集大小的平方個可能的金鑰組合。
3. keyA的計算：在迴圈中，利用affineCipher.getKeyParts(key)[0]來取得當前測試金鑰的Key A部分。這個函式傳回一個包含Key A和Key B的元組，透過索引[0]來提取Key A。

技術深度分析

1. 暴力破解法：本程式採用暴力破解法，嘗試所有可能的金鑰組合。這種方法雖然簡單直接，但對於金鑰空間較大的加密演算法來說，效率較低。然而，對於仿射密碼這種金鑰空間相對較小的加密技術，暴力破解法是可行的。
2. Python的**運算元：在計算金鑰範圍時，使用了Python的**運算元來進行指數運算。例如，len(affineCipher.SYMBOLS) ** 2等同於對符號集大小進行平方運算。
3. continue陳述式的使用：在迴圈中，可以使用continue陳述式來提前跳到下一次迭代。雖然本例中未直接展示continue陳述式的使用，但瞭解其作用有助於更好地控制迴圈流程。

實務應用與改進方向

1. 最佳化金鑰搜尋空間：雖然本程式嘗試所有可能的金鑰組合，但可以透過最佳化搜尋策略來減少不必要的嘗試，例如先驗證Key A的有效性。
2. 提升程式效率：對於較大的符號集，可以考慮使用更高效的演算法或平行處理技術來加速破解過程。

第17章 - 簡單替代加密法

本章涵蓋的主題：

• sort() 列表方法
• 從字串中移除重複字元
• isupper() 和 islower() 字串方法
• 包裝函式

簡單替代加密法介紹

簡單替代加密法是一種比仿射加密法更複雜的加密技術。它的基本原理是將明文中的每個字元替換成另一個字元。替換的規則由一個金鑰決定，這個金鑰是一個包含26個不同字母的字串，按照字母表的順序與明文字元進行對應替換。

金鑰產生與管理

要使用簡單替代加密法，首先需要產生一個有效的金鑰。金鑰必須包含26個英文字母，且每個字母只能出現一次。否則，加密和解密的過程將無法正確進行。

def generateRandomKey():
    key = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
    random.shuffle(key)
    return ''.join(key)

內容解密：

這段程式碼首先將大寫字母表的字串轉換成列表，以便能夠對其進行洗牌操作。random.shuffle(key) 函式用於隨機打亂列表中的元素順序。最後，''.join(key) 將打亂順序的列表重新組合成一個字串，作為簡單替代加密法的金鑰。

簡單替代加密法的實作

簡單替代加密法的實作包括加密和解密兩個主要功能。加密功能根據金鑰對明文進行替換，而解密功能則根據相同的金鑰將密鑰還原成明文。

def encryptMessage(key, message):
    return translateMessage(key, message, 'encrypt')

def decryptMessage(key, message):
    return translateMessage(key, message, 'decrypt')

def translateMessage(key, message, mode):
    translated = ''
    charsA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    charsB = key
    if mode == 'decrypt':
        charsA, charsB = charsB, charsA

    for symbol in message:
        if symbol.upper() in charsA:
            symIndex = charsA.find(symbol.upper())
            if symbol.isupper():
                translated += charsB[symIndex].upper()
            else:
                translated += charsB[symIndex].lower()
        else:
            translated += symbol
    return translated

內容解密：

在 translateMessage 函式中，根據 mode 引數決定是進行加密還是解密。如果是加密，則直接使用提供的金鑰；如果是解密，則交換 charsA 和 charsB 的角色。對於明文或密鑰中的每個字元，如果它是大寫或小寫字母，則根據金鑰找到對應的替換字元，並保持原有的大小寫屬性。非字母字元保持不變。

簡單替代加密法的優缺點

簡單替代加密法相較於之前的加密技術，其金鑰空間大大增加，因為金鑰是由26個不同字母的排列組成的，總共有26!種可能的排列方式，這使得暴力破解變得極為困難。然而，這種加密法仍然可以透過頻率分析等密碼分析技術進行破解。