密码模块安全检测认证实施细则：从申请到拿证的全流程指南

// 检查 NIST SP 800-90B 符合性
#include <openssl/rand.h>

int test_rng_quality() {
    unsigned char buf[1024];
    
    // 获取随机数
    if (RAND_bytes(buf, sizeof(buf)) != 1) {
        return -1;
    }
    
    // 运行 NIST 统计测试套件
    // 参考: https://csrc.nist.gov/projects/random-number-generation
    return nist_test_suite(buf, sizeof(buf));
}

# 正确的锁定实现
class AuthenticationManager:
    def __init__(self):
        self.fail_count = 0
        self.lockout_duration = 300  # 5分钟
        self.threshold = 5
    
    def check_password(self, username: str, password: str) -> bool:
        if self.is_locked(username):
            raise LockoutError("Account locked")
        
        if not self.validate(username, password):
            self.fail_count += 1
            if self.fail_count >= self.threshold:
                self.lock_account(username)
            return False
        
        self.fail_count = 0
        return True
    
    def lock_account(self, username: str):
        # 记录锁定时间和原因
        self.locked_until = time.time() + self.lockout_duration
        self.log_security_event(f"Account locked: {username}")
    
    def is_locked(self, username: str) -> bool:
        if username not in self.locked_users:
            return False
        return time.time() < self.locked_users[username]

// 正确的密钥操作接口设计
typedef struct {
    uint8_t key_id[32];      // 仅存储密钥标识符
    uint8_t key_wrapped[256]; // 加密存储的密钥材料
} key_handle_t;

// 禁止直接导出私钥
int crypto_sign(key_handle_t *handle, const uint8_t *msg, size_t msg_len,
                uint8_t *sig, size_t *sig_len) {
    // 私钥操作在 HSM 内部完成
    // 仅返回签名结果
    return hsm_sign_internal(handle->key_id, msg, msg_len, sig, sig_len);
}

// 密钥导出仅支持加密导出
int crypto_export_public_key(key_handle_t *handle, 
                              uint8_t *pub_key, size_t *pub_key_len) {
    // 只允许导出公钥
    return hsm_get_public_key(handle->key_id, pub_key, pub_key_len);
}

# 安全的日志实现
import hashlib
import json
from datetime import datetime

class SecureLogger:
    def __init__(self, log_path: str):
        self.log_path = log_path
        self.chain_hash = b'\x00' * 32  # 链式哈希
    
    def log(self, event_type: str, user: str, details: dict):
        entry = {
            'timestamp': datetime.utcnow().isoformat(),
            'event_type': event_type,
            'user': user,
            'details': details,
            'prev_hash': self.chain_hash.hex(),
        }
        
        # 计算当前条目的哈希
        entry_data = json.dumps(entry, sort_keys=True).encode()
        entry_hash = hashlib.sha256(entry_data).digest()
        
        # 写入日志文件
        with open(self.log_path, 'a') as f:
            f.write(json.dumps(entry) + '\n')
        
        # 更新链式哈希
        self.chain_hash = hashlib.sha256(
            self.chain_hash + entry_hash
        ).digest()
        
        # 关键操作同时写入异地日志服务器
        if event_type in ['KEY_GENERATE', 'KEY_EXPORT', 'ADMIN_CHANGE']:
            self.remote_log(entry)
    
    def verify_integrity(self) -> bool:
        """验证日志完整性"""
        # 重新计算链式哈希
        # 与存储的链式哈希对比
        pass