个人交易规则加密存储程序，防止自定义买卖策略代码被随意篡改。

个人交易规则加密存储工具（教学

定位：去营销化、中立、可教学、可扩展

⚠️ 全文含免责声明与风险提示，不荐股、不承诺收益、不引导开户、无任何引流

一、实际应用场景描述

在智能证券投资课程中，交易纪律执行与策略保密（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解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！