/* $OpenBSD: pk7_doit.c,v 1.38 2015/09/30 18:41:06 jsing Exp $ */

/* 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 <stdlib.h>

#include <string.h>

#include <openssl/err.h>

#include <openssl/objects.h>

#include <openssl/x509.h>

#include <openssl/x509v3.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)

{

	case NID_pkcs7_data:

	case NID_pkcs7_signed:

	case NID_pkcs7_enveloped:

	case NID_pkcs7_signedAndEnveloped:

	case NID_pkcs7_digest:

	case NID_pkcs7_encrypted:

	default:

	}

}

static ASN1_OCTET_STRING *

PKCS7_get_octet_string(PKCS7 *p7)

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

}

static int

PKCS7_bio_add_digest(BIO **pbio, X509_ALGOR *alg)

	BIO *btmp;

	const EVP_MD *md;

	}

		    PKCS7_R_UNKNOWN_DIGEST_TYPE);

	}

	}

}

static int

pkcs7_encode_rinfo(PKCS7_RECIP_INFO *ri, unsigned char *key, int keylen)

	size_t eklen;

	    EVP_PKEY_CTRL_PKCS7_ENCRYPT, 0, ri) <= 0) {

	}

	}

}

static int

pkcs7_decrypt_rinfo(unsigned char **pek, int *peklen, PKCS7_RECIP_INFO *ri,

    EVP_PKEY *pkey)

	size_t eklen;

	    EVP_PKEY_CTRL_PKCS7_DECRYPT, 0, ri) <= 0) {

	}

	    ri->enc_key->data, ri->enc_key->length) <= 0)

	}

	    ri->enc_key->data, ri->enc_key->length) <= 0) {

	}

	}

}

BIO *

PKCS7_dataInit(PKCS7 *p7, BIO *bio)

	int i;

	}

	/*

	 * 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.

	 */

	}

	case NID_pkcs7_signed:

	case NID_pkcs7_signedAndEnveloped:

			    PKCS7_R_CIPHER_NOT_INITIALIZED);

		}

		break;

	case NID_pkcs7_enveloped:

			    PKCS7_R_CIPHER_NOT_INITIALIZED);

		}

		break;

	case NID_pkcs7_digest:

	case NID_pkcs7_data:

		break;

	default:

		    PKCS7_R_UNSUPPORTED_CONTENT_TYPE);

	}

		unsigned char key[EVP_MAX_KEY_LENGTH];

		unsigned char iv[EVP_MAX_IV_LENGTH];

		int keylen, ivlen;

		EVP_CIPHER_CTX *ctx;

		}

		    NULL, 1) <= 0)

			}

		}

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

		}

		else

	}

		}

	}

	else

	if (0) {

	}

}

static int

pkcs7_cmp_ri(PKCS7_RECIP_INFO *ri, X509 *pcert)

	int ret;

	    pcert->cert_info->issuer);

	    ri->issuer_and_serial->serial);

}

/* int */

BIO *

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

	int i, j;

	X509_ALGOR *xa;

	const EVP_MD *evp_md;

		    PKCS7_R_INVALID_NULL_POINTER);

	}

	}

	case NID_pkcs7_signed:

	case NID_pkcs7_signedAndEnveloped:

			    PKCS7_R_UNSUPPORTED_CIPHER_TYPE);

		}

		break;

	case NID_pkcs7_enveloped:

			    PKCS7_R_UNSUPPORTED_CIPHER_TYPE);

		}

		break;

	default:

		    PKCS7_R_UNSUPPORTED_CONTENT_TYPE);

	}

	/* We will be checking the signature */

				    ERR_R_BIO_LIB);

			}

				    PKCS7_R_UNKNOWN_DIGEST_TYPE);

			}

			else

		}

	}

		}

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

		 * with the private key */

		/* Find the recipientInfo which matches the passed certificate

		 * (if any)

		 */

			}

				    PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE);

			}

		}

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

			/* Always attempt to decrypt all rinfo even

			 * after sucess as a defence against MMA timing

			 * attacks.

			 */

				    ri, pkey) < 0)

			}

		} else {

			/* Only exit on fatal errors, not decrypt failure */

		}

		    NULL, 0) <= 0)

		/* Generate random key as MMA defence */

		}

			/* 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.

			 */

				/* Use random key as MMA defence */

			}

		}

		/* Clear errors so we don't leak information useful in MMA */

		}

		}

		else

	}

	} else {

		else {

		}

	}

	if (0) {

		}

		}

	}

}

static BIO *

PKCS7_find_digest(EVP_MD_CTX **pmd, BIO *bio, int nid)

	for (;;) {

			    PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST);

		}

			    ERR_R_INTERNAL_ERROR);

		}

	}

	return NULL;

}

static int

do_pkcs7_signed_attrib(PKCS7_SIGNER_INFO *si, EVP_MD_CTX *mctx)

	unsigned char md_data[EVP_MAX_MD_SIZE];

	unsigned int md_len;

	/* Add signing time if not already present */

			    ERR_R_MALLOC_FAILURE);

		}

	}

	/* Add digest */

	}

	}

	/* Now sign the attributes */

}

int

PKCS7_dataFinal(PKCS7 *p7, BIO *bio)

	int i, j;

	BIO *btmp;

	PKCS7_SIGNER_INFO *si;

	EVP_MD_CTX *mdc, ctx_tmp;

	STACK_OF(X509_ATTRIBUTE) *sk;

		    PKCS7_R_INVALID_NULL_POINTER);

	}

	}

	case NID_pkcs7_data:

	case NID_pkcs7_signedAndEnveloped:

		/* XXX */

				    ERR_R_MALLOC_FAILURE);

			}

		}

		break;

	case NID_pkcs7_enveloped:

		/* XXX */

				    ERR_R_MALLOC_FAILURE);

			}

		}

		break;

	case NID_pkcs7_signed:

		}

		/* If detached data then the content is excluded */

		}

		break;

	case NID_pkcs7_digest:

		}

		/* If detached data then the content is excluded */

		    p7->detached) {

		}

		break;

	default:

		    PKCS7_R_UNSUPPORTED_CONTENT_TYPE);

	}

			/* We now have the EVP_MD_CTX, lets do the

			 * signing. */

			/* If there are attributes, we add the digest

			 * attribute and only sign the attributes */

			} else {

				unsigned int abuflen;

				    si->pkey)) {

					    ERR_R_EVP_LIB);

				}

			}

		}

		unsigned char md_data[EVP_MAX_MD_SIZE];

		unsigned int md_len;

		    OBJ_obj2nid(p7->d.digest->md->algorithm)))

		    md_len) == 0)

	}

		/*

		 * NOTE: only reach os == NULL here because detached

		 * digested data support is broken?

		 */

			char *cont;

			long contlen;

				    PKCS7_R_UNABLE_TO_FIND_MEM_BIO);

			}

			/*

			 * Mark the BIO read only then we can use its copy

			 * of the data instead of making an extra copy.

			 */

		}

	}

}

int

PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si)

	EVP_MD_CTX mctx;

	EVP_PKEY_CTX *pctx;

	int alen;

	size_t siglen;

	    EVP_PKEY_CTRL_PKCS7_SIGN, 0, si) <= 0) {

	}

	    ASN1_ITEM_rptr(PKCS7_ATTR_SIGN));

	    EVP_PKEY_CTRL_PKCS7_SIGN, 1, si) <= 0) {

	}

}

int

PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, BIO *bio,

    PKCS7 *p7, PKCS7_SIGNER_INFO *si)

{

	PKCS7_ISSUER_AND_SERIAL *ias;

	STACK_OF(X509) *cert;

	X509 *x509;