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

static intdecrypt_token (CcnetProcessor *processor){    USE_PRIV;    int hex_len, encrypted_len, token_len;     char *encrypted_token = NULL;    SeafileCrypt *crypt = NULL;    unsigned char key[16], iv[16];    char *token = NULL;    int ret = 0;    /* raw data is half the length of hexidecimal */    hex_len = strlen(priv->token);    if (hex_len % 2 != 0) {        seaf_warning ("[check tx slave v3] invalid length of encrypted token/n");         ret = -1;        goto out;    }    encrypted_len = hex_len / 2;    encrypted_token = g_malloc (encrypted_len);    hex_to_rawdata (priv->token,                    (unsigned char *)encrypted_token,                    encrypted_len);    EVP_BytesToKey (EVP_aes_128_cbc(), /* cipher mode */                    EVP_sha1(),        /* message digest */                    NULL,              /* slat */                    (unsigned char*)priv->session_key,                    strlen(priv->session_key),                    1,   /* iteration times */                    key, /* the derived key */                    iv); /* IV, initial vector */    crypt = seafile_crypt_new (1, key, iv);        if (seafile_decrypt (&token, &token_len, encrypted_token,                         encrypted_len, crypt) < 0) {        seaf_warning ("[check tx slave v3] failed to decrypt token/n");        ret = -1;        goto out;    }    g_free (priv->token);    /* we can use the decrypted data directly, since the trailing null byte is     * also included when encrypting in the client */    priv->token = token;out:    g_free (crypt);    g_free (encrypted_token);        return ret;}

static const EVP_CIPHER * typeToCIPHER(Cipher::Type t){	if(t == Cipher::TripleDES)		return EVP_des_ede3_cbc();	else if(t == Cipher::AES_128)		return EVP_aes_128_cbc();	else if(t == Cipher::AES_256)		return EVP_aes_256_cbc();	else		return 0;}

static const EVP_CIPHER* cipher_by_name(const char *name) {  if (strcmp(name, "DES-CBC") == 0) {    return EVP_des_cbc();  } else if (strcmp(name, "AES-128-CBC") == 0) {    return EVP_aes_128_cbc();  } else if (strcmp(name,  "AES-256-CBC") == 0) {    return EVP_aes_256_cbc();  } else {    return NULL;  }}

static const EVP_CIPHER * _wi_cipher_cipher(wi_cipher_t *cipher) {	switch(cipher->type) {		case WI_CIPHER_AES128:		return EVP_aes_128_cbc();		case WI_CIPHER_AES192:		return EVP_aes_192_cbc();		case WI_CIPHER_AES256:		return EVP_aes_256_cbc();		case WI_CIPHER_BF128:		return EVP_bf_cbc();		case WI_CIPHER_3DES192:		return EVP_des_ede3_cbc();	}		return NULL;}

int decrypt_and_verify_secrets(CPOR_key *key, unsigned char *input, size_t input_len, unsigned char *plaintext, size_t *plaintext_len, unsigned char *authenticator, size_t authenticator_len) {    EVP_CIPHER_CTX ctx;    EVP_CIPHER *cipher = NULL;    unsigned char mac[EVP_MAX_MD_SIZE];    size_t mac_size = EVP_MAX_MD_SIZE;    int len;    if(!key || !key->k_enc || !key->k_mac || !input || !input_len || !plaintext || !plaintext_len || !authenticator || !authenticator_len) return 0;    OpenSSL_add_all_algorithms();    memset(mac, 0, mac_size);    /* Verify the HMAC-SHA1 */    if(!HMAC(EVP_sha1(), key->k_mac, key->k_mac_size, input, input_len, mac, (unsigned int *)&mac_size)) goto cleanup;    if(authenticator_len != mac_size) goto cleanup;    if(memcmp(mac, authenticator, mac_size) != 0) goto cleanup;    EVP_CIPHER_CTX_init(&ctx);    switch(key->k_enc_size) {    case 16:        cipher = (EVP_CIPHER *)EVP_aes_128_cbc();        break;    case 24:        cipher = (EVP_CIPHER *)EVP_aes_192_cbc();        break;    case 32:        cipher = (EVP_CIPHER *)EVP_aes_256_cbc();        break;    default:        return 0;    }    if(!EVP_DecryptInit(&ctx, cipher, key->k_enc, NULL)) goto cleanup;    *plaintext_len = 0;    if(!EVP_DecryptUpdate(&ctx, plaintext, (int *)plaintext_len, input, input_len)) goto cleanup;    EVP_DecryptFinal(&ctx, plaintext + *plaintext_len, &len);    *plaintext_len += len;    EVP_CIPHER_CTX_cleanup(&ctx);    return 1;cleanup:    *plaintext_len = 0;    return 0;}

void EVP_CIPHER_do_all_sorted(void (*callback)(const EVP_CIPHER *cipher,                                               const char *name,                                               const char *unused, void *arg),                              void *arg) {  callback(EVP_aes_128_cbc(), "AES-128-CBC", NULL, arg);  callback(EVP_aes_128_ctr(), "AES-128-CTR", NULL, arg);  callback(EVP_aes_128_ecb(), "AES-128-ECB", NULL, arg);  callback(EVP_aes_128_ofb(), "AES-128-OFB", NULL, arg);  callback(EVP_aes_256_cbc(), "AES-256-CBC", NULL, arg);  callback(EVP_aes_256_ctr(), "AES-256-CTR", NULL, arg);  callback(EVP_aes_256_ecb(), "AES-256-ECB", NULL, arg);  callback(EVP_aes_256_ofb(), "AES-256-OFB", NULL, arg);  callback(EVP_aes_256_xts(), "AES-256-XTS", NULL, arg);  callback(EVP_des_cbc(), "DES-CBC", NULL, arg);  callback(EVP_des_ecb(), "DES-ECB", NULL, arg);  callback(EVP_des_ede(), "DES-EDE", NULL, arg);  callback(EVP_des_ede_cbc(), "DES-EDE-CBC", NULL, arg);  callback(EVP_des_ede3_cbc(), "DES-EDE3-CBC", NULL, arg);  callback(EVP_rc2_cbc(), "RC2-CBC", NULL, arg);  callback(EVP_rc4(), "RC4", NULL, arg);  // OpenSSL returns everything twice, the second time in lower case.  callback(EVP_aes_128_cbc(), "aes-128-cbc", NULL, arg);  callback(EVP_aes_128_ctr(), "aes-128-ctr", NULL, arg);  callback(EVP_aes_128_ecb(), "aes-128-ecb", NULL, arg);  callback(EVP_aes_128_ofb(), "aes-128-ofb", NULL, arg);  callback(EVP_aes_256_cbc(), "aes-256-cbc", NULL, arg);  callback(EVP_aes_256_ctr(), "aes-256-ctr", NULL, arg);  callback(EVP_aes_256_ecb(), "aes-256-ecb", NULL, arg);  callback(EVP_aes_256_ofb(), "aes-256-ofb", NULL, arg);  callback(EVP_aes_256_xts(), "aes-256-xts", NULL, arg);  callback(EVP_des_cbc(), "des-cbc", NULL, arg);  callback(EVP_des_ecb(), "des-ecb", NULL, arg);  callback(EVP_des_ede(), "des-ede", NULL, arg);  callback(EVP_des_ede_cbc(), "des-ede-cbc", NULL, arg);  callback(EVP_des_ede3_cbc(), "des-ede3-cbc", NULL, arg);  callback(EVP_rc2_cbc(), "rc2-cbc", NULL, arg);  callback(EVP_rc4(), "rc4", NULL, arg);}

void *encfs_common_get_salt(char *ciphertext){	char *ctcopy = strdup(ciphertext);	char *keeptr = ctcopy;	int i;	char *p;	static encfs_common_custom_salt cs;	ctcopy += 7;	p = strtokm(ctcopy, "*");	cs.keySize = atoi(p);	switch(cs.keySize)	{		case 128:			cs.blockCipher = EVP_aes_128_cbc();			cs.streamCipher = EVP_aes_128_cfb();			break;		case 192:			cs.blockCipher = EVP_aes_192_cbc();			cs.streamCipher = EVP_aes_192_cfb();			break;		case 256:		default:			cs.blockCipher = EVP_aes_256_cbc();			cs.streamCipher = EVP_aes_256_cfb();			break;	}	cs.keySize = cs.keySize / 8;	p = strtokm(NULL, "*");	cs.iterations = atoi(p);	p = strtokm(NULL, "*");	cs.cipher = atoi(p);	p = strtokm(NULL, "*");	cs.saltLen = atoi(p);	p = strtokm(NULL, "*");	for (i = 0; i < cs.saltLen; i++)		cs.salt[i] =			atoi16[ARCH_INDEX(p[i * 2])] * 16 +			atoi16[ARCH_INDEX(p[i * 2 + 1])];	p = strtokm(NULL, "*");	cs.dataLen = atoi(p);	p = strtokm(NULL, "*");	for (i = 0; i < cs.dataLen; i++)		cs.data[i] =			atoi16[ARCH_INDEX(p[i * 2])] * 16 +			atoi16[ARCH_INDEX(p[i * 2 + 1])];	cs.ivLength = EVP_CIPHER_iv_length( cs.blockCipher );	MEM_FREE(keeptr);	return (void *) &cs;}

static const EVP_CIPHER *getAesCipher(size32_t keyLen){    switch (keyLen)    {    case 128/8:        return EVP_aes_128_cbc();    case 192/8:        return EVP_aes_192_cbc();    case 256/8:        return EVP_aes_256_cbc();    default:        throw makeStringException(0, "Invalid AES key size, must be 128, 192 or 256 bit");    }}

int encrypt_and_authentucate_secrets(CPOR_key *key, unsigned char *input, size_t input_len, unsigned char *ciphertext, size_t *ciphertext_len, unsigned char *authenticator, size_t *authenticator_len) {    EVP_CIPHER_CTX ctx;    EVP_CIPHER *cipher = NULL;    int len;    if(!key || !key->k_enc || !key->k_mac || !input || !input_len || !ciphertext || !ciphertext_len || !authenticator || !authenticator_len) return 0;    OpenSSL_add_all_algorithms();    EVP_CIPHER_CTX_init(&ctx);    switch(key->k_enc_size) {    case 16:        cipher = (EVP_CIPHER *)EVP_aes_128_cbc();        break;    case 24:        cipher = (EVP_CIPHER *)EVP_aes_192_cbc();        break;    case 32:        cipher = (EVP_CIPHER *)EVP_aes_256_cbc();        break;    default:        return 0;    }    //TODO: Fix the NULL IV    if(!EVP_EncryptInit(&ctx, cipher, key->k_enc, NULL)) goto cleanup;    *ciphertext_len = 0;    if(!EVP_EncryptUpdate(&ctx, ciphertext, (int *)ciphertext_len, input, input_len)) goto cleanup;    EVP_EncryptFinal(&ctx, ciphertext + *ciphertext_len, &len);    *ciphertext_len += len;    *authenticator_len = 0;    /* Do the HMAC-SHA1 */    if(!HMAC(EVP_sha1(), key->k_mac, key->k_mac_size, ciphertext, *ciphertext_len,             authenticator, (unsigned int *)authenticator_len)) goto cleanup;    EVP_CIPHER_CTX_cleanup(&ctx);    return 1;cleanup:    *ciphertext_len = 0;    *authenticator_len = 0;    return 0;}

bool AES_CBC_MAC_Validate(COSE_MacMessage * pcose, int TSize, const byte * pbKey, size_t cbKey, const byte * pbAuthData, size_t cbAuthData, cose_errback * perr){	const EVP_CIPHER * pcipher = NULL;	EVP_CIPHER_CTX ctx;	int cbOut;	byte rgbIV[16] = { 0 };	byte rgbTag[16] = { 0 };	bool f = false;	unsigned int i;	switch (cbKey*8) {	case 128:		pcipher = EVP_aes_128_cbc();		break;	case 256:		pcipher = EVP_aes_256_cbc();		break;	default:		FAIL_CONDITION(COSE_ERR_INVALID_PARAMETER);	}	//  Setup and run the OpenSSL code	EVP_CIPHER_CTX_init(&ctx);	CHECK_CONDITION(EVP_EncryptInit_ex(&ctx, pcipher, NULL, pbKey, rgbIV), COSE_ERR_CRYPTO_FAIL);	TSize /= 8;	for (i = 0; i < (unsigned int) cbAuthData / 16; i++) {		CHECK_CONDITION(EVP_EncryptUpdate(&ctx, rgbTag, &cbOut, pbAuthData+(i*16), 16), COSE_ERR_CRYPTO_FAIL);	}	if (cbAuthData % 16 != 0) {		CHECK_CONDITION(EVP_EncryptUpdate(&ctx, rgbTag, &cbOut, pbAuthData + (i * 16), cbAuthData % 16), COSE_ERR_CRYPTO_FAIL);		CHECK_CONDITION(EVP_EncryptUpdate(&ctx, rgbTag, &cbOut, rgbIV, 16 - (cbAuthData % 16)), COSE_ERR_CRYPTO_FAIL);	}	cn_cbor * cn = _COSE_arrayget_int(&pcose->m_message, INDEX_MAC_TAG);	CHECK_CONDITION(cn != NULL, COSE_ERR_CBOR);	for (i = 0; i < (unsigned int)TSize; i++) f |= (cn->v.bytes[i] != rgbTag[i]);	EVP_CIPHER_CTX_cleanup(&ctx);	return !f;errorReturn:	EVP_CIPHER_CTX_cleanup(&ctx);	return false;}

const EVP_CIPHER * Aes128EncriptionStrategy::getType(EncriptionBlockType mode){	const EVP_CIPHER * type;	switch(mode){		case CBC:			type = EVP_aes_128_cbc(); break;		case OFB:			type = EVP_aes_128_ofb(); break;		case CFB:			type = EVP_aes_128_cfb8(); break;		case ECB:			type = EVP_aes_128_ecb(); break;	}	return type;}

int decrypt(char *message, uint32_t message_size, char *password, char *plaintext){  EVP_CIPHER_CTX *ctx;  int len;  int plaintext_len;  char key[KEY_SIZE_BYTES];  int status = generateKey(password, SALT, key);  if(!status){    return -1;  }  const char *ciphertext = getEncryptedBody(message);  /* Create and initialise the context */  if(!(ctx = EVP_CIPHER_CTX_new())){    return -1;  }     /* Initialise the decryption 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_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, (unsigned char *) key, (unsigned char *) message)){    return -1;  }  /* Provide the message to be decrypted, and obtain the plaintext output.   * EVP_DecryptUpdate can be called multiple times if necessary   */  if(1 != EVP_DecryptUpdate(ctx, (unsigned char *) plaintext, &len, (unsigned char *) ciphertext, message_size - IV_SIZE_BYTES)){    return -1;  }  plaintext_len = len;  /* Finalise the decryption. Further plaintext bytes may be written at   * this stage.   */  if(1 != EVP_DecryptFinal_ex(ctx, (unsigned char *) plaintext + len, &len)){    return -1;  }   plaintext_len += len;  /* Clean up */  EVP_CIPHER_CTX_free(ctx);  return plaintext_len;}

intaes_init (crypt_data_t* crypt_data, crypt_init_t crypt_init){    const EVP_CIPHER* cipher = 0;    switch (crypt_data->keysize) {    case 16:        cipher = EVP_aes_128_cbc ();        break;    case 24:        cipher = EVP_aes_192_cbc ();        break;    case 32:        cipher = EVP_aes_256_cbc ();        break;    default:        fprintf (stderr, "Invalid key size./n");        return -1;    }    EVP_CIPHER_CTX_init (&crypt_data->ctx);    if (!crypt_init (&crypt_data->ctx,                     cipher,                     NULL,                     crypt_data->keybuf,                     crypt_data->ivbuf)) {        fprintf (stderr, "OpenSSL initialization failed./n");        return 1;    }    if (verbose) {        fprintf (stderr,                 "EVP Initialized/n  Algorithm: %s/n",                 EVP_CIPHER_name (EVP_CIPHER_CTX_cipher (&crypt_data->ctx)));        fprintf (stderr, "  IV:  ");        pp_buf (stderr, crypt_data->ivbuf, crypt_data->ivsize, 16, 2);        fprintf (stderr, "  Key: ");        pp_buf (stderr, crypt_data->keybuf, crypt_data->keysize, 16, 2);    }    crypt_data->buf_size = INBUFSIZE;    crypt_data->out_buf =        (char*)malloc (crypt_data->buf_size +                       EVP_CIPHER_CTX_block_size (&crypt_data->ctx));    crypt_data->in_buf = (char*)malloc (crypt_data->buf_size);    if (!crypt_data->out_buf || !crypt_data->in_buf) {        fprintf (stderr, "Unable to allocate memory./n");        return 1;    }    return 0;}

/* token -> AES encrypt with session key -> rawdata_to_hex -> output  */static char *encrypt_token (CcnetProcessor *processor, const char *token){    CcnetPeer *peer = NULL;    char *enc_out = NULL;    SeafileCrypt *crypt = NULL;    unsigned char key[16], iv[16];    int len;    char *output = NULL;    if (!token)        goto out;    peer = ccnet_get_peer(seaf->ccnetrpc_client, processor->peer_id);    if (!peer || !peer->session_key) {        seaf_warning ("[check tx v3] peer or peer session key not exist/n");        goto out;    }    EVP_BytesToKey (EVP_aes_128_cbc(), /* cipher mode */                    EVP_sha1(),        /* message digest */                    NULL,              /* slat */                    (unsigned char*)peer->session_key,                    strlen(peer->session_key),                    1,   /* iteration times */                    key, /* the derived key */                    iv); /* IV, initial vector */    crypt = seafile_crypt_new (CURRENT_ENC_VERSION, key, iv);        /* encrypt the token with session key, including the trailing null byte */    if (seafile_encrypt (&enc_out, &len, token, strlen(token) + 1, crypt) < 0) {        seaf_warning ("[check tx v3] failed to encrypt token/n");        goto out;    }    output = g_malloc (len * 2 + 1);    rawdata_to_hex ((unsigned char *)enc_out, output, len);    output[len * 2] = '/0';    out:    g_free (crypt);    g_free (enc_out);    if (peer)        g_object_unref(peer);    return output;}

int AesFileEnc::do_crypt(FILE *in, FILE *out, int do_encrypt, unsigned char* key){	/* Allow enough space in output buffer for additional block */	unsigned char inbuf[1024], outbuf[1024 + EVP_MAX_BLOCK_LENGTH];	int inlen, outlen;	EVP_CIPHER_CTX ctx;	std::cout << "tutaj";	//	std::cout <<key<<std::endl;	//unsigned char key[] = "0123456789abcdeF";	std::cout <<key<< std::endl;	//unsigned char iv[] = "1234567887654321";	EVP_CIPHER_CTX_init(&ctx);				EVP_CipherInit_ex(&ctx, EVP_aes_128_cbc(), NULL, NULL, NULL,				do_encrypt);				unsigned char *iv = this->iv(EVP_CIPHER_CTX_iv_length(&ctx));				std::cout<< this->keyLength << std::endl;			std::cout<< EVP_CIPHER_CTX_iv_length(&ctx) <<std::endl;			OPENSSL_assert(EVP_CIPHER_CTX_key_length(&ctx) == this->keyLength);			//OPENSSL_assert(EVP_CIPHER_CTX_iv_length(&ctx) == this->keyLength);			EVP_CipherInit_ex(&ctx, NULL, NULL, key, iv, do_encrypt);				for(;;)					{					inlen = fread(inbuf, 1, 1024, in);					if(inlen <= 0) break;					if(!EVP_CipherUpdate(&ctx, outbuf, &outlen, inbuf, inlen))							{								EVP_CIPHER_CTX_cleanup(&ctx);							return 0;							}					fwrite(outbuf, 1, outlen, out);					}			if(!EVP_CipherFinal_ex(&ctx, outbuf, &outlen))					{					EVP_CIPHER_CTX_cleanup(&ctx);					return 0;					}			fwrite(outbuf, 1, outlen, out);			EVP_CIPHER_CTX_cleanup(&ctx);			return 1;			}

/* * AES libcrypto */static int sb_aes_init(struct sb_image_ctx *ictx, uint8_t *iv, int enc){	EVP_CIPHER_CTX *ctx = &ictx->cipher_ctx;	int ret;	/* If there is no init vector, init vector is all zeroes. */	if (!iv)		iv = ictx->image_key;	EVP_CIPHER_CTX_init(ctx);	ret = EVP_CipherInit(ctx, EVP_aes_128_cbc(), ictx->image_key, iv, enc);	if (ret == 1)		EVP_CIPHER_CTX_set_padding(ctx, 0);	return ret;}

	explicit Cipher(Name name = N_AES128_CBC)		: cipher_(0)	{		EVP_CIPHER_CTX_init(&ctx_);		switch (name) {		case N_AES128_CBC: cipher_ = EVP_aes_128_cbc(); break;		case N_AES192_CBC: cipher_ = EVP_aes_192_cbc(); break;		case N_AES256_CBC: cipher_ = EVP_aes_256_cbc(); break;		case N_AES128_ECB: cipher_ = EVP_aes_128_ecb(); break;		case N_AES192_ECB: cipher_ = EVP_aes_192_ecb(); break;		case N_AES256_ECB: cipher_ = EVP_aes_256_ecb(); break;		default:			throw cybozu::Exception("crypto:Cipher:Cipher:name") << (int)name;		}	}

char* decryptToArray(FILE *ifp,char ckey[], char ivec[]) {    fseek(ifp, 0L, SEEK_END); int fsize = ftell(ifp);    fseek(ifp, 0L, SEEK_SET);    int outLen1 = 0; int outLen2 = 0; unsigned char *indata = malloc(fsize);    unsigned char *outdata = malloc(fsize);    fread(indata,sizeof(char),fsize, ifp);//Read Entire File    EVP_CIPHER_CTX ctx; EVP_DecryptInit(&ctx,EVP_aes_128_cbc(),ckey,ivec);    EVP_DecryptUpdate(&ctx,outdata,&outLen1,indata,fsize);    EVP_DecryptFinal(&ctx,outdata + outLen1,&outLen2);    return(outdata); }

/** Get cipher by name constants. * @param cipher cipher name * @return cipher engine */const EVP_CIPHER *cipher_by_name(const char *cipher){  if (strcmp(cipher, LN_aes_128_ecb) == 0) {    return EVP_aes_128_ecb();  } else if (strcmp(cipher, LN_aes_128_cbc) == 0) {    return EVP_aes_128_cbc();  } else if (strcmp(cipher, LN_aes_256_ecb) == 0) {    return EVP_aes_256_ecb();  } else if (strcmp(cipher, LN_aes_256_cbc) == 0) {    return EVP_aes_256_cbc();  } else {    throw std::runtime_error("Unknown cipher type");  }}

/* convert SSH v2 key in OpenSSL PEM format */static intsshkey_private_pem_to_blob(struct sshkey *key, struct sshbuf *blob,    const char *_passphrase, const char *comment){	int success, r;	int blen, len = strlen(_passphrase);	u_char *passphrase = (len > 0) ? (u_char *)_passphrase : NULL;	const EVP_CIPHER *cipher = (len > 0) ? EVP_aes_128_cbc() : NULL;	const u_char *bptr;	BIO *bio = NULL;	if (len > 0 && len <= 4)		return SSH_ERR_PASSPHRASE_TOO_SHORT;	if ((bio = BIO_new(BIO_s_mem())) == NULL)		return SSH_ERR_ALLOC_FAIL;	switch (key->type) {	case KEY_DSA:		success = PEM_write_bio_DSAPrivateKey(bio, key->dsa,		    cipher, passphrase, len, NULL, NULL);		break;	case KEY_ECDSA:		success = PEM_write_bio_ECPrivateKey(bio, key->ecdsa,		    cipher, passphrase, len, NULL, NULL);		break;	case KEY_RSA:		success = PEM_write_bio_RSAPrivateKey(bio, key->rsa,		    cipher, passphrase, len, NULL, NULL);		break;	default:		success = 0;		break;	}	if (success == 0) {		r = SSH_ERR_LIBCRYPTO_ERROR;		goto out;	}	if ((blen = BIO_get_mem_data(bio, &bptr)) <= 0) {		r = SSH_ERR_INTERNAL_ERROR;		goto out;	}	if ((r = sshbuf_put(blob, bptr, blen)) != 0)		goto out;	r = 0; out:	BIO_free(bio);	return r;}

vod_status_t aes_cbc_encrypt_init(	aes_cbc_encrypt_context_t** context,	request_context_t* request_context,	write_callback_t callback,	void* callback_context,	const u_char* key,	const u_char* iv){	aes_cbc_encrypt_context_t* state;	vod_pool_cleanup_t *cln;	state = vod_alloc(request_context->pool, sizeof(*state));	if (state == NULL)	{		vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,			"aes_cbc_encrypt_init: vod_alloc failed");		return VOD_ALLOC_FAILED;	}	cln = vod_pool_cleanup_add(request_context->pool, 0);	if (cln == NULL)	{		vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,			"aes_cbc_encrypt_init: vod_pool_cleanup_add failed");		return VOD_ALLOC_FAILED;	}	cln->handler = (vod_pool_cleanup_pt)aes_cbc_encrypt_cleanup;	cln->data = state;		state->callback = callback;	state->callback_context = callback_context;	state->request_context = request_context;	EVP_CIPHER_CTX_init(&state->cipher);		if (1 != EVP_EncryptInit_ex(&state->cipher, EVP_aes_128_cbc(), NULL, key, iv))	{		vod_log_error(VOD_LOG_ERR, request_context->log, 0,			"aes_cbc_encrypt_init: EVP_EncryptInit_ex failed");		return VOD_ALLOC_FAILED;	}		*context = state;	return VOD_OK;}

/* CMAC-AES128: generate hash of known digest value and compare to known   precomputed correct hash*/static int FIPS_cmac_aes128_test(){    unsigned char key[16] = { 0x2b,0x7e,0x15,0x16, 0x28,0xae,0xd2,0xa6,                              0xab,0xf7,0x15,0x88, 0x09,0xcf,0x4f,0x3c,                            };    unsigned char data[] = "Sample text";    unsigned char kaval[EVP_MAX_MD_SIZE] =    {   0x16,0x83,0xfe,0xac, 0x52,0x9b,0xae,0x23,        0xd7,0xd5,0x66,0xf5, 0xd2,0x8d,0xbd,0x2a,    };    unsigned char *out = NULL;    size_t outlen;    CMAC_CTX *ctx = CMAC_CTX_new();    int r = 0;    ERR_clear_error();    if (!ctx)        goto end;    if (!CMAC_Init(ctx,key,sizeof(key),EVP_aes_128_cbc(),NULL))        goto end;    if (!CMAC_Update(ctx,data,sizeof(data)-1))        goto end;    /* This should return 1.  If not, there's a programming error... */    if (!CMAC_Final(ctx, out, &outlen))        goto end;    out = OPENSSL_malloc(outlen);    if (!CMAC_Final(ctx, out, &outlen))        goto end;#if 0    {        char *hexout = OPENSSL_malloc(outlen * 2 + 1);        bin2hex(out, outlen, hexout);        printf("CMAC-AES128: res = %s/n", hexout);        OPENSSL_free(hexout);    }    r = 1;#else    if (!memcmp(out,kaval,outlen))        r = 1;#endifend:    CMAC_CTX_free(ctx);    if (out)        OPENSSL_free(out);    return r;}

static void evp_cipher_init(struct ssh_cipher_struct *cipher) {    if (cipher->ctx == NULL) {        cipher->ctx = EVP_CIPHER_CTX_new();    }    switch(cipher->ciphertype){    case SSH_AES128_CBC:        cipher->cipher = EVP_aes_128_cbc();        break;    case SSH_AES192_CBC:        cipher->cipher = EVP_aes_192_cbc();        break;    case SSH_AES256_CBC:        cipher->cipher = EVP_aes_256_cbc();        break;#ifdef HAVE_OPENSSL_EVP_AES_CTR    case SSH_AES128_CTR:        cipher->cipher = EVP_aes_128_ctr();        break;    case SSH_AES192_CTR:        cipher->cipher = EVP_aes_192_ctr();        break;    case SSH_AES256_CTR:        cipher->cipher = EVP_aes_256_ctr();        break;#else    case SSH_AES128_CTR:    case SSH_AES192_CTR:    case SSH_AES256_CTR:        SSH_LOG(SSH_LOG_WARNING, "This cipher is not available in evp_cipher_init");        break;#endif    case SSH_3DES_CBC:        cipher->cipher = EVP_des_ede3_cbc();        break;    case SSH_BLOWFISH_CBC:        cipher->cipher = EVP_bf_cbc();        break;        /* ciphers not using EVP */    case SSH_3DES_CBC_SSH1:    case SSH_DES_CBC_SSH1:        SSH_LOG(SSH_LOG_WARNING, "This cipher should not use evp_cipher_init");        break;    case SSH_NO_CIPHER:        SSH_LOG(SSH_LOG_WARNING, "No valid ciphertype found");        break;    }}

    bool crypt_openssl::decode(unsigned char *datain, int lenin, unsigned char *dataout, int lenout)    {        EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, NULL, NULL);        OPENSSL_assert(EVP_CIPHER_CTX_key_length(ctx) == 16);        OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) == 16);        EVP_DecryptInit_ex(ctx, NULL, NULL, key, iv);        if(!EVP_DecryptUpdate(ctx, dataout, &lenout, datain, lenin))        {            return false;        }        if(!EVP_EncryptFinal_ex(ctx, dataout, &lenout))        {            return false;        }    }

SSH2Encryption::SSH2Encryption(const QString & algorithm){    m_ctx = EVP_CIPHER_CTX_new();    if (algorithm == "aes128-cbc") {        m_ivLen = 16;        m_blockSize = 16;        m_secretLen = 16;        m_evptype = EVP_aes_128_cbc();    } else if (algorithm == "3des-cbc") {        m_ivLen = 8;        m_blockSize = 8;        m_secretLen = 24;        m_evptype = EVP_des_ede3_cbc();    }}

bool RarVolume::DecryptInit(int keyLength){#ifdef HAVE_OPENSSL	if (!(m_context = EVP_CIPHER_CTX_new())) return false;	if (!EVP_DecryptInit((EVP_CIPHER_CTX*)m_context,		keyLength == 128 ? EVP_aes_128_cbc() : EVP_aes_256_cbc(),		m_decryptKey, m_decryptIV))		return false;	return true;#elif defined(HAVE_NETTLE)	m_context = new aes_ctx;	aes_set_decrypt_key((aes_ctx*)m_context, keyLength == 128 ? 16 : 32, m_decryptKey);	return true;#else	return false;#endif}

static wi_boolean_t _wi_cipher_set_type(wi_cipher_t *cipher, wi_cipher_type_t type) {	cipher->type = type;	#ifdef WI_CIPHER_OPENSSL	switch(cipher->type) {		case WI_CIPHER_AES128:			cipher->cipher = EVP_aes_128_cbc();			return true;					case WI_CIPHER_AES192:			cipher->cipher = EVP_aes_192_cbc();			return true;					case WI_CIPHER_AES256:			cipher->cipher = EVP_aes_256_cbc();			return true;					case WI_CIPHER_BF128:			cipher->cipher = EVP_bf_cbc();			return true;					case WI_CIPHER_3DES192:			cipher->cipher = EVP_des_ede3_cbc();			return true;					default:			return false;	}#endif			#ifdef WI_CIPHER_COMMONCRYPTO	switch(cipher->type) {		case WI_CIPHER_AES128:			cipher->algorithm = kCCAlgorithmAES128;			return true;				case WI_CIPHER_3DES192:			cipher->algorithm = kCCAlgorithm3DES;			return true;				default:			return false;	}#endif}

//  We are doing CBC-MAC not CMAC at this timebool AES_CMAC_Validate(COSE_MacMessage * pcose, int KeySize, int TagSize, const byte * pbAuthData, int cbAuthData, cose_errback * perr){	CMAC_CTX * pctx = NULL;	const EVP_CIPHER * pcipher = NULL;	byte * rgbOut = NULL;	size_t cbOut;	bool f = false;	unsigned int i;#ifdef USE_CBOR_CONTEXT	cn_cbor_context * context = &pcose->m_message.m_allocContext;#endif	pctx = CMAC_CTX_new();	switch (KeySize) {	case 128: pcipher = EVP_aes_128_cbc(); break;	case 256: pcipher = EVP_aes_256_cbc(); break;	default: FAIL_CONDITION(COSE_ERR_INVALID_PARAMETER); break;	}	rgbOut = COSE_CALLOC(128/8, 1, context);	CHECK_CONDITION(rgbOut != NULL, COSE_ERR_OUT_OF_MEMORY);	CHECK_CONDITION(CMAC_Init(pctx, pcose->pbKey, pcose->cbKey, pcipher, NULL /*impl*/) == 1, COSE_ERR_CRYPTO_FAIL);	CHECK_CONDITION(CMAC_Update(pctx, pbAuthData, cbAuthData), COSE_ERR_CRYPTO_FAIL);	CHECK_CONDITION(CMAC_Final(pctx, rgbOut, &cbOut), COSE_ERR_CRYPTO_FAIL);	cn_cbor * cn = _COSE_arrayget_int(&pcose->m_message, INDEX_MAC_TAG);	CHECK_CONDITION(cn != NULL, COSE_ERR_CBOR);	for (i = 0; i < (unsigned int)TagSize / 8; i++) f |= (cn->v.bytes[i] != rgbOut[i]);	COSE_FREE(rgbOut, context);	CMAC_CTX_cleanup(pctx);	CMAC_CTX_free(pctx);	return !f;errorReturn:	COSE_FREE(rgbOut, context);	CMAC_CTX_cleanup(pctx);	CMAC_CTX_free(pctx);	return false;}

/** Get cipher for PB_ENCRYPTION_* constants. * @param cipher cipher ID * @return cipher engine */const EVP_CIPHER *cipher_by_id(int cipher){  switch (cipher) {  case PB_ENCRYPTION_AES_128_ECB:    return EVP_aes_128_ecb();  case PB_ENCRYPTION_AES_128_CBC:    return EVP_aes_128_cbc();  case PB_ENCRYPTION_AES_256_ECB:    return EVP_aes_256_ecb();  case PB_ENCRYPTION_AES_256_CBC:    return EVP_aes_256_cbc();  default:    throw std::runtime_error("Unknown cipher type");  }}