1
def identify_base_encoding(text):
2
    """
3
    根據字符特征識別Base編碼類型
4
    """
5
    if all(c in '0123456789ABCDEF' for c in text.upper()):
6
        return "可能是Base16 (Hex)"
7

8
    if all(c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=' for c in text.upper()):
9
        return "可能是Base32"
10

11
    if all(c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=' for c in text):
12
        return "可能是Base64"
13

14
    # 檢查是否包含emoji
15
    if any(ord(c) > 127 for c in text):
16
        return "可能是Base100或其他Unicode編碼"
17

18
    return "未知編碼"

1
import base64
2

3
# 示例：三層Base64編碼
4
def multi_base64_decode(text, layers=3):
5
    result = text
6
    for i in range(layers):
7
        try:
8
            result = base64.b64decode(result).decode('utf-8')
9
            print(f"第{i+1}層解碼結果: {result}")
10
        except:
11
            print(f"第{i+1}層解碼失敗")
12
            break
13
    return result

1
# 換表解密示例
2
def custom_base64_decode(cipher, custom_table):
3
    standard_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
4

5
    # 構建轉換字典
6
    trans = str.maketrans(custom_table, standard_table)
7
    standard_cipher = cipher.translate(trans)
8

9
    return base64.b64decode(standard_cipher)
10

11
# 實際案例
12
custom_table = "J K L M N O x y U V z A B C D E F G H 7 8 9 P Q I a b c d e f g h i j k l m W X Y Z 0 1 2 3 4 5 6 R S T n o p q r s t u v w + / ="
13
cipher = "FlZNfnF6Qol6e9w17WwQQoGYBQCgIkGTa9w3IQKw"
14
print(custom_base64_decode(cipher, custom_table))

1
def base64_xor_decode(cipher, key):
2
    # 先Base64解碼
3
    decoded = base64.b64decode(cipher)
4

5
    # 再進行XOR運算
6
    result = bytes([decoded[i] ^ ord(key[i % len(key)]) for i in range(len(decoded))])
7

8
    return result.decode('utf-8')

1
import hashlib
2
import hmac
3

4
# 常用哈希函數示例
5
def hash_examples():
6
    message = b"Hello, Cryptography!"
7

8
    # MD5（不安全，僅作演示）
9
    md5_hash = hashlib.md5(message).hexdigest()
10
    print(f"MD5: {md5_hash}")
11

12
    # SHA-256（推薦）
13
    sha256_hash = hashlib.sha256(message).hexdigest()
14
    print(f"SHA-256: {sha256_hash}")
15

16
    # SHA-3（新標準）
17
    sha3_hash = hashlib.sha3_256(message).hexdigest()
18
    print(f"SHA3-256: {sha3_hash}")
19

20
    # HMAC（帶密鑰的哈希）
21
    key = b"secret_key"
22
    hmac_hash = hmac.new(key, message, hashlib.sha256).hexdigest()
23
    print(f"HMAC-SHA256: {hmac_hash}")
24

25
# 哈希長度擴展攻擊示例
26
def length_extension_attack():
27
    """演示SHA-1/SHA-256的長度擴展攻擊"""
28
    # 已知：hash(secret || known_message) = known_hash
29
    # 目標：計算hash(secret || known_message || padding || attack_message)
30

31
    from hashlib import sha256
32
    import struct
33

34
    def sha256_padding(msg_len):
35
        """計算SHA-256的填充"""
36
        msg_bit_len = msg_len * 8
37
        padding = b'\x80'
38

39
        # 填充到448 mod 512
40
        while (len(padding) + msg_len) % 64 != 56:
41
            padding += b'\x00'
42

43
        # 添加長度（8字節大端序）
44
        padding += struct.pack('>Q', msg_bit_len)
45
        return padding
46

47
    # 這只是演示概念，實際攻擊需要更復雜的實現
48
    print("長度擴展攻擊需要已知消息長度和哈希值")

1
from Crypto.Hash import SHA256
2
from Crypto.PublicKey import RSA
3
from Crypto.Signature import PKCS1_v1_5
4

5
def rsa_sign_verify():
6
    # 生成密鑰對
7
    key = RSA.generate(2048)
8
    private_key = key
9
    public_key = key.publickey()
10

11
    # 要簽名的消息
12
    message = b"Important document"
13

14
    # 創建簽名
15
    hash_obj = SHA256.new(message)
16
    signer = PKCS1_v1_5.new(private_key)
17
    signature = signer.sign(hash_obj)
18

19
    # 驗證簽名
20
    verifier = PKCS1_v1_5.new(public_key)
21
    try:
22
        verifier.verify(hash_obj, signature)
23
        print("簽名驗證成功")
24
    except ValueError:
25
        print("簽名驗證失敗")

1
from ecdsa import SigningKey, VerifyingKey, SECP256k1
2
import hashlib
3

4
def ecdsa_sign_verify():
5
    # 生成密鑰對
6
    private_key = SigningKey.generate(curve=SECP256k1)
7
    public_key = private_key.get_verifying_key()
8

9
    # 簽名
10
    message = b"Blockchain transaction"
11
    signature = private_key.sign(message, hashfunc=hashlib.sha256)
12

13
    # 驗證
14
    try:
15
        public_key.verify(signature, message, hashfunc=hashlib.sha256)
16
        print("ECDSA簽名驗證成功")
17
    except:
18
        print("ECDSA簽名驗證失敗")

1
# 計時攻擊演示
2
import time
3
import statistics
4

5
def timing_attack_demo():
6
    """演示計時攻擊的概念"""
7

8
    def vulnerable_compare(guess, target):
9
        """有漏洞的字符串比較"""
10
        for i in range(min(len(guess), len(target))):
11
            if guess[i] != target[i]:
12
                return False
13
            time.sleep(0.001)  # 模擬處理時間
14
        return len(guess) == len(target)
15

16
    def timing_attack(target_length):
17
        """通過計時攻擊猜測密碼"""
18
        charset = 'abcdefghijklmnopqrstuvwxyz0123456789'
19
        result = ""
20

21
        for pos in range(target_length):
22
            best_char = ''
23
            max_time = 0
24

25
            for char in charset:
26
                guess = result + char + 'a' * (target_length - pos - 1)
27

28
                # 測量多次取平均值
29
                times = []
30
                for _ in range(10):
31
                    start = time.time()
32
                    vulnerable_compare(guess, "secret123")  # 假設目標
33
                    times.append(time.time() - start)
34

35
                avg_time = statistics.mean(times)
36
                if avg_time > max_time:
37
                    max_time = avg_time
38
                    best_char = char
39

40
            result += best_char
41
            print(f"當前猜測: {result}")
42

43
        return result

1
def crypto_challenge_identifier(ciphertext):
2
    """CTF密碼學題型識別工具"""
3

4
    # 統計字符頻率
5
    char_freq = {}
6
    for c in ciphertext:
7
        char_freq[c] = char_freq.get(c, 0) + 1
8

9
    # 分析長度特征
10
    length = len(ciphertext)
11

12
    # 判斷可能的編碼類型
13
    if all(c in '01' for c in ciphertext):
14
        return "二進制編碼"
15

16
    if all(c in '0123456789ABCDEF' for c in ciphertext.upper()):
17
        return "十六進制編碼"
18

19
    if length % 4 == 0 and all(c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=' for c in ciphertext):
20
        return "Base64編碼"
21

22
    # 頻率分析
23
    most_common = max(char_freq.values())
24
    if most_common / length > 0.12:  # 英語中E的頻率約12%
25
        return "可能是單表替換密碼"
26

27
    return "複雜密碼或多重編碼"
28

29
# 自動化解題腳本
30
def auto_decode_pipeline(ciphertext):
31
    """自動化解碼流水線"""
32
    import base64
33

34
    results = []
35

36
    # 嘗試Base64
37
    try:
38
        decoded = base64.b64decode(ciphertext).decode('utf-8')
39
        results.append(f"Base64: {decoded}")
40
    except:
41
        pass
42

43
    # 嘗試十六進制
44
    try:
45
        decoded = bytes.fromhex(ciphertext).decode('utf-8')
46
        results.append(f"Hex: {decoded}")
47
    except:
48
        pass
49

50
    # 嘗試凱撒密碼（所有可能的偏移）
51
    for shift in range(26):
52
        decoded = ''.join([chr((ord(c) - ord('A') - shift) % 26 + ord('A')) if c.isupper()
53
                          else chr((ord(c) - ord('a') - shift) % 26 + ord('a')) if c.islower()
54
                          else c for c in ciphertext])
55
        if 'flag' in decoded.lower() or 'ctf' in decoded.lower():
56
            results.append(f"Caesar {shift}: {decoded}")
57

58
    return results

1
# 推薦的Python密碼學庫
2
libraries = {
3
    'pycryptodome': '現代密碼學實現',
4
    'cryptography': '高級密碼學API',
5
    'hashlib': '哈希函數（內建）',
6
    'gmpy2': '大數運算',
7
    'sympy': '數學計算',
8
    'ecdsa': '橢圓曲線數字簽名',
9
    'sage': '數學計算框架（CTF神器）'
10
}