from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
import base64

class RSACipher:
    """RSA非對稱加密解密工具類"""
    
    def __init__(self, key_size=2048):
        """
        初始化RSA密鑰對
        
        步驟作用：
        1. 設置密鑰長度（2048位是當前安全標準）
        2. 生成RSA密鑰對
        3. 分離公鑰和私鑰
        """
        self.key_size = key_size  # 密鑰位數(shù)，決定安全性
        # RSA.generate()作用：生成RSA密鑰對，基于大素數(shù)分解難題
        self.key_pair = RSA.generate(key_size)
        # 私鑰：用于解密和簽名，必須保密
        self.private_key = self.key_pair
        # 公鑰：用于加密和驗證，可以公開分發(fā)
        self.public_key = self.key_pair.publickey()
        print(f"[RSA初始化] 生成{key_size}位密鑰對完成")
    
    def encrypt(self, plaintext, public_key=None):
        """使用公鑰加密
        
        步驟作用：
        1. 創(chuàng)建PKCS1_OAEP加密器
        2. 將文本轉換為字節(jié)
        3. 檢查長度限制（RSA不能加密太長數(shù)據(jù)）
        4. 執(zhí)行加密
        5. Base64編碼便于傳輸
        """
        try:
            # PKCS1_OAEP.new()作用：創(chuàng)建使用OAEP填充的RSA加密器
            # OAEP填充：增加隨機性，防止確定性攻擊
            cipher = PKCS1_OAEP.new(public_key or self.public_key)
            
            # encode()作用：將字符串轉換為UTF-8字節(jié)序列
            plaintext_bytes = plaintext.encode('utf-8')
            
            # RSA長度限制計算：
            # - 密鑰大?。簁ey_size//8 = 字節(jié)數(shù)
            # - OAEP填充占用42字節(jié)
            max_length = (self.key_size // 8) - 42
            print(f"[RSA加密] 明文長度: {len(plaintext_bytes)}字節(jié), 最大支持: {max_length}字節(jié)")
            
            if len(plaintext_bytes) > max_length:
                raise ValueError(f"文本過長，最大支持 {max_length} 字節(jié)")
            
            # encrypt()作用：使用公鑰加密數(shù)據(jù)
            # 原理：使用公鑰的指數(shù)e和模數(shù)n進行模冪運算
            ciphertext = cipher.encrypt(plaintext_bytes)
            print(f"[RSA加密] 加密完成，密文長度: {len(ciphertext)}字節(jié)")
            
            # base64編碼：將二進制數(shù)據(jù)轉換為可安全傳輸?shù)奈谋靖袷?
            return base64.b64encode(ciphertext).decode('utf-8')
        except Exception as e:
            return f"加密失敗: {e}"
    
    def decrypt(self, ciphertext):
        """使用私鑰解密
        
        步驟作用：
        1. Base64解碼
        2. 創(chuàng)建PKCS1_OAEP解密器
        3. 使用私鑰解密
        4. 將字節(jié)轉換回字符串
        """
        try:
            # 創(chuàng)建使用私鑰的解密器
            cipher = PKCS1_OAEP.new(self.private_key)
            
            # base64解碼：將文本格式轉換回二進制數(shù)據(jù)
            ciphertext_bytes = base64.b64decode(ciphertext)
            print(f"[RSA解密] 密文長度: {len(ciphertext_bytes)}字節(jié)")
            
            # decrypt()作用：使用私鑰解密數(shù)據(jù)
            # 原理：使用私鑰的指數(shù)d和模數(shù)n進行模冪運算
            decrypted_bytes = cipher.decrypt(ciphertext_bytes)
            print(f"[RSA解密] 解密完成，明文長度: {len(decrypted_bytes)}字節(jié)")
            
            # decode()作用：將UTF-8字節(jié)序列轉換回字符串
            return decrypted_bytes.decode('utf-8')
        except Exception as e:
            return f"解密失敗: {e}"
    
    def get_public_key_pem(self):
        """獲取PEM格式的公鑰
        作用：將公鑰轉換為標準PEM格式，便于存儲和傳輸"""
        return self.public_key.export_key().decode('utf-8')
    
    def get_private_key_pem(self):
        """獲取PEM格式的私鑰
        作用：將私鑰轉換為標準PEM格式，便于安全存儲"""
        return self.private_key.export_key().decode('utf-8')

"""
混合加密系統(tǒng)：RSA加密AES密鑰 + AES加密實際數(shù)據(jù)
這是行業(yè)標準做法，兼顧安全性和性能
"""

class HybridEncryptionSystem:
    def __init__(self):
        # RSA用于密鑰交換
        self.rsa_cipher = RSACipher()
        # AES用于數(shù)據(jù)加密
        self.aes_cipher = AESCipher()
    
    def encrypt_data(self, plaintext: str, recipient_public_key) -> dict:
        """
        加密流程：
        1. 使用AES加密原始數(shù)據(jù)（高效）
        2. 使用RSA加密AES密鑰（安全傳輸）
        """
        # AES加密數(shù)據(jù)
        encrypted_data = self.aes_cipher.encrypt(plaintext)
        
        # RSA加密AES密鑰
        encrypted_key = self.rsa_cipher.encrypt(
            self.aes_cipher.get_key_base64(), 
            recipient_public_key
        )
        
        return {
            "encrypted_data": encrypted_data,
            "encrypted_aes_key": encrypted_key,
            "rsa_public_key": self.rsa_cipher.get_public_key_pem()  # 可選，用于回復
        }
    
    def decrypt_data(self, encrypted_package: dict, rsa_private_key) -> str:
        """
        解密流程：
        1. 使用RSA私鑰解密AES密鑰
        2. 使用AES密鑰解密數(shù)據(jù)
        """
        # 解密AES密鑰
        decrypted_key_b64 = self.rsa_cipher.decrypt(
            encrypted_package["encrypted_aes_key"], 
            rsa_private_key
        )
        
        # 設置AES密鑰
        self.aes_cipher.set_key_from_base64(decrypted_key_b64)
        
        # 解密數(shù)據(jù)
        return self.aes_cipher.decrypt(encrypted_package["encrypted_data"])

# 使用示例
def hybrid_encryption_demo():
    # 發(fā)送方
    sender = HybridEncryptionSystem()
    
    # 接收方的RSA公鑰（假設已安全獲?。?
    recipient_public_key = "接收方的RSA公鑰PEM格式"
    
    # 加密數(shù)據(jù)
    original_data = "敏感業(yè)務數(shù)據(jù)"
    encrypted_package = sender.encrypt_data(original_data, recipient_public_key)
    
    print("加密完成:")
    print(f"- AES加密數(shù)據(jù)長度: {len(encrypted_package['encrypted_data'])}")
    print(f"- RSA加密的AES密鑰: {encrypted_package['encrypted_aes_key'][:50]}...")
    
    # 接收方解密（使用自己的RSA私鑰）
    # decrypted = recipient.decrypt_data(encrypted_package, recipient_private_key)

from Crypto.Protocol.KDF import PBKDF2
        from Crypto.Cipher import AES
        import os
        
        # 生成加密密鑰
        salt = os.urandom(32)
        key = PBKDF2(password, salt, 32, count=100000)
        
        # 加密私鑰
        private_key_pem = "RSA私鑰PEM內(nèi)容"
        iv = os.urandom(16)
        cipher = AES.new(key, AES.MODE_CBC, iv)
        encrypted_private_key = cipher.encrypt(pad(private_key_pem.encode(), 16))
        
        # 存儲：salt + iv + 加密私鑰
        storage_data = salt + iv + encrypted_private_key
        
        return {
            "存儲格式": "salt(32) + iv(16) + 加密私鑰",
            "解密要求": "需要正確密碼",
            "安全性": "中等，依賴密碼強度"
        }

# .startswith(prefix): 檢查是否以指定前綴開頭
filename = "document.pdf"
print(filename.startswith("doc"))    # 輸出: True
print(filename.startswith("xls"))    # 輸出: False

# .endswith(suffix): 檢查是否以指定后綴結尾  
print(filename.endswith(".pdf"))     # 輸出: True
print(filename.endswith(".docx"))    # 輸出: False

# .isalpha(): 是否全是字母（中文也被認為是字母）
print("Hello".isalpha())      # 輸出: True
print("Hello123".isalpha())   # 輸出: False
print("你好".isalpha())        # 輸出: True

# .isdigit(): 是否全是數(shù)字
print("123".isdigit())        # 輸出: True
print("12.3".isdigit())       # 輸出: False

# .isalnum(): 是否全是字母或數(shù)字
print("Hello123".isalnum())   # 輸出: True
print("Hello 123".isalnum())  # 輸出: False（包含空格）

# .isspace(): 是否全是空白字符
print("   ".isspace())        # 輸出: True
print("  x  ".isspace())      # 輸出: False

"""
Pydantic - 現(xiàn)代Python的數(shù)據(jù)驗證和設置管理
特點：性能高、類型提示友好、功能強大
安裝：pip install pydantic
"""

from pydantic import BaseModel, EmailStr, validator, Field
from typing import Optional
import re

class User(BaseModel):
    # 基礎字段驗證
    name: str = Field(..., min_length=1, max_length=50)
    age: int = Field(..., ge=0, le=150)  # 大于等于0，小于等于150
    
    # 內(nèi)置郵箱驗證
    email: EmailStr
    
    # 自定義手機號驗證
    phone: str = Field(..., regex=r'^1[3-9]\d{9}$')
    
    # 自定義驗證器
    @validator('name')
    def name_must_contain_letters(cls, v):
        if not any(c.isalpha() for c in v):
            raise ValueError('姓名必須包含字母')
        return v.title()  # 自動格式化
    
    @validator('phone')
    def validate_phone_format(cls, v):
        if not re.match(r'^1[3-9]\d{9}$', v):
            raise ValueError('手機號格式不正確')
        return v

# 使用示例
def pydantic_demo():
    # 正確數(shù)據(jù)
    try:
        user = User(
            name="張三",
            age=25,
            email="test@example.com", 
            phone="13800138000"
        )
        print(f"驗證成功: {user.dict()}")
    except Exception as e:
        print(f"驗證失敗: {e}")
    
    # 錯誤數(shù)據(jù)測試
    test_cases = [
        {"name": "", "age": 25, "email": "invalid", "phone": "123"},
        {"name": "John", "age": 200, "email": "test@example.com", "phone": "13800138000"},
    ]
    
    for data in test_cases:
        try:
            user = User(**data)
        except Exception as e:
            print(f"驗證失敗: {e}")

pydantic_demo()

"""
Cerberus - 輕量級數(shù)據(jù)驗證庫
特點：Schema定義簡單、靈活性強
安裝：pip install cerberus
"""

from cerberus import Validator

# 定義驗證規(guī)則
user_schema = {
    'name': {
        'type': 'string', 
        'minlength': 1, 
        'maxlength': 50,
        'required': True
    },
    'age': {
        'type': 'integer', 
        'min': 0, 
        'max': 150,
        'required': True
    },
    'email': {
        'type': 'string', 
        'regex': r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$',
        'required': True
    },
    'phone': {
        'type': 'string', 
        'regex': r'^1[3-9]\d{9}$',
        'required': True
    }
}

# 自定義驗證規(guī)則
def validate_email_domain(field, value, error):
    """自定義郵箱域名驗證"""
    blocked_domains = ['temp-mail.org', '10minutemail.com']
    domain = value.split('@')[1]
    if domain in blocked_domains:
        error(field, f"不允許使用臨時郵箱域名: {domain}")

user_schema['email']['validator'] = validate_email_domain

def cerberus_demo():
    validator = Validator(user_schema)
    
    # 測試數(shù)據(jù)
    test_data = {
        'name': '李四',
        'age': 30,
        'email': 'lisi@example.com',
        'phone': '13900139000'
    }
    
    if validator.validate(test_data):
        print("數(shù)據(jù)驗證通過")
        print(f"規(guī)范化后的數(shù)據(jù): {validator.document}")
    else:
        print("數(shù)據(jù)驗證失敗:")
        print(f"錯誤信息: {validator.errors}")

cerberus_demo()

"""
Voluptuous - 專注于數(shù)據(jù)驗證的庫
特點：語法優(yōu)雅、錯誤信息清晰
安裝：pip install voluptuous
"""

from voluptuous import Schema, Required, All, Length, Range, Email, Url, MultipleInvalid
import re

# 定義驗證schema
user_schema = Schema({
    Required('name'): All(str, Length(min=1, max=50)),
    Required('age'): All(int, Range(min=0, max=150)),
    Required('email'): Email(),
    Required('phone'): All(str, Length(min=11, max=11)),
    'website': Url(),  # 可選字段
})

# 自定義驗證函數(shù)
def validate_phone(value):
    if not re.match(r'^1[3-9]\d{9}$', value):
        raise ValueError('手機號格式不正確')
    return value

# 更新schema加入自定義驗證
user_schema = Schema({
    Required('name'): All(str, Length(min=1, max=50)),
    Required('age'): All(int, Range(min=0, max=150)),
    Required('email'): Email(),
    Required('phone'): All(str, Length(min=11, max=11), validate_phone),
})

def voluptuous_demo():
    # 正確數(shù)據(jù)
    valid_data = {
        'name': '王五',
        'age': 28,
        'email': 'wangwu@example.com',
        'phone': '13700137000'
    }
    
    try:
        result = user_schema(valid_data)
        print(f"驗證成功: {result}")
    except MultipleInvalid as e:
        print(f"驗證失敗: {e}")
    
    # 錯誤數(shù)據(jù)
    invalid_data = {
        'name': '',
        'age': 200,
        'email': 'invalid-email',
        'phone': '123'
    }
    
    try:
        result = user_schema(invalid_data)
    except MultipleInvalid as e:
        print(f"驗證失敗詳情:")
        for error in e.errors:
            print(f"- {error}")

voluptuous_demo()

import re

# re模塊核心函數(shù)
text = "我的電話是138-0013-8000，郵箱是test@example.com"

# 1. re.search() - 查找第一個匹配
match = re.search(r'\d{3}-\d{4}-\d{4}', text)
if match:
    print(f"找到電話: {match.group()}")  # 138-0013-8000

# 2. re.findall() - 查找所有匹配
emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)
print(f"所有郵箱: {emails}")  # ['test@example.com']

# 3. re.finditer() - 返回迭代器（可獲取位置）
for match in re.finditer(r'\d+', text):
    print(f"數(shù)字: {match.group()}, 位置: {match.span()}")

# 4. re.sub() - 替換
anonymized = re.sub(r'\d{4}$', 'XXXX', '13800138000')
print(f"匿名化: {anonymized}")  # 1380013XXXX

# 5. re.split() - 分割
parts = re.split(r'[，。]', "你好，世界。今天天氣不錯。")
print(f"分割結果: {parts}")  # ['你好', '世界', '今天天氣不錯', '']

"""
正則表達式元字符和語法
"""

def regex_syntax_demo():
    text = "價格是￥100.50，折扣后￥80.25，聯(lián)系人: 張先生"
    
    # 字符類
    print("1. 字符類:")
    print(re.findall(r'[張李王]先生', text))  # ['張先生']
    print(re.findall(r'[0-9]', text))  # ['1', '0', '0', '5', '0', '8', '0', '2', '5']
    
    # 量詞
    print("\n2. 量詞:")
    print(re.findall(r'\d+', text))  # ['100', '50', '80', '25'] - 1次或多次
    print(re.findall(r'\d*', text))  # 包含空字符串
    print(re.findall(r'\d{2,3}', text))  # ['100', '50', '80', '25'] - 2到3次
    print(re.findall(r'￥\d+\.?\d*', text))  # ['￥100.50', '￥80.25']
    
    # 邊界和位置
    print("\n3. 邊界匹配:")
    print(re.findall(r'^價格', text))  # ['價格'] - 開頭
    print(re.findall(r'先生$', "張先生"))  # ['先生'] - 結尾
    print(re.findall(r'\b聯(lián)系人', text))  # ['聯(lián)系人'] - 單詞邊界
    
    # 分組和捕獲
    print("\n4. 分組捕獲:")
    match = re.search(r'￥(\d+)\.(\d+)', text)
    if match:
        print(f"完整匹配: {match.group(0)}")  # ￥100.50
        print(f"整數(shù)部分: {match.group(1)}")  # 100
        print(f"小數(shù)部分: {match.group(2)}")  # 50
        print(f"所有分組: {match.groups()}")  # ('100', '50')

regex_syntax_demo()

import re
def advanced_regex_features():
    """高級正則特性"""

    text = """
    用戶信息:
    - 姓名: 張三, 年齡: 25, 郵箱: zhangsan@example.com
    - 姓名: 李四, 年齡: 30, 郵箱: lisi@test.org
    - 姓名: 王五, 年齡: 28, 郵箱: wangwu@domain.cn
    """

    # 1. 命名分組
    pattern = r"姓名: (?P<name>[^,]+), 年齡: (?P<age>\d+), 郵箱: (?P<email>[^\s]+)"

    for match in re.finditer(pattern, text):
        print(f"\n命名分組結果:")
        print(f"  姓名: {match.group('name')}")
        print(f"  年齡: {match.group('age')}")
        print(f"  郵箱: {match.group('email')}")

    # 2. 非捕獲分組
    # (?:...) 不捕獲的分組
    numbers = "100元 200美元 300歐元"
    currencies = re.findall(r'(\d+)(?:元|美元|歐元)', numbers)
    print(f"\n非捕獲分組: {currencies}")  # ['100', '200', '300']

    # 3. 前后查找
    # (?=...) 正向肯定前瞻, (?!...) 正向否定前瞻
    # (?<=...) 正向肯定后顧, (?<!...) 正向否定后顧

    # 匹配后面是"元"的數(shù)字
    prices = re.findall(r'\d+(?=元)', numbers)
    print(f"價格(元): {prices}")  # ['100']

    # 匹配前面是"$"的數(shù)字
    dollar_text = "價格$100 重量100kg"
    dollar_prices = re.findall(r'(?<=\$)\d+', dollar_text)
    print(f"美元價格: {dollar_prices}")  # ['100']

    # 4. 條件匹配
    pattern = r'(\d+)(?(1)元|美元)'  # 如果有分組1匹配"元"，否則匹配"美元"

    # 5. 注釋和詳細模式
    complex_pattern = r"""
        ^                   # 字符串開始
        (\w+)               # 用戶名 - 分組1
        @                   # @符號
        (\w+                # 域名前綴 - 分組2
        \.                  # 點號
        \w+)                # 域名后綴 - 分組3
        $                   # 字符串結束
    """

    email = "user@example.com"
    match = re.search(complex_pattern, email, re.VERBOSE)
    if match:
        print(f"\n詳細模式解析:")
        print(f"  用戶名: {match.group(1)}")
        print(f"  域名: {match.group(2)}")

advanced_regex_features()

"""
regex庫 - 更強大、更兼容的正則表達式庫
安裝: pip install regex
特點: 支持更多特性、更好的Unicode支持、兼容re API
"""

import regex  # 注意導入的是regex不是re

def regex_library_demo():
    """regex庫高級特性演示"""
    
    text = "測試unicode: ???? 表情符號和中文"
    
    # 1. 更好的Unicode支持
    print("1. Unicode支持:")
    # 匹配所有字母字符（包括中文）
    print(regex.findall(r'\p{L}+', text))  # ['測試unicode', '表情符號和中文']
    # 匹配表情符號
    print(regex.findall(r'\p{Emoji}', text))  # ['??', '??']
    
    # 2. 重疊匹配
    print("\n2. 重疊匹配:")
    text = "aaa"
    # 標準re庫只能找到 ['aaa']
    # regex可以找到所有重疊匹配
    matches = regex.findall(r'a.a', text, overlapped=True)
    print(f"重疊匹配: {matches}")  # ['aaa']
    
    # 3. 模糊匹配（容錯匹配）
    print("\n3. 模糊匹配:")
    text = "color centre favorite"
    # 允許拼寫錯誤（美式vs英式英語）
    pattern = regex.compile(r'(?e)(color){e<=1}')  # 允許1個錯誤
    matches = pattern.findall(text)
    print(f"模糊匹配: {matches}")  # ['color', 'colou']
    
    # 4. 遞歸模式
    print("\n4. 遞歸模式:")
    html = "<div>內(nèi)容<span>嵌套</span>更多內(nèi)容</div>"
    # 匹配嵌套的HTML標簽
    pattern = regex.compile(r'<([^>]+)>(?:[^<>]|(?R))*</\1>')
    matches = pattern.findall(html)
    print(f"遞歸匹配: {matches}")
    
    # 5. 集合操作
    print("\n5. 集合操作:")
    text = "abc123漢字??"
    # 匹配數(shù)字或字母
    matches = regex.findall(r'[[:alnum:]]', text)
    print(f"字母數(shù)字: {matches}")
    
    # 6. 分支重置
    print("\n6. 分支重置:")
    text = "日期: 2023-01-15 或 2023/01/15"
    # 使用分支重置組，組號在不同分支中保持一致
    pattern = r'(\d{4})(?|-(0[1-9]|1[0-2])-([0-2][0-9]|3[01])|/(0[1-9]|1[0-2])/([0-2][0-9]|3[01]))'
    matches = regex.findall(pattern, text)
    print(f"分支重置匹配: {matches}")

regex_library_demo()