/* crypto/pkcs7/pk7_doit.c */

/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

 * All rights reserved.

 *

 * This package is an SSL implementation written

 * by Eric Young (eay@cryptsoft.com).

 * The implementation was written so as to conform with Netscapes SSL.

 * 

 * This library is free for commercial and non-commercial use as long as

 * the following conditions are aheared to.  The following conditions

 * apply to all code found in this distribution, be it the RC4, RSA,

 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

 * included with this distribution is covered by the same copyright terms

 * except that the holder is Tim Hudson (tjh@cryptsoft.com).

 * 

 * Copyright remains Eric Young's, and as such any Copyright notices in

 * the code are not to be removed.

 * If this package is used in a product, Eric Young should be given attribution

 * as the author of the parts of the library used.

 * This can be in the form of a textual message at program startup or

 * in documentation (online or textual) provided with the package.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *    "This product includes cryptographic software written by

 *     Eric Young (eay@cryptsoft.com)"

 *    The word 'cryptographic' can be left out if the rouines from the library

 *    being used are not cryptographic related :-).

 * 4. If you include any Windows specific code (or a derivative thereof) from 

 *    the apps directory (application code) you must include an acknowledgement:

 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

 * 

 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 * 

 * The licence and distribution terms for any publically available version or

 * derivative of this code cannot be changed.  i.e. this code cannot simply be

 * copied and put under another distribution licence

 * [including the GNU Public Licence.]

 */

#include <stdio.h>

#include "cryptlib.h"

#include <openssl/rand.h>

#include <openssl/objects.h>

#include <openssl/x509.h>

#include <openssl/x509v3.h>

#include <openssl/err.h>

static int add_attribute(STACK_OF(X509_ATTRIBUTE) **sk, int nid, int atrtype,

			 void *value);

static ASN1_TYPE *get_attribute(STACK_OF(X509_ATTRIBUTE) *sk, int nid);

static int PKCS7_type_is_other(PKCS7* p7)

	{

	int isOther=1;

	int nid=OBJ_obj2nid(p7->type);

	switch( nid )

		{

	case NID_pkcs7_data:

	case NID_pkcs7_signed:

	case NID_pkcs7_enveloped:

	case NID_pkcs7_signedAndEnveloped:

	case NID_pkcs7_digest:

	case NID_pkcs7_encrypted:

		isOther=0;

		break;

	default:

		isOther=1;

		}

	return isOther;

	}

static ASN1_OCTET_STRING *PKCS7_get_octet_string(PKCS7 *p7)

	{

	if ( PKCS7_type_is_data(p7))

		return p7->d.data;

	if ( PKCS7_type_is_other(p7) && p7->d.other

		&& (p7->d.other->type == V_ASN1_OCTET_STRING))

		return p7->d.other->value.octet_string;

	return NULL;

	}

static int PKCS7_bio_add_digest(BIO **pbio, X509_ALGOR *alg)

	{

	BIO *btmp;

	const EVP_MD *md;

	if ((btmp=BIO_new(BIO_f_md())) == NULL)

		{

		PKCS7err(PKCS7_F_PKCS7_BIO_ADD_DIGEST,ERR_R_BIO_LIB);

		goto err;

		}

	md=EVP_get_digestbyobj(alg->algorithm);

	if (md == NULL)

		{

		PKCS7err(PKCS7_F_PKCS7_BIO_ADD_DIGEST,PKCS7_R_UNKNOWN_DIGEST_TYPE);

		goto err;

		}

	BIO_set_md(btmp,md);

	if (*pbio == NULL)

		*pbio=btmp;

	else if (!BIO_push(*pbio,btmp))

		{

		PKCS7err(PKCS7_F_PKCS7_BIO_ADD_DIGEST,ERR_R_BIO_LIB);

		goto err;

		}

	btmp=NULL;

	return 1;

	err:

	if (btmp)

		BIO_free(btmp);

	return 0;

	}

EXPORT_C 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;

	EVP_PKEY *pkey;

	ASN1_OCTET_STRING *os=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;

	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;

		int jj,max;

		unsigned char *tmp;

		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)

			if (RAND_pseudo_bytes(iv,ivlen) <= 0)

				goto err;

		if (EVP_CipherInit_ex(ctx, evp_cipher, NULL, NULL, NULL, 1)<=0)

			goto err;

		if (EVP_CIPHER_CTX_rand_key(ctx, key) <= 0)

			goto err;

		if (EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, 1) <= 0)

			goto err;

		if (ivlen > 0) {

			if (xalg->parameter == NULL) {

				xalg->parameter = ASN1_TYPE_new();

				if (xalg->parameter == NULL)

					goto err;

			}

			if(EVP_CIPHER_param_to_asn1(ctx, xalg->parameter) < 0)

								       goto err;

		}

		/* Lets do the pub key stuff :-) */

		max=0;

		for (i=0; i<sk_PKCS7_RECIP_INFO_num(rsk); i++)

			{

			ri=sk_PKCS7_RECIP_INFO_value(rsk,i);

			if (ri->cert == NULL)

				{

				PKCS7err(PKCS7_F_PKCS7_DATAINIT,PKCS7_R_MISSING_CERIPEND_INFO);

				goto err;

				}

			if ((pkey=X509_get_pubkey(ri->cert)) == NULL)

				goto err;

			jj=EVP_PKEY_size(pkey);

			EVP_PKEY_free(pkey);

			if (max < jj) max=jj;

			}

		if ((tmp=(unsigned char *)OPENSSL_malloc(max)) == NULL)

			{

			PKCS7err(PKCS7_F_PKCS7_DATAINIT,ERR_R_MALLOC_FAILURE);

			goto err;

			}

		for (i=0; i<sk_PKCS7_RECIP_INFO_num(rsk); i++)

			{

			ri=sk_PKCS7_RECIP_INFO_value(rsk,i);

			if ((pkey=X509_get_pubkey(ri->cert)) == NULL)

				goto err;

			jj=EVP_PKEY_encrypt(tmp,key,keylen,pkey);

			EVP_PKEY_free(pkey);

			if (jj <= 0)

				{

				PKCS7err(PKCS7_F_PKCS7_DATAINIT,ERR_R_EVP_LIB);

				OPENSSL_free(tmp);

				goto err;

				}

			if (!M_ASN1_OCTET_STRING_set(ri->enc_key,tmp,jj))

				{

				PKCS7err(PKCS7_F_PKCS7_DATAINIT,

					ERR_R_MALLOC_FAILURE);

				OPENSSL_free(tmp);

				goto err;

				}

			}

		OPENSSL_free(tmp);

		OPENSSL_cleanse(key, keylen);

		if (out == NULL)

			out=btmp;

		else

			BIO_push(out,btmp);

		btmp=NULL;

		}

	if (bio == NULL)

		{

		if (PKCS7_is_detached(p7))

			bio=BIO_new(BIO_s_null());

		else if (os && os->length > 0)

			bio = BIO_new_mem_buf(os->data, os->length);

		if(bio == NULL)

			{

			bio=BIO_new(BIO_s_mem());

			if (bio == NULL)

				goto err;

			BIO_set_mem_eof_return(bio,0);

			}

		}

	BIO_push(out,bio);

	bio=NULL;

	if (0)

		{

err:

		if (out != NULL)

			BIO_free_all(out);

		if (btmp != NULL)

			BIO_free_all(btmp);

		out=NULL;

		}

	return(out);

	}

static int pkcs7_cmp_ri(PKCS7_RECIP_INFO *ri, X509 *pcert)

	{

	int ret;

	ret = X509_NAME_cmp(ri->issuer_and_serial->issuer,

				pcert->cert_info->issuer);

	if (ret)

		return ret;

	return M_ASN1_INTEGER_cmp(pcert->cert_info->serialNumber,

					ri->issuer_and_serial->serial);

	}

/* int */

EXPORT_C BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert)

	{

	int i,j;

	BIO *out=NULL,*btmp=NULL,*etmp=NULL,*bio=NULL;

	unsigned char *tmp=NULL;

	X509_ALGOR *xa;

	ASN1_OCTET_STRING *data_body=NULL;

	const EVP_MD *evp_md;

	const EVP_CIPHER *evp_cipher=NULL;

	EVP_CIPHER_CTX *evp_ctx=NULL;

	X509_ALGOR *enc_alg=NULL;

	STACK_OF(X509_ALGOR) *md_sk=NULL;

	STACK_OF(PKCS7_RECIP_INFO) *rsk=NULL;

	X509_ALGOR *xalg=NULL;

	PKCS7_RECIP_INFO *ri=NULL;

	i=OBJ_obj2nid(p7->type);

	p7->state=PKCS7_S_HEADER;

	switch (i)

		{

	case NID_pkcs7_signed:

		data_body=PKCS7_get_octet_string(p7->d.sign->contents);

		md_sk=p7->d.sign->md_algs;

		break;

	case NID_pkcs7_signedAndEnveloped:

		rsk=p7->d.signed_and_enveloped->recipientinfo;

		md_sk=p7->d.signed_and_enveloped->md_algs;

		data_body=p7->d.signed_and_enveloped->enc_data->enc_data;

		enc_alg=p7->d.signed_and_enveloped->enc_data->algorithm;

		evp_cipher=EVP_get_cipherbyobj(enc_alg->algorithm);

		if (evp_cipher == NULL)

			{

			PKCS7err(PKCS7_F_PKCS7_DATADECODE,PKCS7_R_UNSUPPORTED_CIPHER_TYPE);

			goto err;

			}

		xalg=p7->d.signed_and_enveloped->enc_data->algorithm;

		break;

	case NID_pkcs7_enveloped:

		rsk=p7->d.enveloped->recipientinfo;

		enc_alg=p7->d.enveloped->enc_data->algorithm;

		data_body=p7->d.enveloped->enc_data->enc_data;

		evp_cipher=EVP_get_cipherbyobj(enc_alg->algorithm);

		if (evp_cipher == NULL)

			{

			PKCS7err(PKCS7_F_PKCS7_DATADECODE,PKCS7_R_UNSUPPORTED_CIPHER_TYPE);

			goto err;

			}

		xalg=p7->d.enveloped->enc_data->algorithm;

		break;

	default:

		PKCS7err(PKCS7_F_PKCS7_DATADECODE,PKCS7_R_UNSUPPORTED_CONTENT_TYPE);

	        goto err;

		}

	/* We will be checking the signature */

	if (md_sk != NULL)

		{

		for (i=0; i<sk_X509_ALGOR_num(md_sk); i++)

			{

			xa=sk_X509_ALGOR_value(md_sk,i);

			if ((btmp=BIO_new(BIO_f_md())) == NULL)

				{

				PKCS7err(PKCS7_F_PKCS7_DATADECODE,ERR_R_BIO_LIB);

				goto err;

				}

			j=OBJ_obj2nid(xa->algorithm);

			evp_md=EVP_get_digestbynid(j);

			if (evp_md == NULL)

				{

				PKCS7err(PKCS7_F_PKCS7_DATADECODE,PKCS7_R_UNKNOWN_DIGEST_TYPE);

				goto err;

				}

			BIO_set_md(btmp,evp_md);

			if (out == NULL)

				out=btmp;

			else

				BIO_push(out,btmp);

			btmp=NULL;

			}

		}

	if (evp_cipher != NULL)

		{

#if 0

		unsigned char key[EVP_MAX_KEY_LENGTH];

		unsigned char iv[EVP_MAX_IV_LENGTH];

		unsigned char *p;

		int keylen,ivlen;

		int max;

		X509_OBJECT ret;

#endif

		int jj;

		if ((etmp=BIO_new(BIO_f_cipher())) == NULL)

			{

			PKCS7err(PKCS7_F_PKCS7_DATADECODE,ERR_R_BIO_LIB);

			goto err;

			}

		/* It was encrypted, we need to decrypt the secret key

		 * with the private key */

		/* Find the recipientInfo which matches the passed certificate

		 * (if any)

		 */

		if (pcert) {

			for (i=0; i<sk_PKCS7_RECIP_INFO_num(rsk); i++) {

				ri=sk_PKCS7_RECIP_INFO_value(rsk,i);

				if (!pkcs7_cmp_ri(ri, pcert))

					break;

				ri=NULL;

			}

			if (ri == NULL) {

				PKCS7err(PKCS7_F_PKCS7_DATADECODE,

				      PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE);

				goto err;

			}

		}

		jj=EVP_PKEY_size(pkey);

		tmp=(unsigned char *)OPENSSL_malloc(jj+10);

		if (tmp == NULL)

			{

			PKCS7err(PKCS7_F_PKCS7_DATADECODE,ERR_R_MALLOC_FAILURE);

			goto err;

			}

		/* If we haven't got a certificate try each ri in turn */

		if (pcert == NULL)

			{

			for (i=0; i<sk_PKCS7_RECIP_INFO_num(rsk); i++)

				{

				ri=sk_PKCS7_RECIP_INFO_value(rsk,i);

				jj=EVP_PKEY_decrypt(tmp,

					M_ASN1_STRING_data(ri->enc_key),

					M_ASN1_STRING_length(ri->enc_key),

						pkey);

				if (jj > 0)

					break;

				ERR_clear_error();

				ri = NULL;

				}

			if (ri == NULL)

				{

				PKCS7err(PKCS7_F_PKCS7_DATADECODE,

				      PKCS7_R_NO_RECIPIENT_MATCHES_KEY);

				goto err;

				}

			}

		else

			{

			jj=EVP_PKEY_decrypt(tmp,

				M_ASN1_STRING_data(ri->enc_key),

				M_ASN1_STRING_length(ri->enc_key), pkey);

			if (jj <= 0)

				{

				PKCS7err(PKCS7_F_PKCS7_DATADECODE,

								ERR_R_EVP_LIB);

				goto err;

				}

			}

		evp_ctx=NULL;

		BIO_get_cipher_ctx(etmp,&evp_ctx);

		if (EVP_CipherInit_ex(evp_ctx,evp_cipher,NULL,NULL,NULL,0) <= 0)

			goto err;

		if (EVP_CIPHER_asn1_to_param(evp_ctx,enc_alg->parameter) < 0)

			goto err;

		if (jj != EVP_CIPHER_CTX_key_length(evp_ctx)) {

			/* Some S/MIME clients don't use the same key

			 * and effective key length. The key length is

			 * determined by the size of the decrypted RSA key.

			 */

			if(!EVP_CIPHER_CTX_set_key_length(evp_ctx, jj))

				{

				PKCS7err(PKCS7_F_PKCS7_DATADECODE,

					PKCS7_R_DECRYPTED_KEY_IS_WRONG_LENGTH);

				goto err;

				}

		} 

		if (EVP_CipherInit_ex(evp_ctx,NULL,NULL,tmp,NULL,0) <= 0)

			goto err;

		OPENSSL_cleanse(tmp,jj);

		if (out == NULL)

			out=etmp;

		else

			BIO_push(out,etmp);

		etmp=NULL;

		}