034_密码学实战：基于哈希的消息认证码HMAC技术深度解析——从原理到安全应用的完整指南

import hashlib

def hash_functions_demo():
    """演示常见哈希函数的使用"""
    message = b"Hello, HMAC World!"
    
    # 使用不同哈希函数计算哈希值
    sha1_hash = hashlib.sha1(message).hexdigest()
    sha256_hash = hashlib.sha256(message).hexdigest()
    sha512_hash = hashlib.sha512(message).hexdigest()
    
    # 打印结果
    print(f"消息: {message.decode()}")
    print(f"SHA-1: {sha1_hash}")
    print(f"SHA-256: {sha256_hash}")
    print(f"SHA-512: {sha512_hash}")
    print(f"\n输出长度:")
    print(f"SHA-1: {len(sha1_hash)*4} 位")  # 每个十六进制字符表示4位
    print(f"SHA-256: {len(sha256_hash)*4} 位")
    print(f"SHA-512: {len(sha512_hash)*4} 位")

# 运行演示
hash_functions_demo()

K' → K'⊕ipad → (K'⊕ipad)||M → H → 内部哈希结果
                                    ↓
K' → K'⊕opad → (K'⊕opad)||(内部哈希结果) → H → HMAC(K,M)

import hmac
import hashlib

def basic_hmac_demo():
    """基本HMAC使用演示"""
    # 密钥和消息
    key = b"my_secret_key"
    message = b"Hello, HMAC World!"
    
    # 使用不同哈希算法计算HMAC
    # SHA-256
    hmac_sha256 = hmac.new(key, message, hashlib.sha256)
    hmac_sha256_hex = hmac_sha256.hexdigest()
    
    # SHA-512
    hmac_sha512 = hmac.new(key, message, hashlib.sha512)
    hmac_sha512_hex = hmac_sha512.hexdigest()
    
    # 打印结果
    print(f"密钥: {key.decode()}")
    print(f"消息: {message.decode()}")
    print(f"HMAC-SHA256: {hmac_sha256_hex}")
    print(f"HMAC-SHA512: {hmac_sha512_hex}")
    
    # 验证HMAC
    def verify_hmac(key, message, expected_hmac, hash_func=hashlib.sha256):
        """验证HMAC值是否正确"""
        computed_hmac = hmac.new(key, message, hash_func).hexdigest()
        # 使用hmac.compare_digest进行安全比较，避免时间侧信道攻击
        return hmac.compare_digest(computed_hmac, expected_hmac)
    
    # 测试验证功能
    is_valid = verify_hmac(key, message, hmac_sha256_hex)
    print(f"\n验证结果: {'有效' if is_valid else '无效'}")
    
    # 测试篡改的消息
    tampered_message = b"Hello, HMAC World! (tampered)"
    is_tampered_valid = verify_hmac(key, tampered_message, hmac_sha256_hex)
    print(f"篡改消息验证结果: {'有效' if is_tampered_valid else '无效'}")

# 运行演示
basic_hmac_demo()

import hashlib

def custom_hmac(key, message, hash_func=hashlib.sha256):
    """手动实现HMAC算法"""
    # 获取哈希函数的块大小
    if hash_func == hashlib.sha256:
        block_size = 64  # SHA-256的块大小为64字节
    elif hash_func == hashlib.sha512:
        block_size = 128  # SHA-512的块大小为128字节
    else:
        # 默认使用64字节作为块大小
        block_size = 64
    
    # 步骤1: 处理密钥
    if len(key) > block_size:
        # 如果密钥长度大于块大小，对密钥进行哈希
        key = hash_func(key).digest()
    if len(key) < block_size:
        # 如果密钥长度小于块大小，在右侧填充0
        key = key.ljust(block_size, b'\x00')
    
    # 步骤2: 准备ipad和opad
    ipad = b'\x36' * block_size
    opad = b'\x5c' * block_size
    
    # 步骤3: 计算内部哈希
    inner_pad = bytes(x ^ y for x, y in zip(key, ipad))
    inner_hash = hash_func(inner_pad + message).digest()
    
    # 步骤4: 计算外部哈希
    outer_pad = bytes(x ^ y for x, y in zip(key, opad))
    hmac_value = hash_func(outer_pad + inner_hash).digest()
    
    return hmac_value

def compare_hmac_implementations():
    """比较自定义HMAC实现与Python标准库实现"""
    key = b"my_secret_key"
    message = b"Hello, HMAC World!"
    
    # 使用标准库计算HMAC
    import hmac
    standard_hmac = hmac.new(key, message, hashlib.sha256).digest()
    
    # 使用自定义实现计算HMAC
    custom_hmac_value = custom_hmac(key, message, hashlib.sha256)
    
    # 比较结果
    print(f"标准库HMAC: {standard_hmac.hex()}")
    print(f"自定义HMAC: {custom_hmac_value.hex()}")
    print(f"实现一致性: {'相同' if standard_hmac == custom_hmac_value else '不同'}")

# 运行比较
compare_hmac_implementations()

import hmac
import hashlib

def streaming_hmac_demo():
    """演示如何流式处理大消息的HMAC计算"""
    key = b"my_secret_key"
    
    # 创建一个HMAC对象
    h = hmac.new(key, digestmod=hashlib.sha256)
    
    # 模拟分块处理大文件
    chunks = [
        b"This is a very large message ",
        b"that needs to be processed ",
        b"in chunks for efficiency."
    ]
    
    # 逐块更新HMAC
    for i, chunk in enumerate(chunks):
        h.update(chunk)
        print(f"已处理块 {i+1}: {chunk.decode()}")
    
    # 获取最终的HMAC值
    hmac_value = h.hexdigest()
    print(f"\n最终HMAC: {hmac_value}")
    
    # 验证结果与一次性处理相同
    full_message = b"This is a very large message that needs to be processed in chunks for efficiency."
    direct_hmac = hmac.new(key, full_message, hashlib.sha256).hexdigest()
    print(f"直接计算HMAC: {direct_hmac}")
    print(f"结果一致性: {'相同' if hmac_value == direct_hmac else '不同'}")

# 运行演示
streaming_hmac_demo()

import hmac
import hashlib

# 服务器端代码
SECRET_KEY = b"very_secure_key"  # 未知密钥

def verify_request(command, received_hmac):
    computed_hmac = hmac.new(SECRET_KEY, command, hashlib.sha256).hexdigest()
    # 存在漏洞的比较方式
    return computed_hmac == received_hmac

def process_request(command, received_hmac):
    if verify_request(command, received_hmac):
        print(f"执行命令: {command.decode()}")
        if b"admin" in command:
            print("获取到flag: FLAG{HMAC_BYPASS_SUCCESS}")
    else:
        print("HMAC验证失败，拒绝执行命令")

import time
import string

def time_based_hmac_attack(target_function, command):
    """使用时间侧信道攻击猜测HMAC值"""
    alphabet = string.ascii_letters + string.digits + "0123456789abcdef"
    hmac_length = 64  # SHA-256生成的HMAC是64个十六进制字符
    guessed_hmac = ""
    
    print("开始时间侧信道攻击...")
    
    # 逐字符猜测HMAC值
    for i in range(hmac_length):
        max_time = 0
        best_char = ""
        
        # 尝试每个可能的字符
        for char in alphabet:
            test_hmac = guessed_hmac + char + "0" * (hmac_length - i - 1)
            
            # 多次测量执行时间以减少噪声
            total_time = 0
            num_trials = 5  # 尝试次数
            
            for _ in range(num_trials):
                start_time = time.time()
                target_function(command, test_hmac)
                end_time = time.time()
                total_time += (end_time - start_time)
            
            avg_time = total_time / num_trials
            
            # 记录最长执行时间的字符
            if avg_time > max_time:
                max_time = avg_time
                best_char = char
        
        # 添加找到的字符到猜测结果
        guessed_hmac += best_char
        print(f"已猜测 {i+1}/{hmac_length} 个字符: {guessed_hmac}")
    
    return guessed_hmac

# 注意：在实际CTF环境中，你需要通过网络请求与服务器交互
# 这里仅作为示例，展示攻击的基本思路

import hmac
import hashlib

def brute_force_hmac_key(message, expected_hmac):
    """暴力破解4位数字PIN作为HMAC密钥"""
    print("开始暴力破解HMAC密钥...")
    
    # 尝试所有4位数字组合
    for pin in range(0, 10000):
        # 格式化为4位，前面补零
        key = f"{pin:04d}".encode()
        
        # 计算HMAC
        computed_hmac = hmac.new(key, message, hashlib.sha256).hexdigest()
        
        # 检查是否匹配
        if computed_hmac == expected_hmac:
            print(f"找到密钥: {key.decode()}")
            return key
        
        # 每1000次尝试输出进度
        if pin % 1000 == 0:
            print(f"已尝试 {pin}/9999 个密钥")
    
    print("未找到密钥")
    return None

# 示例使用
message = b"get_flag"
expected_hmac = "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z6"

found_key = brute_force_hmac_key(message, expected_hmac)
if found_key:
    print(f"使用找到的密钥生成新的HMAC:")
    new_hmac = hmac.new(found_key, b"admin_command", hashlib.sha256).hexdigest()
    print(f"admin_command的HMAC: {new_hmac}")

import hmac
import hashlib

def demonstrate_replay_attack():
    """演示HMAC重放攻击"""
    # 模拟截获的有效请求
    original_command = b"normal_command"
    original_hmac = "abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"
    
    # 模拟服务器验证函数
    def server_verify(command, received_hmac):
        # 注意：没有任何时间戳或nonce验证
        # 在真实服务器中，这里会使用密钥验证HMAC
        # 但在这个演示中，我们假设截获的HMAC总是被接受
        print(f"接收到命令: {command.decode()}")
        print(f"接收到HMAC: {received_hmac}")
        
        # 模拟HMAC验证通过
        print("HMAC验证通过，执行命令")
        
        if b"admin" in command:
            print("危险！执行了管理员命令")
            return True
        return False
    
    # 正常请求
    print("\n正常请求:")
    server_verify(original_command, original_hmac)
    
    # 重放攻击 - 尝试执行管理员命令，但使用相同的HMAC
    print("\n重放攻击尝试1:")
    replay_result = server_verify(b"admin_command", original_hmac)
    
    # 防御措施 - 添加时间戳
    print("\n防御措施演示:")
    
    def secure_server_verify(command_with_timestamp, received_hmac):
        # 提取时间戳和命令
        try:
            timestamp_part, command = command_with_timestamp.split(b":", 1)
            timestamp = int(timestamp_part.decode())
            
            # 检查时间戳是否在允许的时间窗口内（例如5分钟）
            current_time = 1609459200  # 模拟当前时间戳
            time_window = 300  # 5分钟
            
            if abs(current_time - timestamp) > time_window:
                print("时间戳过期，拒绝请求")
                return False
            
            print(f"时间戳有效: {timestamp}")
            print(f"命令: {command.decode()}")
            print("HMAC验证通过")
            return True
            
        except Exception as e:
            print(f"验证失败: {str(e)}")
            return False
    
    # 带时间戳的正常请求
    valid_request = b"1609459200:admin_command"
    print(f"发送带时间戳的请求: {valid_request.decode()}")
    secure_server_verify(valid_request, "any_hmac")
    
    # 过期时间戳的请求
    expired_request = b"1609458600:admin_command"  # 过期10分钟
    print(f"\n发送过期时间戳的请求: {expired_request.decode()}")
    secure_server_verify(expired_request, "any_hmac")

# 运行演示
demonstrate_replay_attack()

import hmac
import hashlib
import random

def hmac_truncation_attack(target_message, target_hmac_prefix, hash_func=hashlib.sha256):
    """HMAC截断攻击"""
    print("开始HMAC截断攻击...")
    print(f"目标消息: {target_message.decode()}")
    print(f"目标HMAC前缀: {target_hmac_prefix}")
    
    attempts = 0
    max_attempts = 1000000  # 设置最大尝试次数，避免无限循环
    
    while attempts < max_attempts:
        # 生成随机消息
        random_bytes = random.randbytes(32)  # 生成32个随机字节
        test_message = f"attack_message_{random_bytes.hex()}".encode()
        
        # 使用未知密钥计算HMAC（在真实场景中，你需要与服务器交互）
        # 这里我们假设密钥是固定的，仅用于演示
        SECRET_KEY = b"unknown_key"  # 在实际场景中未知
        test_hmac = hmac.new(SECRET_KEY, test_message, hash_func).hexdigest()
        
        # 检查前缀是否匹配
        if test_hmac.startswith(target_hmac_prefix):
            print(f"找到匹配！尝试次数: {attempts}")
            print(f"构造的消息: {test_message.decode()}")
            print(f"完整HMAC: {test_hmac}")
            return test_message, test_hmac
        
        attempts += 1
        
        # 每10000次尝试显示进度
        if attempts % 10000 == 0:
            print(f"已尝试 {attempts} 次")
    
    print("在最大尝试次数内未找到匹配")
    return None, None

# 运行演示
target_message = b"original_message"
SECRET_KEY = b"unknown_key"  # 仅用于演示，实际未知
target_hmac = hmac.new(SECRET_KEY, target_message, hashlib.sha256).hexdigest()
target_prefix = target_hmac[:8]  # 假设服务器只验证前8个十六进制字符（4字节）

print(f"原始HMAC: {target_hmac}")
print(f"服务器验证的前缀: {target_prefix}")

attack_message, attack_hmac = hmac_truncation_attack(target_message, target_prefix)

if attack_message:
    print("\n攻击成功！")
    print(f"原始消息: {target_message.decode()}")
    print(f"构造消息: {attack_message.decode()}")
    print(f"两个消息不同，但HMAC前缀相同")

from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
import hmac
import hashlib
import padding
def demonstrate_encrypt_then_mac_issue():
    """演示先加密后MAC与先MAC后加密的区别"""
    # 设置
    key_enc = get_random_bytes(16)  # AES-128密钥
    key_mac = get_random_bytes(16)  # HMAC密钥
    iv = get_random_bytes(16)  # 初始化向量
    message = b"Secret message that needs protection"
    
    print("消息加密与认证演示")
    print(f"原始消息: {message.decode()}")
    
    # 方法1: 先加密后MAC (Encrypt-then-MAC) - 推荐方式
    def encrypt_then_mac(message, key_enc, key_mac, iv):
        # 1. 填充消息
        padded_msg = padding.pad(message, AES.block_size)
        # 2. 加密
        cipher = AES.new(key_enc, AES.MODE_CBC, iv)
        ciphertext = cipher.encrypt(padded_msg)
        # 3. 计算密文的MAC
        mac = hmac.new(key_mac, ciphertext + iv, hashlib.sha256).hexdigest()
        return ciphertext, iv, mac
    
    # 方法2: 先MAC后加密 (MAC-then-Encrypt) - 不安全
    def mac_then_encrypt(message, key_enc, key_mac, iv):
        # 1. 计算消息的MAC
        mac = hmac.new(key_mac, message, hashlib.sha256).hexdigest()
        # 2. 合并消息和MAC
        combined = message + mac.encode()
        # 3. 填充并加密
        padded_combined = padding.pad(combined, AES.block_size)
        cipher = AES.new(key_enc, AES.MODE_CBC, iv)
        ciphertext = cipher.encrypt(padded_combined)
        return ciphertext, iv
    
    # 方法3: 加密并MAC (Encrypt-and-MAC) - 不安全
    def encrypt_and_mac(message, key_enc, key_mac, iv):
        # 1. 填充并加密
        padded_msg = padding.pad(message, AES.block_size)
        cipher = AES.new(key_enc, AES.MODE_CBC, iv)
        ciphertext = cipher.encrypt(padded_msg)
        # 2. 计算原始消息的MAC
        mac = hmac.new(key_mac, message, hashlib.sha256).hexdigest()
        return ciphertext, iv, mac
    
    # 加密并生成MAC
    etm_ciphertext, etm_iv, etm_mac = encrypt_then_mac(message, key_enc, key_mac, iv)
    mte_ciphertext, mte_iv = mac_then_encrypt(message, key_enc, key_mac, iv)
    eam_ciphertext, eam_iv, eam_mac = encrypt_and_mac(message, key_enc, key_mac, iv)
    
    print("\n不同方法的安全性比较:")
    print("1. Encrypt-then-MAC: 安全")
    print("   - 先加密，再对密文计算MAC")
    print("   - MAC验证失败时不会解密消息")
    print("   - 防止填充预言攻击")
    
    print("\n2. MAC-then-Encrypt: 不安全")
    print("   - MAC和消息一起被加密")
    print("   - 可能导致padding oracle攻击")
    print("   - MAC的保护作用被削弱")
    
    print("\n3. Encrypt-and-MAC: 不安全")
    print("   - MAC保护原始消息，不是密文")
    print("   - 可能导致重放攻击")
    print("   - 无法防止对密文的修改")
    
    print("\n安全建议: 始终使用Encrypt-then-MAC方法")

# 注意：运行此代码需要安装pycryptodome库和padding模块
# pip install pycryptodome
# 这里的padding模块需要自己实现或使用现有库
# 在实际CTF环境中，你需要分析服务器实现并利用其漏洞

import hmac
import hashlib
from itertools import product

def password_based_key_attack(message, expected_hmac, charset='abcdefghijklmnopqrstuvwxyz', max_length=4):
    """针对基于密码的HMAC密钥的暴力破解攻击"""
    print(f"开始基于密码的HMAC密钥攻击...")
    print(f"消息: {message.decode()}")
    print(f"目标HMAC: {expected_hmac}")
    
    attempts = 0
    
    # 尝试所有可能的密码组合
    for length in range(1, max_length + 1):
        print(f"尝试长度为 {length} 的密码...")
        
        # 生成所有可能的组合
        for password_tuple in product(charset, repeat=length):
            password = ''.join(password_tuple)
            key = password.encode()
            
            # 计算HMAC
            computed_hmac = hmac.new(key, message, hashlib.sha256).hexdigest()
            attempts += 1
            
            # 检查是否匹配
            if computed_hmac == expected_hmac:
                print(f"找到密钥！尝试次数: {attempts}")
                print(f"密码: {password}")
                return password
            
            # 每10000次尝试显示进度
            if attempts % 10000 == 0:
                print(f"已尝试 {attempts} 个密码")
    
    print("在指定的搜索空间内未找到密钥")
    return None

# 示例使用
message = b"secure_message"
expected_hmac = "1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p7q8r9s0t1u2v3w4x5y6z"  # 示例值

# 注意：在实际应用中，你需要与服务器交互来验证HMAC值
# 这里仅作为示例，演示攻击的基本思路
# password_based_key_attack(message, expected_hmac)

def demonstrate_key_reuse_issue():
    """演示HMAC密钥复用的安全问题"""
    # 使用相同的密钥进行不同用途的HMAC计算
    shared_key = b"reused_hmac_key"
    
    # 场景1: 用于验证API请求
    api_request = b"GET /api/user/profile"
    api_hmac = hmac.new(shared_key, api_request, hashlib.sha256).hexdigest()
    
    # 场景2: 用于生成会话令牌
    session_data = b"user_id=123;role=user"
    session_hmac = hmac.new(shared_key, session_data, hashlib.sha256).hexdigest()
    
    print("HMAC密钥复用安全问题演示:")
    print(f"共享密钥: {shared_key.decode()}")
    print(f"API请求HMAC: {api_hmac}")
    print(f"会话令牌HMAC: {session_hmac}")
    
    print("\n潜在风险:")
    print("1. 跨协议攻击: 如果一个组件被攻破，其他使用相同密钥的组件也会受到威胁")
    print("2. 信息泄露: 可能导致不同系统间的信息泄露")
    print("3. 降级攻击: 攻击者可能利用较弱的应用来攻击较强的应用")
    
    print("\n防御措施:")
    print("1. 为不同用途使用不同的HMAC密钥")
    print("2. 使用密钥派生函数，从主密钥生成多个子密钥")
    print("3. 实施严格的密钥隔离策略")

# 运行演示
demonstrate_key_reuse_issue()

def explain_side_channel_attacks():
    """解释HMAC的侧信道攻击"""
    print("HMAC的侧信道攻击类型:")
    
    print("\n1. 时间侧信道攻击:")
    print("   - 通过测量HMAC计算和验证的时间差异来获取信息")
    print("   - 可能导致密钥部分或全部泄露")
    print("   - 防御: 使用恒定时间比较函数，如hmac.compare_digest")
    
    print("\n2. 功耗分析攻击:")
    print("   - 通过分析设备在计算HMAC时的功耗变化来推断密钥")
    print("   - 特别针对嵌入式设备和智能卡")
    print("   - 防御: 实现功耗均衡技术，如掩码和隐藏")
    
    print("\n3. 电磁辐射分析:")
    print("   - 通过分析设备辐射的电磁场变化来获取密钥信息")
    print("   - 需要特殊的设备和技术")
    print("   - 防御: 电磁屏蔽，抗辐射设计")
    
    print("\n4. 缓存侧信道攻击:")
    print("   - 利用CPU缓存的状态变化来推断加密操作")
    print("   - 特别针对现代处理器架构")
    print("   - 防御: 缓存隔离，安全算法实现")
    
    print("\n综合防御策略:")
    print("1. 使用经过安全审查的密码学库")
    print("2. 实施侧信道防御技术")
    print("3. 进行专门的侧信道安全性测试")
    print("4. 定期更新和修补密码学实现")

# 运行解释
explain_side_channel_attacks()

def explain_length_extension_resistance():
    """解释HMAC对长度扩展攻击的抵抗性"""
    print("HMAC对长度扩展攻击的抵抗性:")
    
    print("\n什么是长度扩展攻击?")
    print("- 针对某些哈希函数(如MD5、SHA-1)的攻击技术")
    print("- 攻击者可以在不知道原始消息的情况下，将额外的数据附加到消息中")
    print("- 并计算出扩展后消息的哈希值")
    
    print("\nHMAC为什么抵抗长度扩展攻击?")
    print("- HMAC的嵌套结构提供了额外的安全性层")
    print("- HMAC(K, M) = H((K' ⊕ opad) || H((K' ⊕ ipad) || M))")
    print("- 即使内部哈希H受到长度扩展攻击，外部哈希仍然提供保护")
    print("- 攻击者需要知道内部哈希的结果才能进行攻击，而这需要知道密钥")
    
    print("\n实际意义:")
    print("1. 即使使用较旧的哈希函数(如SHA-1)，HMAC仍然相对安全")
    print("2. 但仍建议使用SHA-256等更安全的哈希函数作为底层函数")
    print("3. HMAC的这一特性使其成为许多安全协议的首选")

# 运行解释
explain_length_extension_resistance()

def describe_hmac_attack_tools():
    """描述常见的HMAC攻击工具和框架"""
    print("HMAC攻击工具与框架:")
    
    print("\n1. HashPump:")
    print("   - 自动化长度扩展攻击的工具")
    print("   - 支持MD5、SHA-1等哈希函数")
    print("   - 虽然主要针对哈希函数，但可用于HMAC相关测试")
    print("   - 示例命令: hashpump -s <signature> -d <data> -a <append> -k <keylen>")
    
    print("\n2. CryptoLyzer:")
    print("   - 用于分析和测试加密协议和算法的工具")
    print("   - 可用于检测HMAC实现中的安全漏洞")
    print("   - 支持多种哈希函数和加密算法的测试")
    
    print("\n3. Hashcat/JtR:")
    print("   - 强大的密码恢复工具")
    print("   - 可配置用于攻击基于密码的HMAC密钥")
    print("   - 支持GPU加速，大幅提高破解速度")
    print("   - 示例命令: hashcat -m 1400 -a 0 <hashfile> <wordlist>")
    
    print("\n4. FeatherDuster:")
    print("   - 自动化密码学漏洞检测工具")
    print("   - 包含HMAC实现的安全检查")
    print("   - 特别适用于CTF竞赛环境")
    
    print("\n5. Python密码学库:")
    print("   - PyCryptodome: 提供全面的密码学原语实现")
    print("   - cryptography: 提供高级加密接口和安全最佳实践")
    print("   - 可用于构建自定义的HMAC攻击和测试脚本")
    
    print("\n6. 在线HMAC测试工具:")
    print("   - CyberChef: 多功能加密工具，支持HMAC计算和分析")
    print("   - HashCalc: 支持多种哈希和HMAC算法的在线计算器")
    print("   - 可用于快速验证和测试HMAC实现")

# 运行描述
describe_hmac_attack_tools()

# 计算HMAC-SHA256
echo -n "message" | openssl dgst -sha256 -hmac "key"

# 使用文件作为密钥
echo -n "message" | openssl dgst -sha256 -hmac "$(cat keyfile)"

# 计算文件的HMAC
openssl dgst -sha256 -hmac "key" file.txt

# 安装 (Ubuntu/Debian)
# sudo apt-get install hmacsum

# 计算HMAC-SHA256
hmacsum -a sha256 -k "key" "message"

# 验证HMAC
hmacsum -a sha256 -k "key" -c "expected_hmac" "message"

import hmac
import hashlib

# 基本使用
key = b"secret_key"
message = b"Hello, HMAC!"
h = hmac.new(key, message, hashlib.sha256)
print(h.hexdigest())

# 增量更新
key = b"secret_key"
h = hmac.new(key, digestmod=hashlib.sha256)
h.update(b"Part 1")
h.update(b"Part 2")
print(h.hexdigest())

# 安全比较
expected = hmac.new(key, message, hashlib.sha256).hexdigest()
computed = hmac.new(key, message, hashlib.sha256).hexdigest()
print(hmac.compare_digest(expected, computed))

from Crypto.Hash import HMAC, SHA256

# 计算HMAC
h = HMAC.new(b"secret_key", b"Hello, HMAC!", digestmod=SHA256)
print(h.hexdigest())

# 增量更新
h = HMAC.new(b"secret_key", digestmod=SHA256)
h.update(b"Part 1")
h.update(b"Part 2")
print(h.hexdigest())

# 验证
if h.verify(b"expected_hmac_bytes"):
    print("HMAC验证成功")
else:
    print("HMAC验证失败")

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.hmac import HMAC
from cryptography.hazmat.backends import default_backend

# 计算HMAC
key = b"secret_key"
message = b"Hello, HMAC!"
hmac = HMAC(key, hashes.SHA256(), backend=default_backend())
hmac.update(message)
hmac_value = hmac.finalize()
print(hmac_value.hex())

# 验证
try:
    hmac = HMAC(key, hashes.SHA256(), backend=default_backend())
    hmac.update(message)
    hmac.verify(hmac_value)
    print("HMAC验证成功")
except Exception:
    print("HMAC验证失败")

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

public class HMACExample {
    public static void main(String[] args) throws Exception {
        String algorithm = "HmacSHA256";
        String keyString = "secret_key";
        String message = "Hello, HMAC!";
        
        // 获取Mac实例
        Mac mac = Mac.getInstance(algorithm);
        
        // 初始化Mac
        SecretKeySpec keySpec = new SecretKeySpec(keyString.getBytes(), algorithm);
        mac.init(keySpec);
        
        // 计算HMAC
        byte[] hmacBytes = mac.doFinal(message.getBytes());
        
        // 转换为十六进制字符串
        StringBuilder sb = new StringBuilder();
        for (byte b : hmacBytes) {
            sb.append(String.format("%02x", b));
        }
        System.out.println(sb.toString());
    }
}

const crypto = require('crypto');

// 计算HMAC
function computeHMAC(key, message, algorithm = 'sha256') {
    const hmac = crypto.createHmac(algorithm, key);
    hmac.update(message);
    return hmac.digest('hex');
}

// 使用示例
const key = 'secret_key';
const message = 'Hello, HMAC!';
const hmacValue = computeHMAC(key, message);
console.log(hmacValue);

// 验证HMAC
function verifyHMAC(key, message, expectedHMAC, algorithm = 'sha256') {
    const computedHMAC = computeHMAC(key, message, algorithm);
    // Node.js 16+ 推荐使用 timingSafeEqual 进行安全比较
    if (crypto.timingSafeEqual) {
        const expectedBuffer = Buffer.from(expectedHMAC, 'hex');
        const computedBuffer = Buffer.from(computedHMAC, 'hex');
        return crypto.timingSafeEqual(expectedBuffer, computedBuffer);
    }
    return computedHMAC === expectedHMAC;
}

from pwn import *

# 计算HMAC
key = b"secret_key"
message = b"Hello, HMAC!"
hmac_value = hmac.new(key, message, hashlib.sha256).hexdigest()
print(hmac_value)

# 在网络通信中使用HMAC
r = remote('example.com', 1234)
r.recvuntil(b'> ')
r.sendline(b'command' + hmac_value.encode())

HMAC学习路径建议:
基础哈希函数 → HMAC原理 → 安全实现 → CTF挑战 → 高级应用 → 安全研究

HMAC学习路径建议:
基础哈希函数 → HMAC原理 → 安全实现 → CTF挑战 → 高级应用 → 安全研究