个人交易规则加密存储工具（教学
定位：去营销化、中立、可教学、可扩展
⚠️ 全文含免责声明与风险提示，不荐股、不承诺收益、不引导开户、无任何引流
一、实际应用场景描述
在智能证券投资课程中，交易纪律执行与策略保密（Trading Discipline & Strategy Confidentiality）是实盘前最重要的训练环节之一。
本程序适用于：
- 高校量化投资、证券实务课程实验
- 个人投资者交易规则管理与保护
- 量化策略知识产权保护的入门教学
- 多设备同步交易计划时的数据安全演示
核心目标：
- 将自定义买卖策略规则安全存储
- 使用加密算法防止策略被随意篡改或泄露
- 提供读取、更新、验证的完整流程
- 强调本地存储、用户自主管理密钥
✅ 不连接网络
✅ 不执行交易
✅ 仅作为数据安全与策略管理教学工具
二、痛点引入（真实可感知）
痛点 表现
策略写明文 交易规则存 txt/Excel，裸奔
多设备不同步 U 盘拷来拷去，版本混乱
被误改 / 恶意改 策略参数被同事或家人改动
缺乏完整性校验 不知道规则何时被改过
专业工具重 HSM / 密钥管理系统对个人太重
👉 需要一个轻量、本地、可解释、可复现的策略加密存储方案
三、核心逻辑讲解（工程视角）
1️⃣ 数据模型设计
TradingRule
├── rule_id 规则唯一标识（UUID）
├── name 策略名称
├── buy_conditions 买入条件（JSON）
├── sell_conditions 卖出条件（JSON）
├── created_at 创建时间
├── updated_at 最后修改时间
└── checksum 完整性校验值
2️⃣ 加密方案设计（教学用）
层次 技术 作用
序列化 JSON 结构化存储
完整性 HMAC-SHA256 防篡改检测
加密 AES-256-GCM（简化模拟） 防泄露
密钥 用户自定义口令 自主控制
⚠️ 教学中强调：这是教学级方案，生产环境需使用专业密钥管理系统（KMS）。
3️⃣ 核心流程
写入流程：
策略规则 → JSON 序列化 → HMAC 签名 → 加密 → 本地文件
读取流程：
本地文件 → 解密 → HMAC 校验 → JSON 反序列化 → 策略规则
校验流程：
读取文件 → 重新计算 HMAC → 对比存储的 HMAC → 判断完整性
4️⃣ 安全特性
特性 实现方式
防篡改 HMAC 校验，任何改动都会被发现
防泄露 加密存储，无密钥无法读取
版本追踪 创建 / 修改时间戳
完整性证明 Checksum 校验值
5️⃣ 设计原则
- 密钥由用户全权掌控，不存储明文密码
- 规则透明，加密的是存储层
- 可审计，每次读取都校验完整性
四、Python 模块化代码（可直接运行）
📁 项目结构
trading_rule_vault/
│
├── main.py
├── models.py
├── crypto.py
├── vault.py
├── reporter.py
├── storage.py
├── README.md
└── DISCLAIMER.md
✅ models.py（数据建模）
"""
models.py
交易规则数据模型
"""
import uuid
import hashlib
import json
from datetime import datetime
class TradingRule:
"""单条交易规则"""
def __init__(self, name, buy_conditions, sell_conditions):
"""
name: 策略名称
buy_conditions: 买入条件字典
sell_conditions: 卖出条件字典
"""
self.rule_id = str(uuid.uuid4())
self.name = name
self.buy_conditions = buy_conditions
self.sell_conditions = sell_conditions
self.created_at = datetime.now().isoformat()
self.updated_at = self.created_at
self.checksum = None
def to_dict(self):
"""序列化为字典"""
return {
"rule_id": self.rule_id,
"name": self.name,
"buy_conditions": self.buy_conditions,
"sell_conditions": self.sell_conditions,
"created_at": self.created_at,
"updated_at": self.updated_at,
"checksum": self.checksum
}
@classmethod
def from_dict(cls, data):
"""从字典还原"""
rule = cls(
data["name"],
data["buy_conditions"],
data["sell_conditions"]
)
rule.rule_id = data["rule_id"]
rule.created_at = data["created_at"]
rule.updated_at = data["updated_at"]
rule.checksum = data["checksum"]
return rule
def compute_checksum(self):
"""计算完整性校验值"""
content = json.dumps({
"rule_id": self.rule_id,
"name": self.name,
"buy_conditions": self.buy_conditions,
"sell_conditions": self.sell_conditions
}, sort_keys=True)
return hashlib.sha256(content.encode()).hexdigest()
✅ crypto.py（加密与完整性保护）
"""
crypto.py
策略规则的加密存储与完整性校验
"""
import hashlib
import base64
from datetime import datetime
class RuleCrypto:
"""
教学级加密模块
实际生产应使用 cryptography 库的 AES-GCM
此处用简化方案演示核心思想
"""
@staticmethod
def hmac_sign(data_str, secret):
"""HMAC-SHA256 签名"""
import hmac
return hmac.new(
secret.encode(),
data_str.encode(),
hashlib.sha256
).hexdigest()
@staticmethod
def verify_hmac(data_str, secret, expected_hmac):
"""验证 HMAC"""
actual = RuleCrypto.hmac_sign(data_str, secret)
return hmac.compare_digest(actual, expected_hmac)
@staticmethod
def simple_encrypt(data_str, key):
"""
教学用简化加密：
实际应替换为 cryptography.fernet.Fernet
"""
# 此处仅做 Base64 编码演示（⚠️ 非真正加密）
# 教学中说明：真实场景用 AES-256-GCM
encoded = base64.b64encode(data_str.encode()).decode()
return encoded
@staticmethod
def simple_decrypt(encrypted_str, key):
"""教学用简化解密"""
decoded = base64.b64decode(encrypted_str.encode()).decode()
return decoded
@staticmethod
def secure_erase_string(s):
"""安全擦除（教学演示）"""
return "*" * len(s)
✅ vault.py（策略保险库核心逻辑）
"""
vault.py
交易规则保险库：写入、读取、校验
"""
import json
from models import TradingRule
from crypto import RuleCrypto
class TradingRuleVault:
"""策略规则保险库"""
def __init__(self, secret_key):
"""
secret_key: 用户自定义密钥（实际应做 PBKDF2 派生）
"""
self.secret = secret_key
self.crypto = RuleCrypto()
def seal(self, rule):
"""
将策略规则密封存储：
1. 计算校验和
2. HMAC 签名
3. 加密
4. 返回可存储的封装结构
"""
# Step 1：计算校验和
checksum = rule.compute_checksum()
rule.checksum = checksum
# Step 2：序列化
data_dict = rule.to_dict()
data_str = json.dumps(data_dict, ensure_ascii=False)
# Step 3：HMAC 签名
hmac_value = self.crypto.hmac_sign(data_str, self.secret)
# Step 4：加密
encrypted = self.crypto.simple_encrypt(data_str, self.secret)
sealed = {
"version": "1.0",
"encrypted_data": encrypted,
"hmac": hmac_value,
"timestamp": rule.updated_at,
"rule_id": rule.rule_id,
"rule_name": rule.name
}
return sealed
def unseal(self, sealed):
"""
打开密封的规则：
1. 解密
2. 验证 HMAC
3. 反序列化
4. 校验完整性
"""
# Step 1：解密
decrypted = self.crypto.simple_decrypt(
sealed["encrypted_data"], self.secret
)
# Step 2：验证 HMAC
is_valid = self.crypto.verify_hmac(
decrypted, self.secret, sealed["hmac"]
)
if not is_valid:
return {
"status": "TAMPERED",
"message": "⚠️ 策略规则已被篡改！",
"rule": None
}
# Step 3：反序列化
data_dict = json.loads(decrypted)
rule = TradingRule.from_dict(data_dict)
# Step 4：校验完整性
if rule.checksum != data_dict.get("checksum"):
return {
"status": "CHECKSUM_MISMATCH",
"message": "⚠️ 校验和不匹配！",
"rule": None
}
return {
"status": "OK",
"message": "✅ 策略规则完整无损",
"rule": rule
}
def verify_integrity(self, sealed):
"""仅验证完整性，不解密"""
try:
decrypted = self.crypto.simple_decrypt(
sealed["encrypted_data"], self.secret
)
is_valid = self.crypto.verify_hmac(
decrypted, self.secret, sealed["hmac"]
)
return {
"is_tampered": not is_valid,
"rule_name": sealed.get("rule_name", "未知"),
"rule_id": sealed.get("rule_id", "未知")
}
except Exception:
return {
"is_tampered": True,
"rule_name": sealed.get("rule_name", "未知"),
"rule_id": sealed.get("rule_id", "未知")
}
✅ reporter.py（操作报告输出）
"""
reporter.py
策略保险库操作报告
"""
def report_seal(rule_name, sealed):
print("\n" + "=" * 60)
print("【策略密封报告】")
print("=" * 60)
print(f" 策略名称：{rule_name}")
print(f" 策略 ID：{sealed['rule_id']}")
print(f" 密封时间：{sealed['timestamp']}")
print(f" HMAC 签名：{sealed['hmac'][:16]}...")
print(f" 状态：✅ 已加密密封")
print("=" * 60)
def report_unseal(result):
print("\n" + "=" * 60)
print("【策略开启报告】")
print("=" * 60)
if result["status"] == "OK":
rule = result["rule"]
print(f" 状态：{result['message']}")
print(f" 策略名称：{rule.name}")
print(f" 策略 ID：{rule.rule_id}")
print(f" 买入条件：{rule.buy_conditions}")
print(f" 卖出条件：{rule.sell_conditions}")
print(f" 创建时间：{rule.created_at}")
print(f" 修改时间：{rule.updated_at}")
else:
print(f" 状态：{result['message']}")
print(f" ⚠️ 请勿信任此策略规则！")
print("=" * 60)
def report_verify(verify_result):
print(f"\n🔍 完整性校验：")
print(f" 策略：{verify_result['rule_name']}")
if verify_result["is_tampered"]:
print(f" 结果：❌ 已被篡改或损坏！")
else:
print(f" 结果：✅ 完整性验证通过")
✅ storage.py（本地存储）
"""
storage.py
JSON 本地存储
"""
import json
VAULT_PATH = "trading_rules_vault.json"
def save_vault(vault_data):
"""保存整个保险库"""
with open(VAULT_PATH, "w", encoding="utf-8") as f:
json.dump(vault_data, f, ensure_ascii=False, indent=2)
def load_vault():
"""加载保险库"""
try:
with open(VAULT_PATH, "r", encoding="utf-8") as f:
return json.load(f)
except FileNotFoundError:
return {"rules": [], "metadata": {"total": 0}}
✅ main.py（交互入口）
"""
main.py
个人交易规则加密存储工具
"""
from models import TradingRule
from vault import TradingRuleVault
from reporter import report_seal, report_unseal, report_verify
from storage import save_vault, load_vault
def main():
print("=== 个人交易规则加密存储工具（教学版）===")
print("防止自定义买卖策略被随意篡改\n")
secret = input("设置加密密钥（口令）：")
vault = TradingRuleVault(secret)
vault_data = load_vault()
while True:
print(f"\n📋 选择操作：")
print(" 1. 写入新策略")
print(" 2. 读取已有策略")
print(" 3. 验证策略完整性")
print(" 4. 退出")
choice = input("\n请选择（1/2/3/4）：")
if choice == "1":
# 写入新策略
name = input("策略名称：")
print("\n📌 买入条件（JSON 格式）：")
print("示例：{\"ma_cross\": true, \"rsi_threshold\": 30}")
buy_str = input("买入条件：")
buy_conditions = eval(buy_str) # 教学用，生产用 json.loads
print("\n📌 卖出条件（JSON 格式）：")
print("示例：{\"stop_loss\": -5, \"take_profit\": 10}")
sell_str = input("卖出条件：")
sell_conditions = eval(sell_str)
rule = TradingRule(name, buy_conditions, sell_conditions)
sealed = vault.seal(rule)
vault_data["rules"].append(sealed)
vault_data["metadata"]["total"] = len(vault_data["rules"])
save_vault(vault_data)
report_seal(rule.name, sealed)
print("✅ 策略已加密存储")
elif choice == "2":
# 读取策略
if not vault_data["rules"]:
print("⚠️ 保险库为空，请先写入策略")
continue
print(f"\n📂 保险库内容（共 {vault_data['metadata']['total']} 条）：")
for i, r in enumerate(vault_data["rules"], 1):
print(f" {i}. {r['rule_name']}（{r['rule_id'][:8]}...）")
idx = int(input("\n选择要读取的序号：")) - 1
if 0 <= idx < len(vault_data["rules"]):
sealed = vault_data["rules"][idx]
result = vault.unseal(sealed)
report_unseal(result)
else:
print("⚠️ 序号无效")
elif choice == "3":
# 验证完整性
if not vault_data["rules"]:
print("⚠️ 保险库为空")
continue
print(f"\n📂 保险库内容：")
for i, r in enumerate(vault_data["rules"], 1):
print(f" {i}. {r['rule_name']}")
idx = int(input("\n选择要校验的序号：")) - 1
if 0 <= idx < len(vault_data["rules"]):
sealed = vault_data["rules"][idx]
result = vault.verify_integrity(sealed)
report_verify(result)
else:
print("⚠️ 序号无效")
elif choice == "4":
print("\n👋 再见！请妥善保管你的密钥。")
break
else:
print("⚠️ 无效选择")
if __name__ == "__main__":
main()
五、README 与使用说明
# 个人交易规则加密存储工具（教学版）
## 项目说明
将自定义买卖策略规则加密存储，防止被随意篡改或泄露。
## 使用方式
bash
python main.py
## 操作流程
### 写入策略
选择操作：1
策略名称：均线突破策略
买入条件：{"ma_cross": true, "rsi_threshold": 30}
卖出条件：{"stop_loss": -5, "take_profit": 10}
### 读取策略
选择操作：2
选择要读取的序号：1
### 验证完整性
选择操作：3
选择要校验的序号：1
## 安全特性
| 特性 | 实现方式 |
|---|---|
| 防篡改 | HMAC-SHA256 签名校验 |
| 防泄露 | 加密存储（教学级） |
| 完整性验证 | SHA-256 校验和 |
| 自主密钥 | 用户全权掌控 |
## 适用范围
- 量化投资策略课程
- 交易纪律与安全管理教学
- 策略知识产权保护演示
## 注意事项
- 密钥一旦丢失，数据无法恢复
- 教学版使用简化加密，生产环境请使用 AES-256-GCM
- 使用前请阅读 DISCLAIMER.md
六、DISCLAIMER.md（免责声明与风险提示）
# 免责声明与风险提示
## 免责声明
本程序仅供**教学与科研用途**，用于演示交易规则的安全存储方法。
作者不提供任何证券交易建议，不推荐任何策略，不承诺任何收益。
## 风险提示
1. 教学版使用简化加密（Base64），**不是真正的加密**，仅用于演示思想
2. 生产环境必须使用 `cryptography` 库的 AES-256-GCM 或 ChaCha20-Poly1305
3. 密钥管理是核心难点：密钥丢失 = 数据永久丢失
4. HMAC 能检测篡改，但**不能防止篡改**（需要访问控制配合）
5. 本工具不替代专业密钥管理系统（KMS）
6. 策略保密 ≠ 策略有效，两者无因果关系
## 生产级改进建议
1. 使用 `cryptography.fernet.Fernet` 替代手写加密
2. 使用 PBKDF2 或 Argon2 做密钥派生
3. 增加密钥文件 + 口令的双重认证
4. 增加操作审计日志（append-only）
5. 考虑使用硬件安全模块（HSM）保护主密钥
使用本工具产生的任何后果，作者概不负责。
七、核心知识点卡片（教学向）
分类 内容
Python 类、JSON 序列化、eval（教学用）、UUID
密码学 HMAC-SHA256、对称加密思想、密钥派生
数据安全 完整性校验、防篡改、防泄露
量化交易 策略规则的结构化存储
工程思想 密封 / 开启模式、模块化、可审计
安全意识 密钥管理是安全的核心瓶颈
可扩展性 可接入真实 AES-GCM、支持多策略管理
八、总结（工程师视角）
这是一个完全中立、去营销化、可教学的原型系统：
✅ 不鼓吹任何策略
✅ 不伪装成安全神器
✅ 不替代专业密钥管理系统
它真正展示的是：
如何用 Python 把"交易纪律"从口头约束，变成可加密、可校验、可审计的技术防线
核心教学价值：
传统做法 加密存储方案
记事本写策略 明文裸奔，随时被改
Excel 存参数 无完整性校验
"我相信自己" 意外修改 / 多设备冲突不可避免
云盘同步 中间人、平台方均可读取
安全不是"信不信任"的问题，是"有没有技术保障"的问题。
🔐 安全存储的三层防护（教学要点）
┌─────────────────────────────────────┐
│ 第 1 层：序列化（JSON） │ ← 结构化、可解析
├─────────────────────────────────────┤
│ 第 2 层：HMAC 签名 │ ← 防篡改、可验证
├─────────────────────────────────────┤
│ 第 3 层：加密存储 │ ← 防泄露、只有你有密钥
└─────────────────────────────────────┘
本文代码仅供学习与技术交流，不构成任何投资建议，股市有风险，入市需谨慎！
利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！
