polarssl rsa & aes 加密与解密<转>

上周折腾加密与解密，用了openssl, crypto++, polarssl, cyassl, 说起真的让人很沮丧，只有openssl & polarssl两个库的RSA & AES 加密和解密，我用起来了，crypto++各种模板，各种多继承，看的头大，而且对各种常用的加密算法也不了解，所以这个库我在折腾了一天之后就放弃了；cyassl这个库现在没什么印象了；openssl没什么好说的，用起来很方便，尤其是使用win32openssl，都不用自己编译，下载下来安装好了就能用，着实方便；但是我是要在移动终端使用RSA & AES，研究了半天怎么只使用openssl的源代码，发现还真是麻烦；总之呢，现在我决定使用polarssl，接口简单易用，而且使用源代码进行编译，都是C文件，肯定是跨平台的了，很小，很精悍，下面帖出使用polarssl实现的RSA & AES加密和解密的过程，便于日后直接使用

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string>

#include "polarssl/entropy.h"
#include "polarssl/ctr_drbg.h"
#include "polarssl/rsa.h"
#include "polarssl/aes.h"

const unsigned int RSA_KEY_SIZE = ;        // RSA 公钥的位数
const unsigned int AES_KEY_SIZE = ;
const unsigned int EXPONENT = ;
const unsigned int BUFFER_SIZE = ;

class rsa
{
public:
    rsa()
    {
        memset(rsa_n, , BUFFER_SIZE);
        memset(rsa_e, , BUFFER_SIZE);
        memset(rsa_d, , BUFFER_SIZE);
        memset(rsa_p, , BUFFER_SIZE);
        memset(rsa_q, , BUFFER_SIZE);
        memset(rsa_dp, , BUFFER_SIZE);
        memset(rsa_dq, , BUFFER_SIZE);
        memset(rsa_qp, , BUFFER_SIZE);
    }

    unsigned char    rsa_n[BUFFER_SIZE];
    unsigned char    rsa_e[BUFFER_SIZE];
    unsigned char    rsa_d[BUFFER_SIZE];
    unsigned char    rsa_p[BUFFER_SIZE];
    unsigned char    rsa_q[BUFFER_SIZE];
    unsigned char    rsa_dp[BUFFER_SIZE];
    unsigned char    rsa_dq[BUFFER_SIZE];
    unsigned char    rsa_qp[BUFFER_SIZE];

    unsigned int n_len = BUFFER_SIZE;
    unsigned int e_len = BUFFER_SIZE;
    unsigned int d_len = BUFFER_SIZE;
    unsigned int p_len = BUFFER_SIZE;
    unsigned int q_len = BUFFER_SIZE;
    unsigned int dp_len = BUFFER_SIZE;
    unsigned int dq_len = BUFFER_SIZE;
    unsigned int qp_len = BUFFER_SIZE;
};

void generate_rsa(rsa& r)
{
    // 生成RSA密钥对
    rsa_context    rsa;
    entropy_context    entropy;
    ctr_drbg_context    ctr_drbg;

    entropy_init(&entropy);

    assert(ctr_drbg_init(&ctr_drbg, entropy_func, &entropy, nullptr, ) == );

    rsa_init(&rsa, RSA_PKCS_V15, );

    assert(rsa_gen_key(&rsa, ctr_drbg_random, &ctr_drbg, RSA_KEY_SIZE, EXPONENT) == );

    assert(mpi_write_binary(&rsa.N, r.rsa_n, BUFFER_SIZE) == );
    assert(mpi_write_binary(&rsa.E, r.rsa_e, BUFFER_SIZE) == );
    assert(mpi_write_binary(&rsa.D, r.rsa_d, BUFFER_SIZE) == );
    assert(mpi_write_binary(&rsa.P, r.rsa_p, BUFFER_SIZE) == );
    assert(mpi_write_binary(&rsa.Q, r.rsa_q, BUFFER_SIZE) == );
    assert(mpi_write_binary(&rsa.DP, r.rsa_dp, BUFFER_SIZE) == );
    assert(mpi_write_binary(&rsa.DQ, r.rsa_dq, BUFFER_SIZE) == );
    assert(mpi_write_binary(&rsa.QP, r.rsa_qp, BUFFER_SIZE) == );

    //puts(r.rsa_n);
    //puts(r.rsa_e);
}

// 加密
void encrypt(
    const rsa &r,
    const unsigned char* plaintext,
    unsigned int plaintext_size,
    unsigned char *ciphertext,
    unsigned int &ciphertext_size)
{
    rsa_context            rsa;
    entropy_context        entropy;
    ctr_drbg_context    ctr_drbg;

    entropy_init(&entropy);
    assert(ctr_drbg_init(&ctr_drbg, entropy_func, &entropy, nullptr, ) == );

    rsa_init(&rsa, RSA_PKCS_V15, );

    assert(mpi_read_binary(&rsa.N, r.rsa_n, BUFFER_SIZE) == );
    assert(mpi_read_binary(&rsa.E, r.rsa_e, BUFFER_SIZE) == );

    rsa.len = (mpi_msb(&rsa.N) + ) >> ;

    assert(rsa_pkcs1_encrypt(&rsa, ctr_drbg_random, &ctr_drbg, RSA_PUBLIC, plaintext_size, plaintext, ciphertext) == );
}

// 解密
void decrypt(
    const rsa &r,
    const unsigned char* ciphertext,
    unsigned int ciphertext_size,
    unsigned char *plaintext,
    unsigned int &plaintext_size)
{
    rsa_context            rsa;
    entropy_context        entropy;
    ctr_drbg_context    ctr_drbg;

    entropy_init(&entropy);
    assert(ctr_drbg_init(&ctr_drbg, entropy_func, &entropy, nullptr, ) == );

    rsa_init(&rsa, RSA_PKCS_V15, );

    assert(mpi_read_binary(&rsa.N, r.rsa_n, BUFFER_SIZE) == );
    assert(mpi_read_binary(&rsa.E, r.rsa_e, BUFFER_SIZE) == );
    assert(mpi_read_binary(&rsa.D, r.rsa_d, BUFFER_SIZE) == );
    assert(mpi_read_binary(&rsa.P, r.rsa_p, BUFFER_SIZE) == );
    assert(mpi_read_binary(&rsa.Q, r.rsa_q, BUFFER_SIZE) == );
    assert(mpi_read_binary(&rsa.DP, r.rsa_dp, BUFFER_SIZE) == );
    assert(mpi_read_binary(&rsa.DQ, r.rsa_dq, BUFFER_SIZE) == );
    assert(mpi_read_binary(&rsa.QP, r.rsa_qp, BUFFER_SIZE) == );

    rsa.len = (mpi_msb(&rsa.N) + ) >> ;

    assert(rsa_pkcs1_decrypt(&rsa, ctr_drbg_random, &ctr_drbg, RSA_PRIVATE, &plaintext_size, ciphertext, plaintext, plaintext_size) == );
}

void test_aes()
{
    // 产生随机的AES key buffer
    ctr_drbg_context ctr_drbg;
    entropy_context entropy;
    unsigned char aes_key_buf[AES_KEY_SIZE] = {  };

    entropy_init(&entropy);
    assert(ctr_drbg_init(&ctr_drbg, entropy_func, &entropy, nullptr, ) == );
    ctr_drbg_set_prediction_resistance(&ctr_drbg, CTR_DRBG_PR_OFF);
    ctr_drbg_random(&ctr_drbg, aes_key_buf, AES_KEY_SIZE);

    // 生成AES
    aes_context    aes_enc, aes_dec;
    aes_init(&aes_enc);
    aes_init(&aes_dec);

    assert(aes_setkey_enc(&aes_enc, aes_key_buf, AES_KEY_SIZE) == );
    assert(aes_setkey_dec(&aes_dec, aes_key_buf, AES_KEY_SIZE) == );

    // 加密 & 解密. 明文与密文的长度是固定的， 都是16bytes
    /*
    const unsigned int DATA_SIZE = 16;
    unsigned char plaintext[DATA_SIZE] = { 0 };
    unsigned char ciphertext[DATA_SIZE] = { 0 };
    sprintf((char*)plaintext, "%s", "moyakukudi");

    assert(aes_crypt_ecb(&aes_enc, AES_ENCRYPT, plaintext, ciphertext) == 0);
    memset(plaintext, 0, DATA_SIZE);
    assert(aes_crypt_ecb(&aes_dec, AES_DECRYPT, ciphertext, plaintext) == 0);
    */

    // 加密 & 解密. 明文与密文的长度是不固定的, 但必须是16bytes的倍数
    const unsigned int DATA_SIZE = ;
    unsigned char plaintext[DATA_SIZE] = {  };
    unsigned char ciphertext[DATA_SIZE] = {  };
    sprintf((char*)plaintext, "%s", "return 0 if successful, or POLARSSL_ERR_AES_INVALID_INPUT_LENGTH, assert(aes_crypt_ecb(&aes_dec, AES_DECRYPT, ciphertext, plaintext) == 0);");

    const unsigned int IV_SIZE = ;
    unsigned char iv[IV_SIZE] = {  };
    //unsigned char iv2[IV_SIZE] = { 0 };
    //ctr_drbg_random(&ctr_drbg, iv, IV_SIZE);
    //strcpy((char*)iv2, (const char*)iv);

    assert(aes_crypt_cbc(&aes_enc, AES_ENCRYPT, DATA_SIZE, iv, plaintext, ciphertext) == );
    memset(plaintext, , DATA_SIZE);
    memset(iv, , IV_SIZE);
    assert(aes_crypt_cbc(&aes_dec, AES_DECRYPT, DATA_SIZE, iv, ciphertext, plaintext) == );

    puts("over");
}

int main()
{
    goto    AES;

    // RSA
RSA:
    rsa    r;
    generate_rsa(r);

    unsigned char    plaintext[] = "moyakukudi";
    unsigned char    ciphertext[BUFFER_SIZE] = {  };
    unsigned int    ciphertext_len = BUFFER_SIZE;
    encrypt(r, plaintext, sizeof(plaintext), ciphertext, ciphertext_len);

    unsigned char    output[BUFFER_SIZE] = {  };
    unsigned int    output_len = BUFFER_SIZE;
    decrypt(r, ciphertext, ciphertext_len, output, output_len);

    // AES
AES:

    test_aes();

    system("pause");
    return ;
}

https://www.cnblogs.com/emyueguang/p/4072906.html