商业软件License设计与实现指南

n = p × q

φ(n) = (p-1) × (q-1)

加密：c = m^e mod n解密：m = c^d mod n

c^d mod n = (m^e)^d mod n          = m^(e×d) mod n          = m^(k×φ(n)+1) mod n          = (m^φ(n))^k × m mod n          = 1^k × m mod n          = m

License 生产方（持有私钥 d）：用 d 加密 → 生成 License 文件软件运行方（持有公钥 e）：   用 e 解密 → 验证 License 文件

[0x00][0x02][随机非零字节 ≥ 8 个][0x00][真正的明文]  ↑     ↑           ↑               ↑固定  类型标志   引入随机性        分隔符

exp( (1.923 + o(1)) × (ln n)^(1/3) × (ln ln n)^(2/3) )

文件头（明文）：  [魔数][版本][创建时间戳][有效天数][校验和]                  ↑           明文，任何人都可以直接修改

RSA 加密的明文内容（攻击者无法在不知道私钥的情况下修改）：  ┌─────────────────────────────────────────────────────┐  │  created_time（8字节）  ← 创建时间戳                  │  │  expire_days  （4字节）  ← 有效天数                   │  │  business_data[]       ← 核心业务数据（授权范围）      │  └─────────────────────────────────────────────────────┘               ↓  RSA 私钥加密（分块）  [密文块1][密文块2]...[密文块N]  → 写入License文件

[0x00][0x02][至少8个随机非零字节][0x00][真正的数据]

第一层：RSA + PKCS#1 完整性  → 密文任何字节被改动 → PKCS#1 解码失败第二层：解密后的结构化验证  → 解密数据长度必须精确等于预期值  → 时间戳必须合法（不能在未来，不能超过有效期）  → 格式不符即报错终止第三层：文件级 XOR-32 校验和（可选，快速预检）  → 覆盖所有密文块，防止文件传输损坏或粗糙篡改  → 注意：校验和必须覆盖所有密文数据，且本身也要被保护

if (!check_license()) {    printf("License invalid, exiting.\n");    exit(1);}// 继续运行核心功能...run_core_logic();

License 文件中 RSA 加密的数据：  [时间戳][有效天数][数据源ID_1][数据源ID_2][数据源ID_3]...

软件启动  │  ├─── 解密 License 文件  │       ├── RSA 解密 → 得到时间戳 + 业务数据  │       ├── 验证时间戳（有效期检查）  │       └── 验证结构完整性  │  └─── 用解密出的业务数据构建运行时数据结构          │          └─── 后续所有核心操作都依赖这个数据结构               （没有这些数据 = 软件无法完成任何有意义的操作）

                ┌──────────────────────────────┐                │       License 生产方（软件商）  │                │   持有 License生产工具（私钥d）  │                └──────────────┬───────────────┘                               │         ┌─────────────────────┼──────────────────────┐         │ 客户发来：            │ 软件商签发后返回：      │         │ license_request.txt  │ license.dat           │         │ （明文，可公开传输）    │ （加密后，可公开传输）  │         └─────────────────────┼──────────────────────┘                               │                ┌──────────────▼───────────────┐                │            客户               │                │   持有商业软件（内嵌公钥 e）    │                │   只能验证，无法伪造            │                └──────────────────────────────┘

第一步：客户填写申请信息  └── 收集软件运行所需的核心配置（数据源信息、机器码等）      → 生成 license_request.txt（明文，可公开传输）第二步：软件商生成 License  └── 接收 license_request.txt      → 用 License 生产工具（含私钥）签发      → 生成 license.dat（加密后，含时间戳在 RSA 数据内）      → 返回给客户（可公开传输）第三步：客户使用 License  └── 将 license.dat 放入软件指定目录      → 软件启动时自动加载、验证      → 验证通过 → 解密出业务数据 → 正常运行      → 验证失败 → 报错退出第四步：License 续期  └── 客户重新发送 license_request.txt（内容不变）      → 软件商重新签发（创建时间戳更新为当前时间）      → 返回新的 license.dat

偏移    长度    字段名              说明+0      4       magic               魔数，如 "LCNS"，快速识别文件类型+4      4       version             版本号，软件拒绝不兼容的版本+8      4       line_count          业务数据条目数+12     4       block_size          RSA 输出块大小（= 密钥字节数，2048位为256）+16     4       block_count         RSA 加密块数量+20     4       other_data_size     XOR 混淆区字节数+24     4       checksum            全密文区 XOR-32 校验和+28    484       padding            随机填充（凑满512字节文件头）                 ↑ 以上为明文文件头（512字节）━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                 ↓ 以下为加密数据区+512   block_count×256   RSA 加密块（包含时间戳+有效期+核心业务数据）+512+enc_size  256       RSA 加密的 XOR 种子块（245字节随机密钥）+后续  other_data_size   XOR 混淆的辅助业务数据（文件名/路径等）

RSA 分块加密的明文（245字节/块）：  ┌──────────────────────────────────────────────────┐  │ [0..7]   created_time  ：8字节 Unix timestamp      │  │ [8..11]  expire_days   ：4字节 有效天数             │  │ [12..]   business_data[]：剩余空间存核心业务数据     │  └──────────────────────────────────────────────────┘

/* ============================================================ * License 生产工具核心逻辑（含私钥，严禁分发） * ============================================================ */#include<stdio.h>#include<stdlib.h>#include<string.h>#include<time.h>#include"mpi.h"#include"mprsa.h"typedef unsigned int  ub4;typedef unsigned long long ub8;/* RSA 2048-bit 私钥（d）和模数（n），十六进制硬编码 */static const char *PRIV_D_HEX = "...（私钥d的十六进制，仅存在于生产工具中）...";static const char *MOD_N_HEX  = "...（模数n的十六进制）...";#define RSA_BLOCK_SIZE   256   /* 2048-bit RSA 输出固定256字节 */#define RSA_PLAIN_MAX    245   /* 256 - 11（PKCS#1 v1.5 开销）*/#define HEADER_SIZE      512/* License 明文头部结构（将被 RSA 加密，时间戳在此） */typedef struct {    ub8  created_time;   /* Unix epoch，创建时间           */    ub4  expire_days;    /* 有效天数（如30）                */    /* 后续紧跟 business_data[]，内容因软件而异 */} LIC_PLAINTEXT_HEADER;/* * produce_license() *   request_data    : 从 license_request.txt 解析出的业务数据数组 *   request_count   : 业务数据条目数 *   expire_days     : 授权有效天数 *   out_path        : 输出的 license.dat 路径 */intproduce_license(ub4 *request_data, int request_count,                    ub4 expire_days,   const char *out_path){    mp_int priv_d, mod_n;    mp_err err;    FILE  *fp;    /* 1. 加载 RSA 私钥 */    mp_init(&priv_d);    mp_init(&mod_n);    mp_read_radix(&priv_d, PRIV_D_HEX, 16);    mp_read_radix(&mod_n,  MOD_N_HEX,  16);    /* 2. 构建明文数据：[时间戳(8)][有效天数(4)][业务数据(N×4)] */    int plain_total = sizeof(LIC_PLAINTEXT_HEADER) + request_count * 4;    unsigned char *plainbuf = malloc(plain_total);    LIC_PLAINTEXT_HEADER *hdr = (LIC_PLAINTEXT_HEADER *)plainbuf;    hdr->created_time = (ub8)time(NULL);  /* 当前时间写入明文 */    hdr->expire_days  = expire_days;    memcpy(plainbuf + sizeof(LIC_PLAINTEXT_HEADER),           request_data, request_count * 4);    /* 3. 打开输出文件，预写512字节占位头 */    fp = fopen(out_path, "w+b");    unsigned char pad[HEADER_SIZE];    memset(pad, 0, HEADER_SIZE);    fwrite(pad, 1, HEADER_SIZE, fp);   /* 占位，后面回写 */    /* 4. RSA 分块加密明文（每块最多245字节 → 输出256字节） */    unsigned char *p       = plainbuf;    int            remain  = plain_total;    int            block_count = 0;    ub4            checksum    = 0;    while (remain > 0) {        int chunk = (remain >= RSA_PLAIN_MAX) ? RSA_PLAIN_MAX : remain;        char  *enc_buf;        int    enc_len;        err = mp_pkcs1v15_encrypt((char *)p, chunk,                                  &priv_d, &mod_n,                                  &enc_buf, &enc_len, enc_rand);        if (err != MP_OKAY || enc_len != RSA_BLOCK_SIZE) goto fail;        fwrite(enc_buf, 1, enc_len, fp);        /* 计算校验和（覆盖所有密文块） */        ub4 *w = (ub4 *)enc_buf;        for (int i = 0; i < enc_len / 4; i++) checksum ^= w[i];        free(enc_buf);        p      += chunk;        remain -= chunk;        block_count++;    }    /* 5. 生成 XOR 随机种子，RSA 加密后写入 */    unsigned char xor_seed[RSA_PLAIN_MAX];    enc_rand((char *)xor_seed, RSA_PLAIN_MAX);    char *seed_enc; int seed_enc_len;    mp_pkcs1v15_encrypt((char *)xor_seed, RSA_PLAIN_MAX,                        &priv_d, &mod_n, &seed_enc, &seed_enc_len, enc_rand);    fwrite(seed_enc, 1, seed_enc_len, fp);    ub4 *w = (ub4 *)seed_enc;    for (int i = 0; i < seed_enc_len / 4; i++) checksum ^= w[i];    free(seed_enc);    /* 6. XOR 混淆辅助文本（文件名、路径等非关键数据）后写入 */    /* （此处略，原理：辅助数据与 xor_seed 循环异或后写入文件） */    /* 7. 回到文件头，写入真实头部字段 */    rewind(fp);    fwrite("LCNS", 1, 4, fp);                    /* 魔数     */    ub4 ver = 0x01000000; fwrite(&ver, 1, 4, fp); /* 版本     */    /* 注意：line_count、block_count、checksum 等写入明文头 */    /* 时间戳和有效期已经在第2步写入 RSA 加密明文中，此处不重复 */    fclose(fp);    free(plainbuf);    mp_clear(&priv_d);    mp_clear(&mod_n);    return 0;fail:    fclose(fp);    free(plainbuf);    mp_clear(&priv_d);    mp_clear(&mod_n);    return -1;}

/* ============================================================ * 商业软件内部的 License 验证逻辑（含公钥，可分发） * ============================================================ *//* RSA 2048-bit 公钥（e = 65537）和模数（n） */static const char *PUB_E_HEX = "010001";   /* 65537 */static const char *MOD_N_HEX = "...（与生产工具相同的模数n）...";#define LICENSE_EXPIRE_DAYS  30   /* 最长有效天数 */intload_license(constchar *path, BUSINESS_DATA *out_data){    mp_int pub_e, mod_n;    mp_init(&pub_e);  mp_read_radix(&pub_e, PUB_E_HEX, 16);    mp_init(&mod_n);  mp_read_radix(&mod_n, MOD_N_HEX,  16);    FILE *fp = fopen(path, "rb");    if (!fp) FAIL("cannot open license file");    /* 1. 读取并验证明文文件头 */    unsigned char header[HEADER_SIZE];    fread(header, 1, HEADER_SIZE, fp);    if (memcmp(header, "LCNS", 4) != 0)  FAIL("invalid license file");    /* version、block_count 等从 header 中解析... */    /* 2. RSA 解密所有块，拼接还原明文 */    unsigned char plainbuf[MAX_PLAIN_SIZE];    int plain_total = 0;    ub4 checksum    = 0;    for (int i = 0; i < block_count; i++) {        unsigned char cipherblock[RSA_BLOCK_SIZE];        fread(cipherblock, 1, RSA_BLOCK_SIZE, fp);        /* 校验和验证 */        ub4 *w = (ub4 *)cipherblock;        for (int j = 0; j < RSA_BLOCK_SIZE / 4; j++) checksum ^= w[j];        /* RSA 解密 + PKCS#1 填充验证（任何密文改动都会在此失败） */        char *dec_buf; int dec_len;        mp_err err = mp_pkcs1v15_decrypt(                         (char *)cipherblock, RSA_BLOCK_SIZE,                         &pub_e, &mod_n, &dec_buf, &dec_len);        if (err != MP_OKAY)            FAIL("RSA decryption failed: license tampered or invalid");        memcpy(plainbuf + plain_total, dec_buf, dec_len);        plain_total += dec_len;        free(dec_buf);    }    /* 3. 从解密后的明文中提取时间戳（此处才是真正受保护的时间戳） */    LIC_PLAINTEXT_HEADER *lhdr = (LIC_PLAINTEXT_HEADER *)plainbuf;    time_t now = time(NULL);    if ((ub8)now < lhdr->created_time)        FAIL("license timestamp is in the future");    ub8 elapsed_days = ((ub8)now - lhdr->created_time) / 86400;    if (elapsed_days > lhdr->expire_days)        FAIL("license expired");    /* 4. 验证解密数据长度是否符合预期（结构化完整性检查） */    int expected_len = sizeof(LIC_PLAINTEXT_HEADER) + line_count * 4;    if (plain_total != expected_len)        FAIL("decrypted data length mismatch: license corrupted");    /* 5. 验证文件级校验和 */    /* （读取 XOR 种子块、混淆数据并纳入校验和计算，与头部存储值比对） */    if (computed_checksum != stored_checksum)        FAIL("checksum error: license file corrupted");    /* 6. 将业务数据注入核心运行时结构（而非设置"已授权"布尔标志） */    ub4 *biz = (ub4 *)(plainbuf + sizeof(LIC_PLAINTEXT_HEADER));    build_runtime_objects(biz, line_count, out_data);    mp_clear(&pub_e);    mp_clear(&mod_n);    fclose(fp);    return 0;}