linux编写限制软件试用期代码 ,对生成的配置文件进行openssl加密以及锁定，提示剩余使用时间 C++示例

以下是一个简单的实现，可以限制软件试用期为 30 天，并对生成的配置文件进行 OpenSSL 加密和锁定：

#include <iostream>
#include <fstream>
#include <chrono>
#include <ctime>
#include <openssl/evp.h>
#include <openssl/rand.h>
#include <openssl/err.h>

#define KEY_SIZE 32
#define IV_SIZE 16
#define ENCRYPTED_FILE "config.dat"

// 使用 OpenSSL 进行加密和解密
int aes_encrypt(const unsigned char *plaintext, int plaintext_len, const unsigned char *key, const unsigned char *iv, unsigned char *ciphertext) {
    EVP_CIPHER_CTX *ctx;
    int len;
    int ciphertext_len;

    if (!(ctx = EVP_CIPHER_CTX_new())) {
        return -1;
    }

    if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) {
        EVP_CIPHER_CTX_free(ctx);
        return -1;
    }

    if (1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len)) {
        EVP_CIPHER_CTX_free(ctx);
        return -1;
    }
    ciphertext_len = len;

    if (1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) {
        EVP_CIPHER_CTX_free(ctx);
        return -1;
    }
    ciphertext_len += len;

    EVP_CIPHER_CTX_free(ctx);

    return ciphertext_len;
}

int aes_decrypt(const unsigned char *ciphertext, int ciphertext_len, const unsigned char *key, const unsigned char *iv, unsigned char *plaintext) {
    EVP_CIPHER_CTX *ctx;
    int len;
    int plaintext_len;

    if (!(ctx = EVP_CIPHER_CTX_new())) {
        return -1;
    }

    if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) {
        EVP_CIPHER_CTX_free(ctx);
        return -1;
    }

    if (1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len)) {
        EVP_CIPHER_CTX_free(ctx);
        return -1;
    }
    plaintext_len = len;

    if (1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) {
        EVP_CIPHER_CTX_free(ctx);
        return -1;
    }
    plaintext_len += len;

    EVP_CIPHER_CTX_free(ctx);

    return plaintext_len;
}

// 生成随机密钥和 IV
void generate_key_iv(unsigned char *key, unsigned char *iv) {
    RAND_bytes(key, KEY_SIZE);
    RAND_bytes(iv, IV_SIZE);
}

// 锁定配置文件，防止篡改
void lock_config(const unsigned char *key, const unsigned char *iv) {
    std::ifstream input("config.dat", std::ios::binary);
    if (!input) {
        std::cerr << "Failed to open config.dat" << std::endl;
        return;
    }

    // 获取文件长度
    input.seekg(0, std::ios::end);
    int file_len = input.tellg();
    input.seekg(0, std::ios::beg);

    // 读取文件内容
    unsigned char *plaintext = new unsigned char[file_len];
    input.read(reinterpret_cast<char *>(plaintext), file_len);
    input.close();

    // 加密文件内容
    unsigned char *ciphertext = new unsigned char[file_len + EVP_MAX_BLOCK_LENGTH];
    int ciphertext_len = aes_encrypt(plaintext, file_len, key, iv, ciphertext);

    // 写入加密后的文件内容
    std::ofstream output(ENCRYPTED_FILE, std::ios::binary);
    output.write(reinterpret_cast<char *>(ciphertext), ciphertext_len);
    output.close();

    delete[] plaintext;
    delete[] ciphertext;
}

// 解锁配置文件，并返回解密后的内容
unsigned char *unlock_config(const unsigned char *key, const unsigned char *iv, int &file_len) {
    std::ifstream input(ENCRYPTED_FILE, std::ios::binary);
    if (!input) {
        std::cerr << "Failed to open " << ENCRYPTED_FILE << std::endl;
        return nullptr;
    }

    // 获取文件长度
    input.seekg(0, std::ios::end);
    int ciphertext_len = input.tellg();
    input.seekg(0, std::ios::beg);

    // 读取文件内容
    unsigned char *ciphertext = new unsigned char[ciphertext_len];
    input.read(reinterpret_cast<char *>(ciphertext), ciphertext_len);
    input.close();

    // 解密文件内容
    unsigned char *plaintext = new unsigned char[ciphertext_len];
    file_len = aes_decrypt(ciphertext, ciphertext_len, key, iv, plaintext);

    delete[] ciphertext;

    return plaintext;
}

// 计算剩余使用时间
int get_remaining_days(const time_t &start_time) {
    auto now = std::chrono::system_clock::now();
    auto start = std::chrono::system_clock::from_time_t(start_time);
    auto diff = std::chrono::duration_cast<std::chrono::hours>(now - start).count();
    int remaining_days = 30 - static_cast<int>(diff / 24);
    return remaining_days;
}

int main() {
    unsigned char key[KEY_SIZE];
    unsigned char iv[IV_SIZE];
    generate_key_iv(key, iv);

    // 写入配置文件
    std::ofstream output("config.dat", std::ios::binary);
    if (!output) {
        std::cerr << "Failed to open config.dat" << std::endl;
        return 1;
    }

    time_t start_time = std::time(nullptr);  // 记录软件启动时间

    output << start_time;  // 将启动时间写入配置文件
    output.close();

    // 锁定配置文件
    lock_config(key, iv);

    // 解锁配置文件，并计算剩余使用时间
    int file_len;
    unsigned char *plaintext = unlock_config(key, iv, file_len);
    if (!plaintext) {
        return 1;
    }

    time_t start_time_file = *reinterpret_cast<time_t *>(plaintext);  // 从配置文件中读取软件启动时间
    delete[] plaintext;

    int remaining_days = get_remaining_days(start_time_file);
    if (remaining_days <= 0) {  // 软件试用期已过
        std::cout << "Sorry, your trial period has expired." << std::endl;
        return 1;
    }

    std::cout << "You have " << remaining_days << " days left to use the software." << std::endl;

    // 正常使用软件
    // TODO: 在这里编写正常使用软件的代码

    return 0;
}

在上面的代码中，我们使用了 OpenSSL 库进行加密和解密，并使用了时间戳来记录软件启动时间和计算剩余使用时间。我们还使用了 `lock_config()` 函数来锁定配置文件，以防止被篡改。

需要注意的是，我们在使用 OpenSSL 库时，需要在编译时链接相应的库文件。例如，在使用 GCC 编译时，可以使用以下命令：

g++ -o app main.cpp -lcrypto

其中，`-lcrypto` 参数用于链接 OpenSSL 库。