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

//.........这里部分代码省略.........				explicit_bzero(enc_config.keystr,				    strlen(enc_config.keystr));		}		if (enc_config.hiv != NULL &&		    !set_hex(enc_config.hiv, iv, sizeof iv)) {			BIO_printf(bio_err, "invalid hex iv value/n");			goto end;		}		if (enc_config.hiv == NULL && enc_config.keystr == NULL &&		    EVP_CIPHER_iv_length(enc_config.cipher) != 0) {			/*			 * No IV was explicitly set and no IV was generated			 * during EVP_BytesToKey. Hence the IV is undefined,			 * making correct decryption impossible.			 */			BIO_printf(bio_err, "iv undefined/n");			goto end;		}		if (enc_config.hkey != NULL &&		    !set_hex(enc_config.hkey, key, sizeof key)) {			BIO_printf(bio_err, "invalid hex key value/n");			goto end;		}		if ((benc = BIO_new(BIO_f_cipher())) == NULL)			goto end;		/*		 * Since we may be changing parameters work on the encryption		 * context rather than calling BIO_set_cipher().		 */		BIO_get_cipher_ctx(benc, &ctx);		if (!EVP_CipherInit_ex(ctx, enc_config.cipher, NULL, NULL,		    NULL, enc_config.enc)) {			BIO_printf(bio_err, "Error setting cipher %s/n",			    EVP_CIPHER_name(enc_config.cipher));			ERR_print_errors(bio_err);			goto end;		}		if (enc_config.nopad)			EVP_CIPHER_CTX_set_padding(ctx, 0);		if (!EVP_CipherInit_ex(ctx, NULL, NULL, key, iv,		    enc_config.enc)) {			BIO_printf(bio_err, "Error setting cipher %s/n",			    EVP_CIPHER_name(enc_config.cipher));			ERR_print_errors(bio_err);			goto end;		}		if (enc_config.debug) {			BIO_set_callback(benc, BIO_debug_callback);			BIO_set_callback_arg(benc, (char *) bio_err);		}		if (enc_config.printkey) {			if (!enc_config.nosalt) {				printf("salt=");				for (i = 0; i < (int) sizeof(salt); i++)					printf("%02X", salt[i]);				printf("/n");			}			if (enc_config.cipher->key_len > 0) {				printf("key=");				for (i = 0; i < enc_config.cipher->key_len; i++)					printf("%02X", key[i]);				printf("/n");

intcipher_ctx_reset(EVP_CIPHER_CTX *ctx, const uint8_t *iv_buf){    return EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv_buf, -1);}

OM_uint32 _gssapi_unwrap_arcfour(OM_uint32 *minor_status,				 const gsskrb5_ctx context_handle,				 krb5_context context,				 const gss_buffer_t input_message_buffer,				 gss_buffer_t output_message_buffer,				 int *conf_state,				 gss_qop_t *qop_state,				 krb5_keyblock *key){    u_char Klocaldata[16];    krb5_keyblock Klocal;    krb5_error_code ret;    uint32_t seq_number;    size_t datalen;    OM_uint32 omret;    u_char k6_data[16], SND_SEQ[8], Confounder[8];    u_char cksum_data[8];    u_char *p, *p0;    int cmp;    int conf_flag;    size_t padlen = 0, len;    if (conf_state)	*conf_state = 0;    if (qop_state)	*qop_state = 0;    p0 = input_message_buffer->value;    if (IS_DCE_STYLE(context_handle)) {	len = GSS_ARCFOUR_WRAP_TOKEN_SIZE +	    GSS_ARCFOUR_WRAP_TOKEN_DCE_DER_HEADER_SIZE;	if (input_message_buffer->length < len)	    return GSS_S_BAD_MECH;    } else {	len = input_message_buffer->length;    }    omret = _gssapi_verify_mech_header(&p0,				       len,				       GSS_KRB5_MECHANISM);    if (omret)	return omret;    /* length of mech header */    len = (p0 - (u_char *)input_message_buffer->value) +	GSS_ARCFOUR_WRAP_TOKEN_SIZE;    if (len > input_message_buffer->length)	return GSS_S_BAD_MECH;    /* length of data */    datalen = input_message_buffer->length - len;    p = p0;    if (memcmp(p, "/x02/x01", 2) != 0)	return GSS_S_BAD_SIG;    p += 2;    if (memcmp(p, "/x11/x00", 2) != 0) /* SGN_ALG = HMAC MD5 ARCFOUR */	return GSS_S_BAD_SIG;    p += 2;    if (memcmp (p, "/x10/x00", 2) == 0)	conf_flag = 1;    else if (memcmp (p, "/xff/xff", 2) == 0)	conf_flag = 0;    else	return GSS_S_BAD_SIG;    p += 2;    if (memcmp (p, "/xff/xff", 2) != 0)	return GSS_S_BAD_MIC;    p = NULL;    ret = arcfour_mic_key(context, key,			  p0 + 16, 8, /* SGN_CKSUM */			  k6_data, sizeof(k6_data));    if (ret) {	*minor_status = ret;	return GSS_S_FAILURE;    }    {	EVP_CIPHER_CTX rc4_key;	EVP_CIPHER_CTX_init(&rc4_key);	EVP_CipherInit_ex(&rc4_key, EVP_rc4(), NULL, k6_data, NULL, 1);	EVP_Cipher(&rc4_key, SND_SEQ, p0 + 8, 8);	EVP_CIPHER_CTX_cleanup(&rc4_key);	memset(k6_data, 0, sizeof(k6_data));    }    _gss_mg_decode_be_uint32(SND_SEQ, &seq_number);    if (context_handle->more_flags & LOCAL)	cmp = memcmp(&SND_SEQ[4], "/xff/xff/xff/xff", 4);    else	cmp = memcmp(&SND_SEQ[4], "/x00/x00/x00/x00", 4);//.........这里部分代码省略.........

//.........这里部分代码省略.........		else if ((s->enc_write_ctx=OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL)			goto err;		else			/* make sure it's intialized in case we exit later with an error */			EVP_CIPHER_CTX_init(s->enc_write_ctx);		dd= s->enc_write_ctx;		s->write_hash=m;#ifndef OPENSSL_NO_COMP		/* COMPRESS */		if (s->compress != NULL)			{			COMP_CTX_free(s->compress);			s->compress=NULL;			}		if (comp != NULL)			{			s->compress=COMP_CTX_new(comp);			if (s->compress == NULL)				{				SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,SSL_R_COMPRESSION_LIBRARY_ERROR);				goto err2;				}			}#endif		memset(&(s->s3->write_sequence[0]),0,8);		mac_secret= &(s->s3->write_mac_secret[0]);		}	if (reuse_dd)		EVP_CIPHER_CTX_cleanup(dd);	p=s->s3->tmp.key_block;	i=EVP_MD_size(m);	cl=EVP_CIPHER_key_length(c);	j=is_exp ? (cl < SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher) ?		 cl : SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher)) : cl;	/* Was j=(is_exp)?5:EVP_CIPHER_key_length(c); */	k=EVP_CIPHER_iv_length(c);	if (	(which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) ||		(which == SSL3_CHANGE_CIPHER_SERVER_READ))		{		ms=  &(p[ 0]); n=i+i;		key= &(p[ n]); n+=j+j;		iv=  &(p[ n]); n+=k+k;		er1= &(s->s3->client_random[0]);		er2= &(s->s3->server_random[0]);		}	else		{		n=i;		ms=  &(p[ n]); n+=i+j;		key= &(p[ n]); n+=j+k;		iv=  &(p[ n]); n+=k;		er1= &(s->s3->server_random[0]);		er2= &(s->s3->client_random[0]);		}	if (n > s->s3->tmp.key_block_length)		{		SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,ERR_R_INTERNAL_ERROR);		goto err2;		}	EVP_MD_CTX_init(&md);	memcpy(mac_secret,ms,i);	if (is_exp)		{		/* In here I set both the read and write key/iv to the		 * same value since only the correct one will be used :-).		 */		EVP_DigestInit_ex(&md,EVP_md5(), NULL);		EVP_DigestUpdate(&md,key,j);		EVP_DigestUpdate(&md,er1,SSL3_RANDOM_SIZE);		EVP_DigestUpdate(&md,er2,SSL3_RANDOM_SIZE);		EVP_DigestFinal_ex(&md,&(exp_key[0]),NULL);		key= &(exp_key[0]);		if (k > 0)			{			EVP_DigestInit_ex(&md,EVP_md5(), NULL);			EVP_DigestUpdate(&md,er1,SSL3_RANDOM_SIZE);			EVP_DigestUpdate(&md,er2,SSL3_RANDOM_SIZE);			EVP_DigestFinal_ex(&md,&(exp_iv[0]),NULL);			iv= &(exp_iv[0]);			}		}	s->session->key_arg_length=0;	EVP_CipherInit_ex(dd,c,NULL,key,iv,(which & SSL3_CC_WRITE));	OPENSSL_cleanse(&(exp_key[0]),sizeof(exp_key));	OPENSSL_cleanse(&(exp_iv[0]),sizeof(exp_iv));	EVP_MD_CTX_cleanup(&md);	return(1);err:	SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,ERR_R_MALLOC_FAILURE);err2:	return(0);	}

OM_uint32_gssapi_verify_mic_arcfour(OM_uint32 * minor_status,			   const gsskrb5_ctx context_handle,			   krb5_context context,			   const gss_buffer_t message_buffer,			   const gss_buffer_t token_buffer,			   gss_qop_t * qop_state,			   krb5_keyblock *key,			   const char *type){    krb5_error_code ret;    uint32_t seq_number;    OM_uint32 omret;    u_char SND_SEQ[8], cksum_data[8], *p;    char k6_data[16];    int cmp;    if (qop_state)	*qop_state = 0;    p = token_buffer->value;    omret = _gsskrb5_verify_header (&p,				       token_buffer->length,				       type,				       GSS_KRB5_MECHANISM);    if (omret)	return omret;    if (memcmp(p, "/x11/x00", 2) != 0) /* SGN_ALG = HMAC MD5 ARCFOUR */	return GSS_S_BAD_SIG;    p += 2;    if (memcmp (p, "/xff/xff/xff/xff", 4) != 0)	return GSS_S_BAD_MIC;    p += 4;    ret = arcfour_mic_cksum(context,			    key, KRB5_KU_USAGE_SIGN,			    cksum_data, sizeof(cksum_data),			    p - 8, 8,			    message_buffer->value, message_buffer->length,			    NULL, 0);    if (ret) {	*minor_status = ret;	return GSS_S_FAILURE;    }    ret = arcfour_mic_key(context, key,			  cksum_data, sizeof(cksum_data),			  k6_data, sizeof(k6_data));    if (ret) {	*minor_status = ret;	return GSS_S_FAILURE;    }    cmp = ct_memcmp(cksum_data, p + 8, 8);    if (cmp) {	*minor_status = 0;	return GSS_S_BAD_MIC;    }    {	EVP_CIPHER_CTX rc4_key;	EVP_CIPHER_CTX_init(&rc4_key);	EVP_CipherInit_ex(&rc4_key, EVP_rc4(), NULL, (void *)k6_data, NULL, 0);	EVP_Cipher(&rc4_key, SND_SEQ, p, 8);	EVP_CIPHER_CTX_cleanup(&rc4_key);	memset(k6_data, 0, sizeof(k6_data));    }    _gss_mg_decode_be_uint32(SND_SEQ, &seq_number);    if (context_handle->more_flags & LOCAL)	cmp = memcmp(&SND_SEQ[4], "/xff/xff/xff/xff", 4);    else	cmp = memcmp(&SND_SEQ[4], "/x00/x00/x00/x00", 4);    memset(SND_SEQ, 0, sizeof(SND_SEQ));    if (cmp != 0) {	*minor_status = 0;	return GSS_S_BAD_MIC;    }    HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);    omret = _gssapi_msg_order_check(context_handle->gk5c.order, seq_number);    HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);    if (omret)	return omret;    *minor_status = 0;    return GSS_S_COMPLETE;}

BIO *cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec){    BIO *b;    EVP_CIPHER_CTX *ctx;    const EVP_CIPHER *ciph;    X509_ALGOR *calg = ec->contentEncryptionAlgorithm;    unsigned char iv[EVP_MAX_IV_LENGTH], *piv = NULL;    unsigned char *tkey = NULL;    size_t tkeylen = 0;    int ok = 0;    int enc, keep_key = 0;    enc = ec->cipher ? 1 : 0;    b = BIO_new(BIO_f_cipher());    if (b == NULL) {        CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);        return NULL;    }    BIO_get_cipher_ctx(b, &ctx);    if (enc) {        ciph = ec->cipher;        /*         * If not keeping key set cipher to NULL so subsequent calls decrypt.         */        if (ec->key)            ec->cipher = NULL;    } else {        ciph = EVP_get_cipherbyobj(calg->algorithm);        if (!ciph) {            CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, CMS_R_UNKNOWN_CIPHER);            goto err;        }    }    if (EVP_CipherInit_ex(ctx, ciph, NULL, NULL, NULL, enc) <= 0) {        CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,               CMS_R_CIPHER_INITIALISATION_ERROR);        goto err;    }    if (enc) {        int ivlen;        calg->algorithm = OBJ_nid2obj(EVP_CIPHER_CTX_type(ctx));        /* Generate a random IV if we need one */        ivlen = EVP_CIPHER_CTX_iv_length(ctx);        if (ivlen > 0) {            if (RAND_bytes(iv, ivlen) <= 0)                goto err;            piv = iv;        }    } else if (EVP_CIPHER_asn1_to_param(ctx, calg->parameter) <= 0) {        CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,               CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);        goto err;    }    tkeylen = EVP_CIPHER_CTX_key_length(ctx);    /* Generate random session key */    if (!enc || !ec->key) {        tkey = OPENSSL_malloc(tkeylen);        if (tkey == NULL) {            CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);            goto err;        }        if (EVP_CIPHER_CTX_rand_key(ctx, tkey) <= 0)            goto err;    }    if (!ec->key) {        ec->key = tkey;        ec->keylen = tkeylen;        tkey = NULL;        if (enc)            keep_key = 1;        else            ERR_clear_error();    }    if (ec->keylen != tkeylen) {        /* If necessary set key length */        if (EVP_CIPHER_CTX_set_key_length(ctx, ec->keylen) <= 0) {            /*             * Only reveal failure if debugging so we don't leak information             * which may be useful in MMA.             */            if (enc || ec->debug) {                CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,                       CMS_R_INVALID_KEY_LENGTH);                goto err;            } else {                /* Use random key */                OPENSSL_clear_free(ec->key, ec->keylen);                ec->key = tkey;                ec->keylen = tkeylen;//.........这里部分代码省略.........

void cipher_context_init(cipher_ctx_t *ctx, int method, int enc){    if (method <= TABLE || method >= CIPHER_NUM) {        LOGE("cipher_context_init(): Illegal method");        return;    }    if (method >= SALSA20) {        enc_iv_len = supported_ciphers_iv_size[method];        return;    }    const char *ciphername = supported_ciphers[method];#if defined(USE_CRYPTO_APPLECC)    cipher_cc_t *cc = &ctx->cc;    cc->cryptor = NULL;    cc->cipher  = supported_ciphers_applecc[method];    if (cc->cipher == kCCAlgorithmInvalid) {        cc->valid = kCCContextInvalid;    } else {        cc->valid = kCCContextValid;        if (cc->cipher == kCCAlgorithmRC4) {            cc->mode    = kCCModeRC4;            cc->padding = ccNoPadding;        } else {            cc->mode    = kCCModeCFB;            cc->padding = ccPKCS7Padding;        }        return;    }#endif    cipher_evp_t *evp         = &ctx->evp;    const cipher_kt_t *cipher = get_cipher_type(method);#if defined(USE_CRYPTO_OPENSSL)    if (cipher == NULL) {        LOGE("Cipher %s not found in OpenSSL library", ciphername);        FATAL("Cannot initialize cipher");    }    EVP_CIPHER_CTX_init(evp);    if (!EVP_CipherInit_ex(evp, cipher, NULL, NULL, NULL, enc)) {        LOGE("Cannot initialize cipher %s", ciphername);        exit(EXIT_FAILURE);    }    if (!EVP_CIPHER_CTX_set_key_length(evp, enc_key_len)) {        EVP_CIPHER_CTX_cleanup(evp);        LOGE("Invalid key length: %d", enc_key_len);        exit(EXIT_FAILURE);    }    if (method > RC4_MD5) {        EVP_CIPHER_CTX_set_padding(evp, 1);    }#elif defined(USE_CRYPTO_POLARSSL)    if (cipher == NULL) {        LOGE("Cipher %s not found in PolarSSL library", ciphername);        FATAL("Cannot initialize PolarSSL cipher");    }    if (cipher_init_ctx(evp, cipher) != 0) {        FATAL("Cannot initialize PolarSSL cipher context");    }#elif defined(USE_CRYPTO_MBEDTLS)    // XXX: mbedtls_cipher_setup future change    // NOTE:  Currently also clears structure. In future versions you will be required to call    //        mbedtls_cipher_init() on the structure first.    //        void mbedtls_cipher_init( mbedtls_cipher_context_t *ctx );    if (cipher == NULL) {        LOGE("Cipher %s not found in mbed TLS library", ciphername);        FATAL("Cannot initialize mbed TLS cipher");    }    mbedtls_cipher_init(evp);    if (mbedtls_cipher_setup(evp, cipher) != 0) {        FATAL("Cannot initialize mbed TLS cipher context");    }#endif}

long _IKED::packet_ike_encrypt( IDB_PH1 * sa, PACKET_IKE & packet, BDATA * iv ){	log.txt( LLOG_INFO,		">= : cookies %08x%08x:%08x%08x/n",		htonl( *( long * ) &sa->cookies.i[ 0 ] ),		htonl( *( long * ) &sa->cookies.i[ 4 ] ),		htonl( *( long * ) &sa->cookies.r[ 0 ] ),		htonl( *( long * ) &sa->cookies.r[ 4 ] ) );	log.txt( LLOG_INFO,		">= : message %08x/n",		htonl( packet.get_msgid() ) );	//	// check if encrypt is required	//	unsigned char *	data = packet.buff();	size_t		    size = packet.size();	if( !( data[ ISAKMP_FLAGS_OFFSET ] & ISAKMP_FLAG_ENCRYPT ) )		return LIBIKE_OK;	log.bin(		LLOG_DEBUG,		LLOG_DECODE,		iv->buff(),		iv->size(),		">= : encrypt iv" );	log.bin(		LLOG_DEBUG,		LLOG_DECODE,		packet.buff(),		packet.size(),		"== : encrypt packet" );	//	// determine pad length	//	size_t plen = size - sizeof( IKE_HEADER );	size_t blen = EVP_CIPHER_block_size( sa->evp_cipher );	size_t padd = 0;	if( plen % blen )		padd += blen - ( plen % blen );	packet.add_null( padd );	data = packet.buff();	size = packet.size();	//	// set new packet length in header	//	IKE_HEADER * header = ( IKE_HEADER * ) packet.buff();	header->length = htonl( ( uint32_t ) size );	//	// init cipher key and iv and	// encrypt all but header	//	EVP_CIPHER_CTX ctx_cipher;	EVP_CIPHER_CTX_init( &ctx_cipher );	EVP_CipherInit_ex(		&ctx_cipher,		sa->evp_cipher,		NULL,		NULL,		NULL,		1 );	EVP_CIPHER_CTX_set_key_length(		&ctx_cipher,		( int ) sa->key.size() );	EVP_CipherInit_ex(		&ctx_cipher,		NULL,		NULL,		sa->key.buff(),		iv->buff(),		1 );	EVP_Cipher(		&ctx_cipher,		data + sizeof( IKE_HEADER ),		data + sizeof( IKE_HEADER ),		( int ) size - sizeof( IKE_HEADER ) );	EVP_CIPHER_CTX_cleanup( &ctx_cipher );	//	// store cipher iv data	////.........这里部分代码省略.........

krb5_error_code_krb5_evp_encrypt_cts(krb5_context context,		      struct _krb5_key_data *key,		      void *data,		      size_t len,		      krb5_boolean encryptp,		      int usage,		      void *ivec){    size_t i, blocksize;    struct _krb5_evp_schedule *ctx = key->schedule->data;    char tmp[EVP_MAX_BLOCK_LENGTH], ivec2[EVP_MAX_BLOCK_LENGTH];    EVP_CIPHER_CTX *c;    unsigned char *p;    c = encryptp ? &ctx->ectx : &ctx->dctx;    blocksize = EVP_CIPHER_CTX_block_size(c);    if (len < blocksize) {	krb5_set_error_message(context, EINVAL,			       "message block too short");	return EINVAL;    } else if (len == blocksize) {	EVP_CipherInit_ex(c, NULL, NULL, NULL, zero_ivec, -1);	EVP_Cipher(c, data, data, len);	return 0;    }    if (ivec)	EVP_CipherInit_ex(c, NULL, NULL, NULL, ivec, -1);    else	EVP_CipherInit_ex(c, NULL, NULL, NULL, zero_ivec, -1);    if (encryptp) {	p = data;	i = ((len - 1) / blocksize) * blocksize;	EVP_Cipher(c, p, p, i);	p += i - blocksize;	len -= i;	memcpy(ivec2, p, blocksize);	for (i = 0; i < len; i++)	    tmp[i] = p[i + blocksize] ^ ivec2[i];	for (; i < blocksize; i++)	    tmp[i] = 0 ^ ivec2[i];	EVP_CipherInit_ex(c, NULL, NULL, NULL, zero_ivec, -1);	EVP_Cipher(c, p, tmp, blocksize);	memcpy(p + blocksize, ivec2, len);	if (ivec)	    memcpy(ivec, p, blocksize);    } else {	char tmp2[EVP_MAX_BLOCK_LENGTH], tmp3[EVP_MAX_BLOCK_LENGTH];	p = data;	if (len > blocksize * 2) {	    /* remove last two blocks and round up, decrypt this with cbc, then do cts dance */	    i = ((((len - blocksize * 2) + blocksize - 1) / blocksize) * blocksize);	    memcpy(ivec2, p + i - blocksize, blocksize);	    EVP_Cipher(c, p, p, i);	    p += i;	    len -= i + blocksize;	} else {	    if (ivec)		memcpy(ivec2, ivec, blocksize);	    else		memcpy(ivec2, zero_ivec, blocksize);	    len -= blocksize;	}	memcpy(tmp, p, blocksize);	EVP_CipherInit_ex(c, NULL, NULL, NULL, zero_ivec, -1);	EVP_Cipher(c, tmp2, p, blocksize);	memcpy(tmp3, p + blocksize, len);	memcpy(tmp3 + len, tmp2 + len, blocksize - len); /* xor 0 */	for (i = 0; i < len; i++)	    p[i + blocksize] = tmp2[i] ^ tmp3[i];	EVP_CipherInit_ex(c, NULL, NULL, NULL, zero_ivec, -1);	EVP_Cipher(c, p, tmp3, blocksize);	for (i = 0; i < blocksize; i++)	    p[i] ^= ivec2[i];	if (ivec)	    memcpy(ivec, tmp, blocksize);    }    return 0;}

static inttry_decrypt(hx509_context context,	    struct hx509_collector *collector,	    const AlgorithmIdentifier *alg,	    const EVP_CIPHER *c,	    const void *ivdata,	    const void *password,	    size_t passwordlen,	    const void *cipher,	    size_t len){    heim_octet_string clear;    size_t keylen;    void *key;    int ret;    keylen = EVP_CIPHER_key_length(c);    key = malloc(keylen);    if (key == NULL) {	hx509_clear_error_string(context);	return ENOMEM;    }    ret = EVP_BytesToKey(c, EVP_md5(), ivdata,			 password, passwordlen,			 1, key, NULL);    if (ret <= 0) {	hx509_set_error_string(context, 0, HX509_CRYPTO_INTERNAL_ERROR,			       "Failed to do string2key for private key");	return HX509_CRYPTO_INTERNAL_ERROR;    }    clear.data = malloc(len);    if (clear.data == NULL) {	hx509_set_error_string(context, 0, ENOMEM,			       "Out of memory to decrypt for private key");	ret = ENOMEM;	goto out;    }    clear.length = len;    {	EVP_CIPHER_CTX ctx;	EVP_CIPHER_CTX_init(&ctx);	EVP_CipherInit_ex(&ctx, c, NULL, key, ivdata, 0);	EVP_Cipher(&ctx, clear.data, cipher, len);	EVP_CIPHER_CTX_cleanup(&ctx);    }	    ret = _hx509_collector_private_key_add(context,					   collector,					   alg,					   NULL,					   &clear,					   NULL);    memset(clear.data, 0, clear.length);    free(clear.data);out:    memset(key, 0, keylen);    free(key);    return ret;}

BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio){	int i;	BIO *out = NULL, *btmp = NULL;	X509_ALGOR *xa = NULL;	const EVP_CIPHER *evp_cipher = NULL;	STACK_OF(X509_ALGOR) *md_sk = NULL;	STACK_OF(PKCS7_RECIP_INFO) *rsk = NULL;	X509_ALGOR *xalg = NULL;	PKCS7_RECIP_INFO *ri = NULL;	ASN1_OCTET_STRING *os = NULL;	if (p7 == NULL) {		PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_INVALID_NULL_POINTER);		return NULL;	}	/*	 * The content field in the PKCS7 ContentInfo is optional,	 * but that really only applies to inner content (precisely,	 * detached signatures).	 *	 * When reading content, missing outer content is therefore	 * treated as an error.	 *	 * When creating content, PKCS7_content_new() must be called	 * before calling this method, so a NULL p7->d is always	 * an error.	 */	if (p7->d.ptr == NULL) {		PKCS7err(PKCS7_F_PKCS7_DATAINIT, PKCS7_R_NO_CONTENT);		return NULL;	}	i = OBJ_obj2nid(p7->type);	p7->state = PKCS7_S_HEADER;	switch (i) {	case NID_pkcs7_signed:		md_sk = p7->d.sign->md_algs;		os = PKCS7_get_octet_string(p7->d.sign->contents);		break;	case NID_pkcs7_signedAndEnveloped:		rsk = p7->d.signed_and_enveloped->recipientinfo;		md_sk = p7->d.signed_and_enveloped->md_algs;		xalg = p7->d.signed_and_enveloped->enc_data->algorithm;		evp_cipher = p7->d.signed_and_enveloped->enc_data->cipher;		if (evp_cipher == NULL) {			PKCS7err(PKCS7_F_PKCS7_DATAINIT,			    PKCS7_R_CIPHER_NOT_INITIALIZED);			goto err;		}		break;	case NID_pkcs7_enveloped:		rsk = p7->d.enveloped->recipientinfo;		xalg = p7->d.enveloped->enc_data->algorithm;		evp_cipher = p7->d.enveloped->enc_data->cipher;		if (evp_cipher == NULL) {			PKCS7err(PKCS7_F_PKCS7_DATAINIT,			    PKCS7_R_CIPHER_NOT_INITIALIZED);			goto err;		}		break;	case NID_pkcs7_digest:		xa = p7->d.digest->md;		os = PKCS7_get_octet_string(p7->d.digest->contents);		break;	case NID_pkcs7_data:		break;	default:		PKCS7err(PKCS7_F_PKCS7_DATAINIT,		    PKCS7_R_UNSUPPORTED_CONTENT_TYPE);		goto err;	}	for (i = 0; i < sk_X509_ALGOR_num(md_sk); i++)		if (!PKCS7_bio_add_digest(&out, sk_X509_ALGOR_value(md_sk, i)))			goto err;	if (xa && !PKCS7_bio_add_digest(&out, xa))		goto err;	if (evp_cipher != NULL) {		unsigned char key[EVP_MAX_KEY_LENGTH];		unsigned char iv[EVP_MAX_IV_LENGTH];		int keylen, ivlen;		EVP_CIPHER_CTX *ctx;		if ((btmp = BIO_new(BIO_f_cipher())) == NULL) {			PKCS7err(PKCS7_F_PKCS7_DATAINIT, ERR_R_BIO_LIB);			goto err;		}		BIO_get_cipher_ctx(btmp, &ctx);		keylen = EVP_CIPHER_key_length(evp_cipher);		ivlen = EVP_CIPHER_iv_length(evp_cipher);		xalg->algorithm = OBJ_nid2obj(EVP_CIPHER_type(evp_cipher));		if (ivlen > 0)			arc4random_buf(iv, ivlen);		if (EVP_CipherInit_ex(ctx, evp_cipher, NULL, NULL,//.........这里部分代码省略.........

void cipher_context_set_iv(cipher_ctx_t *ctx, uint8_t *iv, size_t iv_len,                           int enc){    const unsigned char *true_key;    if (iv == NULL) {        LOGE("cipher_context_set_iv(): IV is null");        return;    }    if (!enc) {        memcpy(ctx->iv, iv, iv_len);    }    if (enc_method >= SALSA20) {        return;    }    if (enc_method == RC4_MD5) {        unsigned char key_iv[32];        memcpy(key_iv, enc_key, 16);        memcpy(key_iv + 16, iv, 16);        true_key = enc_md5(key_iv, 32, NULL);        iv_len   = 0;    } else {        true_key = enc_key;    }#ifdef USE_CRYPTO_APPLECC    cipher_cc_t *cc = &ctx->cc;    if (cc->valid == kCCContextValid) {        memcpy(cc->iv, iv, iv_len);        memcpy(cc->key, true_key, enc_key_len);        cc->iv_len  = iv_len;        cc->key_len = enc_key_len;        cc->encrypt = enc ? kCCEncrypt : kCCDecrypt;        if (cc->cryptor != NULL) {            CCCryptorRelease(cc->cryptor);            cc->cryptor = NULL;        }        CCCryptorStatus ret;        ret = CCCryptorCreateWithMode(            cc->encrypt,            cc->mode,            cc->cipher,            cc->padding,            cc->iv, cc->key, cc->key_len,            NULL, 0, 0, 0,            &cc->cryptor);        if (ret != kCCSuccess) {            if (cc->cryptor != NULL) {                CCCryptorRelease(cc->cryptor);                cc->cryptor = NULL;            }            FATAL("Cannot set CommonCrypto key and IV");        }        return;    }#endif    cipher_evp_t *evp = &ctx->evp;    if (evp == NULL) {        LOGE("cipher_context_set_iv(): Cipher context is null");        return;    }#if defined(USE_CRYPTO_OPENSSL)    if (!EVP_CipherInit_ex(evp, NULL, NULL, true_key, iv, enc)) {        EVP_CIPHER_CTX_cleanup(evp);        FATAL("Cannot set key and IV");    }#elif defined(USE_CRYPTO_POLARSSL)    // XXX: PolarSSL 1.3.11: cipher_free_ctx deprecated, Use cipher_free() instead.    if (cipher_setkey(evp, true_key, enc_key_len * 8, enc) != 0) {        cipher_free_ctx(evp);        FATAL("Cannot set PolarSSL cipher key");    }#if POLARSSL_VERSION_NUMBER >= 0x01030000    if (cipher_set_iv(evp, iv, iv_len) != 0) {        cipher_free_ctx(evp);        FATAL("Cannot set PolarSSL cipher IV");    }    if (cipher_reset(evp) != 0) {        cipher_free_ctx(evp);        FATAL("Cannot finalize PolarSSL cipher context");    }#else    if (cipher_reset(evp, iv) != 0) {        cipher_free_ctx(evp);        FATAL("Cannot set PolarSSL cipher IV");    }#endif#elif defined(USE_CRYPTO_MBEDTLS)    if (mbedtls_cipher_setkey(evp, true_key, enc_key_len * 8, enc) != 0) {        mbedtls_cipher_free(evp);        FATAL("Cannot set mbed TLS cipher key");    }    if (mbedtls_cipher_set_iv(evp, iv, iv_len) != 0) {        mbedtls_cipher_free(evp);//.........这里部分代码省略.........

//.........这里部分代码省略.........	               cl : SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher)) : cl;	/* Was j=(exp)?5:EVP_CIPHER_key_length(c); */	k=EVP_CIPHER_iv_length(c);	er1= &(s->s3->client_random[0]);	er2= &(s->s3->server_random[0]);	if (	(which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) ||		(which == SSL3_CHANGE_CIPHER_SERVER_READ))		{		ms=  &(p[ 0]); n=i+i;		key= &(p[ n]); n+=j+j;		iv=  &(p[ n]); n+=k+k;		exp_label=(unsigned char *)TLS_MD_CLIENT_WRITE_KEY_CONST;		exp_label_len=TLS_MD_CLIENT_WRITE_KEY_CONST_SIZE;		client_write=1;		}	else		{		n=i;		ms=  &(p[ n]); n+=i+j;		key= &(p[ n]); n+=j+k;		iv=  &(p[ n]); n+=k;		exp_label=(unsigned char *)TLS_MD_SERVER_WRITE_KEY_CONST;		exp_label_len=TLS_MD_SERVER_WRITE_KEY_CONST_SIZE;		client_write=0;		}	if (n > s->s3->tmp.key_block_length)		{		SSLerr(SSL_F_TLS1_CHANGE_CIPHER_STATE,ERR_R_INTERNAL_ERROR);		goto err2;		}	memcpy(mac_secret,ms,i);	mac_key = EVP_PKEY_new_mac_key(mac_type, NULL,			mac_secret,*mac_secret_size);	EVP_DigestSignInit(mac_ctx,NULL,m,NULL,mac_key);	EVP_PKEY_free(mac_key);#ifdef TLS_DEBUGprintf("which = %04X/nmac key=",which);{ int z; for (z=0; z<i; z++) printf("%02X%c",ms[z],((z+1)%16)?' ':'/n'); }#endif	if (is_export)		{		/* In here I set both the read and write key/iv to the		 * same value since only the correct one will be used :-).		 */		tls1_PRF(s->s3->tmp.new_cipher->algorithm2,			 exp_label,exp_label_len,			 s->s3->client_random,SSL3_RANDOM_SIZE,			 s->s3->server_random,SSL3_RANDOM_SIZE,			 NULL,0,NULL,0,			 key,j,tmp1,tmp2,EVP_CIPHER_key_length(c));		key=tmp1;		if (k > 0)			{			tls1_PRF(s->s3->tmp.new_cipher->algorithm2,				 TLS_MD_IV_BLOCK_CONST,TLS_MD_IV_BLOCK_CONST_SIZE,				 s->s3->client_random,SSL3_RANDOM_SIZE,				 s->s3->server_random,SSL3_RANDOM_SIZE,				 NULL,0,NULL,0,				 empty,0,iv1,iv2,k*2);			if (client_write)				iv=iv1;			else				iv= &(iv1[k]);			}		}	s->session->key_arg_length=0;#ifdef KSSL_DEBUG	{        int i;	printf("EVP_CipherInit_ex(dd,c,key=,iv=,which)/n");	printf("/tkey= "); for (i=0; i<c->key_len; i++) printf("%02x", key[i]);	printf("/n");	printf("/t iv= "); for (i=0; i<c->iv_len; i++) printf("%02x", iv[i]);	printf("/n");	}#endif	/* KSSL_DEBUG */	EVP_CipherInit_ex(dd,c,NULL,key,iv,(which & SSL3_CC_WRITE));#ifdef TLS_DEBUGprintf("which = %04X/nkey=",which);{ int z; for (z=0; z<EVP_CIPHER_key_length(c); z++) printf("%02X%c",key[z],((z+1)%16)?' ':'/n'); }printf("/niv=");{ int z; for (z=0; z<k; z++) printf("%02X%c",iv[z],((z+1)%16)?' ':'/n'); }printf("/n");#endif	OPENSSL_cleanse(tmp1,sizeof(tmp1));	OPENSSL_cleanse(tmp2,sizeof(tmp1));	OPENSSL_cleanse(iv1,sizeof(iv1));	OPENSSL_cleanse(iv2,sizeof(iv2));	return(1);err:	SSLerr(SSL_F_TLS1_CHANGE_CIPHER_STATE,ERR_R_MALLOC_FAILURE);err2:	return(0);	}

OM_uint32_gssapi_get_mic_arcfour(OM_uint32 * minor_status,			const gsskrb5_ctx context_handle,			krb5_context context,			gss_qop_t qop_req,			const gss_buffer_t message_buffer,			gss_buffer_t message_token,			krb5_keyblock *key){    krb5_error_code ret;    int32_t seq_number;    size_t len, total_len;    u_char k6_data[16], *p0, *p;    EVP_CIPHER_CTX rc4_key;    _gsskrb5_encap_length (22, &len, &total_len, GSS_KRB5_MECHANISM);    message_token->length = total_len;    message_token->value  = malloc (total_len);    if (message_token->value == NULL) {	*minor_status = ENOMEM;	return GSS_S_FAILURE;    }    p0 = _gssapi_make_mech_header(message_token->value,				  len,				  GSS_KRB5_MECHANISM);    p = p0;    *p++ = 0x01; /* TOK_ID */    *p++ = 0x01;    *p++ = 0x11; /* SGN_ALG */    *p++ = 0x00;    *p++ = 0xff; /* Filler */    *p++ = 0xff;    *p++ = 0xff;    *p++ = 0xff;    p = NULL;    ret = arcfour_mic_cksum(context,			    key, KRB5_KU_USAGE_SIGN,			    p0 + 16, 8,  /* SGN_CKSUM */			    p0, 8, /* TOK_ID, SGN_ALG, Filer */			    message_buffer->value, message_buffer->length,			    NULL, 0);    if (ret) {	_gsskrb5_release_buffer(minor_status, message_token);	*minor_status = ret;	return GSS_S_FAILURE;    }    ret = arcfour_mic_key(context, key,			  p0 + 16, 8, /* SGN_CKSUM */			  k6_data, sizeof(k6_data));    if (ret) {	_gsskrb5_release_buffer(minor_status, message_token);	*minor_status = ret;	return GSS_S_FAILURE;    }    HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);    krb5_auth_con_getlocalseqnumber (context,				     context_handle->auth_context,				     &seq_number);    p = p0 + 8; /* SND_SEQ */    _gss_mg_encode_be_uint32(seq_number, p);    krb5_auth_con_setlocalseqnumber (context,				     context_handle->auth_context,				     ++seq_number);    HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);    memset (p + 4, (context_handle->more_flags & LOCAL) ? 0 : 0xff, 4);    EVP_CIPHER_CTX_init(&rc4_key);    EVP_CipherInit_ex(&rc4_key, EVP_rc4(), NULL, k6_data, NULL, 1);    EVP_Cipher(&rc4_key, p, p, 8);    EVP_CIPHER_CTX_cleanup(&rc4_key);    memset(k6_data, 0, sizeof(k6_data));    *minor_status = 0;    return GSS_S_COMPLETE;}

X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter,				 unsigned char *salt, int saltlen,				 unsigned char *aiv, int prf_nid){	X509_ALGOR *scheme = NULL, *kalg = NULL, *ret = NULL;	int alg_nid, keylen;	EVP_CIPHER_CTX ctx;	unsigned char iv[EVP_MAX_IV_LENGTH];	PBE2PARAM *pbe2 = NULL;	const ASN1_OBJECT *obj;	alg_nid = EVP_CIPHER_nid(cipher);	if(alg_nid == NID_undef) {		OPENSSL_PUT_ERROR(PKCS8, PKCS5_pbe2_set_iv, PKCS8_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER);		goto err;	}	obj = OBJ_nid2obj(alg_nid);	if(!(pbe2 = PBE2PARAM_new())) goto merr;	/* Setup the AlgorithmIdentifier for the encryption scheme */	scheme = pbe2->encryption;	scheme->algorithm = (ASN1_OBJECT*) obj;	if(!(scheme->parameter = ASN1_TYPE_new())) goto merr;	/* Create random IV */	if (EVP_CIPHER_iv_length(cipher))		{		if (aiv)			memcpy(iv, aiv, EVP_CIPHER_iv_length(cipher));		else if (RAND_pseudo_bytes(iv, EVP_CIPHER_iv_length(cipher)) < 0)  			goto err;		}	EVP_CIPHER_CTX_init(&ctx);	/* Dummy cipherinit to just setup the IV, and PRF */	if (!EVP_CipherInit_ex(&ctx, cipher, NULL, NULL, iv, 0))		goto err;	if(param_to_asn1(&ctx, scheme->parameter) < 0) {		OPENSSL_PUT_ERROR(PKCS8, PKCS5_pbe2_set_iv, PKCS8_R_ERROR_SETTING_CIPHER_PARAMS);		EVP_CIPHER_CTX_cleanup(&ctx);		goto err;	}	/* If prf NID unspecified see if cipher has a preference.	 * An error is OK here: just means use default PRF.	 */	if ((prf_nid == -1) && 	EVP_CIPHER_CTX_ctrl(&ctx, EVP_CTRL_PBE_PRF_NID, 0, &prf_nid) <= 0)		{		ERR_clear_error();		prf_nid = NID_hmacWithSHA1;		}	EVP_CIPHER_CTX_cleanup(&ctx);	/* If its RC2 then we'd better setup the key length */	if(alg_nid == NID_rc2_cbc)		keylen = EVP_CIPHER_key_length(cipher);	else		keylen = -1;	/* Setup keyfunc */	X509_ALGOR_free(pbe2->keyfunc);	pbe2->keyfunc = PKCS5_pbkdf2_set(iter, salt, saltlen, prf_nid, keylen);	if (!pbe2->keyfunc)		goto merr;	/* Now set up top level AlgorithmIdentifier */	if(!(ret = X509_ALGOR_new())) goto merr;	if(!(ret->parameter = ASN1_TYPE_new())) goto merr;	ret->algorithm = (ASN1_OBJECT*) OBJ_nid2obj(NID_pbes2);	/* Encode PBE2PARAM into parameter */	if(!ASN1_item_pack(pbe2, ASN1_ITEM_rptr(PBE2PARAM),				 &ret->parameter->value.sequence)) goto merr;	ret->parameter->type = V_ASN1_SEQUENCE;	PBE2PARAM_free(pbe2);	pbe2 = NULL;	return ret;	merr:	OPENSSL_PUT_ERROR(PKCS8, PKCS5_pbe2_set_iv, ERR_R_MALLOC_FAILURE);	err:	PBE2PARAM_free(pbe2);	/* Note 'scheme' is freed as part of pbe2 */	X509_ALGOR_free(kalg);	X509_ALGOR_free(ret);	return NULL;//.........这里部分代码省略.........

//.........这里部分代码省略.........    }    *p++ = 0xff; /* Filler */    *p++ = 0xff;    p = NULL;    HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);    krb5_auth_con_getlocalseqnumber (context,				     context_handle->auth_context,				     &seq_number);    _gss_mg_encode_be_uint32(seq_number, p0 + 8);    krb5_auth_con_setlocalseqnumber (context,				     context_handle->auth_context,				     ++seq_number);    HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);    memset (p0 + 8 + 4,	    (context_handle->more_flags & LOCAL) ? 0 : 0xff,	    4);    krb5_generate_random_block(p0 + 24, 8); /* fill in Confounder */    /* p points to data */    p = p0 + GSS_ARCFOUR_WRAP_TOKEN_SIZE;    memcpy(p, input_message_buffer->value, input_message_buffer->length);    if (!IS_DCE_STYLE(context_handle))	p[input_message_buffer->length] = 1; /* padding */    ret = arcfour_mic_cksum(context,			    key, KRB5_KU_USAGE_SEAL,			    p0 + 16, 8, /* SGN_CKSUM */			    p0, 8, /* TOK_ID, SGN_ALG, SEAL_ALG, Filler */			    p0 + 24, 8, /* Confounder */			    p0 + GSS_ARCFOUR_WRAP_TOKEN_SIZE,			    datalen);    if (ret) {	*minor_status = ret;	_gsskrb5_release_buffer(minor_status, output_message_buffer);	return GSS_S_FAILURE;    }    {	int i;	Klocal.keytype = key->keytype;	Klocal.keyvalue.data = Klocaldata;	Klocal.keyvalue.length = sizeof(Klocaldata);	for (i = 0; i < 16; i++)	    Klocaldata[i] = ((u_char *)key->keyvalue.data)[i] ^ 0xF0;    }    ret = arcfour_mic_key(context, &Klocal,			  p0 + 8, 4, /* SND_SEQ */			  k6_data, sizeof(k6_data));    memset(Klocaldata, 0, sizeof(Klocaldata));    if (ret) {	_gsskrb5_release_buffer(minor_status, output_message_buffer);	*minor_status = ret;	return GSS_S_FAILURE;    }    if(conf_req_flag) {	EVP_CIPHER_CTX rc4_key;	EVP_CIPHER_CTX_init(&rc4_key);	EVP_CipherInit_ex(&rc4_key, EVP_rc4(), NULL, k6_data, NULL, 1);	EVP_Cipher(&rc4_key, p0 + 24, p0 + 24, 8 + datalen);	EVP_CIPHER_CTX_cleanup(&rc4_key);    }    memset(k6_data, 0, sizeof(k6_data));    ret = arcfour_mic_key(context, key,			  p0 + 16, 8, /* SGN_CKSUM */			  k6_data, sizeof(k6_data));    if (ret) {	_gsskrb5_release_buffer(minor_status, output_message_buffer);	*minor_status = ret;	return GSS_S_FAILURE;    }    {	EVP_CIPHER_CTX rc4_key;	EVP_CIPHER_CTX_init(&rc4_key);	EVP_CipherInit_ex(&rc4_key, EVP_rc4(), NULL, k6_data, NULL, 1);	EVP_Cipher(&rc4_key, p0 + 8, p0 + 8 /* SND_SEQ */, 8);	EVP_CIPHER_CTX_cleanup(&rc4_key);	memset(k6_data, 0, sizeof(k6_data));    }    if (conf_state)	*conf_state = conf_req_flag;    *minor_status = 0;    return GSS_S_COMPLETE;}

static long enc_ctrl(BIO *b, int cmd, long num, void *ptr)  {  BIO *dbio;  BIO_ENC_CTX *ctx,*dctx;  long ret=1;  int i;  EVP_CIPHER_CTX **c_ctx;  ctx=(BIO_ENC_CTX *)b->ptr;  switch (cmd)    {  case BIO_CTRL_RESET:    ctx->ok=1;    ctx->finished=0;    EVP_CipherInit_ex(&(ctx->cipher),NULL,NULL,NULL,NULL,      ctx->cipher.encrypt);    ret=BIO_ctrl(b->next_bio,cmd,num,ptr);    break;  case BIO_CTRL_EOF:  /* More to read */    if (ctx->cont <= 0)      ret=1;    else      ret=BIO_ctrl(b->next_bio,cmd,num,ptr);    break;  case BIO_CTRL_WPENDING:    ret=ctx->buf_len-ctx->buf_off;    if (ret <= 0)      ret=BIO_ctrl(b->next_bio,cmd,num,ptr);    break;  case BIO_CTRL_PENDING: /* More to read in buffer */    ret=ctx->buf_len-ctx->buf_off;    if (ret <= 0)      ret=BIO_ctrl(b->next_bio,cmd,num,ptr);    break;  case BIO_CTRL_FLUSH:    /* do a final write */again:    while (ctx->buf_len != ctx->buf_off)      {      i=enc_write(b,NULL,0);      if (i < 0)        return i;      }    if (!ctx->finished)      {      ctx->finished=1;      ctx->buf_off=0;      ret=EVP_CipherFinal_ex(&(ctx->cipher),        (unsigned char *)ctx->buf,        &(ctx->buf_len));      ctx->ok=(int)ret;      if (ret <= 0) break;      /* push out the bytes */      goto again;      }        /* Finally flush the underlying BIO */    ret=BIO_ctrl(b->next_bio,cmd,num,ptr);    break;  case BIO_C_GET_CIPHER_STATUS:    ret=(long)ctx->ok;    break;  case BIO_C_DO_STATE_MACHINE:    BIO_clear_retry_flags(b);    ret=BIO_ctrl(b->next_bio,cmd,num,ptr);    BIO_copy_next_retry(b);    break;  case BIO_C_GET_CIPHER_CTX:    c_ctx=(EVP_CIPHER_CTX **)ptr;    (*c_ctx)= &(ctx->cipher);    b->init=1;    break;  case BIO_CTRL_DUP:    dbio=(BIO *)ptr;    dctx=(BIO_ENC_CTX *)dbio->ptr;    memcpy(&(dctx->cipher),&(ctx->cipher),sizeof(ctx->cipher));    dbio->init=1;    break;  default:    ret=BIO_ctrl(b->next_bio,cmd,num,ptr);    break;    }  return(ret);  }

int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *cctx, const char *pass, int passlen,			 ASN1_TYPE *param, const EVP_CIPHER *cipher, const EVP_MD *md,			 int en_de){	EVP_MD_CTX ctx;	unsigned char md_tmp[EVP_MAX_MD_SIZE];	unsigned char key[EVP_MAX_KEY_LENGTH], iv[EVP_MAX_IV_LENGTH];	int i;	PBEPARAM *pbe;	int saltlen, iter;	unsigned char *salt;	const unsigned char *pbuf;	int mdsize;	/* Extract useful info from parameter */	if (param == NULL || param->type != V_ASN1_SEQUENCE ||	    param->value.sequence == NULL) {		EVPerr(EVP_F_PKCS5_PBE_KEYIVGEN,EVP_R_DECODE_ERROR);		return 0;	}	pbuf = param->value.sequence->data;	if (!(pbe = d2i_PBEPARAM(NULL, &pbuf, param->value.sequence->length))) {		EVPerr(EVP_F_PKCS5_PBE_KEYIVGEN,EVP_R_DECODE_ERROR);		return 0;	}	if (!pbe->iter) iter = 1;	else iter = ASN1_INTEGER_get (pbe->iter);	salt = pbe->salt->data;	saltlen = pbe->salt->length;	if(!pass) passlen = 0;	else if(passlen == -1) passlen = TINYCLR_SSL_STRLEN(pass);	EVP_MD_CTX_init(&ctx);	EVP_DigestInit_ex(&ctx, md, NULL);	EVP_DigestUpdate(&ctx, pass, passlen);	EVP_DigestUpdate(&ctx, salt, saltlen);	PBEPARAM_free(pbe);	EVP_DigestFinal_ex(&ctx, md_tmp, NULL);	mdsize = EVP_MD_size(md);	if (mdsize < 0)	    return 0;	for (i = 1; i < iter; i++) {		EVP_DigestInit_ex(&ctx, md, NULL);		EVP_DigestUpdate(&ctx, md_tmp, mdsize);		EVP_DigestFinal_ex (&ctx, md_tmp, NULL);	}	EVP_MD_CTX_cleanup(&ctx);	TINYCLR_SSL_ASSERT(EVP_CIPHER_key_length(cipher) <= (int)sizeof(md_tmp));	TINYCLR_SSL_MEMCPY(key, md_tmp, EVP_CIPHER_key_length(cipher));	TINYCLR_SSL_ASSERT(EVP_CIPHER_iv_length(cipher) <= 16);	TINYCLR_SSL_MEMCPY(iv, md_tmp + (16 - EVP_CIPHER_iv_length(cipher)),						 EVP_CIPHER_iv_length(cipher));	EVP_CipherInit_ex(cctx, cipher, NULL, key, iv, en_de);	OPENSSL_cleanse(md_tmp, EVP_MAX_MD_SIZE);	OPENSSL_cleanse(key, EVP_MAX_KEY_LENGTH);	OPENSSL_cleanse(iv, EVP_MAX_IV_LENGTH);	return 1;}

int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *cctx, const char *pass, int passlen,                       ASN1_TYPE *param, const EVP_CIPHER *cipher,                       const EVP_MD *md, int en_de){    EVP_MD_CTX *ctx;    unsigned char md_tmp[EVP_MAX_MD_SIZE];    unsigned char key[EVP_MAX_KEY_LENGTH], iv[EVP_MAX_IV_LENGTH];    int i;    PBEPARAM *pbe;    int saltlen, iter;    unsigned char *salt;    int mdsize;    int rv = 0;    /* Extract useful info from parameter */    if (param == NULL || param->type != V_ASN1_SEQUENCE ||        param->value.sequence == NULL) {        EVPerr(EVP_F_PKCS5_PBE_KEYIVGEN, EVP_R_DECODE_ERROR);        return 0;    }    pbe = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(PBEPARAM), param);    if (pbe == NULL) {        EVPerr(EVP_F_PKCS5_PBE_KEYIVGEN, EVP_R_DECODE_ERROR);        return 0;    }    if (!pbe->iter)        iter = 1;    else        iter = ASN1_INTEGER_get(pbe->iter);    salt = pbe->salt->data;    saltlen = pbe->salt->length;    if (!pass)        passlen = 0;    else if (passlen == -1)        passlen = strlen(pass);    ctx = EVP_MD_CTX_new();    if (ctx == NULL) {        EVPerr(EVP_F_PKCS5_PBE_KEYIVGEN, ERR_R_MALLOC_FAILURE);        goto err;    }    if (!EVP_DigestInit_ex(ctx, md, NULL))        goto err;    if (!EVP_DigestUpdate(ctx, pass, passlen))        goto err;    if (!EVP_DigestUpdate(ctx, salt, saltlen))        goto err;    PBEPARAM_free(pbe);    if (!EVP_DigestFinal_ex(ctx, md_tmp, NULL))        goto err;    mdsize = EVP_MD_size(md);    if (mdsize < 0)        return 0;    for (i = 1; i < iter; i++) {        if (!EVP_DigestInit_ex(ctx, md, NULL))            goto err;        if (!EVP_DigestUpdate(ctx, md_tmp, mdsize))            goto err;        if (!EVP_DigestFinal_ex(ctx, md_tmp, NULL))            goto err;    }    OPENSSL_assert(EVP_CIPHER_key_length(cipher) <= (int)sizeof(md_tmp));    memcpy(key, md_tmp, EVP_CIPHER_key_length(cipher));    OPENSSL_assert(EVP_CIPHER_iv_length(cipher) <= 16);    memcpy(iv, md_tmp + (16 - EVP_CIPHER_iv_length(cipher)),           EVP_CIPHER_iv_length(cipher));    if (!EVP_CipherInit_ex(cctx, cipher, NULL, key, iv, en_de))        goto err;    OPENSSL_cleanse(md_tmp, EVP_MAX_MD_SIZE);    OPENSSL_cleanse(key, EVP_MAX_KEY_LENGTH);    OPENSSL_cleanse(iv, EVP_MAX_IV_LENGTH);    rv = 1; err:    EVP_MD_CTX_free(ctx);    return rv;}

//.........这里部分代码省略.........		if ((hiv != NULL) && !set_hex(hiv,iv,sizeof iv))			{			BIO_printf(bio_err,"invalid hex iv value/n");			goto end;			}		if ((hiv == NULL) && (str == NULL)		    && EVP_CIPHER_iv_length(cipher) != 0)			{			/* No IV was explicitly set and no IV was generated			 * during EVP_BytesToKey. Hence the IV is undefined,			 * making correct decryption impossible. */			BIO_printf(bio_err, "iv undefined/n");			goto end;			}		if ((hkey != NULL) && !set_hex(hkey,key,sizeof key))			{			BIO_printf(bio_err,"invalid hex key value/n");			goto end;			}		if ((benc=BIO_new(BIO_f_cipher())) == NULL)			goto end;		/* Since we may be changing parameters work on the encryption		 * context rather than calling BIO_set_cipher().		 */		BIO_get_cipher_ctx(benc, &ctx);		if (non_fips_allow)			EVP_CIPHER_CTX_set_flags(ctx,				EVP_CIPH_FLAG_NON_FIPS_ALLOW);		if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc))			{			BIO_printf(bio_err, "Error setting cipher %s/n",				EVP_CIPHER_name(cipher));			ERR_print_errors(bio_err);			goto end;			}		if (nopad)			EVP_CIPHER_CTX_set_padding(ctx, 0);		if (!EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc))			{			BIO_printf(bio_err, "Error setting cipher %s/n",				EVP_CIPHER_name(cipher));			ERR_print_errors(bio_err);			goto end;			}		if (debug)			{			BIO_set_callback(benc,BIO_debug_callback);			BIO_set_callback_arg(benc,(char *)bio_err);			}		if (printkey)			{			if (!nosalt)				{				printf("salt=");				for (i=0; i<(int)sizeof(salt); i++)					printf("%02X",salt[i]);				printf("/n");

static OM_uint32verify_mic_des           (OM_uint32 * minor_status,            const gsskrb5_ctx context_handle,	    krb5_context context,            const gss_buffer_t message_buffer,            const gss_buffer_t token_buffer,            gss_qop_t * qop_state,	    krb5_keyblock *key,	    const char *type	    ){  u_char *p;  EVP_MD_CTX *md5;  u_char hash[16], *seq;  DES_key_schedule schedule;  EVP_CIPHER_CTX des_ctx;  DES_cblock zero;  DES_cblock deskey;  uint32_t seq_number;  OM_uint32 ret;  int cmp;  p = token_buffer->value;  ret = _gsskrb5_verify_header (&p,				   token_buffer->length,				   type,				   GSS_KRB5_MECHANISM);  if (ret)      return ret;  if (memcmp(p, "/x00/x00", 2) != 0)      return GSS_S_BAD_SIG;  p += 2;  if (memcmp (p, "/xff/xff/xff/xff", 4) != 0)    return GSS_S_BAD_MIC;  p += 4;  p += 16;  /* verify checksum */  md5 = EVP_MD_CTX_create();  EVP_DigestInit_ex(md5, EVP_md5(), NULL);  EVP_DigestUpdate(md5, p - 24, 8);  EVP_DigestUpdate(md5, message_buffer->value, message_buffer->length);  EVP_DigestFinal_ex(md5, hash, NULL);  EVP_MD_CTX_destroy(md5);  memset (&zero, 0, sizeof(zero));  memcpy (&deskey, key->keyvalue.data, sizeof(deskey));  DES_set_key_unchecked (&deskey, &schedule);  DES_cbc_cksum ((void *)hash, (void *)hash, sizeof(hash),		 &schedule, &zero);  if (ct_memcmp (p - 8, hash, 8) != 0) {    memset (deskey, 0, sizeof(deskey));    memset (&schedule, 0, sizeof(schedule));    return GSS_S_BAD_MIC;  }  /* verify sequence number */  HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);  p -= 16;  EVP_CIPHER_CTX_init(&des_ctx);  EVP_CipherInit_ex(&des_ctx, EVP_des_cbc(), NULL, key->keyvalue.data, hash, 0);  EVP_Cipher(&des_ctx, p, p, 8);  EVP_CIPHER_CTX_cleanup(&des_ctx);  memset (deskey, 0, sizeof(deskey));  memset (&schedule, 0, sizeof(schedule));  seq = p;  _gsskrb5_decode_om_uint32(seq, &seq_number);  if (context_handle->more_flags & LOCAL)      cmp = ct_memcmp(&seq[4], "/xff/xff/xff/xff", 4);  else      cmp = ct_memcmp(&seq[4], "/x00/x00/x00/x00", 4);  if (cmp != 0) {    HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);    return GSS_S_BAD_MIC;  }  ret = _gssapi_msg_order_check(context_handle->order, seq_number);  if (ret) {      HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);      return ret;  }  HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);  return GSS_S_COMPLETE;}

static int test_tls13_encryption(void){    SSL_CTX *ctx = NULL;    SSL *s = NULL;    SSL3_RECORD rec;    unsigned char *key = NULL, *iv = NULL, *seq = NULL;    const EVP_CIPHER *ciph = EVP_aes_128_gcm();    int ret = 0;    size_t ivlen, ctr;    /*     * Encrypted TLSv1.3 records always have an outer content type of     * application data, and a record version of TLSv1.2.     */    rec.data = NULL;    rec.type = SSL3_RT_APPLICATION_DATA;    rec.rec_version = TLS1_2_VERSION;    ctx = SSL_CTX_new(TLS_method());    if (!TEST_ptr(ctx)) {        TEST_info("Failed creating SSL_CTX");        goto err;    }    s = SSL_new(ctx);    if (!TEST_ptr(s)) {        TEST_info("Failed creating SSL");        goto err;    }    s->enc_read_ctx = EVP_CIPHER_CTX_new();    if (!TEST_ptr(s->enc_read_ctx))        goto err;    s->enc_write_ctx = EVP_CIPHER_CTX_new();    if (!TEST_ptr(s->enc_write_ctx))        goto err;    s->s3->tmp.new_cipher = SSL_CIPHER_find(s, TLS13_AES_128_GCM_SHA256_BYTES);    if (!TEST_ptr(s->s3->tmp.new_cipher)) {        TEST_info("Failed to find cipher");        goto err;    }    for (ctr = 0; ctr < OSSL_NELEM(refdata); ctr++) {        /* Load the record */        ivlen = EVP_CIPHER_iv_length(ciph);        if (!load_record(&rec, &refdata[ctr], &key, s->read_iv, ivlen,                         RECORD_LAYER_get_read_sequence(&s->rlayer))) {            TEST_error("Failed loading key into EVP_CIPHER_CTX");            goto err;        }        /* Set up the read/write sequences */        memcpy(RECORD_LAYER_get_write_sequence(&s->rlayer),               RECORD_LAYER_get_read_sequence(&s->rlayer), SEQ_NUM_SIZE);        memcpy(s->write_iv, s->read_iv, ivlen);        /* Load the key into the EVP_CIPHER_CTXs */        if (EVP_CipherInit_ex(s->enc_write_ctx, ciph, NULL, key, NULL, 1) <= 0                || EVP_CipherInit_ex(s->enc_read_ctx, ciph, NULL, key, NULL, 0)                   <= 0) {            TEST_error("Failed loading key into EVP_CIPHER_CTX/n");            goto err;        }        /* Encrypt it */        if (!TEST_size_t_eq(tls13_enc(s, &rec, 1, 1), 1)) {            TEST_info("Failed to encrypt record %zu", ctr);            goto err;        }        if (!TEST_true(test_record(&rec, &refdata[ctr], 1))) {            TEST_info("Record %zu encryption test failed", ctr);            goto err;        }        /* Decrypt it */        if (!TEST_int_eq(tls13_enc(s, &rec, 1, 0), 1)) {            TEST_info("Failed to decrypt record %zu", ctr);            goto err;        }        if (!TEST_true(test_record(&rec, &refdata[ctr], 0))) {            TEST_info("Record %zu decryption test failed", ctr);            goto err;        }        OPENSSL_free(rec.data);        OPENSSL_free(key);        OPENSSL_free(iv);        OPENSSL_free(seq);        rec.data = NULL;        key = NULL;        iv = NULL;        seq = NULL;    }    TEST_note("PASS: %zu records tested", ctr);    ret = 1; err://.........这里部分代码省略.........

//.........这里部分代码省略.........        }#endif        RECORD_LAYER_reset_read_sequence(&s->rlayer);        mac_secret = &(s->s3->read_mac_secret[0]);    } else {        if (s->enc_write_ctx != NULL)            reuse_dd = 1;        else if ((s->enc_write_ctx = EVP_CIPHER_CTX_new()) == NULL)            goto err;        else            /*             * make sure it's initialised in case we exit later with an error             */            EVP_CIPHER_CTX_reset(s->enc_write_ctx);        dd = s->enc_write_ctx;        if (ssl_replace_hash(&s->write_hash, m) == NULL) {                SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE, ERR_R_INTERNAL_ERROR);                goto err2;        }#ifndef OPENSSL_NO_COMP        /* COMPRESS */        COMP_CTX_free(s->compress);        s->compress = NULL;        if (comp != NULL) {            s->compress = COMP_CTX_new(comp);            if (s->compress == NULL) {                SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,                       SSL_R_COMPRESSION_LIBRARY_ERROR);                goto err2;            }        }#endif        RECORD_LAYER_reset_write_sequence(&s->rlayer);        mac_secret = &(s->s3->write_mac_secret[0]);    }    if (reuse_dd)        EVP_CIPHER_CTX_reset(dd);    p = s->s3->tmp.key_block;    i = EVP_MD_size(m);    if (i < 0)        goto err2;    cl = EVP_CIPHER_key_length(c);    j = cl;    k = EVP_CIPHER_iv_length(c);    if ((which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) ||        (which == SSL3_CHANGE_CIPHER_SERVER_READ)) {        ms = &(p[0]);        n = i + i;        key = &(p[n]);        n += j + j;        iv = &(p[n]);        n += k + k;    } else {        n = i;        ms = &(p[n]);        n += i + j;        key = &(p[n]);        n += j + k;        iv = &(p[n]);        n += k;    }    if (n > s->s3->tmp.key_block_length) {        SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE, ERR_R_INTERNAL_ERROR);        goto err2;    }    memcpy(mac_secret, ms, i);    EVP_CipherInit_ex(dd, c, NULL, key, iv, (which & SSL3_CC_WRITE));#ifdef OPENSSL_SSL_TRACE_CRYPTO    if (s->msg_callback) {        int wh = which & SSL3_CC_WRITE ?            TLS1_RT_CRYPTO_WRITE : TLS1_RT_CRYPTO_READ;        s->msg_callback(2, s->version, wh | TLS1_RT_CRYPTO_MAC,                        mac_secret, EVP_MD_size(m), s, s->msg_callback_arg);        if (c->key_len)            s->msg_callback(2, s->version, wh | TLS1_RT_CRYPTO_KEY,                            key, c->key_len, s, s->msg_callback_arg);        if (k) {            s->msg_callback(2, s->version, wh | TLS1_RT_CRYPTO_IV,                            iv, k, s, s->msg_callback_arg);        }    }#endif    OPENSSL_cleanse(exp_key, sizeof(exp_key));    OPENSSL_cleanse(exp_iv, sizeof(exp_iv));    return (1); err:    SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE, ERR_R_MALLOC_FAILURE); err2:    OPENSSL_cleanse(exp_key, sizeof(exp_key));    OPENSSL_cleanse(exp_iv, sizeof(exp_iv));    return (0);}

int AesFileEnc::do_crypt(FILE *in, FILE *out, int do_encrypt){	/* 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";	unsigned char* key = this->key();	//	std::cout <<key<<std::endl;	//unsigned char key[] = "0123456789abcdeF";	std::cout <<key<< std::endl;	//unsigned char iv[] = "1234567887654321";	EVP_CIPHER_CTX_init(&ctx);		switch(this->type)	{		case cbc128:			EVP_CipherInit_ex(&ctx, EVP_aes_128_cbc(), NULL, NULL, NULL,				do_encrypt);			break;		case cbc192:			EVP_CipherInit_ex(&ctx, EVP_aes_192_cbc(), NULL, NULL, NULL,				do_encrypt);		break;		case cbc256:			EVP_CipherInit_ex(&ctx, EVP_aes_256_cbc(), NULL, NULL, NULL,				do_encrypt);			break;		case ecb128:			EVP_CipherInit_ex(&ctx, EVP_aes_128_ecb(), NULL, NULL, NULL,				do_encrypt);			break;		case ecb192:			EVP_CipherInit_ex(&ctx, EVP_aes_192_ecb(), NULL, NULL, NULL,				do_encrypt);			break;		case ecb256:			EVP_CipherInit_ex(&ctx, EVP_aes_256_ecb(), NULL, NULL, NULL,				do_encrypt);			break;		case cfb128:			EVP_CipherInit_ex(&ctx, EVP_aes_128_cfb(), NULL, NULL, NULL,				do_encrypt);			break;		case cfb192:			EVP_CipherInit_ex(&ctx, EVP_aes_192_cfb(), NULL, NULL, NULL,				do_encrypt);			break;		case cfb256:			EVP_CipherInit_ex(&ctx, EVP_aes_256_cfb(), NULL, NULL, NULL,				do_encrypt);			break;		case ofb128:			EVP_CipherInit_ex(&ctx, EVP_aes_128_ofb(), NULL, NULL, NULL,				do_encrypt);			break;		case ofb192:			EVP_CipherInit_ex(&ctx, EVP_aes_192_ofb(), NULL, NULL, NULL,				do_encrypt);			break;		case ofb256:			EVP_CipherInit_ex(&ctx, EVP_aes_256_ofb(), NULL, NULL, NULL,				do_encrypt);			break;	}	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;			}