自学教程：C++ AES_decrypt函数代码示例

void aes_decrypt(struct aes_keys *aes, uchar *buf, int32_t n){	int32_t i;	for(i = 0; i < n; i += 16)	{		AES_decrypt(buf + i, buf + i, &aes->aeskey_decrypt);	}}

voidAES_cbc_encrypt(const unsigned char *in, unsigned char *out,		unsigned long size, const AES_KEY *key,		unsigned char *iv, int forward_encrypt){    unsigned char tmp[AES_BLOCK_SIZE];    int i;    if (forward_encrypt) {	while (size >= AES_BLOCK_SIZE) {	    for (i = 0; i < AES_BLOCK_SIZE; i++)		tmp[i] = in[i] ^ iv[i];	    AES_encrypt(tmp, out, key);	    memcpy(iv, out, AES_BLOCK_SIZE);	    size -= AES_BLOCK_SIZE;	    in += AES_BLOCK_SIZE;	    out += AES_BLOCK_SIZE;	}	if (size) {	    for (i = 0; i < size; i++)		tmp[i] = in[i] ^ iv[i];	    for (i = size; i < AES_BLOCK_SIZE; i++)		tmp[i] = iv[i];	    AES_encrypt(tmp, out, key);	    memcpy(iv, out, AES_BLOCK_SIZE);	}    } else {	while (size >= AES_BLOCK_SIZE) {	    memcpy(tmp, in, AES_BLOCK_SIZE);	    AES_decrypt(tmp, out, key);	    for (i = 0; i < AES_BLOCK_SIZE; i++)		out[i] ^= iv[i];	    memcpy(iv, tmp, AES_BLOCK_SIZE);	    size -= AES_BLOCK_SIZE;	    in += AES_BLOCK_SIZE;	    out += AES_BLOCK_SIZE;	}	if (size) {	    memcpy(tmp, in, AES_BLOCK_SIZE);	    AES_decrypt(tmp, out, key);	    for (i = 0; i < size; i++)		out[i] ^= iv[i];	    memcpy(iv, tmp, AES_BLOCK_SIZE);	}    }}

int crypt_dec_block(cipher_context *cctx, uint8 *in, uint8 *out, int len){	if(len%cctx->block_size)		return 0;			switch(cctx->alg){	case ALG_AES_ECB:	case ALG_AES_CTR:	{		int j;		for(j=0; j<len; j+=cctx->block_size){			AES_decrypt(in+j, out+j, cctx->enc_ctx);		}		return 1;	}	case ALG_AES_CBC:	{		int i, j;		uint8 temp[MAX_CIPHER_BLOCK_SIZE];		for(j=0; j<len; j+=cctx->block_size){			memcpy(temp, in+j, cctx->block_size);			AES_decrypt(temp, out+j, cctx->enc_ctx);			for(i=0; i<cctx->block_size; i++){				out[j+i]^=cctx->iv[i];			}						memcpy(cctx->iv, temp, cctx->block_size);		}		return 1;	}	case ALG_SM4_ECB:	case ALG_SM4_CTR:		sm4_crypt_ecb(cctx->enc_ctx, SM4_DECRYPT, len, in, out);		return 1;		break;	case ALG_SM4_CBC:		sm4_crypt_cbc(cctx->enc_ctx, SM4_DECRYPT, len, cctx->iv, in, out);		return 1;		break;	}		return 0;}

 ustring aes_decode(ustring const& passphrase, ustring const& indata, int length) {     AES_KEY key;     AES_set_decrypt_key(passphrase.c_str(), 8 * length, &key);     unsigned char* outdata = new unsigned char[length];     AES_decrypt(indata.c_str(), outdata, &key);     ustring res(outdata, length);     delete[] outdata;     return res; }

static void test_xts_aes_decrypt(const void *ctx,                                 size_t length,                                 uint8_t *dst,                                 const uint8_t *src){    const struct TestAES *aesctx = ctx;    AES_decrypt(src, dst, &aesctx->dec);}

int cbcdec(unsigned char* CText, int length){  unsigned char MBlock[16];  unsigned char CBlock_cur[16];  unsigned char CBlock_prev[16];  unsigned char Key[16];  int i, j, tmp;  FILE *fpOut;  AES_KEY AESkey;  // This is just for illustration; the actual key used was not the all-0 key!  Key[0] = Key[1] = Key[2] = Key[3] = 0x00;  Key[4] = Key[5] = Key[6] = Key[7] = 0x00;  Key[8] = Key[9] = Key[10] = Key[11] = 0x00;  Key[12] = Key[13] = Key[14] = Key[15] = 0x00;  AES_set_decrypt_key((const unsigned char *) Key, 128, &AESkey);  if (length < 2) return 0;  for (i=0; i<16; i++)    CBlock_prev[i] = CText[i];  j = 1;  while (j < length) {    for (i=0; i<16; i++)      CBlock_cur[i] = CText[16*j+i];    AES_decrypt((const unsigned char *) CBlock_cur, MBlock, (const AES_KEY *) &AESkey);    for (i=0; i<16; i++) {      MBlock[i] ^= CBlock_prev[i];      // fprintf(fpOut, "%X", MBlock[i]/16), fprintf(fpOut, "%X", MBlock[i]%16);      // Uncomment this to output the message + the padding for debugging purposes.      // If we were implementing this for real, we would only output the message      CBlock_prev[i] = CBlock_cur[i];    }    j++;  }  j = MBlock[15];  if ((j==0) || (j>16)) {   // printf("Error: final byte out of range/n");    return 0;  }  for (i=14; i>=16-j; i--) {    if (MBlock[i] != j) {      // printf("Error: incorrect padding/n");      return 0;    }  }  // printf("Everything fine/n");  return 1;}

void AES_ecb_encrypt(const unsigned char *in, unsigned char *out,		     const AES_KEY *key, const int enc) {    assert(in && out && key);	assert((AES_ENCRYPT == enc)||(AES_DECRYPT == enc));	if (AES_ENCRYPT == enc)		AES_encrypt(in, out, key);	else		AES_decrypt(in, out, key);}

int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size){    mz_crypt_aes *aes = (mz_crypt_aes *)handle;    if (aes == NULL || buf == NULL)        return MZ_PARAM_ERROR;    if (size != MZ_AES_BLOCK_SIZE)        return MZ_PARAM_ERROR;    AES_decrypt(buf, buf, &aes->key);    return size;}

/** * mega_aes_key_decrypt_raw: * @aes_key: a #MegaAesKey * @cipher: (element-type guint8) (array length=len): Ciphertext * @plain: (element-type guint8) (array length=len) (out caller-allocates): Plaintext output data * @len: 16 byte aligned length of ciphertext and plaintext data. * * Decrypt ciphertext blocks using AES key */void mega_aes_key_decrypt_raw(MegaAesKey* aes_key, const guchar* cipher, guchar* plain, gsize len){    gsize off;    g_return_if_fail(MEGA_IS_AES_KEY(aes_key));    g_return_if_fail(cipher != NULL);    g_return_if_fail(plain != NULL);    g_return_if_fail(len % 16 == 0);    for (off = 0; off < len; off += 16)        AES_decrypt(cipher + off, plain + off, &aes_key->priv->dec_key);}

static int __license_decrypt_time(int fd, time_t *_limit){        int ret, cnt;        time_t limit;        uint8_t epad[AES_BLOCK_SIZE];        uint8_t etime[AES_BLOCK_SIZE], etime_hex[LICENSE_AES_HEXLEN];        AES_KEY key;        ret = lseek(fd, 0, SEEK_SET);        if (ret < 0) {                ret = errno;                GOTO(err_ret, ret);        }        cnt = read(fd, etime_hex, sizeof(etime_hex));        if (cnt != sizeof(etime_hex)) {                ret = EIO;                GOTO(err_ret, ret);        }        if (!memcmp(etime_hex, LICENSE_VERSION_2, sizeof(etime_hex))) {                cnt = pread(fd, etime_hex, sizeof(etime_hex), sizeof(etime_hex) * 2);                if (cnt != sizeof(etime_hex)) {                        ret = EIO;                        GOTO(err_ret, ret);                }        }        if (!__arrcmp(permanent_free, 10, etime_hex, sizeof(etime_hex))) {               *_limit = -1;               return 0;        }        ret = __hex2str(etime_hex, sizeof(etime_hex), etime, sizeof(etime));        if (ret)                GOTO(err_ret, ret);        ret = AES_set_decrypt_key((uint8_t *)LICENSE_AES_KEY, 128, &key);        if (ret < 0) {                ret = EFAULT;                GOTO(err_ret, ret);        }        AES_decrypt((uint8_t *)etime, (uint8_t *)epad, &key);        memcpy(&limit, epad, sizeof(time_t));        *_limit = LICENSE_DECRYPT(limit);        return 0;err_ret:        return ret;}

// cipterText: 
C++ AES_set_decrypt_key函数代码示例
C++ AES_cbc_encrypt函数代码示例