符合vs10环境用C++语言和openssl编写RSA的签名认证算法并附上每行代码注释

好的，下面是符合vs10环境用C++语言和openssl编写RSA的签名认证算法并附上每行代码注释的示例：

#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>

// 用于生成RSA密钥对的函数
void generate_key_pair(RSA** rsa_private_key, RSA** rsa_public_key) {
    // 生成一个2048位的RSA密钥对
    *rsa_private_key = RSA_generate_key(2048, RSA_F4, nullptr, nullptr);
    // 从RSA私钥中提取公钥
    *rsa_public_key = RSAPublicKey_dup(*rsa_private_key);
}

// 用于读取PEM格式的RSA密钥对的函数
void read_key_pair(const char* private_key_file, const char* public_key_file, RSA** rsa_private_key, RSA** rsa_public_key) {
    // 打开私钥文件
    FILE* fp_private = fopen(private_key_file, "rb");
    // 读取PEM格式的RSA私钥
    *rsa_private_key = PEM_read_RSAPrivateKey(fp_private, nullptr, nullptr, nullptr);
    fclose(fp_private);
    
    // 打开公钥文件
    FILE* fp_public = fopen(public_key_file, "rb");
    // 读取PEM格式的RSA公钥
    *rsa_public_key = PEM_read_RSAPublicKey(fp_public, nullptr, nullptr, nullptr);
    fclose(fp_public);
}

// 用于进行RSA签名的函数
bool rsa_sign(const unsigned char* data, size_t data_len, RSA* rsa_private_key, unsigned char* signature, unsigned int* signature_len) {
    // 创建一个EVP_MD_CTX对象，用于计算消息的摘要
    EVP_MD_CTX* md_ctx = EVP_MD_CTX_create();
    if (md_ctx == nullptr) {
        return false;
    }
    
    // 选择摘要算法SHA256
    const EVP_MD* md = EVP_sha256();
    
    // 初始化EVP_MD_CTX对象
    if (EVP_DigestInit_ex(md_ctx, md, nullptr) != 1) {
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 计算消息的摘要
    if (EVP_DigestUpdate(md_ctx, data, data_len) != 1) {
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 获取消息的摘要值
    unsigned char digest[EVP_MAX_MD_SIZE];
    unsigned int digest_len = 0;
    if (EVP_DigestFinal_ex(md_ctx, digest, &digest_len) != 1) {
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 创建一个EVP_PKEY对象，用于进行签名
    EVP_PKEY* pkey = EVP_PKEY_new();
    if (pkey == nullptr) {
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 将RSA私钥添加到EVP_PKEY对象中
    if (EVP_PKEY_assign_RSA(pkey, rsa_private_key) != 1) {
        EVP_PKEY_free(pkey);
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 创建一个EVP_MD_CTX对象，用于进行RSA签名
    EVP_MD_CTX* sign_ctx = EVP_MD_CTX_create();
    if (sign_ctx == nullptr) {
        EVP_PKEY_free(pkey);
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 初始化EVP_MD_CTX对象
    if (EVP_DigestSignInit(sign_ctx, nullptr, md, nullptr, pkey) != 1) {
        EVP_PKEY_free(pkey);
        EVP_MD_CTX_destroy(md_ctx);
        EVP_MD_CTX_destroy(sign_ctx);
        return false;
    }
    
    // 进行RSA签名
    if (EVP_DigestSignUpdate(sign_ctx, digest, digest_len) != 1) {
        EVP_PKEY_free(pkey);
        EVP_MD_CTX_destroy(md_ctx);
        EVP_MD_CTX_destroy(sign_ctx);
        return false;
    }
    
    // 获取RSA签名结果
    if (EVP_DigestSignFinal(sign_ctx, signature, signature_len) != 1) {
        EVP_PKEY_free(pkey);
        EVP_MD_CTX_destroy(md_ctx);
        EVP_MD_CTX_destroy(sign_ctx);
        return false;
    }
    
    EVP_PKEY_free(pkey);
    EVP_MD_CTX_destroy(md_ctx);
    EVP_MD_CTX_destroy(sign_ctx);
    return true;
}

// 用于进行RSA验签的函数
bool rsa_verify(const unsigned char* data, size_t data_len, RSA* rsa_public_key, const unsigned char* signature, unsigned int signature_len) {
    // 创建一个EVP_MD_CTX对象，用于计算消息的摘要
    EVP_MD_CTX* md_ctx = EVP_MD_CTX_create();
    if (md_ctx == nullptr) {
        return false;
    }
    
    // 选择摘要算法SHA256
    const EVP_MD* md = EVP_sha256();
    
    // 初始化EVP_MD_CTX对象
    if (EVP_DigestInit_ex(md_ctx, md, nullptr) != 1) {
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 计算消息的摘要
    if (EVP_DigestUpdate(md_ctx, data, data_len) != 1) {
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 获取消息的摘要值
    unsigned char digest[EVP_MAX_MD_SIZE];
    unsigned int digest_len = 0;
    if (EVP_DigestFinal_ex(md_ctx, digest, &digest_len) != 1) {
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 创建一个EVP_PKEY对象，用于进行验签
    EVP_PKEY* pkey = EVP_PKEY_new();
    if (pkey == nullptr) {
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 将RSA公钥添加到EVP_PKEY对象中
    if (EVP_PKEY_assign_RSA(pkey, rsa_public_key) != 1) {
        EVP_PKEY_free(pkey);
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 创建一个EVP_MD_CTX对象，用于进行RSA验签
    EVP_MD_CTX* verify_ctx = EVP_MD_CTX_create();
    if (verify_ctx == nullptr) {
        EVP_PKEY_free(pkey);
        EVP_MD_CTX_destroy(md_ctx);
        return false;
    }
    
    // 初始化EVP_MD_CTX对象
    if (EVP_DigestVerifyInit(verify_ctx, nullptr, md, nullptr, pkey) != 1) {
        EVP_PKEY_free(pkey);
        EVP_MD_CTX_destroy(md_ctx);
        EVP_MD_CTX_destroy(verify_ctx);
        return false;
    }
    
    // 进行RSA验签
    if (EVP_DigestVerifyUpdate(verify_ctx, digest, digest_len) != 1) {
        EVP_PKEY_free(pkey);
        EVP_MD_CTX_destroy(md_ctx);
        EVP_MD_CTX_destroy(verify_ctx);
        return false;
    }
    
    // 验证RSA签名结果
    int verify_result = EVP_DigestVerifyFinal(verify_ctx, signature, signature_len);
    if (verify_result != 1) {
        EVP_PKEY_free(pkey);
        EVP_MD_CTX_destroy(md_ctx);
        EVP_MD_CTX_destroy(verify_ctx);
        return false;
    }
    
    EVP_PKEY_free(pkey);
    EVP_MD_CTX_destroy(md_ctx);
    EVP_MD_CTX_destroy(verify_ctx);
    return true;
}

int main() {
    // 生成RSA密钥对
    RSA* rsa_private_key = nullptr;
    RSA* rsa_public_key = nullptr;
    generate_key_pair(&rsa_private_key, &rsa_public_key);
    
    // 保存RSA密钥对到文件
    FILE* fp_private = fopen("private.key", "wb");
    PEM_write_RSAPrivateKey(fp_private, rsa_private_key, nullptr, nullptr, 0, nullptr, nullptr);
    fclose(fp_private);
    
    FILE* fp_public = fopen("public.key", "wb");
    PEM_write_RSAPublicKey(fp_public, rsa_public_key);
    fclose(fp_public);
    
    // 读取RSA密钥对
    RSA* rsa_private_key2 = nullptr;
    RSA* rsa_public_key2 = nullptr;
    read_key_pair("private.key", "public.key", &rsa_private_key2, &rsa_public_key2);
    
    // 进行RSA签名
    const unsigned char data[] = "hello, world!";
    unsigned char signature[2048 / 8] = { 0 };
    unsigned int signature_len = 0;
    rsa_sign(data, sizeof(data), rsa_private_key2, signature, &signature_len);
    
    // 进行RSA验签
    bool verify_result = rsa_verify(data, sizeof(data), rsa_public_key2, signature, signature_len);
    
    // 输出验签结果
    printf("%s\n", verify_result ? "verify succeed" : "verify failed");
    
    RSA_free(rsa_private_key);
    RSA_free(rsa_public_key);
    RSA_free(rsa_private_key2);
    RSA_free(rsa_public_key2);
    return 0;
}

注：这段代码示例仅供参考，请根据实际情况进行调整。