密钥管理系统 - 开发者指南¶

// 使用HMAC-SHA256生成签名
const signature = crypto.createHmac('sha256', secretKey)
  .update(`${licenseKey}-${applicationId}-${licenseTypeId}`)
  .digest('hex');

// 验证签名
const expectedSignature = generateSignature(licenseKey, applicationId, licenseTypeId);
const isValid = signature === expectedSignature;

// 1. 检查密钥是否存在
const license = await db.get('SELECT * FROM licenses WHERE license_key = ?', [licenseKey]);

// 2. 检查密钥是否被暂停
if (license.paused_at) {
  return { success: false, message: '密钥已被暂停' };
}

// 3. 检查密钥状态
if (license.status === 'inactive') {
  // 首次验证时激活密钥
  await activateLicense(license);
}

// 计算过期时间（基于密钥类型的有效期天数）
const expiresAt = calculateExpiryTime(licenseType.default_validity_days);

// 激活密钥
await db.run(`
  UPDATE licenses 
  SET status = 'active', activated_at = ?, expires_at = ? 
  WHERE id = ?
`, [currentTime, expiresAt, license.id]);

// 检查是否过期（使用UTC时间）
if (license.expires_at && moment.utc().isAfter(license.expires_at)) {
  return { success: false, message: '密钥已过期' };
}

// 检查使用次数限制
if (license.max_uses > 0 && license.current_uses >= license.max_uses) {
  return { success: false, message: '密钥使用次数已达上限' };
}

// 检查设备数量限制
if (license.max_devices > 0) {
  validateDeviceAccess(license, machineId, deviceInfo, clientIP);
}

// 检查设备是否在当前周期内从未验证过
const isNewInCurrentPeriod = !existingDevice.last_verified_date || 
                            existingDevice.last_verified_date !== currentUtcDate;

if (isNewInCurrentPeriod) {
  // 检查当前周期内已验证的设备数量
  const currentPeriodDevices = await getCurrentPeriodDeviceCount(license.id, currentUtcDate);

  if (currentPeriodDevices < license.max_devices) {
    // 通过验证
    return recordUsageAndRespond(license, machineId, deviceInfo, clientIP);
  } else {
    // 拒绝：设备数量已达上限
    return { 
      success: false, 
      message: '设备数量已达上限',
      error: 'MAX_DEVICES_REACHED'
    };
  }
} else {
  // 同一天内已验证过，直接通过
  return recordUsageAndRespond(license, machineId, deviceInfo, clientIP);
}

// 支持多种代理头
const clientIP = req.headers['x-forwarded-for'] || 
                 req.headers['x-real-ip'] || 
                 req.headers['x-client-ip'] || 
                 req.headers['cf-connecting-ip'] || 
                 req.connection.remoteAddress;

// 自动识别本地地址和私有IP范围
const isLocalAddress = (ip) => {
  const localAddresses = ['127.0.0.1', '::1', 'localhost'];
  const privateRanges = [/^10\./, /^172\.(1[6-9]|2[0-9]|3[0-1])\./, /^192\.168\./];

  return localAddresses.includes(ip) || privateRanges.some(range => range.test(ip));
};

// 每次验证都记录详细信息
await db.run(`
  INSERT INTO license_usage (license_id, machine_id, ip_address, user_agent) 
  VALUES (?, ?, ?, ?)
`, [license.id, machineId, clientIP, deviceInfo]);

// 更新当前使用次数
await db.run(`
  UPDATE licenses 
  SET current_uses = current_uses + 1 
  WHERE id = ?
`, [license.id]);

// 使用UTC时间确保跨时区一致性
const currentUtcTime = moment.utc().format('YYYY-MM-DD HH:mm:ss');
const currentUtcDate = moment.utc().format('YYYY-MM-DD');

// 支持密钥暂停功能
if (license.paused_at) {
  return { success: false, message: '密钥已被暂停' };
}

// 自动过期检查
if (license.expires_at && moment.utc().isAfter(license.expires_at)) {
  return { success: false, message: '密钥已过期' };
}

// 验证密钥
async function verifyLicense(licenseKey, machineId) {
    try {
        const response = await fetch('/api/license/verify', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                licenseKey: licenseKey,
                machineId: machineId,
                deviceInfo: JSON.stringify({
                    userAgent: navigator.userAgent,
                    platform: navigator.platform,
                    timestamp: new Date().toISOString()
                })
            })
        });

        const result = await response.json();

        if (result.success) {
            console.log('License验证成功');
            return result.data;
        } else {
            console.log('License验证失败:', result.message);
            return null;
        }
    } catch (error) {
        console.error('验证请求失败:', error);
        return null;
    }
}

// 生成机器ID
function generateMachineId() {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    ctx.textBaseline = 'top';
    ctx.font = '14px Arial';
    ctx.fillText('Machine ID', 2, 2);

    const fingerprint = canvas.toDataURL();
    const userAgent = navigator.userAgent;
    const screenRes = `${screen.width}x${screen.height}`;
    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;

    let hash = 0;
    const str = fingerprint + userAgent + screenRes + timezone;
    for (let i = 0; i < str.length; i++) {
        const char = str.charCodeAt(i);
        hash = ((hash << 5) - hash) + char;
        hash = hash & hash;
    }

    return `machine_${Math.abs(hash)}`;
}

class ServerMachineId {
  // 生成服务器机器码
  generateMachineId() {
    // 收集最稳定的硬件特征
    const hardwareFeatures = {
      platform: os.platform(),           // 操作系统平台
      hardwareConcurrency: os.cpus().length, // CPU核心数
      deviceMemory: os.totalmem(),       // 系统内存大小
      cpuModel: this.getCPUModel(),      // CPU型号信息
      cpuId: this.getCPUId(),            // CPU序列号或ID
      motherboardInfo: this.getMotherboardInfo(), // 主板信息
      osInfo: this.getOSInfo(),          // 操作系统信息
      arch: os.arch(),                   // CPU架构
      hostId: this.getHostId()           // 宿主机标识
    };

    // 生成哈希
    const str = JSON.stringify(sortedFeatures, sortedKeys);
    const hash = crypto.createHash('sha256').update(str, 'utf8').digest('hex');
    const machineId = `server_${hash.substring(0, 16)}`;

    return machineId;
  }
}

// 使用示例
async function checkLicense() {
    const licenseKey = 'PRO-5F587EBFE85D59419FFB40CB82CFA3FB';
    const machineId = generateMachineId();

    const license = await verifyLicense(licenseKey, machineId);
    if (license) {
        console.log('License类型:', license.licenseTypeName);
        console.log('剩余使用次数:', license.maxUses - license.currentUses);
        console.log('设备数量:', license.currentDevices + '/' + license.maxDevices);
        console.log('过期时间:', license.expiresAt);

        // 根据License信息启用功能
        enableFeatures(license);
    } else {
        // License验证失败，显示错误信息
        showLicenseError();
    }
}

// 启用功能
function enableFeatures(license) {
    if (license.licenseTypeName === '专业版') {
        enableProFeatures();
    } else if (license.licenseTypeName === '企业版') {
        enableEnterpriseFeatures();
    }
}

import { useState, useEffect } from 'react';

export function useLicense(licenseKey) {
    const [license, setLicense] = useState(null);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);

    useEffect(() => {
        async function verifyLicense() {
            try {
                const machineId = generateMachineId();
                const result = await fetch('/api/license/verify', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json'
                    },
                    body: JSON.stringify({
                        licenseKey,
                        machineId,
                        deviceInfo: JSON.stringify({
                            userAgent: navigator.userAgent,
                            platform: navigator.platform
                        })
                    })
                });

                const data = await result.json();

                if (data.success) {
                    setLicense(data.data);
                } else {
                    setError(data.message);
                }
            } catch (err) {
                setError('网络错误');
            } finally {
                setLoading(false);
            }
        }

        if (licenseKey) {
            verifyLicense();
        }
    }, [licenseKey]);

    return { license, loading, error };
}

import React from 'react';
import { useLicense } from './useLicense';

function App() {
    const { license, loading, error } = useLicense('PRO-5F587EBFE85D59419FFB40CB82CFA3FB');

    if (loading) {
        return <div>验证License中...</div>;
    }

    if (error) {
        return <div>License验证失败: {error}</div>;
    }

    if (!license) {
        return <div>无效的License</div>;
    }

    return (
        <div>
            <h1>欢迎使用 {license.applicationName}</h1>
            <p>License类型: {license.licenseTypeName}</p>
            <p>剩余使用次数: {license.maxUses - license.currentUses}</p>
            <p>设备数量: {license.currentDevices}/{license.maxDevices}</p>
            <p>过期时间: {new Date(license.expiresAt).toLocaleDateString()}</p>
        </div>
    );
}

import { ref, onMounted } from 'vue';

export function useLicense(licenseKey) {
    const license = ref(null);
    const loading = ref(true);
    const error = ref(null);

    const verifyLicense = async () => {
        try {
            const machineId = generateMachineId();
            const response = await fetch('/api/license/verify', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    licenseKey,
                    machineId,
                    deviceInfo: JSON.stringify({
                        userAgent: navigator.userAgent,
                        platform: navigator.platform
                    })
                })
            });

            const data = await response.json();

            if (data.success) {
                license.value = data.data;
            } else {
                error.value = data.message;
            }
        } catch (err) {
            error.value = '网络错误';
        } finally {
            loading.value = false;
        }
    };

    onMounted(() => {
        if (licenseKey) {
            verifyLicense();
        }
    });

    return {
        license,
        loading,
        error,
        verifyLicense
    };
}

const axios = require('axios');
const crypto = require('crypto');

class LicenseClient {
    constructor(baseURL, licenseKey) {
        this.baseURL = baseURL;
        this.licenseKey = licenseKey;
        this.machineId = this.generateMachineId();
    }

    generateMachineId() {
        const os = require('os');
        const networkInterfaces = os.networkInterfaces();
        const macAddress = Object.values(networkInterfaces)
            .flat()
            .find(interface => !interface.internal)?.mac;

        const hostname = os.hostname();
        const platform = os.platform();

        const data = `${macAddress}-${hostname}-${platform}`;
        const hash = crypto.createHash('md5').update(data).digest('hex');

        return `machine_${hash}`;
    }

    async verify() {
        try {
            const response = await axios.post(`${this.baseURL}/api/license/verify`, {
                licenseKey: this.licenseKey,
                machineId: this.machineId,
                deviceInfo: JSON.stringify({
                    platform: process.platform,
                    arch: process.arch,
                    version: process.version,
                    hostname: require('os').hostname()
                })
            });

            return response.data;
        } catch (error) {
            if (error.response) {
                return error.response.data;
            }
            throw error;
        }
    }

    async checkFeature(featureName) {
        const result = await this.verify();

        if (!result.success) {
            return false;
        }

        const license = result.data;

        // 检查License是否有效
        if (license.status !== 'active') {
            return false;
        }

        // 检查是否过期
        if (license.expiresAt && new Date() > new Date(license.expiresAt)) {
            return false;
        }

        // 根据License类型检查功能
        switch (license.licenseTypeName) {
            case '专业版':
                return ['feature1', 'feature2', 'feature3'].includes(featureName);
            case '企业版':
                return ['feature1', 'feature2', 'feature3', 'feature4', 'feature5'].includes(featureName);
            default:
                return false;
        }
    }
}

module.exports = LicenseClient;

const LicenseClient = require('./license-client');

async function main() {
    const client = new LicenseClient(
        'http://localhost:3005',
        'PRO-5F587EBFE85D59419FFB40CB82CFA3FB'
    );

    // 验证License
    const result = await client.verify();
    if (result.success) {
        console.log('License验证成功:', result.data);

        // 检查功能
        const hasFeature1 = await client.checkFeature('feature1');
        console.log('功能1可用:', hasFeature1);

        const hasFeature4 = await client.checkFeature('feature4');
        console.log('功能4可用:', hasFeature4);
    } else {
        console.log('License验证失败:', result.message);
    }
}

main().catch(console.error);

// 使用HTTPS
const API_BASE_URL = 'https://your-domain.com';

// 实现重试机制
async function verifyLicenseWithRetry(licenseKey, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
        try {
            return await verifyLicense(licenseKey);
        } catch (error) {
            if (i === maxRetries - 1) throw error;
            await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
        }
    }
}

// 本地缓存License信息
function cacheLicense(license) {
    localStorage.setItem('license', JSON.stringify({
        ...license,
        cachedAt: new Date().toISOString()
    }));
}

function getCachedLicense() {
    const cached = localStorage.getItem('license');
    if (!cached) return null;

    const license = JSON.parse(cached);
    const cachedAt = new Date(license.cachedAt);
    const now = new Date();

    // 缓存1小时
    if (now - cachedAt > 60 * 60 * 1000) {
        localStorage.removeItem('license');
        return null;
    }

    return license;
}

// 统一错误处理
function handleLicenseError(error) {
    switch (error.error) {
        case 'EXPIRED_LICENSE':
            showMessage('License已过期，请续费');
            break;
        case 'MAX_DEVICES_REACHED':
            showMessage(`设备数量已达上限，最多支持${error.maxDevices}台设备`);
            break;
        case 'MAX_USES_REACHED':
            showMessage('License使用次数已达上限');
            break;
        case 'LICENSE_PAUSED':
            showMessage('License已被暂停');
            break;
        default:
            showMessage('License验证失败，请检查网络连接');
    }
}

const { verifyLicense } = require('../utils/licenseGenerator');

describe('License验证测试', () => {
    test('有效License应该通过验证', () => {
        const license = {
            licenseKey: 'PRO-5F587EBFE85D59419FFB40CB82CFA3FB',
            status: 'active',
            maxUses: 5,
            currentUses: 1,
            maxDevices: 3,
            currentDevices: 1,
            expiresAt: '2024-12-31T23:59:59Z'
        };

        const result = verifyLicense(license, 'machine_123');
        expect(result.success).toBe(true);
    });

    test('过期License应该被拒绝', () => {
        const license = {
            licenseKey: 'PRO-5F587EBFE85D59419FFB40CB82CFA3FB',
            status: 'active',
            maxUses: 5,
            currentUses: 1,
            maxDevices: 3,
            currentDevices: 1,
            expiresAt: '2020-12-31T23:59:59Z'
        };

        const result = verifyLicense(license, 'machine_123');
        expect(result.success).toBe(false);
        expect(result.error).toBe('EXPIRED_LICENSE');
    });
});

const request = require('supertest');
const app = require('../server');

describe('API接口测试', () => {
    test('POST /api/license/verify 应该验证License', async () => {
        const response = await request(app)
            .post('/api/license/verify')
            .send({
                licenseKey: 'PRO-5F587EBFE85D59419FFB40CB82CFA3FB',
                machineId: 'machine_123'
            });

        expect(response.status).toBe(200);
        expect(response.body).toHaveProperty('success');
    });

    test('POST /api/auth/login 应该验证用户登录', async () => {
        const response = await request(app)
            .post('/api/auth/login')
            .send({
                username: 'admin',
                password: 'admin123'
            });

        expect(response.status).toBe(200);
        expect(response.body.success).toBe(true);
        expect(response.body.data).toHaveProperty('token');
    });
});