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

//An encryption function that uses blowish and a variable length key to encrypt//'size' bytes of data. This function is only really used to encrypt verification//digests of filesunsigned char *blowfish_enc(unsigned char *key, unsigned char *data, int size){	unsigned char* out = malloc(size);	int outlen;	int tmplen;	unsigned char iv[] = {0}; //TODO maybe not this?	EVP_CIPHER_CTX ctx;	EVP_CIPHER_CTX_init(&ctx);	EVP_EncryptInit_ex(&ctx, EVP_bf_ecb(), NULL, key, iv);	EVP_CIPHER_CTX_set_padding(&ctx, 0);		EVP_EncryptUpdate(&ctx, out, &outlen, data, size);	if(!EVP_EncryptFinal_ex(&ctx, out + outlen, &tmplen)) {		ssl_error("Didn't do encrypt final");	}	outlen += tmplen;	EVP_CIPHER_CTX_cleanup(&ctx);	return out;}

/* * aes_icm_set_iv(c, iv) sets the counter value to the exor of iv with * the offset */static srtp_err_status_t srtp_aes_icm_openssl_set_iv (void *cv, uint8_t *iv, srtp_cipher_direction_t dir){    srtp_aes_icm_ctx_t *c = (srtp_aes_icm_ctx_t *)cv;    v128_t nonce;    /* set nonce (for alignment) */    v128_copy_octet_string(&nonce, iv);    debug_print(srtp_mod_aes_icm, "setting iv: %s", v128_hex_string(&nonce));    v128_xor(&c->counter, &c->offset, &nonce);    debug_print(srtp_mod_aes_icm, "set_counter: %s", v128_hex_string(&c->counter));    if (!EVP_EncryptInit_ex(c->ctx, NULL,                            NULL, NULL, c->counter.v8)) {        return srtp_err_status_fail;    } else {        return srtp_err_status_ok;    }}

/** * Create an 256 bit key and IV using the supplied key_data. salt can be added for taste. * Fills in the encryption and decryption ctx objects and returns 0 on success **/int aes_init(unsigned char *key_data, int key_data_len, unsigned char *salt, EVP_CIPHER_CTX *e_ctx){  int i, nrounds = 5;  unsigned char key[32], iv[32];    /*   * Gen key & IV for AES 256 CBC mode. A SHA1 digest is used to hash the supplied key material.   * nrounds is the number of times the we hash the material. More rounds are more secure but   * slower.   */  i = EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha1(), salt, key_data, key_data_len, nrounds, key, iv);  if (i != 32) {    printf("Key size is %d bits - should be 256 bits/n", i);    return -1;  }  EVP_CIPHER_CTX_init(e_ctx);  EVP_EncryptInit_ex(e_ctx, EVP_aes_256_cbc(), NULL, key, iv);  return 0;}

/*  * Encrypts the plaintext and sets it to out * @param message: the plaintext string * @param length: the number of chars for the plaintext * @param encKey: the aes 256 key * @param encIv: the aes 128 iv * @param out: where the enc message is put */unsigned int aes_encrypt_message(unsigned char *message, unsigned int length, unsigned char *encKey, unsigned char *encIv, unsigned char **out) {    unsigned char *encMsg = (unsigned char *)malloc(length*(unsigned char) + AES_BLOCK_SIZE);    EVP_CIPHER_CTX *ctx;    int len;    int ciphertext_len;    if (!(ctx = EVP_CIPHER_CTX_new())) {        printf ("EVP_CIPHER_CTX_new() failed/n");        exit (EXIT_FAILURE);    }    if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, encKey, encIv)) {        printf ("EVP_EncryptInit_ex failed/n");        exit (EXIT_FAILURE);    }    if (1 != EVP_EncryptUpdate(ctx, encMsg, &len, message, length)) {        printf ("EVP_ENcryptUpdate failed/n");        exit (EXIT_FAILURE);    }    ciphertext_len = len;    if (1 != EVP_EncryptFinal_ex(ctx, encMsg + len, &len)) {        printf ("EVP_EncryptFinal_ex() failed/n");        exit (EXIT_FAILURE);    }    ciphertext_len += len;    EVP_CIPHER_CTX_free(ctx);    *(encMsg + ciphertext_len) = '/0';    if (Base64Encode(encMsg, ciphertext_len, (char **)out) < 0) {        printf ("Base64Encode in aes_encrypt_message failed/n");    }    return ciphertext_len;}

/** * AES-ECB-PKCS5Padding加密 * * LUA示例: * local codec = require('codec') * local src = 'something' * local key = [[...]] --16位数字串 * local bs = codec.aes_encrypt(src, key) * local dst = codec.base64_encode(bs) --BASE64密文 */static int codec_aes_encrypt(lua_State *L){    size_t len;    const char *src = luaL_checklstring(L, 1, &len);    char *key = luaL_checkstring(L, 2);    EVP_CIPHER_CTX ctx;    EVP_CIPHER_CTX_init(&ctx);    int ret = EVP_EncryptInit_ex(&ctx, EVP_aes_128_ecb(), NULL, (unsigned char *)key, NULL);    if(ret != 1)    {        EVP_CIPHER_CTX_cleanup(&ctx);        return luaL_error(L, "EVP encrypt init error");    }    int dstn = len + 128, n, wn;    char dst[dstn];    memset(dst, 0, dstn);    ret = EVP_EncryptUpdate(&ctx, (unsigned char *)dst, &wn, (unsigned char *)src, len);    if(ret != 1)    {        EVP_CIPHER_CTX_cleanup(&ctx);        return luaL_error(L, "EVP encrypt update error");    }    n = wn;    ret = EVP_EncryptFinal_ex(&ctx, (unsigned char *)(dst + n), &wn);    if(ret != 1)    {        EVP_CIPHER_CTX_cleanup(&ctx);        return luaL_error(L, "EVP encrypt final error");    }    EVP_CIPHER_CTX_cleanup(&ctx);    n += wn;    lua_pushlstring(L, dst, n);    return 1;}

static int encrypt(void *plaintext, size_t plaintext_len, void *key, void *iv, void *ciphertext) {	EVP_CIPHER_CTX *ctx;	int len;	int ciphertext_len;	// initialize the CryptoExcreter	if(!(ctx = EVP_CIPHER_CTX_new())) {		secreteLibSSLError();	}	/* Initialise the encryption operation. IMPORTANT - ensure you use a key	* and IV size appropriate for your cipher	* In this example we are using 256 bit AES (i.e. a 256 bit key). The	* IV size for *most* modes is the same as the block size. For AES this	* is 128 bits */	if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) {		secreteLibSSLError();	}	// encrypt pls	if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len)) {		secreteLibSSLError();	}	ciphertext_len = len;	// finalize	if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) {		secreteLibSSLError();	}	ciphertext_len += len;	// Clean up	EVP_CIPHER_CTX_free(ctx);	return ciphertext_len;}

int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,  unsigned char *iv, unsigned char *ciphertext){  EVP_CIPHER_CTX *ctx;  int len;  int ciphertext_len;  /* Create and initialise the context */  if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors();  /* Initialise the encryption operation. IMPORTANT - ensure you use a key   * and IV size appropriate for your cipher   * In this example we are using 256 bit AES (i.e. a 256 bit key). The   * IV size for *most* modes is the same as the block size. For AES this   * is 128 bits */  if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))    handleErrors();  /* Provide the message to be encrypted, and obtain the encrypted output.   * EVP_EncryptUpdate can be called multiple times if necessary   */  if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))    handleErrors();  ciphertext_len = len;  /*     Finalise the encryption. Further ciphertext bytes may be written at   * this stage.   */  if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) handleErrors();  ciphertext_len += len;  /* Clean up */  EVP_CIPHER_CTX_free(ctx);  return ciphertext_len;}

/*** 功能描述:3DES解密* @param pData：原始数据* @param ilen: 原始数据长度* @param ppDecryptData: 解密后数据* @return -1: 失败, 其他: 解密数据长度**/int TripleDESDecrypt(const char* pData, int ilen, char** ppDecryptData){    /*密钥*/    unsigned char key[24] = {43,14,54,109,109,8,84,87,116,30,19,68,35,51,83,72,16,2,83,48,117,85,9,80};    /*初始化向量*/    unsigned char iv[8] = {111,121,47,42,75,34,33,124};    EVP_CIPHER_CTX ctx;    EVP_CIPHER_CTX_init(&ctx);    int rc = EVP_EncryptInit_ex(&ctx,EVP_des_ede3_cbc(),NULL,key,iv);    if (rc != 1)    {        EVP_CIPHER_CTX_cleanup(&ctx);        return -1;    }    int outlen = ilen + 1;    *ppDecryptData = (char*)malloc(outlen);    memset(*ppDecryptData, 0 , outlen);    rc = EVP_DecryptUpdate(&ctx, (unsigned char*)(*ppDecryptData), &outlen, (unsigned char*)pData, ilen);    if(rc != 1)    {        EVP_CIPHER_CTX_cleanup(&ctx);        free(*ppDecryptData);        return -1;    }    int outlentmp = 0;    rc = EVP_DecryptFinal_ex(&ctx, (unsigned char*)(*ppDecryptData) + outlen,&outlentmp);    if(rc != 1)    {        EVP_CIPHER_CTX_cleanup(&ctx);        free(*ppDecryptData);        return -1;    }    outlen += outlentmp;    EVP_CIPHER_CTX_cleanup(&ctx);    return outlen;}

size32_t aesEncrypt(MemoryBuffer &out, size32_t inSz, const void *inBytes, size32_t keyLen, const char *key, const char iv[aesBlockSize]){    if (0 == inSz)        return 0;    OwnedEVPCipherCtx ctx(EVP_CIPHER_CTX_new());    if (!ctx)        throw makeEVPException(0, "Failed EVP_CIPHER_CTX_new");    /* Initialise the encryption operation. IMPORTANT - ensure you use a key     * and IV size appropriate for your cipher     * In this example we are using 256 bit AES (i.e. a 256 bit key). The     * IV size for *most* modes is the same as the block size. For AES this     * is 128 bits     * */    if (!iv) iv = staticAesIV;    if (1 != EVP_EncryptInit_ex(ctx, getAesCipher(keyLen), nullptr, (const unsigned char *)key, (const unsigned char *)iv))        throw makeEVPException(0, "Failed EVP_EncryptInit_ex");    /* Provide the message to be encrypted, and obtain the encrypted output.     * EVP_EncryptUpdate can be called multiple times if necessary     */    const size32_t cipherBlockSz = 128;    size32_t outMaxSz = inSz + cipherBlockSz/8;    size32_t startSz = out.length();    byte *outPtr = (byte *)out.reserveTruncate(outMaxSz);    int outSz;    if (1 != EVP_EncryptUpdate(ctx, (unsigned char *)outPtr, &outSz, (unsigned char *)inBytes, inSz))        throw makeEVPException(0, "Failed EVP_EncryptUpdate");    int ciphertext_len = outSz;    /* Finalise the encryption. Further ciphertext bytes may be written at     * this stage.     */    if (1 != EVP_EncryptFinal_ex(ctx, outPtr + outSz, &outSz))        throw makeEVPException(0, "Failed EVP_EncryptFinal_ex");    ciphertext_len += outSz;    out.setLength(startSz+ciphertext_len); // truncate length of 'out' to final size    return (size32_t)ciphertext_len;}

int Crypt::enc_data(uint8_t *plain_text, int plain_text_len, uint8_t *cipher_text, uint64_t k_nas_enc) {	EVP_CIPHER_CTX *ctx;	int len;	int cipher_text_len;	if (!(ctx = EVP_CIPHER_CTX_new())) {		handle_crypt_error();	}	if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) {		handle_crypt_error();	}	if (1 != EVP_EncryptUpdate(ctx, cipher_text, &len, plain_text, plain_text_len)) {		handle_crypt_error();	}	cipher_text_len = len;	if (1 != EVP_EncryptFinal_ex(ctx, cipher_text + len, &len)) {		handle_crypt_error(); 	}	cipher_text_len += len;	EVP_CIPHER_CTX_free(ctx);	return cipher_text_len;}

intencrypt_data(const void *in, int inlen, void *out, int *outlen,             const void *iv, const void *key){    int len;    ERR_clear_error();    cryptutil_init();    /* In this we are using 256 bit AES (i.e. a 256 bit key). The     * IV size for *most* modes is the same as the block size. For AES this     * is 128 bits */    if(EVP_EncryptInit_ex(&ctx, EVP_aes_256_cbc(), NULL, key, iv) != 1) {        log_crypt_err("Not able to initialize encrypt context for AES-256");        return 0;    }    /* Provide the message to be encrypted, and obtain the encrypted output */    if(EVP_EncryptUpdate(&ctx, out, &len, in, inlen) != 1) {        log_crypt_err("Not able to encrypt using AES-256");        return 0;    }    *outlen = len;    /* Finalise the encryption. Further ciphertext bytes may be written at     * this stage     */    if(EVP_EncryptFinal_ex(&ctx, out + len, &len) != 1) {        log_crypt_err("Not able to finalize encryption using AES-256");        return 0;    }    *outlen += len;    return 1;}

/* * aes_icm_set_iv(c, iv) sets the counter value to the exor of iv with * the offset */err_status_t aes_icm_openssl_set_iv (aes_icm_ctx_t *c, void *iv, int dir){    const EVP_CIPHER *evp;    v128_t nonce;    /* set nonce (for alignment) */    v128_copy_octet_string(&nonce, iv);    debug_print(mod_aes_icm, "setting iv: %s", v128_hex_string(&nonce));    v128_xor(&c->counter, &c->offset, &nonce);    debug_print(mod_aes_icm, "set_counter: %s", v128_hex_string(&c->counter));    switch (c->key_size) {    case AES_256_KEYSIZE:        evp = EVP_aes_256_ctr();        break;#ifndef BORINGSSL    case AES_192_KEYSIZE:        evp = EVP_aes_192_ctr();        break;#endif    case AES_128_KEYSIZE:        evp = EVP_aes_128_ctr();        break;    default:        return err_status_bad_param;        break;    }    if (!EVP_EncryptInit_ex(&c->ctx, evp,                            NULL, c->key.v8, c->counter.v8)) {        return err_status_fail;    } else {        return err_status_ok;    }}

bool CryptFileDevice::flush(){    if (!m_encrypted)        return false;    if (m_wasFlushed)        return true;    if (m_buffer.isEmpty())        return false;    m_wasFlushed = true;    int len = m_buffer.length();    int maxCipherLen = len + AES_BLOCK_SIZE - (len % AES_BLOCK_SIZE) + AES_BLOCK_SIZE;    int finalLen = 0;    unsigned char *cipherText = new unsigned char[maxCipherLen];    EVP_EncryptInit_ex(&m_encCtx, NULL, NULL, NULL, NULL);    EVP_EncryptUpdate(&m_encCtx, cipherText, &maxCipherLen, (unsigned char *)m_buffer.data(), len);    EVP_EncryptFinal_ex(&m_encCtx, &cipherText[maxCipherLen], &finalLen);    len = maxCipherLen;    if (m_device->pos() >= m_device->size())        len += finalLen;    m_device->write((char *)cipherText, len);    delete[] cipherText;    m_blockFlush = true;    seek(pos() + m_buffer.length());    m_blockFlush = false;    m_wasSought = false;    m_buffer.clear();    return true;}

int s3fs::Crypto::encrypt_block(const unsigned char plain[], int inlen, unsigned char outbuf[]){    int outlen;    int tmplen;    EVP_CIPHER_CTX_init(&ctx);    EVP_CIPHER_CTX_set_padding(&ctx, 1L);    EVP_EncryptInit_ex(&ctx, EVP_aes_256_ctr() , NULL, key, iv);        if(!EVP_EncryptUpdate(&ctx, outbuf, &outlen, plain, inlen))    {        cerr << "An error has occurred while encrypting the plain text." << endl;        EVP_CIPHER_CTX_cleanup(&ctx);    }    if(!EVP_EncryptFinal_ex(&ctx, outbuf + outlen, &tmplen))    {        cerr << "An error has occurred while encrypting the plain text." << endl;        EVP_CIPHER_CTX_cleanup(&ctx);    }    outlen += tmplen;    EVP_CIPHER_CTX_cleanup(&ctx);    return outlen;}

       bool AESCipher::init2(unsigned char *key_data, int key_data_len)    {        int i, nrounds = 1;        unsigned char key[32], iv[32];        /*        * Gen key & IV for AES 256 CBC mode. A SHA1 digest is used to hash the supplied key material.        * nrounds is the number of times the we hash the material. More rounds are more secure but        * slower.        */        i = EVP_BytesToKey(EVP_aes_256_cfb(), EVP_md5(), NULL, key_data, key_data_len, nrounds, key, iv);        if (i != 32) {            //printf("Key size is %d bits - should be 256 bits/n", i);            return false;        }        EVP_CIPHER_CTX_init(&m_ectx);        EVP_EncryptInit_ex(&m_ectx, EVP_aes_256_cfb(), NULL, key, iv);        EVP_CIPHER_CTX_init(&m_dctx);        EVP_DecryptInit_ex(&m_dctx, EVP_aes_256_cfb(), NULL, key, iv);        return true;    }

/* * Encrypt *len bytes of data * All data going in & out is considered binary (unsigned char[]) */unsigned char *crypto_aes_encrypt(EVP_CIPHER_CTX *e, unsigned char *plaintext,		int *len){	/* max ciphertext len for a n bytes of plaintext is	 * n + AES_BLOCK_SIZE -1 bytes */	int c_len = *len + AES_BLOCK_SIZE - 1, f_len = 0;	unsigned char *ciphertext = (unsigned char *)malloc(c_len);	if(ciphertext == NULL) {		LM_ERR("no more system memory/n");		return NULL;	}	/* allows reusing of 'e' for multiple encryption cycles */	if(!EVP_EncryptInit_ex(e, NULL, NULL, NULL, NULL)){		LM_ERR("failure in EVP_EncryptInit_ex /n");		free(ciphertext);		return NULL;	}	/* update ciphertext, c_len is filled with the length of ciphertext	 * generated, *len is the size of plaintext in bytes */	if(!EVP_EncryptUpdate(e, ciphertext, &c_len, plaintext, *len)){		LM_ERR("failure in EVP_EncryptUpdate /n");		free(ciphertext);		return NULL;	}	/* update ciphertext with the final remaining bytes */	if(!EVP_EncryptFinal_ex(e, ciphertext+c_len, &f_len)){		LM_ERR("failure in EVP_EncryptFinal_ex /n");		free(ciphertext);		return NULL;	}	*len = c_len + f_len;	return ciphertext;}

// General secure AES 256 CBC encryption routinebool OldEncryptAES256(const SecureString& sKey, const SecureString& sPlaintext, const std::string& sIV, std::string& sCiphertext){    // max ciphertext len for a n bytes of plaintext is    // n + AES_BLOCK_SIZE - 1 bytes    int nLen = sPlaintext.size();    int nCLen = nLen + AES_BLOCK_SIZE;    int nFLen = 0;    // Verify key sizes    if(sKey.size() != 32 || sIV.size() != AES_BLOCK_SIZE) {        LogPrintf("crypter EncryptAES256 - Invalid key or block size: Key: %d sIV:%d/n", sKey.size(), sIV.size());        return false;    }    // Prepare output buffer    sCiphertext.resize(nCLen);    // Perform the encryption    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();    if (!ctx) return false;    bool fOk = true;    EVP_CIPHER_CTX_init(ctx);    if (fOk) fOk = EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, (const unsigned char*) &sKey[0], (const unsigned char*) &sIV[0]);    if (fOk) fOk = EVP_EncryptUpdate(ctx, (unsigned char*) &sCiphertext[0], &nCLen, (const unsigned char*) &sPlaintext[0], nLen);    if (fOk) fOk = EVP_EncryptFinal_ex(ctx, (unsigned char*) (&sCiphertext[0])+nCLen, &nFLen);    EVP_CIPHER_CTX_cleanup(ctx);    EVP_CIPHER_CTX_free(ctx);    if (!fOk) return false;    sCiphertext.resize(nCLen + nFLen);    return true;}

/** * Create an 256 bit key and IV using the supplied key_data and salt. * Fills in the encryption and decryption ctx objects and returns 0 on success */int crypto_aes_init(unsigned char *key_data, int key_data_len,		unsigned char *salt, EVP_CIPHER_CTX *e_ctx, EVP_CIPHER_CTX *d_ctx){	int i, nrounds = 5;	int x;	unsigned char key[32], iv[32];	/*	 * Gen key & IV for AES 256 CBC mode. A SHA1 digest is used to hash	 * the supplied key material.	 * nrounds is the number of times the we hash the material. More rounds	 * are more secure but slower.	 */	i = EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha1(), salt,			key_data, key_data_len, nrounds, key, iv);	if (i != 32) {		LM_ERR("key size is %d bits - should be 256 bits/n", i);		return -1;	}	for(x = 0; x<32; ++x)		LM_DBG("key: %x iv: %x /n", key[x], iv[x]);	for(x = 0; x<8; ++x)		LM_DBG("salt: %x/n", salt[x]);	if(e_ctx) {		EVP_CIPHER_CTX_init(e_ctx);		EVP_EncryptInit_ex(e_ctx, EVP_aes_256_cbc(), NULL, key, iv);	}	if(d_ctx) {		EVP_CIPHER_CTX_init(d_ctx);		EVP_DecryptInit_ex(d_ctx, EVP_aes_256_cbc(), NULL, key, iv);	}	return 0;}

int aes_encrypt(EVP_CIPHER_CTX *e,int in,int out )	 /* this function encryptes the  file:fd is passed as parameter */{	char inbuf [SIZE];	char outbuf[SIZE+AES_BLOCK_SIZE];		int inlen = 0,flen=0,outlen =0;				if(!EVP_EncryptInit_ex(e, NULL, NULL, NULL, NULL)) 				/* allows reusing of e for multiple cipher cycles */	{		perror("/n Error,ENCRYPR_INIT:");		return 1;	}	while((inlen = read(in,inbuf,SIZE)) > 0)	{		if(!EVP_EncryptUpdate(e,(unsigned char*) outbuf, &outlen,(unsigned char*) inbuf,inlen)) 		/* Update cipher text */		{			perror("/n ERROR,ENCRYPR_UPDATE:");			return 1;		}		if(write(out,outbuf,outlen) != outlen)			{			perror("/n ERROR,Cant write encrypted bytes to outfile:");			return 1;		}		}	if(!EVP_EncryptFinal_ex(e, (unsigned char*) outbuf, &flen)) 			/* updates the remaining bytes */	{		perror("/n ERROR,ENCRYPT_FINAL:");		return 1;	}	if(write(out,outbuf,flen) != flen)	{		perror("/n ERROR,Wriring final bytes of data:");		return 1;	}	return 0;	}

/* * AES encrypt plaintext */unsigned char *oidc_crypto_aes_encrypt(request_rec *r, oidc_cfg *cfg,		unsigned char *plaintext, int *len) {	if (oidc_crypto_init(cfg, r->server) == FALSE)		return NULL;	/* max ciphertext len for a n bytes of plaintext is n + AES_BLOCK_SIZE -1 bytes */	int c_len = *len + AES_BLOCK_SIZE, f_len = 0;	unsigned char *ciphertext = apr_palloc(r->pool, c_len);	/* allows reusing of 'e' for multiple encryption cycles */	if (!EVP_EncryptInit_ex(cfg->encrypt_ctx, NULL, NULL, NULL, NULL)) {		oidc_error(r, "EVP_EncryptInit_ex failed: %s",				ERR_error_string(ERR_get_error(), NULL));		return NULL;	}	/* update ciphertext, c_len is filled with the length of ciphertext generated, len is the size of plaintext in bytes */	if (!EVP_EncryptUpdate(cfg->encrypt_ctx, ciphertext, &c_len, plaintext,			*len)) {		oidc_error(r, "EVP_EncryptUpdate failed: %s",				ERR_error_string(ERR_get_error(), NULL));		return NULL;	}	/* update ciphertext with the final remaining bytes */	if (!EVP_EncryptFinal_ex(cfg->encrypt_ctx, ciphertext + c_len, &f_len)) {		oidc_error(r, "EVP_EncryptFinal_ex failed: %s",				ERR_error_string(ERR_get_error(), NULL));		return NULL;	}	*len = c_len + f_len;	return ciphertext;}

/** * Create an 256 bit key and IV using the supplied key_data. salt can be added for taste. * Fills in the encryption and decryption ctx objects and returns 0 on success **/bool OpensslAES::init(const QByteArray &keyData,                         const QByteArray &saltData){    int i, nrounds = 5;    unsigned char key[32], iv[32];    const EVP_CIPHER *evpCipher = getEvpCipher();    if (evpCipher == 0)        return false;    /* 8 bytes (required EVP_BytesToKey) to salt the key_data during key generation. */    unsigned char salt[8] = {0xAD, 0x7E, 0xF8, 0x14, 0x92, 0x31,0x2B, 0x3F};    QByteArray saltDataHash = QCryptographicHash::hash(saltData, QCryptographicHash::Md5);    memcpy(salt, saltDataHash.constData(), 8);    /*     * Gen key & IV for choosen algoritm. A SHA1 digest is used to hash the supplied key material.     * nrounds is the number of times the we hash the material. More rounds are more secure but     * slower.     */    i = EVP_BytesToKey(evpCipher, EVP_sha1(), salt,                       (const unsigned char*) keyData.constData(), keyData.size(),                       nrounds, key, iv);    if (i*8 != m_blockSize) { // i*8 = blocksize in bits        printf("Key size is %d bytes - should be %d bits/n", i, m_blockSize);        return false;    }    EVP_CIPHER_CTX_init(&m_encoder);    EVP_EncryptInit_ex(&m_encoder, evpCipher, 0, key, iv);    EVP_CIPHER_CTX_init(&m_decoder);    EVP_DecryptInit_ex(&m_decoder, evpCipher, 0, key, iv);    return true;}

QString UBCryptoUtils::symetricEncrypt(const QString& clear){    QByteArray clearData = clear.toUtf8();    int cipheredLength = clearData.length() + AES_BLOCK_SIZE;    int paddingLength = 0;    unsigned char *ciphertext = (unsigned char *)malloc(cipheredLength);    if(!EVP_EncryptInit_ex(&mAesEncryptContext, NULL, NULL, NULL, NULL))        return QString();    if(!EVP_EncryptUpdate(&mAesEncryptContext, ciphertext, &cipheredLength, (unsigned char *)clearData.data(), clearData.length()))        return QString();    /* update ciphertext with the final remaining bytes */    if(!EVP_EncryptFinal_ex(&mAesEncryptContext, ciphertext + cipheredLength, &paddingLength))        return QString();    QByteArray cipheredData((const char *)ciphertext, cipheredLength + paddingLength);    free(ciphertext);    return QString::fromAscii(cipheredData.toBase64());}

bool CCrypter::Encrypt(const CKeyingMaterial& vchPlaintext, std::vector<unsigned char> &vchCiphertext){    if (!fKeySet)        return false;    // max ciphertext len for a n bytes of plaintext is    // n + AES_BLOCK_SIZE - 1 bytes    int nLen = vchPlaintext.size();    int nCLen = nLen + AES_BLOCK_SIZE, nFLen = 0;    vchCiphertext = std::vector<unsigned char> (nCLen);    EVP_CIPHER_CTX ctx;    EVP_CIPHER_CTX_init(&ctx);    EVP_EncryptInit_ex(&ctx, EVP_aes_256_cbc(), NULL, chKey, chIV);    EVP_EncryptUpdate(&ctx, &vchCiphertext[0], &nCLen, &vchPlaintext[0], nLen);    EVP_EncryptFinal_ex(&ctx, (&vchCiphertext[0])+nCLen, &nFLen);    EVP_CIPHER_CTX_cleanup(&ctx);    vchCiphertext.resize(nCLen + nFLen);    return true;}

static int do_encrypt(EVP_CIPHER_CTX* aes256, pubnub_bymebl_t msg, uint8_t const* key, uint8_t const* iv, pubnub_bymebl_t *encrypted){    int len = 0;    if (!EVP_EncryptInit_ex(aes256, EVP_aes_256_cbc(), NULL, key, iv)) {        ERR_print_errors_cb(print_to_pubnub_log, NULL);        PUBNUB_LOG_ERROR("Failed to initialize AES-256 encryption/n");        return -1;    }    if (!EVP_EncryptUpdate(aes256, encrypted->ptr, &len, msg.ptr, msg.size)) {        ERR_print_errors_cb(print_to_pubnub_log, NULL);        PUBNUB_LOG_ERROR("Failed to AES-256 encrypt the mesage/n");        return -1;    }    encrypted->size = len;    if (!EVP_EncryptFinal_ex(aes256, encrypted->ptr + len, &len)) {        ERR_print_errors_cb(print_to_pubnub_log, NULL);        PUBNUB_LOG_ERROR("Failed to finalize AES-256 encryption/n");        return -1;    }    encrypted->size += len;        return 0;}

int crypto_aes_encrypt (crypto_aes_t *crypto,                        const void *src,                        unsigned int src_size,                        void *dst,                        unsigned int *dst_size){    EVP_CIPHER_CTX *e = &(crypto->enc);    int psize = 0;    int fsize = 0;    /* allows reusing of 'e' for multiple encryption cycles */    if (!EVP_EncryptInit_ex(e, NULL, NULL, NULL, NULL)) {        pthread_mutex_unlock(&(crypto->lock));        return(-1);    }    /* update ciphertext, c_len is filled with the length of ciphertext     * generated, *len is the size of plaintext in bytes     */    if (!EVP_EncryptUpdate(e, dst, &psize, src, src_size)) {        pthread_mutex_unlock(&(crypto->lock));        return(-2);    }    /* update ciphertext with the final remaining bytes */    if (!EVP_EncryptFinal_ex(e, dst + psize, &fsize)) {        pthread_mutex_unlock(&(crypto->lock));        return(-3);    }    if (dst_size != NULL)        *dst_size = psize + fsize;    pthread_mutex_unlock(&(crypto->lock));    return(0);}

        OpenSSLSymmetricCipherContext OpenSSLSymmetricCipher::start(OpenSSLSymmetricCipher::Method method, const SymmetricKey& key, const InitializationVector& iv, bool padding)        {            OpenSSLSymmetricCipherContext context(method);            int r = 0;            const EVP_CIPHER* evpCipher = getEVPCipher(key);            EXCEPTION_ASSERT(evpCipher, std::invalid_argument, "No cipher found that can use the supplied key");            switch (context.method())            {            case M_ENCRYPT:            {                r = EVP_EncryptInit_ex(context.ctx(), evpCipher, NULL, &key.data()[0], &iv.data()[0]);                break;            }            case M_DECRYPT:            {                r = EVP_DecryptInit_ex(context.ctx(), evpCipher, NULL, &key.data()[0], &iv.data()[0]);                break;            }            default:            {                THROW_EXCEPTION_WITH_LOG(std::runtime_error, "Unhandled method");            }            }            EXCEPTION_ASSERT_WITH_LOG(r == 1, OpenSSLException, "");            context.data().clear();            context.setPadding(padding);            return context;        }

/* * Encrypt *len bytes of data * All data going in & out is considered binary (unsigned char[]) */unsigned char *aes_encrypt(EVP_CIPHER_CTX *e, unsigned char *plaintext, int *len, int *retlen){  /* max ciphertext len for a n bytes of plaintext is n + AES_BLOCK_SIZE -1 bytes */	int rc=0;  int c_len = *len + AES_BLOCK_SIZE, f_len = 0;	//fprintf(stderr, "Line: %d -- len: %d , c_len: %d , f_len: %d/n", __LINE__, *len, c_len, f_len);  unsigned char *ciphertext = malloc(c_len);  /* allows reusing of 'e' for multiple encryption cycles */	rc=EVP_EncryptInit_ex(e, NULL, NULL, NULL, NULL);//  rc=EVP_EncryptInit_ex(e, EVP_aes_256_cbc(), NULL, key, iv);	assert(rc==1);  /* update ciphertext, c_len is filled with the length of ciphertext generated,    *len is the size of plaintext in bytes */  rc=EVP_EncryptUpdate(e, ciphertext, &c_len, plaintext, *len);	assert(rc==1);  /* update ciphertext with the final remaining bytes */	  rc=EVP_EncryptFinal_ex(e, ciphertext+c_len, &f_len);		assert(rc==1);  *len = c_len + f_len;  return ciphertext;}

int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp,           char *x, const EVP_CIPHER *enc, unsigned char *kstr,           int klen, pem_password_cb *callback, void *u)  {  EVP_CIPHER_CTX ctx;  int dsize=0,i,j,ret=0;  unsigned char *p,*data=NULL;  const char *objstr=NULL;  char buf[PEM_BUFSIZE];  unsigned char key[EVP_MAX_KEY_LENGTH];  unsigned char iv[EVP_MAX_IV_LENGTH];    if (enc != NULL)    {    objstr=OBJ_nid2sn(EVP_CIPHER_nid(enc));    if (objstr == NULL)      {      PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,PEM_R_UNSUPPORTED_CIPHER);      goto err;      }    }  if ((dsize=i2d(x,NULL)) < 0)    {    PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,ERR_R_ASN1_LIB);    dsize=0;    goto err;    }  /* dzise + 8 bytes are needed */  /* actually it needs the cipher block size extra... */  data=(unsigned char *)OPENSSL_malloc((unsigned int)dsize+20);  if (data == NULL)    {    PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,ERR_R_MALLOC_FAILURE);    goto err;    }  p=data;  i=i2d(x,&p);  if (enc != NULL)    {    if (kstr == NULL)      {      if (callback == NULL)        klen=PEM_def_callback(buf,PEM_BUFSIZE,1,u);      else        klen=(*callback)(buf,PEM_BUFSIZE,1,u);      if (klen <= 0)        {        PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,PEM_R_READ_KEY);        goto err;        }#ifdef CHARSET_EBCDIC      /* Convert the pass phrase from EBCDIC */      ebcdic2ascii(buf, buf, klen);#endif      kstr=(unsigned char *)buf;      }    RAND_add(data,i,0);/* put in the RSA key. */    OPENSSL_assert(enc->iv_len <= (int)sizeof(iv));    if (RAND_pseudo_bytes(iv,enc->iv_len) < 0) /* Generate a salt */      goto err;    /* The 'iv' is used as the iv and as a salt.  It is     * NOT taken from the BytesToKey function */    EVP_BytesToKey(enc,EVP_md5(),iv,kstr,klen,1,key,NULL);    if (kstr == (unsigned char *)buf) OPENSSL_cleanse(buf,PEM_BUFSIZE);    OPENSSL_assert(strlen(objstr)+23+2*enc->iv_len+13 <= sizeof buf);    buf[0]='/0';    PEM_proc_type(buf,PEM_TYPE_ENCRYPTED);    PEM_dek_info(buf,objstr,enc->iv_len,(char *)iv);    /* k=strlen(buf); */    EVP_CIPHER_CTX_init(&ctx);    EVP_EncryptInit_ex(&ctx,enc,NULL,key,iv);    EVP_EncryptUpdate(&ctx,data,&j,data,i);    EVP_EncryptFinal_ex(&ctx,&(data[j]),&i);    EVP_CIPHER_CTX_cleanup(&ctx);    i+=j;    ret=1;    }  else    {    ret=1;    buf[0]='/0';    }  i=PEM_write_bio(bp,name,buf,data,i);  if (i <= 0) ret=0;err:  OPENSSL_cleanse(key,sizeof(key));  OPENSSL_cleanse(iv,sizeof(iv));  OPENSSL_cleanse((char *)&ctx,sizeof(ctx));  OPENSSL_cleanse(buf,PEM_BUFSIZE);  if (data != NULL)    {    OPENSSL_cleanse(data,(unsigned int)dsize);    OPENSSL_free(data);    }//.........这里部分代码省略.........

intseafile_encrypt (char **data_out,                 int *out_len,                 const char *data_in,                 const int in_len,                 SeafileCrypt *crypt){    *data_out = NULL;    *out_len = -1;    /* check validation */    if ( data_in == NULL || in_len <= 0 || crypt == NULL) {        g_warning ("Invalid params./n");        return -1;    }    EVP_CIPHER_CTX ctx;    int ret;    int blks;    /* Prepare CTX for encryption. */    EVP_CIPHER_CTX_init (&ctx);    if (crypt->version >= 1)        ret = EVP_EncryptInit_ex (&ctx,                                  EVP_aes_128_cbc(), /* cipher mode */                                  NULL, /* engine, NULL for default */                                  crypt->key,  /* derived key */                                  crypt->iv);  /* initial vector */    else        ret = EVP_EncryptInit_ex (&ctx,                                  EVP_aes_128_ecb(), /* cipher mode */                                  NULL, /* engine, NULL for default */                                  crypt->key,  /* derived key */                                  crypt->iv);  /* initial vector */    if (ret == ENC_FAILURE)        return -1;    /* Allocating output buffer. */        /*      For EVP symmetric encryption, padding is always used __even if__      data size is a multiple of block size, in which case the padding      length is the block size. so we have the following:    */        blks = (in_len / BLK_SIZE) + 1;    *data_out = (char *)g_malloc (blks * BLK_SIZE);    if (*data_out == NULL) {        g_warning ("failed to allocate the ouput buffer./n");        goto enc_error;    }                    int update_len, final_len;    /* Do the encryption. */    ret = EVP_EncryptUpdate (&ctx,                             (unsigned char*)*data_out,                             &update_len,                             (unsigned char*)data_in,                             in_len);    if (ret == ENC_FAILURE)        goto enc_error;    /* Finish the possible partial block. */    ret = EVP_EncryptFinal_ex (&ctx,                               (unsigned char*)*data_out + update_len,                               &final_len);    *out_len = update_len + final_len;    /* out_len should be equal to the allocated buffer size. */    if (ret == ENC_FAILURE || *out_len != (blks * BLK_SIZE))        goto enc_error;        EVP_CIPHER_CTX_cleanup (&ctx);    return 0;enc_error:    EVP_CIPHER_CTX_cleanup (&ctx);    *out_len = -1;    if (*data_out != NULL)        g_free (*data_out);    *data_out = NULL;    return -1;    }

static int dh_cms_set_shared_info(EVP_PKEY_CTX *pctx, CMS_RecipientInfo *ri){    int rv = 0;    X509_ALGOR *alg, *kekalg = NULL;    ASN1_OCTET_STRING *ukm;    const unsigned char *p;    unsigned char *dukm = NULL;    size_t dukmlen = 0;    int keylen, plen;    const EVP_CIPHER *kekcipher;    EVP_CIPHER_CTX *kekctx;    if (!CMS_RecipientInfo_kari_get0_alg(ri, &alg, &ukm))        goto err;    /*     * For DH we only have one OID permissible. If ever any more get defined     * we will need something cleverer.     */    if (OBJ_obj2nid(alg->algorithm) != NID_id_smime_alg_ESDH) {        DHerr(DH_F_DH_CMS_SET_SHARED_INFO, DH_R_KDF_PARAMETER_ERROR);        goto err;    }    if (EVP_PKEY_CTX_set_dh_kdf_type(pctx, EVP_PKEY_DH_KDF_X9_42) <= 0)        goto err;    if (EVP_PKEY_CTX_set_dh_kdf_md(pctx, EVP_sha1()) <= 0)        goto err;    if (alg->parameter->type != V_ASN1_SEQUENCE)        goto err;    p = alg->parameter->value.sequence->data;    plen = alg->parameter->value.sequence->length;    kekalg = d2i_X509_ALGOR(NULL, &p, plen);    if (!kekalg)        goto err;    kekctx = CMS_RecipientInfo_kari_get0_ctx(ri);    if (!kekctx)        goto err;    kekcipher = EVP_get_cipherbyobj(kekalg->algorithm);    if (!kekcipher || EVP_CIPHER_mode(kekcipher) != EVP_CIPH_WRAP_MODE)        goto err;    if (!EVP_EncryptInit_ex(kekctx, kekcipher, NULL, NULL, NULL))        goto err;    if (EVP_CIPHER_asn1_to_param(kekctx, kekalg->parameter) <= 0)        goto err;    keylen = EVP_CIPHER_CTX_key_length(kekctx);    if (EVP_PKEY_CTX_set_dh_kdf_outlen(pctx, keylen) <= 0)        goto err;    /* Use OBJ_nid2obj to ensure we use built in OID that isn't freed */    if (EVP_PKEY_CTX_set0_dh_kdf_oid(pctx,                                     OBJ_nid2obj(EVP_CIPHER_type(kekcipher)))        <= 0)        goto err;    if (ukm) {        dukmlen = ASN1_STRING_length(ukm);        dukm = BUF_memdup(ASN1_STRING_data(ukm), dukmlen);        if (!dukm)            goto err;    }    if (EVP_PKEY_CTX_set0_dh_kdf_ukm(pctx, dukm, dukmlen) <= 0)        goto err;    dukm = NULL;    rv = 1; err:    if (kekalg)        X509_ALGOR_free(kekalg);    if (dukm)        OPENSSL_free(dukm);    return rv;}