125606
数字签名程序设计。要求：

（1）对任意字符串及任意文件进行签名与验证签名。

（2）简单用户界面，密钥对生成，输入任意字符串或选择的任意文件，生成签名。

（3）对签名文件进行签名验证。
算法用rsa或者dsa都行，两天时间，预算150
C++或者c++都可以

您可以使用RSA或DSA算法来设计一个数字签名程序。以下是一个使用C++编程语言实现的简单示例：

#include <iostream>
#include <fstream>
#include <string>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>

// 生成密钥对
bool generateKeyPair(const std::string& publicKeyPath, const std::string& privateKeyPath) {
    RSA* rsaKeyPair = RSA_generate_key(2048, RSA_F4, nullptr, nullptr);
    if (!rsaKeyPair) {
        return false;
    }

    // 保存公钥
    FILE* publicKeyFile = fopen(publicKeyPath.c_str(), "wb");
    if (!publicKeyFile) {
        RSA_free(rsaKeyPair);
        return false;
    }
    if (!PEM_write_RSA_PUBKEY(publicKeyFile, rsaKeyPair)) {
        fclose(publicKeyFile);
        RSA_free(rsaKeyPair);
        return false;
    }
    fclose(publicKeyFile);

    // 保存私钥
    FILE* privateKeyFile = fopen(privateKeyPath.c_str(), "wb");
    if (!privateKeyFile) {
        RSA_free(rsaKeyPair);
        return false;
    }
    if (!PEM_write_RSAPrivateKey(privateKeyFile, rsaKeyPair, nullptr, nullptr, 0, nullptr, nullptr)) {
        fclose(privateKeyFile);
        RSA_free(rsaKeyPair);
        return false;
    }
    fclose(privateKeyFile);
    RSA_free(rsaKeyPair);

    return true;
}

// 签名
bool signFile(const std::string& privateKeyPath, const std::string& filePath, const std::string& signaturePath) {
    // 读取私钥
    FILE* privateKeyFile = fopen(privateKeyPath.c_str(), "rb");
    if (!privateKeyFile) {
        return false;
    }
    RSA* rsaPrivateKey = PEM_read_RSAPrivateKey(privateKeyFile, nullptr, nullptr, nullptr);
    fclose(privateKeyFile);
    if (!rsaPrivateKey) {
        return false;
    }

    // 读取文件
    std::ifstream file(filePath, std::ios::binary);
    if (!file) {
        RSA_free(rsaPrivateKey);
        return false;
    }

    // 计算文件哈希值
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    char buffer[4096];
    while (file.read(buffer, sizeof(buffer))) {
        SHA256_Update(&sha256, buffer, file.gcount());
    }
    SHA256_Final(hash, &sha256);
    file.close();

    // 对哈希值进行签名
    unsigned char signature[RSA_size(rsaPrivateKey)];
    unsigned int signatureLength;
    if (RSA_sign(NID_sha256, hash, sizeof(hash), signature, &signatureLength, rsaPrivateKey) != 1) {
        RSA_free(rsaPrivateKey);
        return false;
    }

    // 保存签名
    FILE* signatureFile = fopen(signaturePath.c_str(), "wb");
    if (!signatureFile) {
        RSA_free(rsaPrivateKey);
        return false;
    }
    fwrite(signature, sizeof(unsigned char), signatureLength, signatureFile);
    fclose(signatureFile);

    RSA_free(rsaPrivateKey);

    return true;
}

// 验证签名
bool verifySignature(const std::string& publicKeyPath, const std::string& filePath, const std::string& signaturePath) {
    // 读取公钥
    FILE* publicKeyFile = fopen(publicKeyPath.c_str(), "rb");
    if (!publicKeyFile) {
        return false;
    }
    RSA* rsaPublicKey = PEM_read_RSA_PUBKEY(publicKeyFile, nullptr, nullptr, nullptr);
    fclose(publicKeyFile);
    if (!rsaPublicKey) {
        return false;
    }

    // 读取文件
    std::ifstream file(filePath, std::ios::binary);
    if (!file) {
        RSA_free(rsaPublicKey);
        return false;
    }

    // 计算文件哈希值
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    char buffer[4096];
    while (file.read(buffer, sizeof(buffer))) {
        SHA256_Update(&sha256, buffer, file.gcount());
    }
    SHA256_Final(hash, &sha256);
    file.close();

    // 读取签名
    FILE* signatureFile = fopen(signaturePath.c_str(), "rb");
    if (!signatureFile) {
        RSA_free(rsaPublicKey);
        return false;
    }
    fseek(signatureFile, 0, SEEK_END);
    long signatureSize = ftell(signatureFile);
    rewind(signatureFile);
    unsigned char* signature = new unsigned char[signatureSize];
    fread(signature, sizeof(unsigned char), signatureSize, signatureFile);
    fclose(signatureFile);

    // 验证签名
    if (RSA_verify(NID_sha256, hash, sizeof(hash), signature, signatureSize, rsaPublicKey) != 1) {
        delete[] signature;
        RSA_free(rsaPublicKey);
        return false;
    }

    delete[] signature;
    RSA_free(rsaPublicKey);

    return true;
}

int main() {
    std::cout << "1. 生成密钥对" << std::endl;
    std::cout << "2. 对文件进行签名" << std::endl;
    std::cout << "3. 对签名文件进行验证" << std::endl;
    std::cout << "请选择操作：";
    int choice;
    std::cin >> choice;

    if (choice == 1) {
        std::string publicKeyPath = "public_key.pem";
        std::string privateKeyPath = "private_key.pem";
        if (generateKeyPair(publicKeyPath, privateKeyPath)) {
            std::cout << "密钥对生成成功！" << std::endl;
        } else {
            std::cout << "密钥对生成失败！" << std::endl;
        }
        return 0;
    }

    std::string publicKeyPath = "public_key.pem";
    std::string privateKeyPath = "private_key.pem";
    std::string filePath = "file.txt";
    std::string signaturePath = "signature.bin";

    if (choice == 2) {
        if (signFile(privateKeyPath, filePath, signaturePath)) {
            std::cout << "文件签名成功！" << std::endl;
        } else {
            std::cout << "文件签名失败！" << std::endl;
        }
    } else if (choice == 3) {
        if (verifySignature(publicKeyPath, filePath, signaturePath)) {
            std::cout << "签名验证通过！" << std::endl;
        } else {
            std::cout << "签名验证失败！" << std::endl;
        }
    }

    return 0;
}

请确保您已经安装OpenSSL库，并将OpenSSL的include和lib目录添加到编译器的搜索路径中。

这个示例程序提供了生成密钥对、对文件进行签名以及对签名文件进行验证的功能。您可以根据需要修改文件路径和名称。