C语言RSA算法实现（基于Mbedtls），线程同步面试题

oem_porting.c

sdk_porting.c

authref.c

test.c

${my_src_crypto}

${my_src_crypto_dbg}

)

SET(SRC_LIST_DECRYPT_LIB

oem_porting.c

sdk_porting.c

authref.c

auth.c

${my_src_crypto}

${my_src_crypto_dbg}

)

#SET(SRC_LIST_AUTH_DEV

oem_porting.c sdk_porting.c authref.c ${my_src_crypto} ${my_src_crypto_dbg}

#)

add_definitions(-fPIC)

#ADD_LIBRARY(authd STATIC ${SRC_LIST_AUTH_DEV})

ADD_LIBRARY(authoal STATIC ${SRC_LIST_DECRYPT_LIB})

ADD_EXECUTABLE(eaidkAuth ${SRC_LIST_ENCRYPT_BIN})

工程结构如下：

引入完成之后我们就可以开始RSA代码编写。

3、RSA代码编写

authref.h 头文件代码如下：

#ifndef AUTHREF_H

#define AUTHREF_H

#include

#include

#include

#include

#undef DEBUG

#define RSA_KEY_SIZE 1024 // RSA 公钥的位数

#define EXPonENT 65537

#define BUFFER_SIZE 1024

#define RSA_KEY_LEN 256

#define AES_KEY_DEC_LEN 8

#define LICENSE_DEC_LEN 64

typedef struct __rsa

{

uint8_t buf[BUFFER_SIZE*8];

uint8_t* rsa_n;

uint8_t* rsa_e;

uint8_t* rsa_d;

uint8_t* rsa_p;

uint8_t* rsa_q;

uint8_t* rsa_dp;

uint8_t* rsa_dq;

uint8_t* rsa_qp;

uint32_t n_len;

uint32_t e_len;

uint32_t d_len;

uint32_t p_len;

uint32_t q_len;

uint32_t dp_len;

uint32_t dq_len;

uint32_t qp_len;

}T_rsa;

void generate_rsa(T_rsa* r);

void init_rsa_keys(T_rsa* rsa);

void rsa_encrypt( const T_rsa *r,

const unsigned char* plaintext,

unsigned int plaintext_size,

unsigned char *ciphertext,

size_t *ciphertext_size);

void rsa_decrypt(

const T_rsa *r,

const unsigned char* ciphertext,

//unsigned int ciphertext_size,

unsigned char *plaintext,

size_t *plaintext_size);

#ifdef __cplusplus

}

#endif

#endif //AUTHREF_H

authref.c 代码如下：

#include “authref.h”

#include “mbedtls/entropy.h”

#include “mbedtls/ctr_drbg.h”

#include “mbedtls/rsa.h”

#define RSA_KEY_SIZE 1024 // RSA 公钥的位数

#define EXPonENT 65537

#define BUFFER_SIZE 1024

#define RSA_KEY_LEN 256

#define AES_KEY_DEC_LEN 8

#define LICENSE_DEC_LEN 64

void generate_rsa(T_rsa* r)

{

mbedtls_rsa_context rsa;

mbedtls_entropy_context entropy;

mbedtls_ctr_drbg_context ctr_drbg;

mbedtls_entropy_init(&entropy);

mbedtls_ctr_drbg_init(&ctr_drbg);

mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0);

mbedtls_rsa_init(&rsa, MBEDTLS_RSA_PKCS_V15, 0);

mbedtls_rsa_gen_key(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg, RSA_KEY_SIZE, EXPONENT);

mbedtls_mpi_write_binary(&rsa.N, r->rsa_

【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】

浏览器打开：qq.cn.hn/FTf 免费领取

n, BUFFER_SIZE);

mbedtls_mpi_write_binary(&rsa.E, r->rsa_e, BUFFER_SIZE);

mbedtls_mpi_write_binary(&rsa.D, r->rsa_d, BUFFER_SIZE);

mbedtls_mpi_write_binary(&rsa.P, r->rsa_p, BUFFER_SIZE);

mbedtls_mpi_write_binary(&rsa.Q, r->rsa_q, BUFFER_SIZE);

mbedtls_mpi_write_binary(&rsa.DP, r->rsa_dp, BUFFER_SIZE);

mbedtls_mpi_write_binary(&rsa.DQ, r->rsa_dq, BUFFER_SIZE);

mbedtls_mpi_write_binary(&rsa.QP, r->rsa_qp, BUFFER_SIZE);

mbedtls_rsa_free(&rsa);

mbedtls_ctr_drbg_free(&ctr_drbg);

mbedtls_entropy_free(&entropy);

}

void init_rsa_keys(T_rsa *rsa) {

memset(rsa->buf, 0, BUFFER_SIZE * 8);

rsa->rsa_n = &rsa->buf[BUFFER_SIZE * 0];

rsa->rsa_e = &rsa->buf[BUFFER_SIZE * 1];

rsa->rsa_d = &rsa->buf[BUFFER_SIZE * 2];

rsa->rsa_p = &rsa->buf[BUFFER_SIZE * 3];

rsa->rsa_q = &rsa->buf[BUFFER_SIZE * 4];

rsa->rsa_dp = &rsa->buf[BUFFER_SIZE * 5];

rsa->rsa_dq = &rsa->buf[BUFFER_SIZE * 6];

rsa->rsa_qp = &rsa->buf[BUFFER_SIZE * 7];

rsa->n_len = BUFFER_SIZE;

rsa->e_len = BUFFER_SIZE;

rsa->d_len = BUFFER_SIZE;

rsa->p_len = BUFFER_SIZE;

rsa->q_len = BUFFER_SIZE;

rsa->dp_len = BUFFER_SIZE;

rsa->dq_len = BUFFER_SIZE;

rsa->qp_len = BUFFER_SIZE;

}

// 加密

void rsa_encrypt(

const T_rsa *r,

const unsigned char *plaintext,

unsigned int plaintext_size,

unsigned char *ciphertext,

size_t *ciphertext_size) {

mbedtls_rsa_context rsa;

mbedtls_entropy_context entropy;

mbedtls_ctr_drbg_context ctr_drbg;

int rett = 0;

mbedtls_entropy_init(&entropy);

//assert(mbedtls_ctr_drbg_init(&ctr_drbg, mbedtls_entropy_func, &entropy, nullptr, 0) == 0);

mbedtls_ctr_drbg_init(&ctr_drbg);

assert(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0) == 0);

mbedtls_rsa_init(&rsa, MBEDTLS_RSA_PKCS_V15, 0);

assert(mbedtls_mpi_read_binary(&rsa.N, r->rsa_n, BUFFER_SIZE) == 0);

assert(mbedtls_mpi_read_binary(&rsa.E, r->rsa_e, BUFFER_SIZE) == 0);

*ciphertext_size = rsa.len = (mbedtls_mpi_bitlen(&rsa.N) + 7) >> 3;

//assert(mbedtls_rsa_pkcs1_encrypt(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg, MBEDTLS_RSA_PUBLIC, plaintext_size, plaintext, ciphertext) == 0);

rett = mbedtls_rsa_pkcs1_encrypt(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg, MBEDTLS_RSA_PUBLIC, plaintext_size,

plaintext, ciphertext);

assert(rett == 0);

mbedtls_rsa_free(&rsa);

mbedtls_ctr_drbg_free(&ctr_drbg);

mbedtls_entropy_free(&entropy);

}

// 解密

void rsa_decrypt(

const T_rsa *r,

const unsigned char *ciphertext,

//unsigned int ciphertext_size,

unsigned char *plaintext,

size_t *plaintext_size) {

mbedtls_rsa_context rsa;

mbedtls_entropy_context entropy;

mbedtls_ctr_drbg_context ctr_drbg;

mbedtls_entropy_init(&entropy);

//assert(mbedtls_ctr_drbg_init(&ctr_drbg, mbedtls_entropy_func, &entropy, nullptr, 0) == 0);

mbedtls_ctr_drbg_init(&ctr_drbg);

assert(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0) == 0);

mbedtls_rsa_init(&rsa, MBEDTLS_RSA_PKCS_V15, 0);

assert(mbedtls_mpi_read_binary(&rsa.N, r->rsa_n, BUFFER_SIZE) == 0);

assert(mbedtls_mpi_read_binary(&rsa.E, r->rsa_e, BUFFER_SIZE) == 0);

assert(mbedtls_mpi_read_binary(&rsa.D, r->rsa_d, BUFFER_SIZE) == 0);

assert(mbedtls_mpi_read_binary(&rsa.P, r->rsa_p, BUFFER_SIZE) == 0);

assert(mbedtls_mpi_read_binary(&rsa.Q, r->rsa_q, BUFFER_SIZE) == 0);

assert(mbedtls_mpi_read_binary(&rsa.DP, r->rsa_dp, BUFFER_SIZE) == 0);

assert(mbedtls_mpi_read_binary(&rsa.DQ, r->rsa_dq, BUFFER_SIZE) == 0);

assert(mbedtls_mpi_read_binary(&rsa.QP, r->rsa_qp, BUFFER_SIZE) == 0);

rsa.len = (mbedtls_mpi_bitlen(&rsa.N) + 7) >> 3;

assert(mbedtls_rsa_pkcs1_decrypt(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg, MBEDTLS_RSA_PRIVATE, plaintext_size,

ciphertext, plaintext, *plaintext_size) == 0);

mbedtls_rsa_free(&rsa);

mbedtls_ctr_drbg_free(&ctr_drbg);

mbedtls_entropy_free(&entropy);

}

int do_ras_encrypt(authhandle *hdl, uint8_t contract_id[CONTRACTID_LEN], uint8_t user_id[USERID_LEN],

uint8_t uid[FINAL_UID_LEN]) {

T_rsa r;

uint8_t uid_local[UID_LEN];

uint8_t ciphertext[SN_LEN];

size_t ciphertext_len = SN_LEN;

GenRawUID(hdl, contract_id, user_id, uid_local);

//encryp UID

init_rsa_keys(&r);

if (hdl->callback_func.GetServerPublicKey) {

hdl->callback_func.GetServerPublicKey(r.buf);

} else {

GetServerPublicKey(hdl, r.buf); //load 2048 bytes for public key

}

rsa_encrypt(&r, uid_local, UID_LEN, ciphertext, &ciphertext_len);

//printf(“ciphertext_len: %ldn”, ciphertext_len);

//copy SWID

#if 0

int i;

printf("CipherUID: ");

for(i = 0; i < FINAL_UID_LEN; ++i){

printf("%02x, ", uid[i]);