//+------------------------------------------------------------------+
//|                                                  HardwareID.mqh  |
//|                        Copyright 2026, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+----------------------------------------------------------------+
#property copyright "Copyright 2026"
#property link      "https://www.eafxtech.com"
#property version   "1.00"
#property strict

#include 

//+------------------------------------------------------------------+
//| 硬件指纹生成类                                                    |
//+------------------------------------------------------------------+
class CHardwareID
{
public:
   string GetMachineCode();   // 获取机器码（32位十六进制字符串）

private:
   string GetCPUID();         // 获取CPU标识
   string GetVolumeID();      // 获取系统盘卷序列号
   string GetMACAddress();    // 获取首个物理网卡MAC
   string MD5Hash(string input); // 简单哈希（实际建议用SHA-256）
};

//+------------------------------------------------------------------+
//| 获取CPU标识（通过Windows API）                                    |
//+------------------------------------------------------------------+
string CHardwareID::GetCPUID()
{
   // 注意：MQL5中通过__cpuid内部函数或汇编获取CPU信息
   // 此处采用组合方案：CPU名 + 核心数 + 制造商
   string cpu_name = TerminalInfoString(TERMINAL_SERVER_NAME);
   int    cores    = TerminalInfoInteger(TERMINAL_CORES);
   string vendor   = IntegerToString(GetVersion() & 0xFFFF);
   
   // 组合后返回
   return "CPU_" + cpu_name + "_" + IntegerToString(cores) + "_" + vendor;
}

//+------------------------------------------------------------------+
//| 获取系统盘卷序列号                                                |
//+------------------------------------------------------------------+
string CHardwareID::GetVolumeID()
{
   // 通过GetDriveType判断系统盘，用GetVolumeInformation获取序列号
   // MQL5沙箱下部分API受限，这里采用兼容方案：读取Terminal路径所在盘信息
   string path = TerminalInfoString(TERMINAL_PATH);
   string drive = StringSubstr(path, 0, 2); // 如 "C:"
   
   // 使用文件系统特征作为替代指纹
   ulong total_space = DiskInfoInteger(drive, DISK_TOTAL_SPACE);
   ulong free_space  = DiskInfoInteger(drive, DISK_FREE_SPACE);
   
   return "VOL_" + drive + "_" + IntegerToString((long)total_space);
}

//+------------------------------------------------------------------+
//| 获取MAC地址（简化版，通过账户信息辅助生成）                        |
//+------------------------------------------------------------------+
string CHardwareID::GetMACAddress()
{
   // 注意：纯MQL5无法直接读取网卡MAC（沙箱限制）
   // 实际生产环境建议通过DLL调用GetAdaptersInfo获取
   // 此处用账户登录名 + 终端实例ID作为替代因子
   string account = IntegerToString((long)AccountInfoInteger(ACCOUNT_LOGIN));
   string server  = AccountInfoString(ACCOUNT_SERVER);
   return "NET_" + account + "_" + server;
}

//+------------------------------------------------------------------+
//| 生成最终机器码（组合三因子后哈希）                                |
//+------------------------------------------------------------------+
string CHardwareID::GetMachineCode()
{
   string raw = GetCPUID() + "|" + GetVolumeID() + "|" + GetMACAddress();
   
   // 使用MQL5内置的CryptEncode进行简单加密处理
   // 实际工程中建议替换为成熟的SHA-256哈希算法实现
   uchar src[];
   uchar dst[];
   StringToCharArray(raw, src);
   
   // 这里用Base64编码作为简化演示，生产环境替换为SHA-256
   if(CryptEncode(CRYPT_BASE64, src, 0, dst, 0))
   {
      string result = CharArrayToString(dst);
      // 截取前32位并转大写作为机器码
      return StringUpper(StringSubstr(result, 0, 32));
   }
   
   return "UNKNOWN_MACHINE_ID";
}

//+------------------------------------------------------------------+
//| 使用示例                                                          |
//+------------------------------------------------------------------+
/*
void OnStart()
{
   CHardwareID hw;
   string machine_code = hw.GetMachineCode();
   Print("本机机器码: ", machine_code);
}
*/

//+------------------------------------------------------------------+
//|                                    LicenseClient.mqh             |
//|                        EA授权系统 - 客户端激活模块                |
//+------------------------------------------------------------------+
#property strict

// 服务器地址（实际使用时请换成你的域名）
#define LICENSE_SERVER "https://license.yourdomain.com/api"
// 服务器公钥（用于验签，注意这是RSA公钥，不是私钥）
#define SERVER_PUB_KEY "-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----"

//+------------------------------------------------------------------+
//| 授权状态枚举                                                      |
//+------------------------------------------------------------------+
enum ENUM_LICENSE_STATUS
{
   LICENSE_VALID,       // 授权有效
   LICENSE_EXPIRED,     // 授权过期
   LICENSE_INVALID,     // 授权无效（激活码错误等）
   LICENSE_MACHINE_MISMATCH, // 机器码不匹配
   LICENSE_NETWORK_ERROR   // 网络错误，使用缓存
};

//+------------------------------------------------------------------+
//| 授权信息结构体                                                    |
//+------------------------------------------------------------------+
struct SLicenseInfo
{
   string   activation_code;   // 激活码
   string   machine_code;      // 绑定的机器码
   datetime expire_time;       // 过期时间
   string   license_type;      // 授权类型（试用/月度/永久）
   int      max_devices;       // 最大设备数
   string   signature;         // 服务器签名
};

//+------------------------------------------------------------------+
//| 在线激活主类                                                      |
//+------------------------------------------------------------------+
class CLicenseClient
{
public:
   // 激活：输入激活码，返回是否成功
   bool Activate(string activation_code, string machine_code);
   // 验证当前授权状态
   ENUM_LICENSE_STATUS Validate();
   // 获取授权信息
   SLicenseInfo GetLicenseInfo() { return m_license; }

private:
   SLicenseInfo m_license;
   
   // 发送HTTP POST请求
   string HttpPost(string url, string post_data);
   // 验证服务器返回的签名
   bool VerifySignature(string data, string signature);
   // 本地加密存储授权信息
   bool SaveLicenseToFile();
   // 从本地文件读取授权信息
   bool LoadLicenseFromFile();
};

//+------------------------------------------------------------------+
//| 执行激活操作                                                      |
//+------------------------------------------------------------------+
bool CLicenseClient::Activate(string activation_code, string machine_code)
{
   // 构建请求JSON
   string post_data = "{\"activation_code\":\"" + activation_code + "\","
                     "\"machine_code\":\"" + machine_code + "\","
                     "\"timestamp\":\"" + IntegerToString(TimeCurrent()) + "\"}";
   
   // 发送激活请求
   string response = HttpPost(LICENSE_SERVER + "/activate", post_data);
   
   if(response == "")
   {
      Print("激活失败：网络请求失败");
      return false;
   }
   
   // 解析JSON响应（生产环境建议用专业JSON库）
   // 简化版：手动提取字段
   if(StringFind(response, "\"success\":true") < 0)
   {
      Print("激活失败：服务器返回错误 - ", response);
      return false;
   }
   
   // 提取授权信息并验签
   // ...（解析逻辑省略，实际项目中用json-c或cJSON库）
   
   // 保存到本地
   SaveLicenseToFile();
   
   return true;
}

//+------------------------------------------------------------------+
//| 验证授权状态                                                      |
//+------------------------------------------------------------------+
ENUM_LICENSE_STATUS CLicenseClient::Validate()
{
   // 先尝试从本地加载
   if(!LoadLicenseFromFile())
      return LICENSE_INVALID;
   
   // 检查过期时间
   if(m_license.expire_time < TimeCurrent())
      return LICENSE_EXPIRED;
   
   // 检查机器码匹配
   CHardwareID hw;
   if(m_license.machine_code != hw.GetMachineCode())
      return LICENSE_MACHINE_MISMATCH;
   
   // 验证签名（防止本地文件篡改）
   string data_to_verify = m_license.activation_code + m_license.machine_code + 
                           IntegerToString((long)m_license.expire_time);
   if(!VerifySignature(data_to_verify, m_license.signature))
      return LICENSE_INVALID;
   
   // 尝试在线续期（后台静默执行，失败不影响使用）
   // ...（续期逻辑）
   
   return LICENSE_VALID;
}

//+------------------------------------------------------------------+
//| HTTP POST请求（通过WinHTTP实现，实际建议封装到DLL）               |
//+------------------------------------------------------------------+
string CLicenseClient::HttpPost(string url, string post_data)
{
   // 注意：纯MQL5环境下网络请求能力有限
   // 生产环境建议通过DLL调用WinHTTP或WinInet
   // 此处为框架示意，具体实现见配套DLL代码
   
   // MQL5自带WebRequest函数示例：
   char headers[] = "Content-Type: application/json\r\n";
   char data[];
   char result[];
   
   StringToCharArray(post_data, data);
   
   int res_code = 0;
   string cookies = "";
   
   // 使用MQL5的WebRequest（需要在EA设置中允许Web请求）
   if(!WebRequest("POST", url, cookies, 0, 5000, data, 
                  StringLen(post_data), result, res_code, headers))
   {
      Print("WebRequest失败，错误码: ", GetLastError());
      return "";
   }
   
   return CharArrayToString(result);
}

//+------------------------------------------------------------------+
//|                                       StringCrypto.mqh           |
//|                        字符串加密工具 - XTEA算法轻量实现          |
//+------------------------------------------------------------------+
#property strict

// 加密密钥（实际使用请更换为你自己的密钥，至少16字节）
uchar g_crypto_key[] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
                         0x0F, 0xED, 0xCB, 0xA9, 0x87, 0x65, 0x43, 0x21};

//+------------------------------------------------------------------+
//| 简单XOR流加密（轻量版，防静态分析够用）                           |
//| 注意：生产环境建议使用AES等标准算法，此处为教学简化版             |
//+------------------------------------------------------------------+
string EncryptString(string plain_text)
{
   uchar src[];
   StringToCharArray(plain_text, src);
   
   int len = ArraySize(src);
   uchar dst[];
   ArrayResize(dst, len);
   
   for(int i = 0; i < len; i++)
   {
      dst[i] = src[i] ^ g_crypto_key[i % 16];
      // 再加一层位移混淆
      dst[i] = (dst[i] << 3) | (dst[i] >> 5);
   }
   
   // Base64编码后返回，方便作为字符串常量存储
   uchar b64[];
   CryptEncode(CRYPT_BASE64, dst, 0, b64, 0);
   return CharArrayToString(b64);
}

//+------------------------------------------------------------------+
//| 解密字符串                                                        |
//+------------------------------------------------------------------+
string DecryptString(string cipher_text)
{
   // 先Base64解码
   uchar src[];
   StringToCharArray(cipher_text, src);
   
   uchar decoded[];
   CryptDecode(CRYPT_BASE64, src, 0, decoded, 0);
   
   int len = ArraySize(decoded);
   uchar dst[];
   ArrayResize(dst, len);
   
   for(int i = 0; i < len; i++)
   {
      // 反向位移
      uchar c = decoded[i];
      c = (c >> 3) | (c << 5);
      // XOR解密
      dst[i] = c ^ g_crypto_key[i % 16];
   }
   
   return CharArrayToString(dst);
}

//+------------------------------------------------------------------+
//| 使用示例 - 敏感字符串不要直接写在代码里                           |
//+------------------------------------------------------------------+
/*
// ❌ 不要这样写：破解者直接搜字符串就能找到
if(result == "activation_failed") { ... }

// ✅ 应该这样写：加密存储，运行时解密
string err_msg = DecryptString("aGVsbG9fd29ybGQ="); // 密文
if(result == err_msg) { ... }
*/

//+------------------------------------------------------------------+
//|                                        TrialManager.mqh          |
//|                        试用管理器 - 限时+累计时长双模式           |
//+------------------------------------------------------------------+
#property strict

#define TRIAL_FILE_NAME "trial_data.dat"
#define TRIAL_DAYS 7          // 自然日试用期
#define TRIAL_HOURS 24        // 累计运行时长试用期（小时）

//+------------------------------------------------------------------+
//| 试用状态枚举                                                      |
//+------------------------------------------------------------------+
enum ENUM_TRIAL_STATUS
{
   TRIAL_ACTIVE,      // 试用中
   TRIAL_EXPIRED,     // 试用已过期
   TRIAL_TIME_SUSPECT // 时间篡改嫌疑
};

//+------------------------------------------------------------------+
//| 试用数据结构体（加密存储）                                        |
//+------------------------------------------------------------------+
struct STrialData
{
   datetime first_run_time;   // 首次运行时间
   datetime last_run_time;    // 上次运行时间
   int      total_seconds;    // 累计运行秒数
   int      checksum;         // 数据校验和（防止篡改）
   uchar    reserved[32];     // 预留字段，增加篡改检测难度
};

//+------------------------------------------------------------------+
//| 试用管理器类                                                      |
//+------------------------------------------------------------------+
class CTrialManager
{
public:
   CTrialManager();
  ~CTrialManager();
   
   ENUM_TRIAL_STATUS GetStatus();     // 获取试用状态
   int  GetRemainingDays();           // 剩余天数
   int  GetRemainingHours();          // 剩余小时数
   void OnTick();                     // 每个Tick调用，累计运行时长

private:
   STrialData m_data;
   bool       m_loaded;
   datetime   m_last_tick_time;
   
   bool LoadData();                   // 从文件加载试用数据
   bool SaveData();                   // 保存试用数据到文件
   int  CalcChecksum(STrialData &d);  // 计算校验和
   bool ValidateData(STrialData &d);  // 验证数据完整性
   bool CheckTimeTampering();         // 检测时间篡改
   void XorCrypt(uchar data[], int len); // 简单异或加密
};

//+------------------------------------------------------------------+
//| 构造函数                                                          |
//+------------------------------------------------------------------+
CTrialManager::CTrialManager()
{
   m_loaded = false;
   m_last_tick_time = 0;
   
   if(!LoadData())
   {
      // 首次运行，初始化试用数据
      m_data.first_run_time = TimeCurrent();
      m_data.last_run_time  = TimeCurrent();
      m_data.total_seconds  = 0;
      m_data.checksum       = CalcChecksum(m_data);
      ZeroMemory(m_data.reserved, 32);
      SaveData();
   }
}

//+------------------------------------------------------------------+
//| 获取试用状态                                                      |
//+------------------------------------------------------------------+
ENUM_TRIAL_STATUS CTrialManager::GetStatus()
{
   if(!m_loaded) return TRIAL_EXPIRED;
   
   // 检查数据完整性
   if(!ValidateData(m_data))
      return TRIAL_EXPIRED;
   
   // 检查时间篡改
   if(CheckTimeTampering())
      return TRIAL_TIME_SUSPECT;
   
   // 检查自然日是否过期
   datetime expire_time = m_data.first_run_time + TRIAL_DAYS * 86400;
   if(TimeCurrent() > expire_time)
      return TRIAL_EXPIRED;
   
   // 检查累计时长是否过期
   if(m_data.total_seconds >= TRIAL_HOURS * 3600)
      return TRIAL_EXPIRED;
   
   return TRIAL_ACTIVE;
}

//+------------------------------------------------------------------+
//| Tick调用 - 累计运行时长                                           |
//+------------------------------------------------------------------+
void CTrialManager::OnTick()
{
   datetime now = TimeCurrent();
   if(m_last_tick_time > 0 && now > m_last_tick_time)
   {
      int delta = (int)(now - m_last_tick_time);
      if(delta > 0 && delta < 3600) // 防止跳变
         m_data.total_seconds += delta;
   }
   m_last_tick_time = now;
   m_data.last_run_time = now;
   m_data.checksum = CalcChecksum(m_data);
   SaveData();
}

//+------------------------------------------------------------------+
//| 加载试用数据（加密读取）                                          |
//+------------------------------------------------------------------+
bool CTrialManager::LoadData()
{
   int handle = FileOpen(TRIAL_FILE_NAME, FILE_READ | FILE_BIN);
   if(handle < 0) return false;
   
   uchar buffer[];
   int size = FileSize(handle);
   ArrayResize(buffer, size);
   FileReadArray(handle, buffer);
   FileClose(handle);
   
   // 解密
   XorCrypt(buffer, size);
   
   // 转换为结构体
   if(size >= sizeof(STrialData))
   {
      ArrayCopy((uchar&)m_data, buffer, 0, 0, sizeof(STrialData));
      m_loaded = ValidateData(m_data);
      return m_loaded;
   }
   
   return false;
}

//+------------------------------------------------------------------+
//| 保存试用数据（加密存储）                                          |
//+------------------------------------------------------------------+
bool CTrialManager::SaveData()
{
   int handle = FileOpen(TRIAL_FILE_NAME, FILE_WRITE | FILE_BIN);
   if(handle < 0) return false;
   
   uchar buffer[];
   ArrayResize(buffer, sizeof(STrialData));
   ArrayCopy(buffer, (uchar&)m_data);
   
   // 加密
   XorCrypt(buffer, sizeof(STrialData));
   
   FileWriteArray(handle, buffer);
   FileClose(handle);
   return true;
}

//+------------------------------------------------------------------+
//| 计算校验和（防止篡改）                                            |
//+------------------------------------------------------------------+
int CTrialManager::CalcChecksum(STrialData &d)
{
   // 简单的校验和算法，生产环境建议用CRC32或SHA-256
   int sum = 0;
   uchar *p = (uchar*)&d;
   // 注意：计算校验和时要排除checksum字段本身
   int offset = (int)&d.checksum - (int)&d;
   for(int i = 0; i < (int)sizeof(STrialData); i++)
   {
      if(i >= offset && i < offset + sizeof(int)) continue;
      sum += p[i] * (i + 1);
   }
   return sum;
}

//+------------------------------------------------------------------+
//|                                    LicenseManager.mqh            |
//|                        授权管理器 - 主类（MQL5侧调用层）          |
//+------------------------------------------------------------------+
#property strict

// 引入各子模块
#include "HardwareID.mqh"
#include "TrialManager.mqh"

// DLL导入声明（核心验证逻辑在DLL中）
#import "LicenseDLL.dll"
   int  License_Init(string server_url, string public_key);
   int  License_Activate(string activation_code, string machine_code);
   int  License_Validate();
   int  License_GetExpireTime();
   void License_Shutdown();
#import

//+------------------------------------------------------------------+
//| 授权管理器主类                                                    |
//+------------------------------------------------------------------+
class CLicenseManager
{
public:
   CLicenseManager();
  ~CLicenseManager();
   
   bool Init();                                    // 初始化
   bool Activate(string activation_code);          // 执行激活
   bool IsLicensed();                              // 是否已授权
   bool IsTrialActive();                           // 是否在试用期
   ENUM_TRIAL_STATUS GetTrialStatus();             // 获取试用状态
   string GetStatusText();                         // 获取状态文字（用于UI显示）
   void OnTick();                                  // 每Tick调用
   void OnDeinit();                                // 反初始化

private:
   CHardwareID  m_hw_id;       // 硬件指纹
   CTrialManager m_trial;      // 试用管理器
   bool        m_initialized;  // 是否已初始化
   bool        m_licensed;     // 是否已授权
   datetime    m_last_check;   // 上次检查时间
   int         m_check_interval; // 检查间隔（秒）
};

//+------------------------------------------------------------------+
//| 初始化                                                            |
//+------------------------------------------------------------------+
bool CLicenseManager::Init()
{
   // 初始化DLL
   string server_url = "https://license.yourdomain.com/api";
   string pub_key    = "你的服务器公钥（加密存储）";
   
   if(License_Init(server_url, pub_key) != 0)
   {
      Print("授权系统初始化失败");
      return false;
   }
   
   // 检查是否已有授权
   m_licensed = (License_Validate() == 0);
   
   m_initialized = true;
   m_last_check = TimeCurrent();
   m_check_interval = 300; // 每5分钟检查一次
   
   return true;
}

//+------------------------------------------------------------------+
//| Tick中定期检查                                                    |
//+------------------------------------------------------------------+
void CLicenseManager::OnTick()
{
   if(!m_initialized) return;
   
   // 更新试用计时
   m_trial.OnTick();
   
   // 定期验证授权
   datetime now = TimeCurrent();
   if(now - m_last_check > m_check_interval)
   {
      m_last_check = now;
      m_licensed = (License_Validate() == 0);
   }
}