windows、vs2017编译64位openssl-1.1.1v及使用

已于 2023-10-16 17:29:49 修改
阅读量772 收藏 2
点赞数
文章标签： windows
于 2023-10-10 09:05:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hx0318/article/details/133736325
版权

一、环境准备

ActivePerl    -    ActivePerl-5.26.3.2603-MSWin32-x64-a95bce075.exe

nasm    -    nasm-2.14.02-installer-x64.exe

以上两个下载地址：【免费】windows、vs2017编译64位openssl-1.1.1v所需要用到的ActivePerl和nasm资源-CSDN文库

以上两个工具都全部默认安装即可；

如上，需确保两个工具的路径存在于环境变量中，如没有，请手动添加；

如上，管理员身份使用vs2017的命令行工具分别执行perl -v和nasm -v，得到版本信息则两个工具的环境已经正常；

二、编译

依然以管理员身份使用vs2017的命令行工具进入到openssl的源码目录：

配置编译：

编译动态库：

perl configure VC-WIN64A --prefix=D:\lib\OpenSSL\x64

编译静态库：

perl configure no-shared VC-WIN64A --prefix=D:\lib\OpenSSL\x64

此阶段可能会出现如下报错：Can't open perl script "configure": No such file or directory

这时候检查下你的目录是否正确，一般会是cd进入的目录有误导致

编译：nmake

安装到目录：nmake install

三、使用

测试源码如下：

#include <string>

/** 基于openssl对字符串进行base64编码：c_original-原始字符串，i_len-原始字符串长度 */
std::string string_encode_openssl_base64(const char *c_original, int i_len);
/** 基于openssl对字符串进行base64解码：ss_base64-base64字符串，c_original-原始字符串，s_len-原始字符串长度 */
void string_decode_openssl_base64(const std::string &ss_base64, char *c_original, size_t &s_len);
/** 基于openssl的des加密算法以cfb64模式对字符串进行加密（加密前后长度一致，不存在补'\0'情况）：c_original-原始字符串，i_len-原始字符串长度，c_encrypt-加密字符串，ss_key_1-密匙1，ss_key_2-密匙2，ss_key_3-密匙3 */
void string_encrypt_openssl_des_cfb64(char *c_original, int i_len, char *c_encrypt, const std::string &ss_key_1 = "", const std::string &ss_key_2 = "", const std::string &ss_key_3 = "");
/** 基于openssl的des解密算法以cfb64模式对字符串进行解密（解密前后长度一致，不存在补'\0'情况）：c_encrypt-加密字符串，i_len-加密字符串长度，c_encrypt-原始字符串，ss_key_1-密匙1，ss_key_2-密匙2，ss_key_3-密匙3 */
void string_decrypt_openssl_des_cfb64(char *c_encrypt, int i_len, char *c_original, const std::string &ss_key_1 = "", const std::string &ss_key_2 = "", const std::string &ss_key_3 = "");
/** 基于openssl的des加密算法以cbc模式对字符串进行加密：ss_original-原始字符串（必须使用确定不会出现'\0'的字符串，否则在解密阶段处理结尾恰好为'\0'的字符串会丢失内容），ss_key-密匙 */
std::string string_encrypt_openssl_des_cbc(const std::string &ss_original, const std::string &ss_key = "");
/** 基于openssl的des解密算法以cbc模式对字符串进行解密：ss_encrypt-加密字符串，ss_key-密匙 */
std::string string_decrypt_openssl_des_cbc(const std::string &ss_encrypt, const std::string &ss_key = "");
/** 基于openssl的des加密算法以ecb模式对字符串进行加密：ss_original-原始字符串（必须使用确定不会出现'\0'的字符串，否则在解密阶段处理结尾恰好为'\0'的字符串会丢失内容），ss_key-密匙 */
std::string string_encrypt_openssl_des_ecb(const std::string &ss_original, const std::string &ss_key = "");
/** 基于openssl的des解密算法以ecb模式对字符串进行解密：ss_encrypt-加密字符串，ss_key-密匙 */
std::string string_decrypt_openssl_des_ecb(const std::string &ss_encrypt, const std::string &ss_key = "");

#include "OpensslCommon.h"
#include "openssl/bio.h"
#include "openssl/evp.h"
#include "openssl/buffer.h"
#include "openssl/des.h"
#include <vector>

#pragma warning(disable:4996)

std::string string_encode_openssl_base64(const char *c_original, int i_len)
{
    std::string ss_base64 = "";
    if (c_original != nullptr && i_len > 0)
    {
        BIO *base64_bio = BIO_new(BIO_f_base64());//base64过滤器：编解码操作的bio接口
        if (base64_bio != nullptr)
        {
            BIO_set_flags(base64_bio, BIO_FLAGS_BASE64_NO_NL);//去掉所有换行符
            BIO *mem_bio = BIO_new(BIO_s_mem());//内存读写操作的bio接口
            if (mem_bio != nullptr)
            {
                BIO_push(base64_bio, mem_bio);
                if (BIO_write(base64_bio, c_original, i_len) > 0)
                {
                    BIO_flush(base64_bio);
                    BUF_MEM *p_data = nullptr;
                    BIO_get_mem_ptr(base64_bio, &p_data);
                    if (p_data != nullptr)
                    {
                        ss_base64 = std::string(p_data->data, p_data->length);
                    }
                }
            }
            BIO_free_all(base64_bio);
        }
    }
    return ss_base64;
}

void string_decode_openssl_base64(const std::string &ss_base64, char *c_original, size_t &s_len)
{
    s_len = 0;
    if (c_original == nullptr)
    {
        return;
    }

    BIO *base64_bio = BIO_new(BIO_f_base64());
    if (base64_bio == nullptr)
    {
        return;
    }

    BIO_set_flags(base64_bio, BIO_FLAGS_BASE64_NO_NL);
    BIO *mem_bio = BIO_new_mem_buf(ss_base64.c_str(), ss_base64.length());
    if (mem_bio == nullptr)
    {
        BIO_free_all(base64_bio);
        return;
    }

    BIO_push(base64_bio, mem_bio);
    BIO_read_ex(base64_bio, c_original, ss_base64.length() + 1, &s_len);
    if (s_len <= 0)
    {
        BIO_free_all(base64_bio);
        return;
    }

    BIO_free_all(base64_bio);
}

void string_encrypt_openssl_des_cfb64(char *c_original, int i_len, char *c_encrypt, const std::string &ss_key_1, const std::string &ss_key_2, const std::string &ss_key_3)
{
    if (c_original == nullptr || i_len <= 0 || c_encrypt == nullptr)
    {
        return;
    }

    DES_cblock key;
    memset(key, 0, sizeof(DES_cblock));
    memcpy(key, ss_key_1.c_str(), ss_key_1.length() <= 8 ? ss_key_1.length() : 8);
    DES_key_schedule key_schedule_1 = {};
    DES_set_key_unchecked(&key, &key_schedule_1);
    memset(key, 0, sizeof(DES_cblock));
    memcpy(key, ss_key_2.c_str(), ss_key_2.length() <= 8 ? ss_key_2.length() : 8);
    DES_key_schedule key_schedule_2 = {};
    DES_set_key_unchecked(&key, &key_schedule_2);
    memset(key, 0, sizeof(DES_cblock));
    memcpy(key, ss_key_3.c_str(), ss_key_3.length() <= 8 ? ss_key_3.length() : 8);
    DES_key_schedule key_schedule_3 = {};
    DES_set_key_unchecked(&key, &key_schedule_3);
    DES_cblock ivec = {};
    int num = 0;
    DES_ede3_cfb64_encrypt((const unsigned char *)c_original, (unsigned char *)c_encrypt, i_len, &key_schedule_1, &key_schedule_2, &key_schedule_3, &ivec, &num, DES_ENCRYPT);
}

void string_decrypt_openssl_des_cfb64(char *c_encrypt, int i_len, char *c_original, const std::string &ss_key_1, const std::string &ss_key_2, const std::string &ss_key_3)
{
    if (c_encrypt == nullptr || i_len <= 0 || c_original == nullptr)
    {
        return;
    }

    DES_cblock key;
    memset(key, 0, sizeof(DES_cblock));
    memcpy(key, ss_key_1.c_str(), ss_key_1.length() <= 8 ? ss_key_1.length() : 8);
    DES_key_schedule key_schedule_1 = {};
    DES_set_key_unchecked(&key, &key_schedule_1);
    memset(key, 0, sizeof(DES_cblock));
    memcpy(key, ss_key_2.c_str(), ss_key_2.length() <= 8 ? ss_key_2.length() : 8);
    DES_key_schedule key_schedule_2 = {};
    DES_set_key_unchecked(&key, &key_schedule_2);
    memset(key, 0, sizeof(DES_cblock));
    memcpy(key, ss_key_3.c_str(), ss_key_3.length() <= 8 ? ss_key_3.length() : 8);
    DES_key_schedule key_schedule_3 = {};
    DES_set_key_unchecked(&key, &key_schedule_3);
    DES_cblock ivec = {};
    int num = 0;
    DES_ede3_cfb64_encrypt((const unsigned char *)c_encrypt, (unsigned char *)c_original, i_len, &key_schedule_1, &key_schedule_2, &key_schedule_3, &ivec, &num, DES_DECRYPT);
}

std::string string_encrypt_openssl_des_cbc(const std::string &ss_original, const std::string &ss_key)
{
    size_t s_len = (ss_original.length() + 7) / 8 * 8;
    unsigned char *output = nullptr;
    try
    {
        output = new unsigned char[s_len + 1];
    }
    catch (const std::exception &e)
    {
        return "";
    }

    DES_cblock key = {};
    memcpy(key, ss_key.c_str(), ss_key.length() <= 8 ? ss_key.length() : 8);
    DES_key_schedule key_schedule = {};
    DES_set_key_unchecked(&key, &key_schedule);
    DES_cblock ivec = {};
    DES_ncbc_encrypt((const unsigned char *)ss_original.c_str(), output, ss_original.length(), &key_schedule, &ivec, DES_ENCRYPT);
    std::string ss_encrypt = std::string((char *)output, s_len);
    delete output;
    output = nullptr;
    return ss_encrypt;
}

std::string string_decrypt_openssl_des_cbc(const std::string &ss_encrypt, const std::string &ss_key)
{
    size_t s_len = ss_encrypt.length();
    unsigned char *output = nullptr;
    try
    {
        output = new unsigned char[s_len + 1];
    }
    catch (const std::exception &e)
    {
        return "";
    }

    DES_cblock key = {};
    memcpy(key, ss_key.c_str(), ss_key.length() <= 8 ? ss_key.length() : 8);
    DES_key_schedule key_schedule = {};
    DES_set_key_unchecked(&key, &key_schedule);
    DES_cblock ivec = {};
    DES_ncbc_encrypt((const unsigned char *)ss_encrypt.c_str(), output, s_len, &key_schedule, &ivec, DES_DECRYPT);
    for (size_t i = s_len - 1; i >= 0; i--)
    {
        if(*(output+i) != '\0')
        {
            break;
        }

        s_len--;
    }
    std::string ss_decrypt = std::string((char *)output, s_len);
    delete output;
    output = nullptr;
    return ss_decrypt;
}

std::string string_encrypt_openssl_des_ecb(const std::string &ss_original, const std::string &ss_key)
{
    DES_cblock key = {};//密钥
    memcpy(key, ss_key.c_str(), ss_key.length() <= 8 ? ss_key.length() : 8);
    DES_key_schedule key_schedule = {};//存放密钥的结构体
    DES_set_key_unchecked(&key, &key_schedule);
    const_DES_cblock input = {};//需要加密的数据
    DES_cblock output = {};//加密后的数据
    unsigned char tmp[8] = {};
    std::vector<unsigned char> svuc_encrypt = {};
    for (int i = 0; i < ss_original.length() / 8; i++)//8字节循环加密
    {
        memcpy(input, ss_original.c_str() + i * 8, 8);
        DES_ecb_encrypt(&input, &output, &key_schedule, DES_ENCRYPT);
        memcpy(tmp, output, 8);
        for (int j = 0; j < 8; j++)
        {
            svuc_encrypt.push_back(tmp[j]);
        }
    }
    if (ss_original.length() % 8 != 0)//超过8的倍数的部分的字节依然8字节循环加密
    {
        int tmp1 = ss_original.length() / 8 * 8;
        int tmp2 = ss_original.length() - tmp1;
        memset(input, 0, 8);//全部置为'\0'，这样因长度不足而被补充的字节在解密的阶段解析出来也是'\0'，解密阶段去掉结尾的'\0'即可
        memcpy(input, ss_original.c_str() + tmp1, tmp2);
        DES_ecb_encrypt(&input, &output, &key_schedule, DES_ENCRYPT);
        memcpy(tmp, output, 8);
        for (int j = 0; j < 8; j++)
        {
            svuc_encrypt.push_back(tmp[j]);
        }
    }
    std::string ss_encrypt = "";
    ss_encrypt.assign(svuc_encrypt.begin(), svuc_encrypt.end());
    return ss_encrypt;
}

std::string string_decrypt_openssl_des_ecb(const std::string &ss_encrypt, const std::string &ss_key)
{
    DES_cblock key = {};
    memcpy(key, ss_key.c_str(), ss_key.length() <= 8 ? ss_key.length() : 8);
    DES_key_schedule key_schedule = {};
    DES_set_key_unchecked(&key, &key_schedule);
    const_DES_cblock input = {};
    DES_cblock output = {};
    unsigned char tmp[8] = {};
    std::vector<unsigned char> svuc_decrypt = {};
    for (int i = 0; i < ss_encrypt.length() / 8; i++)
    {
        memcpy(input, ss_encrypt.c_str() + i * 8, 8);
        DES_ecb_encrypt(&input, &output, &key_schedule, DES_DECRYPT);
        memcpy(tmp, output, 8);
        for (int j = 0; j < 8; j++)
        {
            if (i == (ss_encrypt.length() / 8 - 1))//结尾的数据
            {
                if (tmp[j] != '\0')//不要多余的'\0'
                {
                    svuc_decrypt.push_back(tmp[j]);
                }
            }
            else
            {
                svuc_decrypt.push_back(tmp[j]);
            }
        }
    }
    std::string ss_decrypt = "";
    ss_decrypt.assign(svuc_decrypt.begin(), svuc_decrypt.end());
    return ss_decrypt;
}

#include "OpensslCommon.h"

//#define openssl_base64
#define openssl_cfb64

int main(int argc, char **argv)
{
#ifdef openssl_base64
    char c_original[20] = {};
    memcpy(c_original, "this is an", 10);
    c_original[10] = '\0';
    memcpy(c_original + 11, " example", 8);
    printf("*****\n");
    for (size_t i = 0; i < 19; i++)
    {
        if (*(c_original + i) == '\0')
        {
            printf("-");
        }
        else
        {
            printf("%c", *(c_original + i));
        }
    }
    printf("\n");

    std::string ss_base64 = string_encode_openssl_base64(c_original, 19);
    printf("*****\n");
    printf("%s    -    %llu\n", ss_base64.c_str(), ss_base64.length());

    memset(c_original, 0, sizeof(c_original));
    size_t s_len = 0;
    string_decode_openssl_base64(ss_base64, c_original, s_len);
    if (s_len > 0)
    {
        printf("*****\n");
        for (size_t i = 0; i < s_len; i++)
        {
            if (*(c_original + i) == '\0')
            {
                printf("-");
            }
            else
            {
                printf("%c", *(c_original + i));
            }
        }
        printf("\n");
    }
#endif
#ifdef openssl_cfb64
    char c_original[20] = {};
    memcpy(c_original, "this is an", 10);
    c_original[10] = '\0';
    memcpy(c_original + 11, " example", 8);
    printf("*****\n");
    for (size_t i = 0; i < 19; i++)
    {
        if (*(c_original + i) == '\0')
        {
            printf("-");
        }
        else
        {
            printf("%c", *(c_original + i));
        }
    }
    printf("\n");

    char c_encrypt[20] = {};
    std::string ss_key_1 = "11111111";
    std::string ss_key_2 = "22222222";
    std::string ss_key_3 = "33333333";
    string_encrypt_openssl_des_cfb64(c_original, 19, c_encrypt, ss_key_1, ss_key_2, ss_key_3);
    printf("*****\n");
    printf("%s\n", c_encrypt);

    memset(c_original, 0, sizeof(c_original));
    string_decrypt_openssl_des_cfb64(c_encrypt, 19, c_original, ss_key_1, ss_key_2, ss_key_3);
    printf("*****\n");
    for (size_t i = 0; i < 19; i++)
    {
        if (*(c_original + i) == '\0')
        {
            printf("-");
        }
        else
        {
            printf("%c", *(c_original + i));
        }
    }
    printf("\n");
#endif

    system("pause");
    return 0;
}

使用静态库的时候，会可能遇到如下报错（使用动态库不会有该报错）：

LNK2019    无法解析的外部符号 __imp_CertOpenStore，该符号在函数 capi_open_store 中被引用
该报错原因：

OpenSSL库使用了windows的一个密码学库： Crypt32

该报错解决办法：

在 项目属性 - 链接器 - 输入 - 附加依赖项 中加入： Crypt32.lib

错误：

LNK2019: 无法解析的外部符号 __imp_DeregisterEventSource，该符号在函数 OPENSSL_showfatal 中被引用

解决：

advapi32.lib

错误：

LNK2019: 无法解析的外部符号 __imp_GetProcessWindowStation，该符号在函数 OPENSSL_isservice 中被引用

解决：

user32.lib

黄忻
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
openssl代码
12-20
用于开发安全套接字的开源软件包，非常好用。有帮助文档
OpenSSL源代码
06-27
openssl-1.0.0s.tar.gz
WIN10编译openssl1.1.1
最新发布
陨星落云的博客
04-28 208
官网下载并安装 Strawberry Perl 这里选择的是目前最新版本 Strawberry Perl 5.32.1.1 安装过程中务必选择完整安装 安装完成之后会自动添加环境变量，无需手动添加。使用 install_sw 代替 install 是因为默认 install 会生成 40M 左右的 HTML 文档，若不需要就使用 install_sw 仅安装二进制文件和库。将编译后的安装目录下的 bin 文件夹添加到系统 Path 目录下 打开cmd测试安装。配置 makefile。版本 对应架构命令行。
Windows安装配置C/C++（VS2017）OpenSSL开发环境配置教程
08-29
主要为大家详细介绍了Windows安装配置C/C++，OpenSSL开发环境配置教程，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
openssl在Windows系统下的编译
qq_34488939的博客
06-22 5022
Openssl在Windows系统下的编译
Windows环境下C++ 安装OpenSSL库 源码编译及使用（VS2019）
肥宝的实验室
04-26 5337
第一步下载的openssl解压一下，放到E盘，这里我第一次操作的时候，是进入E盘，就输入命令行的。所以搞了第二次的时候，我直接创建了一个叫xxx的文件夹，把解压的内容放到xxx里面。由于我要生成的是32版本的openssl，所以下载了32版本，不过我觉得应该不影响的。令我费解的是既然这个是不是也不影响生成的版本的呢，因为下面的命令行是要填生成的是64还是32的。1.首先确认一下自己的代码是Win32的还是Win64的，我操作系统是64的，忘记程序不知道什么时候改为32的了，后来又重新搞了一遍。
windows下vs2017 编译openssl
thehunters的专栏
11-19 1312
1,准备好openssl 2，安装perl 3,打开vs2017 开发人员命令行提示符，执行 perl Configure no-shared no-asm VC-WIN32 --debug --prefix=C:\OpenSSL --openssldir=C:\OpenSSL 参数说明如下表： 编译平台及其对应指令集 编译类型 编译执指令 编译32位动态库debug版本 perl Configure debug-VC-WIN32 no-asm --prefi..
在 64 位 Win10 上使用 VS 2019 编译 OpenSSL-1.1.1d
henter的专栏
11-22 7546
到 OpenSSL 官网 https://www.openssl.org/ 下载 openssl-1.1.1d.tar.gz ，本文中将该压缩文件中 openssl-1.1.1d 子目录中所有的文件解压到 d:\OpenSSL\openssl-1.1.1d 路径下。 编译 OpenSSL 源代码需要用到 C 语言编译器、Perl 语言解释器、汇编编译器，前两项是必选...
Windows vc编译openssl-1.1.1
qq_16754667的博客
06-14 513
Windows vc编译openssl-1.1.1
windows、vs2017编译64位openssl-1.1.1v所需要用到的ActivePerl和nasm
10-10
windows、vs2017编译64位openssl-1.1.1v所需要用到的ActivePerl和nasm
openssl-1.1.1g编译、交叉编译方式.rar
08-03
linux下编译/交叉编译openssl-1.1.1g生成动态库和静态库方法： 一、编译linux版本 1. cp openssl-1.1.1g.tar.gz /opt/ 2. tar -zxvf openssl-1.1.1g.tar.gz 3. mkdir build 4. ./config --prefix=/opt/openssl-1.1.1...
Windows x64 的 Openssl 1.1.1 安装包msi
06-23
Windows x64 的 Openssl 1.1.1 安装包msi OpenSSL 是一个安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及SSL协议，并提供丰富的应用程序供测试或其它目的使用。 OpenSSL被曝出现严重安全漏洞后，发现多数通过SSL协议加密的网站使用名为OpenSSL的开源软件包。OpenSSL漏洞不仅影响以https开头的网站，黑客还可利用此漏洞直接对个人电脑发起"心脏出血"(Heartbleed)攻击。据分析，Windows上有大量软件使用了存在漏洞的OpenSSL代码库，可能被黑客攻击抓取用户电脑上的内存数据。
OpenSSL_1.1.1
02-12
OpenSSL win32 1.1.1版本 包含dll include lib和html帮助文件
Win64OpenSSL-1_1_0h.rar
06-17
用于Windows环境下生成公钥、私钥、证书的必备软件Openssl。 安装便捷，解压之后选择对应位数的Windows环境的exe文件，按照提示安装后以管理员身份运行cmd，输入Openssl查看是否安装成功。
openssl-1.1.1t版本安装包
11-01
**OpenSSL 1.1.1t 安装与安全指南** OpenSSL 是一个强大的安全套接层（SSL）和传输层安全（TLS）协议实现库，广泛用于各种网络服务，如Web服务器、邮件服务器以及应用程序，以确保数据传输的安全性。在网络安全中，...
VS2019刚刚编译的openssl-1.1.1静态编译 static 32位 x86-release
12-06
使用VS2019编译OpenSSL，可以充分利用其强大的调试和优化工具，同时保证代码与Windows API的良好兼容性。 在32位（x86）平台上编译，意味着这个OpenSSL库适用于32位操作系统。虽然64位系统可以运行32位程序，但有些...
openssl-1.1.1w-1.el6.x86-64-centos6.tgz
01-10
**openssl-1.1.1w-1.el6.x86-64-centos6.tgz** 是一个针对CentOS 6和Red Hat Enterprise Linux 6（RHEL 6）x86架构操作系统的软件包，它包含了OpenSSL库的更新版本——1.1.1w。OpenSSL是一款强大的安全套接层（SSL）...
win10 64位系统下openssl编译
蛐蛐的博客
01-03 731
1.下载 https://www.openssl.org/source/old/ 2.编译 进入根目录，找到INSTALL.W64，发现： To build for Win64/x64: > perl Configure VC-WIN64A > ms\do_win64a > nmake -f ms\ntdll.mak > cd out32dll > ..\ms\test To build for Win64/IA64: ......
window下编译openssl
MashiMaroJ的专栏
08-27 706
window下编译openssl
openssl-1.1.1t windows编译
08-08
要在Windows上编译openssl-1.1.1t，你需要遵循以下步骤： 1. 首先，你需要下载并安装Cygwin（https://www.cygwin.com/）或MinGW（http://www.mingw.org/）。这些是在Windows上编译类Unix程序所需的工具。 2. 安装完成后，打开Cygwin或MinGW的终端窗口，并进入你要安装OpenSSL的目录。 3. 从openssl官方网站（https://www.openssl.org/source/）下载 openssl-1.1.1t 源码包，并将其解压到你的目录中。 4. 进入解压后的OpenSSL源码目录。 5. 运行以下命令来生成配置文件： ``` perl Configure VC-WIN32 no-asm --prefix=/usr/local/ssl ``` 这将配置OpenSSL以在Windows上进行编译。 6. 运行以下命令来编译并安装OpenSSL： ``` make make install ``` 这将花费一些时间编译和安装默认的OpenSSL库和可执行文件。 7. 编译完成后，你将可以在指定的 `--prefix` 目录中找到编译好的OpenSSL文件。 请注意，编译OpenSSL可能需要一些额外的依赖项，在配置和编译过程中可能会遇到一些错误。确保你已经正确安装和设置了Cygwin或MinGW，并按照OpenSSL的文档进行操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值