openssl engine引擎 实现RSA引擎 （4）

已于 2023-08-30 11:35:23 修改
阅读量213 收藏 3
点赞数
分类专栏： openssl engine使用 文章标签： 算法 linux ubuntu 网络 密码学
于 2023-08-16 13:39:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu942947766/article/details/132317594
版权
openssl engine引擎 实现RSA引擎 （4）

通过对openssl rsa_st结构体进行重新赋值并导入到引擎中，在使用openssl与rsa相关的算法中都会调用引擎中的rsa算法

rsa算法中主要包括

  1. public_encrypto //公钥加密
  2. public_decrypto //公钥解密
  3. private_encrypto //私钥加密
  4. private_decrypto //私钥解密
  5. sign //签名
  6. verify //验签
  7. gen_key //生成密钥
rangine.h
#ifndef __RANG_ENG_H__
#define __RANG_ENG_H__
#include <openssl/engine.h>
#include <stdio.h>
#include <openssl/rsa.h>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/rand.h>
#include <openssl/ecdh.h>
#include <openssl/crypto.h>
#include <string.h>

#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#include <openssl/ssl.h>

const char *eng_id="randeng";
const char *eng_name="rand engines for OpenSSL";

/*需要声明一下结构体*/

typedef volatile int CRYPTO_REF_COUNT;
struct rsa_st {
    /*
     * The first parameter is used to pickup errors where this is passed
     * instead of an EVP_PKEY, it is set to 0
     */
    int pad;
    int32_t version;
    const RSA_METHOD *meth;
    /* functional reference if 'meth' is ENGINE-provided */
    ENGINE *engine;
    BIGNUM *n;
    BIGNUM *e;
    BIGNUM *d;
    BIGNUM *p;
    BIGNUM *q;
    BIGNUM *dmp1;
    BIGNUM *dmq1;
    BIGNUM *iqmp;
    /* for multi-prime RSA, defined in RFC 8017 */
    STACK_OF(RSA_PRIME_INFO) *prime_infos;
    /* If a PSS only key this contains the parameter restrictions */
    RSA_PSS_PARAMS *pss;
    /* be careful using this if the RSA structure is shared */
    CRYPTO_EX_DATA ex_data;
    CRYPTO_REF_COUNT references;
    int flags;
    /* Used to cache montgomery values */
    BN_MONT_CTX *_method_mod_n;
    BN_MONT_CTX *_method_mod_p;
    BN_MONT_CTX *_method_mod_q;
    /*
     * all BIGNUM values are actually in the following data, if it is not
     * NULL
     */
    char *bignum_data;
    BN_BLINDING *blinding;
    BN_BLINDING *mt_blinding;
    CRYPTO_RWLOCK *lock;
};


struct rsa_meth_st {
    char *name;
    int (*rsa_pub_enc) (int flen, const unsigned char *from,
                        unsigned char *to, RSA *rsa, int padding);
    int (*rsa_pub_dec) (int flen, const unsigned char *from,
                        unsigned char *to, RSA *rsa, int padding);
    int (*rsa_priv_enc) (int flen, const unsigned char *from,
                         unsigned char *to, RSA *rsa, int padding);
    int (*rsa_priv_dec) (int flen, const unsigned char *from,
                         unsigned char *to, RSA *rsa, int padding);
    /* Can be null */
    int (*rsa_mod_exp) (BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx);
    /* Can be null */
    int (*bn_mod_exp) (BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                       const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
    /* called at new */
    int (*init) (RSA *rsa);
    /* called at free */
    int (*finish) (RSA *rsa);
    /* RSA_METHOD_FLAG_* things */
    int flags;
    /* may be needed! */
    char *app_data;
    /*
     * New sign and verify functions: some libraries don't allow arbitrary
     * data to be signed/verified: this allows them to be used. Note: for
     * this to work the RSA_public_decrypt() and RSA_private_encrypt() should
     * *NOT* be used RSA_sign(), RSA_verify() should be used instead.
     */
    int (*rsa_sign) (int type,
                     const unsigned char *m, unsigned int m_length,
                     unsigned char *sigret, unsigned int *siglen,
                     const RSA *rsa);
    int (*rsa_verify) (int dtype, const unsigned char *m,
                       unsigned int m_length, const unsigned char *sigbuf,
                       unsigned int siglen, const RSA *rsa);
    /*
     * If this callback is NULL, the builtin software RSA key-gen will be
     * used. This is for behavioural compatibility whilst the code gets
     * rewired, but one day it would be nice to assume there are no such
     * things as "builtin software" implementations.
     */
    int (*rsa_keygen) (RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
    int (*rsa_multi_prime_keygen) (RSA *rsa, int bits, int primes,
                                   BIGNUM *e, BN_GENCB *cb);
};


#endif // DEBUG
rangine.c
#include "rangeng.h"

static int myrand_init(ENGINE *e)
{
    printf("myrand_init\n");
    return 1;
}
static int myrand_finish(ENGINE *e)
{
    printf("myrand_finish\n");
    return 1;
}
static int myrand_destroy(ENGINE *e)
{
    printf("myrand_destroy\n");
    return 1;
}
//自己写的一个加密算法 askii+10
static int my_rsa_pub_enc(int flen, const unsigned char *from,
                        unsigned char *to, RSA *rsa, int padding)
{
    printf("my_rsa_pub_enc\n");
    for (int i = 0; i < flen; i++)
    {
        to[i]=from[i]+10;
    }
    return flen;
}

static int my_rsa_pub_dec(int flen, const unsigned char *from,
                        unsigned char *to, RSA *rsa, int padding)
{
    printf("my_rsa_pub_dec\n");
    for (int i = 0; i < flen; i++)
    {
        to[i]=from[i]-10;
    }
    return flen;
}

static int my_rsa_priv_enc(int flen, const unsigned char *from,
                        unsigned char *to, RSA *rsa, int padding)
{
    printf("my_rsa_priv_enc\n");
    return 1;
}

static int my_rsa_priv_dec(int flen, const unsigned char *from,
                        unsigned char *to, RSA *rsa, int padding)
{
    printf("my_rsa_priv_dec\n");
    return 1;
}

static int my_rsa_sign (int type,const unsigned char *m, unsigned int m_length,
unsigned char *sigret, unsigned int *siglen,const RSA *rsa)
{
    printf("my_rsa_sign\n");
    return 1;
}

static int my_rsa_verify (int type,const unsigned char *m, unsigned int m_length,
unsigned char *sigret, unsigned int *siglen,const RSA *rsa)
{
    printf("my_rsa_verify\n");
    return 1;
}

static int my_rsa_init(RSA *rsa)
{
    printf("my_rsa_init\n");
    return 1;
}

static int my_rsa_finish(RSA *rsa)
{
    printf("my_rsa_finish\n");
    return 1;
}

//对照引擎rsa_st结构体一一对应，必须保持参数一致
const RSA_METHOD rsa_method = {
    "rsa_engine_test",
    my_rsa_pub_enc,
    my_rsa_pub_dec,
    NULL,
    NULL,
    NULL,
    NULL,
    my_rsa_init,
    my_rsa_finish,
    ENGINE_METHOD_RSA,
    NULL,
    my_rsa_sign,
    my_rsa_verify,
    NULL,
    NULL
};

/*绑定函数*/
static int bind_pp(ENGINE *e)
{
     if(!ENGINE_set_id(e,eng_id)||
    !ENGINE_set_name(e,eng_name)||   
    !ENGINE_set_destroy_function(e,myrand_destroy)||
    !ENGINE_set_init_function(e,myrand_init)||
    !ENGINE_set_finish_function(e,myrand_finish)||
    !ENGINE_set_RSA(e,&rsa_method))
        return 0;
    printf("ERR_load_rsa success\n");
    return 1;
}


static ENGINE *enging_range(void)
{
    ENGINE*e =ENGINE_new();
    if(!e)
        return NULL;
    if(!bind_pp(e))
    {
        ENGINE_free(e);
		return NULL;
    }
    return e;
}
void ENGINE_load_rand()
{
    ENGINE* e=enging_range();
    if(!e)
        return ;
    ENGINE_add(e);
    ENGINE_free(e);
}
static void display_engine_list()
{
	ENGINE *h;
	int loop;
	
	h = ENGINE_get_first();
	loop = 0;
	printf("start:\n");
	while(h)
	{
		printf("engine %i, id = \"%s\", name = \"%s\"\n",
			loop++, ENGINE_get_id(h), ENGINE_get_name(h));
		h = ENGINE_get_next(h);
	}
	printf("end of list\n");
	ENGINE_free(h);
}

int main()
{
    
    // 初始化 OpenSSL 引擎系统
    ENGINE_load_builtin_engines();
    ENGINE_register_all_complete();
    //加载引擎
    ENGINE_load_rand();
    display_engine_list();	
    ENGINE *e=NULL;
    e=ENGINE_by_id(eng_id);
    if(!e)
    {
        printf("err load engine failed\n");
        return 0;
    }    

    ENGINE_init(e);
    printf("RSA-----BEGIN---END\n");
    ENGINE_register_RSA(e); //
    RSA *rsa = RSA_new();
    BIGNUM *bn = BN_new();
    BN_set_word(bn, RSA_F4);
    RSA_generate_key_ex(rsa, 2048, bn, NULL);
    printf("RSA Key Pair:\n");
    RSA_print_fp(stdout, rsa, 0); //打印密钥

    // 使用引擎进行 RSA 加密
    unsigned char plaintext[] = "Hello, World!";
    unsigned char ciphertext[256]={0}; // 注意，缓冲区大小可能需要根据您的密钥长度进行调整
    unsigned char plaintext1[256]={0};
    int len = RSA_public_encrypt(sizeof(plaintext), plaintext, ciphertext, rsa, RSA_PKCS1_PADDING);
    len=RSA_public_decrypt(len, ciphertext, plaintext1, rsa, RSA_PKCS1_PADDING);


    // 打印加密后的数据
    printf("Encrypted data: ");
    for (int i = 0; i < len; i++) {
        printf("%02x ", ciphertext[i]);
    }
    printf("\n");
    printf("ciphertext=%s\n",ciphertext);

    // 打印加密后的数据
    printf("decrypted data: ");
    for (int i = 0; i < len; i++) {
        printf("%02x ", plaintext1[i]);
    }
    printf("\n");
    printf("ciphertext=%s\n",plaintext1);
    // 清理引擎资源
    ENGINE_finish(e);
    ENGINE_free(e);
}
编译
gcc rangine.c -ldl -lpthread -lcrypto -lssl -o engINE
拒绝黑仔
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
用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
openssl engine概述（1）
liu942947766的博客
08-16 999
OpenSSL 引擎（Engine）是 OpenSSL 库的一个扩展机制，用于实现加密、解密、签名、验证等操作的定制化实现。引擎可以通过共享库（动态链接库）的方式被加载和使用，从而扩展 OpenSSL 的功能。引擎类型：OpenSSL 引擎可以分为静态引擎和动态引擎。静态引擎是编译到 OpenSSL 库中的，而动态引擎是通过共享库加载的。动态引擎允许在运行时加载和替换，从而更灵活地定制 OpenSSL 功能。
OPENSSL交叉编译，引用第三方engine
最新发布
weixin_43624575的博客
06-13 579
对openssl进行交叉编译、移植并保证第三方engine可用。
openssl engine实现和原理
liu942947766的博客
02-01 2174
openssl的引擎和实现，在本文中有详细介绍和实现代码
RSA数据结构关系
newlifenewwork的博客
03-05 7222
RSA为一个非对称加密算法,基本包含的数据类型为struct rsa_st { BIGNUM *n; BIGNUM *e; BIGNUM *d; BIGNUM *p; BIGNUM *q; BIGNUM *dmp1; BIGNUM *dmq1; BIGNUM *iqmp; }; typedef struct rsa_st RSA;下面
openssl动态引擎
ughome的专栏
12-15 1121
openssl动态引擎 dynamic engine
openssl engine引擎 使用流程和函数介绍（5）
liu942947766的博客
08-16 1062
引擎结构：每个引擎都有一个对应的ENGINE结构体，其中定义了引擎的属性、方法、名称等信息。引擎可以实现各种密码算法、加密算法、随机数生成器等功能。引擎的方法：引擎可以提供各种密码学操作的方法，如加密、解密、签名、验证等。通过调用引擎的方法，可以使用定制的算法来执行这些操作。引擎的初始化：在使用引擎之前，需要进行引擎的初始化。这包括加载引擎、注册引擎等步骤。可以使用和函数进行初始化。引擎的加载和使用：动态引擎可以通过函数获取，并通过各种控制函数进行配置和使用。
openssl 1.0.2d实现加解密engine的适配
08-07
在OpenSSL库中，Engine（引擎）是一种机制，它允许用户自定义加密算法的实现，以便在不修改核心OpenSSL库的情况下使用特定硬件或软件加速器。在"openssl 1.0.2d实现加解密engine的适配"这个项目中，重点是将Engine...
openssl-engine-0.9.6l.tar.gz_ENGINE openssl_openssl加密解密
09-24
《OpenSSL Engine与OpenSSL加密解密技术详解》 OpenSSL是一个强大的安全套接层（SSL）和传输层安全（TLS）协议实现库，广泛应用于网络服务器、客户端应用程序以及各种安全相关的软件中。其核心功能包括加密算法的...
fast-rsa-engine:该gem通过更快的实现替换了jruby-openssl的RSA签名密码
05-20
用于jruby-openssl gem的快速RSA引擎 该gem通过必须更快地实现的方式替换了jruby-openssl的RSA签名和RSA密码。 参见 但这仅适用于darwin和linux- x84_64平台，因为squareup使用了该库。 性能的提高使使用RSA的...
openssl_engine_pkcs11_src
11-15
本文将重点探讨OpenSSL Engine中的PKCS#11引擎，并结合提供的源码进行深入解析。 PKCS#11是由RSA Security制定的一套用于智能卡和硬件安全模块的接口标准，它定义了应用程序如何与这些设备交互，执行如公钥加密、...
openssl-engine-0.9.6m
08-29
例如，某些硬件引擎可以加速RSA、DSA或AES等算法的计算，这对于处理大量加密操作的服务器尤其重要。配置 Engine 通常涉及以下几个步骤： 1. **加载 Engine**：首先，你需要加载特定的 Engine 模块，这可以通过 ...
openssl测试时指定engine加载目录
choumin的专栏
06-20 746
在 openssl 测试时指定 engine 加载目录的方法
利用ENGINE替换OPENSSL中的加解密算法
bytxl的专栏
09-23 7025
一：ENGINE的目的： ENGINE是OPENSSL预留的加载第三方加密库，主要包括了动态库加载的代码和加密函数指针管理的一系列接口。如果要使用Engine（假设你已经加载上该Engine了），那么首先要Load该Engine(比如ENGINE_load_XXXX)，然后选择要使用的算法或者使用支持的所有加密算法（有相关函数）。这样你的应用程序在调用加解密算法时，它就会指向你加载的动态库里的加
openssl engine 实现SM4 引擎
viqjeee的博客
10-10 2688
openssl engine 实现SM4 引擎一 openssl engine基本介绍二 SM4引擎实现1 Openssl定义好的主接口2 定义bind函数3 实现ciphers函数4 定义算法结构evp_cipher_st5 实现sm4_init 函数体6 实现sm4_func 函数体7编译和测试本文章相关源码 一 openssl engine基本介绍 Engine机制目的是为了使OpenSSL能够透明地使用第三方提供的软件加密库或者硬件加密设备进行加密。OpenSSL的Engine机制成功地..
OpenSSL engine
maimang1001的专栏
01-01 1128
ENGINE API在OpenSSL 0.9.6版本中作为一种底层接口被引入，用于添加加密原语的替代实现，特别是用于集成硬件加密设备。ENGINE接口存在一些限制，并已被PROVIDER API所取代，在OpenSSL version 3.0中已被弃用。以下文档被保存，以帮助需要维护或支持现有ENGINE实现的用户。应通过提供者(providers)来添加对新硬件设备或新算法的支持，并尽快将现有引擎转换为提供者(providers)。
OpenSSL之RSA用法
史D芬周
10-21 5678
RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥，“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，而解密密钥（即秘密密钥）SK是需要保密的。加密算法E和解密算法D也都是公开的。虽然解密密钥SK是由公开密钥PK决定的，但却不能根据PK计算出SK。正是基于这种理论，1978年出现了著名的RSA算法，它通常是先生成一对RSA密钥，其中之一是保密密钥，由用户保存；另一个为公开密钥，可对外公开，甚至可在网络服务器中注册。
【OpenSSL 之一】OpenSSL初体验（编译安装、工作机制、Engine加载（afalg、cryptodev-linux）、offload等）
KXue0703的博客
03-14 5522
OpenSSL是一个安全套接字层密码库，囊括主要的密码算法、常用密钥、证书封装管理功能及实现SSL协议。整个软件包大概可以分成三个主要的功能部分：SSL协议库libssl、应用程序命令工具以及密码算法库libcrypto。
错误：OpenSSL 1.1.0 中“无效使用不完整类型 ‘RSA {aka struct rsa_st}”
萧海的博客
02-26 2836
问题： 我有旧代码是为了链接旧版本的 openssl 而编写的。此代码的一部分从 PEM 文件加载密钥，并尝试使用以下代码了解此密钥是私钥还是公钥： if( (prv->p==0 || prv->q==0) ) { // This is not a private key! throw error("No private key for decryption"); } 使用最新版本的 openssl，这（有理由）无法编译： crypto.cpp: In function ‘ke
c++ 使用openssl 1.1版本 实现rsa 1024加密
05-30
使用 OpenSSL 库可以更方便地实现 RSA 加密算法。以下是一个简单的示例程序，展示了如何使用 OpenSSL 库进行 RSA 1024 加密。 首先，需要安装 OpenSSL 库，并在程序中包含相应的头文件： ```c++ #include <openssl/rsa.h> #include <openssl/pem.h> ``` 接着，可以使用 OpenSSL 库中的函数生成 RSA 密钥对： ```c++ RSA *keypair = RSA_new(); BIGNUM *e = BN_new(); int bits = 1024; unsigned long e_value = RSA_F4; BN_set_word(e, e_value); RSA_generate_key_ex(keypair, bits, e, NULL); ``` 这里使用了 `RSA_new()` 函数创建了一个 RSA 结构体，使用 `BN_new()` 函数创建了一个大数结构体 `e`，表示公钥指数 `e` 的值，使用 `RSA_generate_key_ex()` 函数生成了 RSA 密钥对，其中 `bits` 表示密钥长度，`e` 表示公钥指数，`NULL` 表示使用默认的随机数生成器。 生成密钥对后，就可以使用公钥加密数据了。以下是一个示例函数，用于 RSA 加密： ```c++ // 使用公钥加密数据 // 返回加密后的数据长度，加密失败返回0 int rsa_encrypt(const unsigned char *src, int src_len, unsigned char *dst, RSA *key) { int flen = RSA_size(key); int ret = RSA_public_encrypt(src_len, src, dst, key, RSA_PKCS1_PADDING); if (ret != flen) { return 0; } return ret; } ``` 其中，`src` 表示要加密的数据，`src_len` 表示数据长度，`dst` 表示加密后的数据，`key` 表示公钥。 接着，可以使用私钥解密数据。以下是一个示例函数，用于 RSA 解密： ```c++ // 使用私钥解密数据 // 返回解密后的数据长度，解密失败返回0 int rsa_decrypt(const unsigned char *src, int src_len, unsigned char *dst, RSA *key) { int flen = RSA_size(key); int ret = RSA_private_decrypt(src_len, src, dst, key, RSA_PKCS1_PADDING); if (ret <= 0 || ret >= flen) { return 0; } return ret; } ``` 其中，`src` 表示要解密的数据，`src_len` 表示数据长度，`dst` 表示解密后的数据，`key` 表示私钥。 完整的示例程序如下： ```c++ #include <iostream> #include <cstring> #include <openssl/rsa.h> #include <openssl/pem.h> using namespace std; // 使用公钥加密数据 // 返回加密后的数据长度，加密失败返回0 int rsa_encrypt(const unsigned char *src, int src_len, unsigned char *dst, RSA *key) { int flen = RSA_size(key); int ret = RSA_public_encrypt(src_len, src, dst, key, RSA_PKCS1_PADDING); if (ret != flen) { return 0; } return ret; } // 使用私钥解密数据 // 返回解密后的数据长度，解密失败返回0 int rsa_decrypt(const unsigned char *src, int src_len, unsigned char *dst, RSA *key) { int flen = RSA_size(key); int ret = RSA_private_decrypt(src_len, src, dst, key, RSA_PKCS1_PADDING); if (ret <= 0 || ret >= flen) { return 0; } return ret; } int main() { RSA *keypair = RSA_new(); BIGNUM *e = BN_new(); int bits = 1024; unsigned long e_value = RSA_F4; BN_set_word(e, e_value); RSA_generate_key_ex(keypair, bits, e, NULL); // 输出公钥和私钥 BIO *bp_private = BIO_new(BIO_s_mem()); BIO *bp_public = BIO_new(BIO_s_mem()); PEM_write_bio_RSAPrivateKey(bp_private, keypair, NULL, NULL, 0, NULL, NULL); PEM_write_bio_RSAPublicKey(bp_public, keypair); char *private_key; char *public_key; long private_key_len = BIO_get_mem_data(bp_private, &private_key); long public_key_len = BIO_get_mem_data(bp_public, &public_key); cout << "Private Key: " << endl << string(private_key, private_key_len) << endl; cout << "Public Key: " << endl << string(public_key, public_key_len) << endl; // 加密 const unsigned char *msg = (const unsigned char *)"Hello, world!"; int msg_len = strlen((const char *)msg); unsigned char ciphertext[4096]; int ciphertext_len = rsa_encrypt(msg, msg_len, ciphertext, keypair); cout << "Encrypted Message: " << endl; for (int i = 0; i < ciphertext_len; i++) { printf("%02x", ciphertext[i]); } cout << endl; // 解密 unsigned char plaintext[4096]; int plaintext_len = rsa_decrypt(ciphertext, ciphertext_len, plaintext, keypair); cout << "Decrypted Message: " << endl; cout << string((const char *)plaintext, plaintext_len) << endl; RSA_free(keypair); BN_free(e); BIO_free_all(bp_private); BIO_free_all(bp_public); return 0; } ``` 该程序使用 OpenSSL 库生成 RSA 密钥对，并使用公钥加密和私钥解密数据。注意，为了方便输出公钥和私钥，该程序使用了 `PEM_write_bio_RSAPrivateKey()` 和 `PEM_write_bio_RSAPublicKey()` 函数将密钥转换成 PEM 格式输出。在实际应用中，可以直接使用 RSA 结构体表示密钥。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值