win下c++编译和测试openssl

最新推荐文章于 2025-06-13 20:25:11 发布
最新推荐文章于 2025-06-13 20:25:11 发布
阅读量792 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 加解密 文章标签： openssl 编译
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhanglidn013/article/details/90212343

openssl的编译

win下openssl 编译
x86环境,请输入
perl Configure VC-WIN32 no-asm --prefix="D:\workspace\openssl-1.1.1b\x86"
如果是x64环境 , 请输入 
perl Configure VC-WIN64A no-asm --prefix="D:\workspace\openssl-1.1.1b\x64" 
其中, --prefix=是指定的库和工具头文件等最终输出目录,请根据实际进行修改

在x86和x64下各自执行

nmake
nmake test
nmake install
nmake clean

 

openssl的测试例子

#include <iostream>  
#include <cassert>
#include <string>  
#include <vector>  
#include<Windows.h>
#include<stdio.h>
#include<stdlib.h>
#include <time.h>
#include <fstream>
#include "openssl/md5.h"  
#include "openssl/sha.h"  
#include "openssl/des.h"  
#include "openssl/rsa.h"  
#include "openssl/pem.h"  
#include "openssl/aes.h"
#include "openssl/err.h"



#define RELESE(P) if (P)        \
{                               \
    delete P;                   \
    P = NULL;                   \
}

#define RELESE_ARRAY(P) if (P)  \
{                               \
    delete[] P;                 \
    P = NULL;                   \
}

// ---- md5摘要哈希 ---- //  
void md5(const std::string& srcStr, std::string& encodedStr, std::string& encodedHexStr)
{
    // 调用md5哈希  
    unsigned char mdStr[33] = { 0 };
    MD5((const unsigned char*)srcStr.c_str(), srcStr.length(), mdStr);

    // 哈希后的字符串  
    encodedStr = std::string((const char*)mdStr);
    // 哈希后的十六进制串 32字节  
    char buf[65] = { 0 };
    char tmp[3] = { 0 };
    for (int i = 0; i < 32; i++)
    {
        sprintf(tmp, "%02x", mdStr[i]);
        strcat(buf, tmp);
    }
    buf[32] = '\0'; // 后面都是0，从32字节截断  
    encodedHexStr = std::string(buf);
}

// ---- sha256摘要哈希 ---- //  
void sha256(const std::string& srcStr, std::string& encodedStr, std::string& encodedHexStr)
{
    // 调用sha256哈希  
    unsigned char mdStr[33] = { 0 };
    SHA256((const unsigned char*)srcStr.c_str(), srcStr.length(), mdStr);

    // 哈希后的字符串  
    encodedStr = std::string((const char*)mdStr);
    // 哈希后的十六进制串 32字节  
    char buf[65] = { 0 };
    char tmp[3] = { 0 };
    for (int i = 0; i < 32; i++)
    {
        sprintf(tmp, "%02x", mdStr[i]);
        strcat(buf, tmp);
    }
    buf[32] = '\0'; // 后面都是0，从32字节截断  
    encodedHexStr = std::string(buf);
}

// ---- des对称加解密 ---- //  
// 加密 ecb模式  
std::string des_encrypt(const std::string& clearText, const std::string& key)
{
    std::string cipherText; // 密文  

    DES_cblock keyEncrypt;
    memset(keyEncrypt, 0, 8);

    // 构造补齐后的密钥  
    if (key.length() <= 8)
        memcpy(keyEncrypt, key.c_str(), key.length());
    else
        memcpy(keyEncrypt, key.c_str(), 8);

    // 密钥置换  
    DES_key_schedule keySchedule;
    DES_set_key_unchecked(&keyEncrypt, &keySchedule);

    // 循环加密，每8字节一次  
    const_DES_cblock inputText;
    DES_cblock outputText;
    std::vector<unsigned char> vecCiphertext;
    unsigned char tmp[8];

    for (int i = 0; i < clearText.length() / 8; i++)
    {
        memcpy(inputText, clearText.c_str() + i * 8, 8);
        DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_ENCRYPT);
        memcpy(tmp, outputText, 8);

        for (int j = 0; j < 8; j++)
        {
            vecCiphertext.push_back(tmp[j]);
        }
    }

    if (clearText.length() % 8 != 0)
    {
        int tmp1 = clearText.length() / 8 * 8;
        int tmp2 = clearText.length() - tmp1;
        memset(inputText, 0, 8);
        memcpy(inputText, clearText.c_str() + tmp1, tmp2);
        // 加密函数  
        DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_ENCRYPT);
        memcpy(tmp, outputText, 8);

        for (int j = 0; j < 8; j++)
        {
            vecCiphertext.push_back(tmp[j]);
        }
    }

    cipherText.clear();
    cipherText.assign(vecCiphertext.begin(), vecCiphertext.end());

    return cipherText;
}

// 解密 ecb模式  
std::string des_decrypt(const std::string & cipherText, const std::string & key)
{
    std::string clearText; // 明文  

    DES_cblock keyEncrypt;
    memset(keyEncrypt, 0, 8);

    if (key.length() <= 8)
        memcpy(keyEncrypt, key.c_str(), key.length());
    else
        memcpy(keyEncrypt, key.c_str(), 8);

    DES_key_schedule keySchedule;
    DES_set_key_unchecked(&keyEncrypt, &keySchedule);

    const_DES_cblock inputText;
    DES_cblock outputText;
    std::vector<unsigned char> vecCleartext;
    unsigned char tmp[8];

    for (int i = 0; i < cipherText.length() / 8; i++)
    {
        memcpy(inputText, cipherText.c_str() + i * 8, 8);
        DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_DECRYPT);
        memcpy(tmp, outputText, 8);

        for (int j = 0; j < 8; j++)
            vecCleartext.push_back(tmp[j]);
    }

    if (cipherText.length() % 8 != 0)
    {
        int tmp1 = cipherText.length() / 8 * 8;
        int tmp2 = cipherText.length() - tmp1;
        memset(inputText, 0, 8);
        memcpy(inputText, cipherText.c_str() + tmp1, tmp2);
        // 解密函数  
        DES_ecb_encrypt(&inputText, &outputText, &keySchedule, DES_DECRYPT);
        memcpy(tmp, outputText, 8);

        for (int j = 0; j < 8; j++)
            vecCleartext.push_back(tmp[j]);
    }

    clearText.clear();
    clearText.assign(vecCleartext.begin(), vecCleartext.end());

    return clearText;
}


// ---- rsa非对称加解密 ---- //  
#define KEY_LENGTH  2048               // 密钥长度
#define PUB_KEY_FILE "pubkey.pem"    // 公钥路径
#define PRI_KEY_FILE "prikey.pem"    // 私钥路径

// 函数方法生成密钥对 
void generateRSAKey(std::string strKey[2])
{
    // 公私密钥对  
    size_t pri_len;
    size_t pub_len;
    char* pri_key = NULL;
    char* pub_key = NULL;

    // 生成密钥对  
    RSA* keypair = RSA_generate_key(KEY_LENGTH, RSA_3, NULL, NULL);

    BIO* pri = BIO_new(BIO_s_mem());
    BIO* pub = BIO_new(BIO_s_mem());

    PEM_write_bio_RSAPrivateKey(pri, keypair, NULL, NULL, 0, NULL, NULL);
    PEM_write_bio_RSAPublicKey(pub, keypair);

    // 获取长度  
    pri_len = BIO_pending(pri);
    pub_len = BIO_pending(pub);

    // 密钥对读取到字符串  
    pri_key = (char*)malloc(pri_len + 1);
    pub_key = (char*)malloc(pub_len + 1);

    BIO_read(pri, pri_key, pri_len);
    BIO_read(pub, pub_key, pub_len);

    pri_key[pri_len] = '\0';
    pub_key[pub_len] = '\0';

    // 存储密钥对  
    strKey[0] = pub_key;
    strKey[1] = pri_key;

    // 存储到磁盘（这种方式存储的是begin rsa public key/ begin rsa private key开头的）
    FILE * pubFile = fopen(PUB_KEY_FILE, "w");
    if (pubFile == NULL)
    {
        assert(false);
        return;
    }
    fputs(pub_key, pubFile);
    fclose(pubFile);

    FILE* priFile = fopen(PRI_KEY_FILE, "w");
    if (priFile == NULL)
    {
        assert(false);
        return;
    }
    fputs(pri_key, priFile);
    fclose(priFile);

    // 内存释放
    RSA_free(keypair);
    BIO_free_all(pub);
    BIO_free_all(pri);

    free(pri_key);
    free(pub_key);
}

// 命令行方法生成公私钥对（begin public key/ begin private key）
// 找到openssl命令行工具，运行以下
// openssl genrsa -out prikey.pem 1024 
// openssl rsa - in privkey.pem - pubout - out pubkey.pem

// 公钥加密  
std::string rsa_pub_encrypt(const std::string & clearText, const std::string & pubKey)
{
    std::string strRet;
    RSA* rsa = NULL;
    BIO* keybio = BIO_new_mem_buf((unsigned char*)pubKey.c_str(), -1);
    // 此处有三种方法
    // 1, 读取内存里生成的密钥对，再从内存生成rsa
    // 2, 读取磁盘里生成的密钥对文本文件，在从内存生成rsa
    // 3，直接从读取文件指针生成rsa
    RSA * pRSAPublicKey = RSA_new();
    rsa = PEM_read_bio_RSAPublicKey(keybio, &rsa, NULL, NULL);

    int len = RSA_size(rsa);
    char* encryptedText = (char*)malloc(len + 1);
    memset(encryptedText, 0, len + 1);

    // 加密函数
    int ret = RSA_public_encrypt(clearText.length(), (const unsigned char*)clearText.c_str(), (unsigned char*)encryptedText, rsa, RSA_PKCS1_PADDING);
    if (ret >= 0)
        strRet = std::string(encryptedText, ret);

    // 释放内存
    free(encryptedText);
    BIO_free_all(keybio);
    RSA_free(rsa);

    return strRet;
}

// 私钥解密  
std::string rsa_pri_decrypt(const std::string & cipherText, const std::string & priKey)
{
    std::string strRet;
    RSA* rsa = RSA_new();
    BIO* keybio;
    keybio = BIO_new_mem_buf((unsigned char*)priKey.c_str(), -1);

    // 此处有三种方法
    // 1, 读取内存里生成的密钥对，再从内存生成rsa
    // 2, 读取磁盘里生成的密钥对文本文件，在从内存生成rsa
    // 3，直接从读取文件指针生成rsa
    rsa = PEM_read_bio_RSAPrivateKey(keybio, &rsa, NULL, NULL);

    int len = RSA_size(rsa);
    char* decryptedText = (char*)malloc(len + 1);
    memset(decryptedText, 0, len + 1);

    // 解密函数
    int ret = RSA_private_decrypt(cipherText.length(), (const unsigned char*)cipherText.c_str(), (unsigned char*)decryptedText, rsa, RSA_PKCS1_PADDING);
    if (ret >= 0)
        strRet = std::string(decryptedText, ret);

    // 释放内存
    free(decryptedText);
    BIO_free_all(keybio);
    RSA_free(rsa);

    return strRet;
}

// AES文件加密函数 ///////////////////////////////////////////////////////////
int TestAesEncryptFile(std::string in_file_path, std::string out_file_path, char Key[32])
{
    int encrypt_chunk_size = 16;

    std::ifstream fin(in_file_path.c_str(), std::ios::binary);
    std::ofstream fout(out_file_path, std::ios::binary);

    if (!fin)
    {
        std::cout << "Can not open fin file." << std::endl;
        return 1;
    }
    if (!fout)
    {
        std::cout << "Can not open fout file." << std::endl;
        return 1;
    }

    //用指定密钥对一段内存进行加密，结果放在outbuffer中
    unsigned char aes_keybuf[32];
    memset(aes_keybuf, 0, sizeof(aes_keybuf));
    strcpy((char*)aes_keybuf, Key);
    AES_KEY aeskey;
    AES_set_encrypt_key(aes_keybuf, 256, &aeskey);

    char* in_data = new char[encrypt_chunk_size + 1];
    char* out_data = new char[encrypt_chunk_size + 1];
    while (!fin.eof())
    {
        fin.read(in_data, encrypt_chunk_size);
        if (fin.gcount() < encrypt_chunk_size)
        {
            fout.write(in_data, fin.gcount());
        }
        else
        {
            AES_encrypt((const unsigned char*)in_data, (unsigned char*)out_data, &aeskey);
            fout.write(out_data, fin.gcount());
        }
    };

    fout.close();
    fin.close();

    RELESE_ARRAY(in_data);
    RELESE_ARRAY(out_data);

    return 0;
}

// AES文件解密函数 //////////////////////////////////////////////////////////
int TestAesDecryptFile(std::string in_file_path, std::string out_file_path, char Key[32])
{
    int encrypt_chunk_size = 16;
    std::ifstream fin(in_file_path.c_str(), std::ios::binary);
    std::ofstream fout(out_file_path, std::ios::binary);

    if (!fin)
    {
        std::cout << "Can not open fin file." << std::endl;
        return 1;
    }
    if (!fout)
    {
        std::cout << "Can not open fout file." << std::endl;
        return 1;
    }

    //用指定密钥对一段内存进行加密，结果放在outbuffer中
    unsigned char aes_keybuf[32];
    memset(aes_keybuf, 0, sizeof(aes_keybuf));
    strcpy((char*)aes_keybuf, Key);
    AES_KEY aeskey;
    AES_set_decrypt_key(aes_keybuf, 256, &aeskey);

    char* in_data = new char[encrypt_chunk_size + 1];
    char* out_data = new char[encrypt_chunk_size + 1];
    int i = 0;
    while (!fin.eof())
    {
        fin.read(in_data, encrypt_chunk_size);
        if (fin.gcount() < encrypt_chunk_size)
        {
            fout.write(in_data, fin.gcount());
        }
        else
        {
            AES_decrypt((unsigned char*)in_data, (unsigned char*)out_data, &aeskey);
            fout.write(out_data, fin.gcount());
        }
    };

    fout.close();
    fin.close();

    RELESE_ARRAY(in_data);
    RELESE_ARRAY(out_data);

    return 0;
}


int main(int argc, char** argv)
{
    time_t t1, t2, t3, t4;
    t1 = time(NULL);
    printf("加解密起始时间： %s\n", ctime(&t1));
    char strkey[] = "xxyy1234567890";
    TestAesEncryptFile("D://test.txt", "D://test.txtkey", strkey);
    t2 = time(NULL);
    printf("AES256加密成功!\n");
    printf("加密用时: %lld秒\n", (t2 - t1));
    t3 = time(NULL);
    TestAesDecryptFile("D://test.txtkey", "D://test1.txt", strkey);
    t4 = time(NULL);
    printf("AES256解密成功!\n");
    printf("解密用时: %lld秒\n", (t4 - t3));

    /*
    BYTE userKey[AES_BLOCK_SIZE];
    unsigned char* data = (unsigned char*)malloc(AES_BLOCK_SIZE * 3);
    unsigned char* encrypto = (unsigned char*)malloc(AES_BLOCK_SIZE * 3);
    unsigned char* plain = (unsigned char*)malloc(AES_BLOCK_SIZE * 3);
    AES_KEY key;

    memcpy(userKey, "zheshiopensslexq", 16);
    memset((void*)data, 'p', AES_BLOCK_SIZE * 3);
    memset((void*)encrypto, 0, AES_BLOCK_SIZE * 3);
    memset((void*)plain, 0, AES_BLOCK_SIZE * 3);

    //设置加密key及秘钥长度
    //理论上AES加密是根据S盒进行字节替换的，因此原文和密文个字节一一对应大小相同
    AES_set_encrypt_key((const unsigned char*)userKey, AES_BLOCK_SIZE * 8, &key);

    int len = 0;
    //循环加密， 每次加密长度是AES_BLOCK_SIZE长度的数据
    while (len < AES_BLOCK_SIZE * 3)
    {
        AES_encrypt(data + len, encrypto + len, &key);
        len += AES_BLOCK_SIZE;
    }

    //设置解密key及秘钥长度
    AES_set_decrypt_key((const unsigned char*)userKey, AES_BLOCK_SIZE * 8, &key);

    len = 0;
    //循环解密
    //每次输入16字节，输出16字节，如果不够需要填充
    while (len < AES_BLOCK_SIZE * 3)
    {
        AES_decrypt(encrypto + len, plain + len, &key);
        len += AES_BLOCK_SIZE;
    }

    //解密后与元数据是否一致
    if (memcmp(plain, data, AES_BLOCK_SIZE * 3) == 0)
    {
        printf("test success\n");
    }
    else
    {
        printf("test failed\n");
    }
    return 0;


    
    unsigned char buf[16];
    memset(buf, 1, sizeof(buf));
    strcpy((char*)buf, "thisisexample");

    std::cout << "current buf value is :" << buf << std::endl;

    unsigned char buf2[16];
    unsigned char buf3[16];
    unsigned char aes_keybuf[32];

    memset(aes_keybuf, 0, sizeof(aes_keybuf));
    strcpy((char*)aes_keybuf, "key1");
    std::cout << "current aes_keybuf value is :" << aes_keybuf << std::endl;
    AES_KEY aeskey;

    AES_set_encrypt_key(aes_keybuf, 256, &aeskey);
    //cout << "AESkey is:" << aeskey << endl;

    AES_encrypt(buf, buf2, &aeskey);
    std::cout << "current buf2 value is :" << buf2 << std::endl;

    memset(aes_keybuf, 0, sizeof(aes_keybuf));
    strcpy((char*)aes_keybuf, "key1");
    std::cout << "current aes_keybuf value is :" << aes_keybuf << std::endl;

    AES_set_decrypt_key(aes_keybuf, 256, &aeskey);

    AES_decrypt(buf2, buf3, &aeskey);
    std::cout << "current buf2 value is :" << buf2 << std::endl;
    std::cout << "*********************************" << std::endl;
    std::cout << "current buf3 value is :" << buf3 << std::endl;

    if (memcmp(buf, buf3, sizeof(buf)) == 0)
        printf("AES256 test success\r\n");
    else
        printf("AES256 test fail\r\n");
    return 0;



    // 原始明文  
    std::string srcText = "this is an example";

    std::string encryptText;
    std::string encryptHexText;
    std::string decryptText;

    std::cout << "=== 原始明文 ===" << std::endl;
    std::cout << srcText << std::endl;

    // md5  
    std::cout << "=== md5哈希 ===" << std::endl;
    md5(srcText, encryptText, encryptHexText);
    std::cout << "摘要字符： " << encryptText << std::endl;
    std::cout << "摘要串： " << encryptHexText << std::endl;

    // sha256  
    std::cout << "=== sha256哈希 ===" << std::endl;
    sha256(srcText, encryptText, encryptHexText);
    std::cout << "摘要字符： " << encryptText << std::endl;
    std::cout << "摘要串： " << encryptHexText << std::endl;

    // des  
    std::cout << "=== des加解密 ===" << std::endl;
    std::string desKey = "1234567890";
    encryptText = des_encrypt(srcText, desKey);
    std::cout << "加密字符： " << std::endl;
    std::cout << encryptText << std::endl;
    decryptText = des_decrypt(encryptText, desKey);
    std::cout << "解密字符： " << std::endl;
    std::cout << decryptText << std::endl;

    // rsa  
    std::cout << "=== rsa加解密 ===" << std::endl;
    std::string key[2];
    generateRSAKey(key);
    std::cout << "公钥: " << std::endl;
    std::cout << key[0] << std::endl;
    std::cout << "私钥： " << std::endl;
    std::cout << key[1] << std::endl;
    encryptText = rsa_pub_encrypt(srcText, key[0]);
    std::cout << "加密字符： " << std::endl;
    std::cout << encryptText << std::endl;
    decryptText = rsa_pri_decrypt(encryptText, key[1]);
    std::cout << "解密字符： " << std::endl;
    std::cout << decryptText << std::endl;

    system("pause");
    return 0;
    */
}

 

用C++编译 Openssl Engine及分享一个Openssl Engine框架
10-19
本模板程序定义了实现openssl ENGINE的Engine框架。 实现的基本思路是要通过Engine来替换openssl原来的 ASE-CBC算法和MD5算法。 本程序定义了必须实现的接口。用户只需要根据程序中 的说明，实现相应的接口即可。 实现ENGINE的时候，可以使用CSP。P11或者算法实现的API等。 本模板支持Linux、Windows 、Mac。兼容:openssl1.0和.0.9.8 如果在使用过程中有任何问题。 在windows上编译，使用vc2005或vc2008 在linux下，请运行 make
C++的OpenSSL支持库(含win32和x64),安装即可使用，无需编译！
12-26
C++的OpenSSL支持库(含win32和x64),安装后目录下有include文件夹和dll以及lib文件 免编译使用！
【C/C++】新手 OpenSSL 环境搭建
最新发布
聚焦实战技术的 “白话解读” 和入门级操作指南。
06-13 504
WSL+Ubuntu+VsCode搭建openssl环境
openssl的使用（c/c++）
weixin_59665492的博客
11-30 8289
目录 环境部署 一、opensslRSA加解密、 使用接口生成秘钥 2、使用openssl对文件进行签名认证 环境部署 关于openssl的移植，在之前wifi功能移植中有过说明，或者网上大把详细步骤 一、opensslRSA加解密、 使用接口生成秘钥 命令行的方式生成证书： https://blog.youkuaiyun.com/gengxiaoming7/article/details/78505107 参考文章：https://blog.youkuaiyun.com/qq_30667875/arti..
C/C++编程：openssl使用（win10+vs2019）
热门推荐
OceanStar的博客
01-19 2万+
当前环境 系统：win10 开发工具： vs2019 openssl版本：Win64 OpenSSL v1.1.1i 安装OpenSSL有两种方法，第一种为下载OpenSSL源代码并由自己编译后使用；第二种为下载已编译好的安装包，安装后直接可以使用。因第一种方法十分繁琐，需要安装Ruby进行编译，同时编译过程中可能产生各种各种的问题，因此在此采用第二种方法 开始 1、从http://slproweb.com/products/Win32OpenSSL.html下载已经编译好的包含 lib 和 inc
Windows下的OpenSSL的编译
持之以恒2016
08-16 2226
安装ActivePerl 切换至安装目录，默认为 C:\Perl64\bin 测试是否安装成功 perl example.pl 初始化VC运行 切换至VC目录，默认为 C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin 初始化环境 vcvars32.bat 编译OpenSSL 切换至OpenSSL目录...
win10上编译好的openssl
05-22
在Windows 10上编译OpenSSL，你需要Visual Studio或者MinGW等C/C++编译环境。通常，编译步骤包括设置环境变量、配置、编译和安装。但在本案例中，我们已经有一个预编译好的版本，这简化了开发者的流程。预编译的库...
编译好的 windows c++ openssl v3.0 x86和x64编译库，可以直接使用
07-03
本资源提供的是预编译好的Windows平台上的C++ OpenSSL v3.0库，包括了x86（32位）和x64（64位）两个版本，适用于Visual Studio 2022开发环境。 首先，我们来了解一下OpenSSL的核心功能。OpenSSL包含了两个主要部分...
编译OpenSSL3.3.2静态库（win10+msvc2019-x64)
10-15
在介绍编译OpenSSL3.3.2静态库的详细知识点之前，需要明确，OpenSSL是一个强大的开源加密库，广泛用于各种平台上提供安全通信，包括SSL和TLS协议。从给出的信息来看，本文的重点在于Windows系统下，使用Microsoft ...
win10 VS2017 编译成功的openssl 32位和64位 动、静态链接库
08-02
总结起来，这个压缩包包含的文件代表了在Windows 10环境下，使用Visual Studio 2017编译OpenSSL的结果，提供了32位和64位的动态及静态链接库。这些库文件可以供开发者在他们的应用程序中使用OpenSSL的功能，如加密、...
【小沐学C++】C++ OpenSSL库编译及使用（VS2017，Python）
爱看书的小沐
07-22 9928
OpenSSL是用于传输层安全(TLS)协议（以前称为安全套接字层(SSL)协议）的强大、商业级、功能齐全的开源工具包。协议实现基于全强度通用密码库，也可以单独使用。OpenSSL源自EricA.Young和TimJ.Hudson开发的SSLeay库。OpenSSL项目的官方主页是www.openssl.org。OpenSSL（密码学和SSL/TLS工具包）项目开发和维护OpenSSL软件——一个强大的、商业级的、功能齐全的工具包，用于通用加密和安全通信。..........................
windows下完全编译的openSSL，源码和lib
06-03
windows下完全的openSSL，其中包含openssl的源码和lib文件
windows下编译好的openssl
04-26
windows下编译好的openssl，是32位的，可以在程序中直接使用
Windows安装配置C/C++（VS2017）OpenSSL开发环境配置教程
08-29
主要为大家详细介绍了Windows安装配置C/C++，OpenSSL开发环境配置教程，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
openssl 编译好的版本
05-31
vs2015 编译，win32平台，编译的版本为openssl-OpenSSL_1_1_0f
windows下调用openssl需要的include和lib
10-08
这个是windows调用openssl需要的include包和lib包，东西都在压缩文件里面，需要什么自己将里面的复制进vc的include和lib中即可使用openssl，本人亲测好用
记录一个openssl在windows下面测试
LiuMang专栏
08-23 311
工具：http://code.google.com/p/openssl-for-windows/   genrsa -out ca/ca2-key.pem 1024 req -new -out ca/ca-req.csr -key ca/ca2-key.pem  x509 -req -in ca/ca-req.csr -out ca/ca2-cert.pem -signkey ca/ca...
Windows C++下使用c++-httplib库与Openssl库搭建https服务器与客户端通讯的保姆教程
qq_41876419的博客
09-05 4540
实现一个c++的https客户端请求https服务器是实现数据通信。基于已封装好的c++ -httplib库搭建SSL/TLS环境实现。
linux系统openssl的C++开发环境搭建
N阶二进制的博客
10-22 2668
在Linux上进行OpenSSL的C++开发，你需要安装OpenSSL库并且在编译时链接该库。
64位Win7环境下编译sqlcipher与openssl整合版dll教程
它说明了该DLL是基于特定版本的SQLCipher和OpenSSL编译的，分别是3.4.2和0.9.8l。SQLCipher依赖于OpenSSL库进行加密操作，这里提到的OpenSSL版本对于理解库可能的加密能力以及潜在的安全性方面是重要的。描述中还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值