mirror of
https://github.com/ossrs/srs.git
synced 2025-03-09 15:49:59 +00:00
Upgrade openssl from 1.1.0e to 1.1.1b, with source code. 4.0.78
This commit is contained in:
parent
8f1c992379
commit
96dbd7bced
1476 changed files with 616554 additions and 4 deletions
24
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/bio_pk7.c
vendored
Normal file
24
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/bio_pk7.c
vendored
Normal file
|
@ -0,0 +1,24 @@
|
|||
/*
|
||||
* Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <openssl/asn1.h>
|
||||
#include <openssl/pkcs7.h>
|
||||
#include <openssl/bio.h>
|
||||
|
||||
#if !defined(OPENSSL_SYS_VXWORKS)
|
||||
# include <memory.h>
|
||||
#endif
|
||||
#include <stdio.h>
|
||||
|
||||
/* Streaming encode support for PKCS#7 */
|
||||
|
||||
BIO *BIO_new_PKCS7(BIO *out, PKCS7 *p7)
|
||||
{
|
||||
return BIO_new_NDEF(out, (ASN1_VALUE *)p7, ASN1_ITEM_rptr(PKCS7));
|
||||
}
|
4
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/build.info
vendored
Normal file
4
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/build.info
vendored
Normal file
|
@ -0,0 +1,4 @@
|
|||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]=\
|
||||
pk7_asn1.c pk7_lib.c pkcs7err.c pk7_doit.c pk7_smime.c pk7_attr.c \
|
||||
pk7_mime.c bio_pk7.c
|
202
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_asn1.c
vendored
Normal file
202
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_asn1.c
vendored
Normal file
|
@ -0,0 +1,202 @@
|
|||
/*
|
||||
* Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include "internal/cryptlib.h"
|
||||
#include <openssl/asn1t.h>
|
||||
#include <openssl/pkcs7.h>
|
||||
#include <openssl/x509.h>
|
||||
|
||||
/* PKCS#7 ASN1 module */
|
||||
|
||||
/* This is the ANY DEFINED BY table for the top level PKCS#7 structure */
|
||||
|
||||
ASN1_ADB_TEMPLATE(p7default) = ASN1_EXP_OPT(PKCS7, d.other, ASN1_ANY, 0);
|
||||
|
||||
ASN1_ADB(PKCS7) = {
|
||||
ADB_ENTRY(NID_pkcs7_data, ASN1_NDEF_EXP_OPT(PKCS7, d.data, ASN1_OCTET_STRING_NDEF, 0)),
|
||||
ADB_ENTRY(NID_pkcs7_signed, ASN1_NDEF_EXP_OPT(PKCS7, d.sign, PKCS7_SIGNED, 0)),
|
||||
ADB_ENTRY(NID_pkcs7_enveloped, ASN1_NDEF_EXP_OPT(PKCS7, d.enveloped, PKCS7_ENVELOPE, 0)),
|
||||
ADB_ENTRY(NID_pkcs7_signedAndEnveloped, ASN1_NDEF_EXP_OPT(PKCS7, d.signed_and_enveloped, PKCS7_SIGN_ENVELOPE, 0)),
|
||||
ADB_ENTRY(NID_pkcs7_digest, ASN1_NDEF_EXP_OPT(PKCS7, d.digest, PKCS7_DIGEST, 0)),
|
||||
ADB_ENTRY(NID_pkcs7_encrypted, ASN1_NDEF_EXP_OPT(PKCS7, d.encrypted, PKCS7_ENCRYPT, 0))
|
||||
} ASN1_ADB_END(PKCS7, 0, type, 0, &p7default_tt, NULL);
|
||||
|
||||
/* PKCS#7 streaming support */
|
||||
static int pk7_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
|
||||
void *exarg)
|
||||
{
|
||||
ASN1_STREAM_ARG *sarg = exarg;
|
||||
PKCS7 **pp7 = (PKCS7 **)pval;
|
||||
|
||||
switch (operation) {
|
||||
|
||||
case ASN1_OP_STREAM_PRE:
|
||||
if (PKCS7_stream(&sarg->boundary, *pp7) <= 0)
|
||||
return 0;
|
||||
/* fall thru */
|
||||
case ASN1_OP_DETACHED_PRE:
|
||||
sarg->ndef_bio = PKCS7_dataInit(*pp7, sarg->out);
|
||||
if (!sarg->ndef_bio)
|
||||
return 0;
|
||||
break;
|
||||
|
||||
case ASN1_OP_STREAM_POST:
|
||||
case ASN1_OP_DETACHED_POST:
|
||||
if (PKCS7_dataFinal(*pp7, sarg->ndef_bio) <= 0)
|
||||
return 0;
|
||||
break;
|
||||
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
ASN1_NDEF_SEQUENCE_cb(PKCS7, pk7_cb) = {
|
||||
ASN1_SIMPLE(PKCS7, type, ASN1_OBJECT),
|
||||
ASN1_ADB_OBJECT(PKCS7)
|
||||
}ASN1_NDEF_SEQUENCE_END_cb(PKCS7, PKCS7)
|
||||
|
||||
IMPLEMENT_ASN1_FUNCTIONS(PKCS7)
|
||||
|
||||
IMPLEMENT_ASN1_NDEF_FUNCTION(PKCS7)
|
||||
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(PKCS7)
|
||||
|
||||
ASN1_NDEF_SEQUENCE(PKCS7_SIGNED) = {
|
||||
ASN1_SIMPLE(PKCS7_SIGNED, version, ASN1_INTEGER),
|
||||
ASN1_SET_OF(PKCS7_SIGNED, md_algs, X509_ALGOR),
|
||||
ASN1_SIMPLE(PKCS7_SIGNED, contents, PKCS7),
|
||||
ASN1_IMP_SEQUENCE_OF_OPT(PKCS7_SIGNED, cert, X509, 0),
|
||||
ASN1_IMP_SET_OF_OPT(PKCS7_SIGNED, crl, X509_CRL, 1),
|
||||
ASN1_SET_OF(PKCS7_SIGNED, signer_info, PKCS7_SIGNER_INFO)
|
||||
} ASN1_NDEF_SEQUENCE_END(PKCS7_SIGNED)
|
||||
|
||||
IMPLEMENT_ASN1_FUNCTIONS(PKCS7_SIGNED)
|
||||
|
||||
/* Minor tweak to operation: free up EVP_PKEY */
|
||||
static int si_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
|
||||
void *exarg)
|
||||
{
|
||||
if (operation == ASN1_OP_FREE_POST) {
|
||||
PKCS7_SIGNER_INFO *si = (PKCS7_SIGNER_INFO *)*pval;
|
||||
EVP_PKEY_free(si->pkey);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
ASN1_SEQUENCE_cb(PKCS7_SIGNER_INFO, si_cb) = {
|
||||
ASN1_SIMPLE(PKCS7_SIGNER_INFO, version, ASN1_INTEGER),
|
||||
ASN1_SIMPLE(PKCS7_SIGNER_INFO, issuer_and_serial, PKCS7_ISSUER_AND_SERIAL),
|
||||
ASN1_SIMPLE(PKCS7_SIGNER_INFO, digest_alg, X509_ALGOR),
|
||||
/* NB this should be a SET OF but we use a SEQUENCE OF so the
|
||||
* original order * is retained when the structure is reencoded.
|
||||
* Since the attributes are implicitly tagged this will not affect
|
||||
* the encoding.
|
||||
*/
|
||||
ASN1_IMP_SEQUENCE_OF_OPT(PKCS7_SIGNER_INFO, auth_attr, X509_ATTRIBUTE, 0),
|
||||
ASN1_SIMPLE(PKCS7_SIGNER_INFO, digest_enc_alg, X509_ALGOR),
|
||||
ASN1_SIMPLE(PKCS7_SIGNER_INFO, enc_digest, ASN1_OCTET_STRING),
|
||||
ASN1_IMP_SET_OF_OPT(PKCS7_SIGNER_INFO, unauth_attr, X509_ATTRIBUTE, 1)
|
||||
} ASN1_SEQUENCE_END_cb(PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO)
|
||||
|
||||
IMPLEMENT_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO)
|
||||
|
||||
ASN1_SEQUENCE(PKCS7_ISSUER_AND_SERIAL) = {
|
||||
ASN1_SIMPLE(PKCS7_ISSUER_AND_SERIAL, issuer, X509_NAME),
|
||||
ASN1_SIMPLE(PKCS7_ISSUER_AND_SERIAL, serial, ASN1_INTEGER)
|
||||
} ASN1_SEQUENCE_END(PKCS7_ISSUER_AND_SERIAL)
|
||||
|
||||
IMPLEMENT_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL)
|
||||
|
||||
ASN1_NDEF_SEQUENCE(PKCS7_ENVELOPE) = {
|
||||
ASN1_SIMPLE(PKCS7_ENVELOPE, version, ASN1_INTEGER),
|
||||
ASN1_SET_OF(PKCS7_ENVELOPE, recipientinfo, PKCS7_RECIP_INFO),
|
||||
ASN1_SIMPLE(PKCS7_ENVELOPE, enc_data, PKCS7_ENC_CONTENT)
|
||||
} ASN1_NDEF_SEQUENCE_END(PKCS7_ENVELOPE)
|
||||
|
||||
IMPLEMENT_ASN1_FUNCTIONS(PKCS7_ENVELOPE)
|
||||
|
||||
/* Minor tweak to operation: free up X509 */
|
||||
static int ri_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
|
||||
void *exarg)
|
||||
{
|
||||
if (operation == ASN1_OP_FREE_POST) {
|
||||
PKCS7_RECIP_INFO *ri = (PKCS7_RECIP_INFO *)*pval;
|
||||
X509_free(ri->cert);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
ASN1_SEQUENCE_cb(PKCS7_RECIP_INFO, ri_cb) = {
|
||||
ASN1_SIMPLE(PKCS7_RECIP_INFO, version, ASN1_INTEGER),
|
||||
ASN1_SIMPLE(PKCS7_RECIP_INFO, issuer_and_serial, PKCS7_ISSUER_AND_SERIAL),
|
||||
ASN1_SIMPLE(PKCS7_RECIP_INFO, key_enc_algor, X509_ALGOR),
|
||||
ASN1_SIMPLE(PKCS7_RECIP_INFO, enc_key, ASN1_OCTET_STRING)
|
||||
} ASN1_SEQUENCE_END_cb(PKCS7_RECIP_INFO, PKCS7_RECIP_INFO)
|
||||
|
||||
IMPLEMENT_ASN1_FUNCTIONS(PKCS7_RECIP_INFO)
|
||||
|
||||
ASN1_NDEF_SEQUENCE(PKCS7_ENC_CONTENT) = {
|
||||
ASN1_SIMPLE(PKCS7_ENC_CONTENT, content_type, ASN1_OBJECT),
|
||||
ASN1_SIMPLE(PKCS7_ENC_CONTENT, algorithm, X509_ALGOR),
|
||||
ASN1_IMP_OPT(PKCS7_ENC_CONTENT, enc_data, ASN1_OCTET_STRING_NDEF, 0)
|
||||
} ASN1_NDEF_SEQUENCE_END(PKCS7_ENC_CONTENT)
|
||||
|
||||
IMPLEMENT_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT)
|
||||
|
||||
ASN1_NDEF_SEQUENCE(PKCS7_SIGN_ENVELOPE) = {
|
||||
ASN1_SIMPLE(PKCS7_SIGN_ENVELOPE, version, ASN1_INTEGER),
|
||||
ASN1_SET_OF(PKCS7_SIGN_ENVELOPE, recipientinfo, PKCS7_RECIP_INFO),
|
||||
ASN1_SET_OF(PKCS7_SIGN_ENVELOPE, md_algs, X509_ALGOR),
|
||||
ASN1_SIMPLE(PKCS7_SIGN_ENVELOPE, enc_data, PKCS7_ENC_CONTENT),
|
||||
ASN1_IMP_SET_OF_OPT(PKCS7_SIGN_ENVELOPE, cert, X509, 0),
|
||||
ASN1_IMP_SET_OF_OPT(PKCS7_SIGN_ENVELOPE, crl, X509_CRL, 1),
|
||||
ASN1_SET_OF(PKCS7_SIGN_ENVELOPE, signer_info, PKCS7_SIGNER_INFO)
|
||||
} ASN1_NDEF_SEQUENCE_END(PKCS7_SIGN_ENVELOPE)
|
||||
|
||||
IMPLEMENT_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE)
|
||||
|
||||
ASN1_NDEF_SEQUENCE(PKCS7_ENCRYPT) = {
|
||||
ASN1_SIMPLE(PKCS7_ENCRYPT, version, ASN1_INTEGER),
|
||||
ASN1_SIMPLE(PKCS7_ENCRYPT, enc_data, PKCS7_ENC_CONTENT)
|
||||
} ASN1_NDEF_SEQUENCE_END(PKCS7_ENCRYPT)
|
||||
|
||||
IMPLEMENT_ASN1_FUNCTIONS(PKCS7_ENCRYPT)
|
||||
|
||||
ASN1_NDEF_SEQUENCE(PKCS7_DIGEST) = {
|
||||
ASN1_SIMPLE(PKCS7_DIGEST, version, ASN1_INTEGER),
|
||||
ASN1_SIMPLE(PKCS7_DIGEST, md, X509_ALGOR),
|
||||
ASN1_SIMPLE(PKCS7_DIGEST, contents, PKCS7),
|
||||
ASN1_SIMPLE(PKCS7_DIGEST, digest, ASN1_OCTET_STRING)
|
||||
} ASN1_NDEF_SEQUENCE_END(PKCS7_DIGEST)
|
||||
|
||||
IMPLEMENT_ASN1_FUNCTIONS(PKCS7_DIGEST)
|
||||
|
||||
/* Specials for authenticated attributes */
|
||||
|
||||
/*
|
||||
* When signing attributes we want to reorder them to match the sorted
|
||||
* encoding.
|
||||
*/
|
||||
|
||||
ASN1_ITEM_TEMPLATE(PKCS7_ATTR_SIGN) =
|
||||
ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_ORDER, 0, PKCS7_ATTRIBUTES, X509_ATTRIBUTE)
|
||||
ASN1_ITEM_TEMPLATE_END(PKCS7_ATTR_SIGN)
|
||||
|
||||
/*
|
||||
* When verifying attributes we need to use the received order. So we use
|
||||
* SEQUENCE OF and tag it to SET OF
|
||||
*/
|
||||
|
||||
ASN1_ITEM_TEMPLATE(PKCS7_ATTR_VERIFY) =
|
||||
ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_IMPTAG | ASN1_TFLG_UNIVERSAL,
|
||||
V_ASN1_SET, PKCS7_ATTRIBUTES, X509_ATTRIBUTE)
|
||||
ASN1_ITEM_TEMPLATE_END(PKCS7_ATTR_VERIFY)
|
||||
|
||||
IMPLEMENT_ASN1_PRINT_FUNCTION(PKCS7)
|
121
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_attr.c
vendored
Normal file
121
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_attr.c
vendored
Normal file
|
@ -0,0 +1,121 @@
|
|||
/*
|
||||
* Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <openssl/bio.h>
|
||||
#include <openssl/asn1.h>
|
||||
#include <openssl/asn1t.h>
|
||||
#include <openssl/pem.h>
|
||||
#include <openssl/pkcs7.h>
|
||||
#include <openssl/x509.h>
|
||||
#include <openssl/err.h>
|
||||
|
||||
int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si,
|
||||
STACK_OF(X509_ALGOR) *cap)
|
||||
{
|
||||
ASN1_STRING *seq;
|
||||
|
||||
if ((seq = ASN1_STRING_new()) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
seq->length = ASN1_item_i2d((ASN1_VALUE *)cap, &seq->data,
|
||||
ASN1_ITEM_rptr(X509_ALGORS));
|
||||
return PKCS7_add_signed_attribute(si, NID_SMIMECapabilities,
|
||||
V_ASN1_SEQUENCE, seq);
|
||||
}
|
||||
|
||||
STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si)
|
||||
{
|
||||
ASN1_TYPE *cap;
|
||||
const unsigned char *p;
|
||||
|
||||
cap = PKCS7_get_signed_attribute(si, NID_SMIMECapabilities);
|
||||
if (cap == NULL || (cap->type != V_ASN1_SEQUENCE))
|
||||
return NULL;
|
||||
p = cap->value.sequence->data;
|
||||
return (STACK_OF(X509_ALGOR) *)
|
||||
ASN1_item_d2i(NULL, &p, cap->value.sequence->length,
|
||||
ASN1_ITEM_rptr(X509_ALGORS));
|
||||
}
|
||||
|
||||
/* Basic smime-capabilities OID and optional integer arg */
|
||||
int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg)
|
||||
{
|
||||
ASN1_INTEGER *nbit = NULL;
|
||||
X509_ALGOR *alg;
|
||||
|
||||
if ((alg = X509_ALGOR_new()) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_SIMPLE_SMIMECAP, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
ASN1_OBJECT_free(alg->algorithm);
|
||||
alg->algorithm = OBJ_nid2obj(nid);
|
||||
if (arg > 0) {
|
||||
if ((alg->parameter = ASN1_TYPE_new()) == NULL) {
|
||||
goto err;
|
||||
}
|
||||
if ((nbit = ASN1_INTEGER_new()) == NULL) {
|
||||
goto err;
|
||||
}
|
||||
if (!ASN1_INTEGER_set(nbit, arg)) {
|
||||
goto err;
|
||||
}
|
||||
alg->parameter->value.integer = nbit;
|
||||
alg->parameter->type = V_ASN1_INTEGER;
|
||||
nbit = NULL;
|
||||
}
|
||||
if (!sk_X509_ALGOR_push(sk, alg)) {
|
||||
goto err;
|
||||
}
|
||||
return 1;
|
||||
err:
|
||||
PKCS7err(PKCS7_F_PKCS7_SIMPLE_SMIMECAP, ERR_R_MALLOC_FAILURE);
|
||||
ASN1_INTEGER_free(nbit);
|
||||
X509_ALGOR_free(alg);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid)
|
||||
{
|
||||
if (PKCS7_get_signed_attribute(si, NID_pkcs9_contentType))
|
||||
return 0;
|
||||
if (!coid)
|
||||
coid = OBJ_nid2obj(NID_pkcs7_data);
|
||||
return PKCS7_add_signed_attribute(si, NID_pkcs9_contentType,
|
||||
V_ASN1_OBJECT, coid);
|
||||
}
|
||||
|
||||
int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t)
|
||||
{
|
||||
if (t == NULL && (t = X509_gmtime_adj(NULL, 0)) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME,
|
||||
ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
return PKCS7_add_signed_attribute(si, NID_pkcs9_signingTime,
|
||||
V_ASN1_UTCTIME, t);
|
||||
}
|
||||
|
||||
int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si,
|
||||
const unsigned char *md, int mdlen)
|
||||
{
|
||||
ASN1_OCTET_STRING *os;
|
||||
os = ASN1_OCTET_STRING_new();
|
||||
if (os == NULL)
|
||||
return 0;
|
||||
if (!ASN1_STRING_set(os, md, mdlen)
|
||||
|| !PKCS7_add_signed_attribute(si, NID_pkcs9_messageDigest,
|
||||
V_ASN1_OCTET_STRING, os)) {
|
||||
ASN1_OCTET_STRING_free(os);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
1180
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_doit.c
vendored
Normal file
1180
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_doit.c
vendored
Normal file
File diff suppressed because it is too large
Load diff
588
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_lib.c
vendored
Normal file
588
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_lib.c
vendored
Normal file
|
@ -0,0 +1,588 @@
|
|||
/*
|
||||
* Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include "internal/cryptlib.h"
|
||||
#include <openssl/objects.h>
|
||||
#include <openssl/x509.h>
|
||||
#include "internal/asn1_int.h"
|
||||
#include "internal/evp_int.h"
|
||||
|
||||
long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg)
|
||||
{
|
||||
int nid;
|
||||
long ret;
|
||||
|
||||
nid = OBJ_obj2nid(p7->type);
|
||||
|
||||
switch (cmd) {
|
||||
/* NOTE(emilia): does not support detached digested data. */
|
||||
case PKCS7_OP_SET_DETACHED_SIGNATURE:
|
||||
if (nid == NID_pkcs7_signed) {
|
||||
ret = p7->detached = (int)larg;
|
||||
if (ret && PKCS7_type_is_data(p7->d.sign->contents)) {
|
||||
ASN1_OCTET_STRING *os;
|
||||
os = p7->d.sign->contents->d.data;
|
||||
ASN1_OCTET_STRING_free(os);
|
||||
p7->d.sign->contents->d.data = NULL;
|
||||
}
|
||||
} else {
|
||||
PKCS7err(PKCS7_F_PKCS7_CTRL,
|
||||
PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE);
|
||||
ret = 0;
|
||||
}
|
||||
break;
|
||||
case PKCS7_OP_GET_DETACHED_SIGNATURE:
|
||||
if (nid == NID_pkcs7_signed) {
|
||||
if (!p7->d.sign || !p7->d.sign->contents->d.ptr)
|
||||
ret = 1;
|
||||
else
|
||||
ret = 0;
|
||||
|
||||
p7->detached = ret;
|
||||
} else {
|
||||
PKCS7err(PKCS7_F_PKCS7_CTRL,
|
||||
PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE);
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
break;
|
||||
default:
|
||||
PKCS7err(PKCS7_F_PKCS7_CTRL, PKCS7_R_UNKNOWN_OPERATION);
|
||||
ret = 0;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int PKCS7_content_new(PKCS7 *p7, int type)
|
||||
{
|
||||
PKCS7 *ret = NULL;
|
||||
|
||||
if ((ret = PKCS7_new()) == NULL)
|
||||
goto err;
|
||||
if (!PKCS7_set_type(ret, type))
|
||||
goto err;
|
||||
if (!PKCS7_set_content(p7, ret))
|
||||
goto err;
|
||||
|
||||
return 1;
|
||||
err:
|
||||
PKCS7_free(ret);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data)
|
||||
{
|
||||
int i;
|
||||
|
||||
i = OBJ_obj2nid(p7->type);
|
||||
switch (i) {
|
||||
case NID_pkcs7_signed:
|
||||
PKCS7_free(p7->d.sign->contents);
|
||||
p7->d.sign->contents = p7_data;
|
||||
break;
|
||||
case NID_pkcs7_digest:
|
||||
PKCS7_free(p7->d.digest->contents);
|
||||
p7->d.digest->contents = p7_data;
|
||||
break;
|
||||
case NID_pkcs7_data:
|
||||
case NID_pkcs7_enveloped:
|
||||
case NID_pkcs7_signedAndEnveloped:
|
||||
case NID_pkcs7_encrypted:
|
||||
default:
|
||||
PKCS7err(PKCS7_F_PKCS7_SET_CONTENT, PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
|
||||
goto err;
|
||||
}
|
||||
return 1;
|
||||
err:
|
||||
return 0;
|
||||
}
|
||||
|
||||
int PKCS7_set_type(PKCS7 *p7, int type)
|
||||
{
|
||||
ASN1_OBJECT *obj;
|
||||
|
||||
/*
|
||||
* PKCS7_content_free(p7);
|
||||
*/
|
||||
obj = OBJ_nid2obj(type); /* will not fail */
|
||||
|
||||
switch (type) {
|
||||
case NID_pkcs7_signed:
|
||||
p7->type = obj;
|
||||
if ((p7->d.sign = PKCS7_SIGNED_new()) == NULL)
|
||||
goto err;
|
||||
if (!ASN1_INTEGER_set(p7->d.sign->version, 1)) {
|
||||
PKCS7_SIGNED_free(p7->d.sign);
|
||||
p7->d.sign = NULL;
|
||||
goto err;
|
||||
}
|
||||
break;
|
||||
case NID_pkcs7_data:
|
||||
p7->type = obj;
|
||||
if ((p7->d.data = ASN1_OCTET_STRING_new()) == NULL)
|
||||
goto err;
|
||||
break;
|
||||
case NID_pkcs7_signedAndEnveloped:
|
||||
p7->type = obj;
|
||||
if ((p7->d.signed_and_enveloped = PKCS7_SIGN_ENVELOPE_new())
|
||||
== NULL)
|
||||
goto err;
|
||||
if (!ASN1_INTEGER_set(p7->d.signed_and_enveloped->version, 1))
|
||||
goto err;
|
||||
p7->d.signed_and_enveloped->enc_data->content_type
|
||||
= OBJ_nid2obj(NID_pkcs7_data);
|
||||
break;
|
||||
case NID_pkcs7_enveloped:
|
||||
p7->type = obj;
|
||||
if ((p7->d.enveloped = PKCS7_ENVELOPE_new())
|
||||
== NULL)
|
||||
goto err;
|
||||
if (!ASN1_INTEGER_set(p7->d.enveloped->version, 0))
|
||||
goto err;
|
||||
p7->d.enveloped->enc_data->content_type = OBJ_nid2obj(NID_pkcs7_data);
|
||||
break;
|
||||
case NID_pkcs7_encrypted:
|
||||
p7->type = obj;
|
||||
if ((p7->d.encrypted = PKCS7_ENCRYPT_new())
|
||||
== NULL)
|
||||
goto err;
|
||||
if (!ASN1_INTEGER_set(p7->d.encrypted->version, 0))
|
||||
goto err;
|
||||
p7->d.encrypted->enc_data->content_type = OBJ_nid2obj(NID_pkcs7_data);
|
||||
break;
|
||||
|
||||
case NID_pkcs7_digest:
|
||||
p7->type = obj;
|
||||
if ((p7->d.digest = PKCS7_DIGEST_new())
|
||||
== NULL)
|
||||
goto err;
|
||||
if (!ASN1_INTEGER_set(p7->d.digest->version, 0))
|
||||
goto err;
|
||||
break;
|
||||
default:
|
||||
PKCS7err(PKCS7_F_PKCS7_SET_TYPE, PKCS7_R_UNSUPPORTED_CONTENT_TYPE);
|
||||
goto err;
|
||||
}
|
||||
return 1;
|
||||
err:
|
||||
return 0;
|
||||
}
|
||||
|
||||
int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other)
|
||||
{
|
||||
p7->type = OBJ_nid2obj(type);
|
||||
p7->d.other = other;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *psi)
|
||||
{
|
||||
int i, j, nid;
|
||||
X509_ALGOR *alg;
|
||||
STACK_OF(PKCS7_SIGNER_INFO) *signer_sk;
|
||||
STACK_OF(X509_ALGOR) *md_sk;
|
||||
|
||||
i = OBJ_obj2nid(p7->type);
|
||||
switch (i) {
|
||||
case NID_pkcs7_signed:
|
||||
signer_sk = p7->d.sign->signer_info;
|
||||
md_sk = p7->d.sign->md_algs;
|
||||
break;
|
||||
case NID_pkcs7_signedAndEnveloped:
|
||||
signer_sk = p7->d.signed_and_enveloped->signer_info;
|
||||
md_sk = p7->d.signed_and_enveloped->md_algs;
|
||||
break;
|
||||
default:
|
||||
PKCS7err(PKCS7_F_PKCS7_ADD_SIGNER, PKCS7_R_WRONG_CONTENT_TYPE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
nid = OBJ_obj2nid(psi->digest_alg->algorithm);
|
||||
|
||||
/* If the digest is not currently listed, add it */
|
||||
j = 0;
|
||||
for (i = 0; i < sk_X509_ALGOR_num(md_sk); i++) {
|
||||
alg = sk_X509_ALGOR_value(md_sk, i);
|
||||
if (OBJ_obj2nid(alg->algorithm) == nid) {
|
||||
j = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!j) { /* we need to add another algorithm */
|
||||
if ((alg = X509_ALGOR_new()) == NULL
|
||||
|| (alg->parameter = ASN1_TYPE_new()) == NULL) {
|
||||
X509_ALGOR_free(alg);
|
||||
PKCS7err(PKCS7_F_PKCS7_ADD_SIGNER, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
alg->algorithm = OBJ_nid2obj(nid);
|
||||
alg->parameter->type = V_ASN1_NULL;
|
||||
if (!sk_X509_ALGOR_push(md_sk, alg)) {
|
||||
X509_ALGOR_free(alg);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (!sk_PKCS7_SIGNER_INFO_push(signer_sk, psi))
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int PKCS7_add_certificate(PKCS7 *p7, X509 *x509)
|
||||
{
|
||||
int i;
|
||||
STACK_OF(X509) **sk;
|
||||
|
||||
i = OBJ_obj2nid(p7->type);
|
||||
switch (i) {
|
||||
case NID_pkcs7_signed:
|
||||
sk = &(p7->d.sign->cert);
|
||||
break;
|
||||
case NID_pkcs7_signedAndEnveloped:
|
||||
sk = &(p7->d.signed_and_enveloped->cert);
|
||||
break;
|
||||
default:
|
||||
PKCS7err(PKCS7_F_PKCS7_ADD_CERTIFICATE, PKCS7_R_WRONG_CONTENT_TYPE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (*sk == NULL)
|
||||
*sk = sk_X509_new_null();
|
||||
if (*sk == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_ADD_CERTIFICATE, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
X509_up_ref(x509);
|
||||
if (!sk_X509_push(*sk, x509)) {
|
||||
X509_free(x509);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl)
|
||||
{
|
||||
int i;
|
||||
STACK_OF(X509_CRL) **sk;
|
||||
|
||||
i = OBJ_obj2nid(p7->type);
|
||||
switch (i) {
|
||||
case NID_pkcs7_signed:
|
||||
sk = &(p7->d.sign->crl);
|
||||
break;
|
||||
case NID_pkcs7_signedAndEnveloped:
|
||||
sk = &(p7->d.signed_and_enveloped->crl);
|
||||
break;
|
||||
default:
|
||||
PKCS7err(PKCS7_F_PKCS7_ADD_CRL, PKCS7_R_WRONG_CONTENT_TYPE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (*sk == NULL)
|
||||
*sk = sk_X509_CRL_new_null();
|
||||
if (*sk == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_ADD_CRL, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
X509_CRL_up_ref(crl);
|
||||
if (!sk_X509_CRL_push(*sk, crl)) {
|
||||
X509_CRL_free(crl);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
|
||||
const EVP_MD *dgst)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/* We now need to add another PKCS7_SIGNER_INFO entry */
|
||||
if (!ASN1_INTEGER_set(p7i->version, 1))
|
||||
goto err;
|
||||
if (!X509_NAME_set(&p7i->issuer_and_serial->issuer,
|
||||
X509_get_issuer_name(x509)))
|
||||
goto err;
|
||||
|
||||
/*
|
||||
* because ASN1_INTEGER_set is used to set a 'long' we will do things the
|
||||
* ugly way.
|
||||
*/
|
||||
ASN1_INTEGER_free(p7i->issuer_and_serial->serial);
|
||||
if (!(p7i->issuer_and_serial->serial =
|
||||
ASN1_INTEGER_dup(X509_get_serialNumber(x509))))
|
||||
goto err;
|
||||
|
||||
/* lets keep the pkey around for a while */
|
||||
EVP_PKEY_up_ref(pkey);
|
||||
p7i->pkey = pkey;
|
||||
|
||||
/* Set the algorithms */
|
||||
|
||||
X509_ALGOR_set0(p7i->digest_alg, OBJ_nid2obj(EVP_MD_type(dgst)),
|
||||
V_ASN1_NULL, NULL);
|
||||
|
||||
if (pkey->ameth && pkey->ameth->pkey_ctrl) {
|
||||
ret = pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_PKCS7_SIGN, 0, p7i);
|
||||
if (ret > 0)
|
||||
return 1;
|
||||
if (ret != -2) {
|
||||
PKCS7err(PKCS7_F_PKCS7_SIGNER_INFO_SET,
|
||||
PKCS7_R_SIGNING_CTRL_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
PKCS7err(PKCS7_F_PKCS7_SIGNER_INFO_SET,
|
||||
PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
|
||||
err:
|
||||
return 0;
|
||||
}
|
||||
|
||||
PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509, EVP_PKEY *pkey,
|
||||
const EVP_MD *dgst)
|
||||
{
|
||||
PKCS7_SIGNER_INFO *si = NULL;
|
||||
|
||||
if (dgst == NULL) {
|
||||
int def_nid;
|
||||
if (EVP_PKEY_get_default_digest_nid(pkey, &def_nid) <= 0)
|
||||
goto err;
|
||||
dgst = EVP_get_digestbynid(def_nid);
|
||||
if (dgst == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_ADD_SIGNATURE, PKCS7_R_NO_DEFAULT_DIGEST);
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
if ((si = PKCS7_SIGNER_INFO_new()) == NULL)
|
||||
goto err;
|
||||
if (!PKCS7_SIGNER_INFO_set(si, x509, pkey, dgst))
|
||||
goto err;
|
||||
if (!PKCS7_add_signer(p7, si))
|
||||
goto err;
|
||||
return si;
|
||||
err:
|
||||
PKCS7_SIGNER_INFO_free(si);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md)
|
||||
{
|
||||
if (PKCS7_type_is_digest(p7)) {
|
||||
if ((p7->d.digest->md->parameter = ASN1_TYPE_new()) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_SET_DIGEST, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
p7->d.digest->md->parameter->type = V_ASN1_NULL;
|
||||
p7->d.digest->md->algorithm = OBJ_nid2obj(EVP_MD_nid(md));
|
||||
return 1;
|
||||
}
|
||||
|
||||
PKCS7err(PKCS7_F_PKCS7_SET_DIGEST, PKCS7_R_WRONG_CONTENT_TYPE);
|
||||
return 1;
|
||||
}
|
||||
|
||||
STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7)
|
||||
{
|
||||
if (p7 == NULL || p7->d.ptr == NULL)
|
||||
return NULL;
|
||||
if (PKCS7_type_is_signed(p7)) {
|
||||
return p7->d.sign->signer_info;
|
||||
} else if (PKCS7_type_is_signedAndEnveloped(p7)) {
|
||||
return p7->d.signed_and_enveloped->signer_info;
|
||||
} else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
|
||||
X509_ALGOR **pdig, X509_ALGOR **psig)
|
||||
{
|
||||
if (pk)
|
||||
*pk = si->pkey;
|
||||
if (pdig)
|
||||
*pdig = si->digest_alg;
|
||||
if (psig)
|
||||
*psig = si->digest_enc_alg;
|
||||
}
|
||||
|
||||
void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc)
|
||||
{
|
||||
if (penc)
|
||||
*penc = ri->key_enc_algor;
|
||||
}
|
||||
|
||||
PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509)
|
||||
{
|
||||
PKCS7_RECIP_INFO *ri;
|
||||
|
||||
if ((ri = PKCS7_RECIP_INFO_new()) == NULL)
|
||||
goto err;
|
||||
if (!PKCS7_RECIP_INFO_set(ri, x509))
|
||||
goto err;
|
||||
if (!PKCS7_add_recipient_info(p7, ri))
|
||||
goto err;
|
||||
return ri;
|
||||
err:
|
||||
PKCS7_RECIP_INFO_free(ri);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri)
|
||||
{
|
||||
int i;
|
||||
STACK_OF(PKCS7_RECIP_INFO) *sk;
|
||||
|
||||
i = OBJ_obj2nid(p7->type);
|
||||
switch (i) {
|
||||
case NID_pkcs7_signedAndEnveloped:
|
||||
sk = p7->d.signed_and_enveloped->recipientinfo;
|
||||
break;
|
||||
case NID_pkcs7_enveloped:
|
||||
sk = p7->d.enveloped->recipientinfo;
|
||||
break;
|
||||
default:
|
||||
PKCS7err(PKCS7_F_PKCS7_ADD_RECIPIENT_INFO,
|
||||
PKCS7_R_WRONG_CONTENT_TYPE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!sk_PKCS7_RECIP_INFO_push(sk, ri))
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509)
|
||||
{
|
||||
int ret;
|
||||
EVP_PKEY *pkey = NULL;
|
||||
if (!ASN1_INTEGER_set(p7i->version, 0))
|
||||
return 0;
|
||||
if (!X509_NAME_set(&p7i->issuer_and_serial->issuer,
|
||||
X509_get_issuer_name(x509)))
|
||||
return 0;
|
||||
|
||||
ASN1_INTEGER_free(p7i->issuer_and_serial->serial);
|
||||
if (!(p7i->issuer_and_serial->serial =
|
||||
ASN1_INTEGER_dup(X509_get_serialNumber(x509))))
|
||||
return 0;
|
||||
|
||||
pkey = X509_get0_pubkey(x509);
|
||||
|
||||
if (!pkey || !pkey->ameth || !pkey->ameth->pkey_ctrl) {
|
||||
PKCS7err(PKCS7_F_PKCS7_RECIP_INFO_SET,
|
||||
PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_PKCS7_ENCRYPT, 0, p7i);
|
||||
if (ret == -2) {
|
||||
PKCS7err(PKCS7_F_PKCS7_RECIP_INFO_SET,
|
||||
PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
|
||||
goto err;
|
||||
}
|
||||
if (ret <= 0) {
|
||||
PKCS7err(PKCS7_F_PKCS7_RECIP_INFO_SET,
|
||||
PKCS7_R_ENCRYPTION_CTRL_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
||||
X509_up_ref(x509);
|
||||
p7i->cert = x509;
|
||||
|
||||
return 1;
|
||||
|
||||
err:
|
||||
return 0;
|
||||
}
|
||||
|
||||
X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si)
|
||||
{
|
||||
if (PKCS7_type_is_signed(p7))
|
||||
return (X509_find_by_issuer_and_serial(p7->d.sign->cert,
|
||||
si->issuer_and_serial->issuer,
|
||||
si->
|
||||
issuer_and_serial->serial));
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher)
|
||||
{
|
||||
int i;
|
||||
PKCS7_ENC_CONTENT *ec;
|
||||
|
||||
i = OBJ_obj2nid(p7->type);
|
||||
switch (i) {
|
||||
case NID_pkcs7_signedAndEnveloped:
|
||||
ec = p7->d.signed_and_enveloped->enc_data;
|
||||
break;
|
||||
case NID_pkcs7_enveloped:
|
||||
ec = p7->d.enveloped->enc_data;
|
||||
break;
|
||||
default:
|
||||
PKCS7err(PKCS7_F_PKCS7_SET_CIPHER, PKCS7_R_WRONG_CONTENT_TYPE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Check cipher OID exists and has data in it */
|
||||
i = EVP_CIPHER_type(cipher);
|
||||
if (i == NID_undef) {
|
||||
PKCS7err(PKCS7_F_PKCS7_SET_CIPHER,
|
||||
PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ec->cipher = cipher;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7)
|
||||
{
|
||||
ASN1_OCTET_STRING *os = NULL;
|
||||
|
||||
switch (OBJ_obj2nid(p7->type)) {
|
||||
case NID_pkcs7_data:
|
||||
os = p7->d.data;
|
||||
break;
|
||||
|
||||
case NID_pkcs7_signedAndEnveloped:
|
||||
os = p7->d.signed_and_enveloped->enc_data->enc_data;
|
||||
if (os == NULL) {
|
||||
os = ASN1_OCTET_STRING_new();
|
||||
p7->d.signed_and_enveloped->enc_data->enc_data = os;
|
||||
}
|
||||
break;
|
||||
|
||||
case NID_pkcs7_enveloped:
|
||||
os = p7->d.enveloped->enc_data->enc_data;
|
||||
if (os == NULL) {
|
||||
os = ASN1_OCTET_STRING_new();
|
||||
p7->d.enveloped->enc_data->enc_data = os;
|
||||
}
|
||||
break;
|
||||
|
||||
case NID_pkcs7_signed:
|
||||
os = p7->d.sign->contents->d.data;
|
||||
break;
|
||||
|
||||
default:
|
||||
os = NULL;
|
||||
break;
|
||||
}
|
||||
|
||||
if (os == NULL)
|
||||
return 0;
|
||||
|
||||
os->flags |= ASN1_STRING_FLAG_NDEF;
|
||||
*boundary = &os->data;
|
||||
|
||||
return 1;
|
||||
}
|
48
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_mime.c
vendored
Normal file
48
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_mime.c
vendored
Normal file
|
@ -0,0 +1,48 @@
|
|||
/*
|
||||
* Copyright 1999-2017 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include "internal/cryptlib.h"
|
||||
#include <openssl/x509.h>
|
||||
#include <openssl/asn1.h>
|
||||
|
||||
/* PKCS#7 wrappers round generalised stream and MIME routines */
|
||||
|
||||
int i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags)
|
||||
{
|
||||
return i2d_ASN1_bio_stream(out, (ASN1_VALUE *)p7, in, flags,
|
||||
ASN1_ITEM_rptr(PKCS7));
|
||||
}
|
||||
|
||||
int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags)
|
||||
{
|
||||
return PEM_write_bio_ASN1_stream(out, (ASN1_VALUE *)p7, in, flags,
|
||||
"PKCS7", ASN1_ITEM_rptr(PKCS7));
|
||||
}
|
||||
|
||||
int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags)
|
||||
{
|
||||
STACK_OF(X509_ALGOR) *mdalgs;
|
||||
int ctype_nid = OBJ_obj2nid(p7->type);
|
||||
if (ctype_nid == NID_pkcs7_signed)
|
||||
mdalgs = p7->d.sign->md_algs;
|
||||
else
|
||||
mdalgs = NULL;
|
||||
|
||||
flags ^= SMIME_OLDMIME;
|
||||
|
||||
return SMIME_write_ASN1(bio, (ASN1_VALUE *)p7, data, flags,
|
||||
ctype_nid, NID_undef, mdalgs,
|
||||
ASN1_ITEM_rptr(PKCS7));
|
||||
}
|
||||
|
||||
PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont)
|
||||
{
|
||||
return (PKCS7 *)SMIME_read_ASN1(bio, bcont, ASN1_ITEM_rptr(PKCS7));
|
||||
}
|
549
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_smime.c
vendored
Normal file
549
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pk7_smime.c
vendored
Normal file
|
@ -0,0 +1,549 @@
|
|||
/*
|
||||
* Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
/* Simple PKCS#7 processing functions */
|
||||
|
||||
#include <stdio.h>
|
||||
#include "internal/cryptlib.h"
|
||||
#include <openssl/x509.h>
|
||||
#include <openssl/x509v3.h>
|
||||
|
||||
|
||||
#define BUFFERSIZE 4096
|
||||
|
||||
static int pkcs7_copy_existing_digest(PKCS7 *p7, PKCS7_SIGNER_INFO *si);
|
||||
|
||||
PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
|
||||
BIO *data, int flags)
|
||||
{
|
||||
PKCS7 *p7;
|
||||
int i;
|
||||
|
||||
if ((p7 = PKCS7_new()) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_SIGN, ERR_R_MALLOC_FAILURE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!PKCS7_set_type(p7, NID_pkcs7_signed))
|
||||
goto err;
|
||||
|
||||
if (!PKCS7_content_new(p7, NID_pkcs7_data))
|
||||
goto err;
|
||||
|
||||
if (pkey && !PKCS7_sign_add_signer(p7, signcert, pkey, NULL, flags)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_SIGN, PKCS7_R_PKCS7_ADD_SIGNER_ERROR);
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (!(flags & PKCS7_NOCERTS)) {
|
||||
for (i = 0; i < sk_X509_num(certs); i++) {
|
||||
if (!PKCS7_add_certificate(p7, sk_X509_value(certs, i)))
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
if (flags & PKCS7_DETACHED)
|
||||
PKCS7_set_detached(p7, 1);
|
||||
|
||||
if (flags & (PKCS7_STREAM | PKCS7_PARTIAL))
|
||||
return p7;
|
||||
|
||||
if (PKCS7_final(p7, data, flags))
|
||||
return p7;
|
||||
|
||||
err:
|
||||
PKCS7_free(p7);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int PKCS7_final(PKCS7 *p7, BIO *data, int flags)
|
||||
{
|
||||
BIO *p7bio;
|
||||
int ret = 0;
|
||||
|
||||
if ((p7bio = PKCS7_dataInit(p7, NULL)) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_FINAL, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
SMIME_crlf_copy(data, p7bio, flags);
|
||||
|
||||
(void)BIO_flush(p7bio);
|
||||
|
||||
if (!PKCS7_dataFinal(p7, p7bio)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_FINAL, PKCS7_R_PKCS7_DATASIGN);
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
|
||||
err:
|
||||
BIO_free_all(p7bio);
|
||||
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
||||
/* Check to see if a cipher exists and if so add S/MIME capabilities */
|
||||
|
||||
static int add_cipher_smcap(STACK_OF(X509_ALGOR) *sk, int nid, int arg)
|
||||
{
|
||||
if (EVP_get_cipherbynid(nid))
|
||||
return PKCS7_simple_smimecap(sk, nid, arg);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int add_digest_smcap(STACK_OF(X509_ALGOR) *sk, int nid, int arg)
|
||||
{
|
||||
if (EVP_get_digestbynid(nid))
|
||||
return PKCS7_simple_smimecap(sk, nid, arg);
|
||||
return 1;
|
||||
}
|
||||
|
||||
PKCS7_SIGNER_INFO *PKCS7_sign_add_signer(PKCS7 *p7, X509 *signcert,
|
||||
EVP_PKEY *pkey, const EVP_MD *md,
|
||||
int flags)
|
||||
{
|
||||
PKCS7_SIGNER_INFO *si = NULL;
|
||||
STACK_OF(X509_ALGOR) *smcap = NULL;
|
||||
if (!X509_check_private_key(signcert, pkey)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_SIGN_ADD_SIGNER,
|
||||
PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ((si = PKCS7_add_signature(p7, signcert, pkey, md)) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_SIGN_ADD_SIGNER,
|
||||
PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!(flags & PKCS7_NOCERTS)) {
|
||||
if (!PKCS7_add_certificate(p7, signcert))
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (!(flags & PKCS7_NOATTR)) {
|
||||
if (!PKCS7_add_attrib_content_type(si, NULL))
|
||||
goto err;
|
||||
/* Add SMIMECapabilities */
|
||||
if (!(flags & PKCS7_NOSMIMECAP)) {
|
||||
if ((smcap = sk_X509_ALGOR_new_null()) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_SIGN_ADD_SIGNER, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
if (!add_cipher_smcap(smcap, NID_aes_256_cbc, -1)
|
||||
|| !add_digest_smcap(smcap, NID_id_GostR3411_2012_256, -1)
|
||||
|| !add_digest_smcap(smcap, NID_id_GostR3411_2012_512, -1)
|
||||
|| !add_digest_smcap(smcap, NID_id_GostR3411_94, -1)
|
||||
|| !add_cipher_smcap(smcap, NID_id_Gost28147_89, -1)
|
||||
|| !add_cipher_smcap(smcap, NID_aes_192_cbc, -1)
|
||||
|| !add_cipher_smcap(smcap, NID_aes_128_cbc, -1)
|
||||
|| !add_cipher_smcap(smcap, NID_des_ede3_cbc, -1)
|
||||
|| !add_cipher_smcap(smcap, NID_rc2_cbc, 128)
|
||||
|| !add_cipher_smcap(smcap, NID_rc2_cbc, 64)
|
||||
|| !add_cipher_smcap(smcap, NID_des_cbc, -1)
|
||||
|| !add_cipher_smcap(smcap, NID_rc2_cbc, 40)
|
||||
|| !PKCS7_add_attrib_smimecap(si, smcap))
|
||||
goto err;
|
||||
sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free);
|
||||
smcap = NULL;
|
||||
}
|
||||
if (flags & PKCS7_REUSE_DIGEST) {
|
||||
if (!pkcs7_copy_existing_digest(p7, si))
|
||||
goto err;
|
||||
if (!(flags & PKCS7_PARTIAL) && !PKCS7_SIGNER_INFO_sign(si))
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
return si;
|
||||
err:
|
||||
sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Search for a digest matching SignerInfo digest type and if found copy
|
||||
* across.
|
||||
*/
|
||||
|
||||
static int pkcs7_copy_existing_digest(PKCS7 *p7, PKCS7_SIGNER_INFO *si)
|
||||
{
|
||||
int i;
|
||||
STACK_OF(PKCS7_SIGNER_INFO) *sinfos;
|
||||
PKCS7_SIGNER_INFO *sitmp;
|
||||
ASN1_OCTET_STRING *osdig = NULL;
|
||||
sinfos = PKCS7_get_signer_info(p7);
|
||||
for (i = 0; i < sk_PKCS7_SIGNER_INFO_num(sinfos); i++) {
|
||||
sitmp = sk_PKCS7_SIGNER_INFO_value(sinfos, i);
|
||||
if (si == sitmp)
|
||||
break;
|
||||
if (sk_X509_ATTRIBUTE_num(sitmp->auth_attr) <= 0)
|
||||
continue;
|
||||
if (!OBJ_cmp(si->digest_alg->algorithm, sitmp->digest_alg->algorithm)) {
|
||||
osdig = PKCS7_digest_from_attributes(sitmp->auth_attr);
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (osdig)
|
||||
return PKCS7_add1_attrib_digest(si, osdig->data, osdig->length);
|
||||
|
||||
PKCS7err(PKCS7_F_PKCS7_COPY_EXISTING_DIGEST,
|
||||
PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store,
|
||||
BIO *indata, BIO *out, int flags)
|
||||
{
|
||||
STACK_OF(X509) *signers;
|
||||
X509 *signer;
|
||||
STACK_OF(PKCS7_SIGNER_INFO) *sinfos;
|
||||
PKCS7_SIGNER_INFO *si;
|
||||
X509_STORE_CTX *cert_ctx = NULL;
|
||||
char *buf = NULL;
|
||||
int i, j = 0, k, ret = 0;
|
||||
BIO *p7bio = NULL;
|
||||
BIO *tmpin = NULL, *tmpout = NULL;
|
||||
|
||||
if (!p7) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_INVALID_NULL_POINTER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!PKCS7_type_is_signed(p7)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_WRONG_CONTENT_TYPE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Check for no data and no content: no data to verify signature */
|
||||
if (PKCS7_get_detached(p7) && !indata) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_NO_CONTENT);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (flags & PKCS7_NO_DUAL_CONTENT) {
|
||||
/*
|
||||
* This was originally "#if 0" because we thought that only old broken
|
||||
* Netscape did this. It turns out that Authenticode uses this kind
|
||||
* of "extended" PKCS7 format, and things like UEFI secure boot and
|
||||
* tools like osslsigncode need it. In Authenticode the verification
|
||||
* process is different, but the existing PKCs7 verification works.
|
||||
*/
|
||||
if (!PKCS7_get_detached(p7) && indata) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_CONTENT_AND_DATA_PRESENT);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
sinfos = PKCS7_get_signer_info(p7);
|
||||
|
||||
if (!sinfos || !sk_PKCS7_SIGNER_INFO_num(sinfos)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_NO_SIGNATURES_ON_DATA);
|
||||
return 0;
|
||||
}
|
||||
|
||||
signers = PKCS7_get0_signers(p7, certs, flags);
|
||||
if (!signers)
|
||||
return 0;
|
||||
|
||||
/* Now verify the certificates */
|
||||
|
||||
cert_ctx = X509_STORE_CTX_new();
|
||||
if (cert_ctx == NULL)
|
||||
goto err;
|
||||
if (!(flags & PKCS7_NOVERIFY))
|
||||
for (k = 0; k < sk_X509_num(signers); k++) {
|
||||
signer = sk_X509_value(signers, k);
|
||||
if (!(flags & PKCS7_NOCHAIN)) {
|
||||
if (!X509_STORE_CTX_init(cert_ctx, store, signer,
|
||||
p7->d.sign->cert)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, ERR_R_X509_LIB);
|
||||
goto err;
|
||||
}
|
||||
X509_STORE_CTX_set_default(cert_ctx, "smime_sign");
|
||||
} else if (!X509_STORE_CTX_init(cert_ctx, store, signer, NULL)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, ERR_R_X509_LIB);
|
||||
goto err;
|
||||
}
|
||||
if (!(flags & PKCS7_NOCRL))
|
||||
X509_STORE_CTX_set0_crls(cert_ctx, p7->d.sign->crl);
|
||||
i = X509_verify_cert(cert_ctx);
|
||||
if (i <= 0)
|
||||
j = X509_STORE_CTX_get_error(cert_ctx);
|
||||
X509_STORE_CTX_cleanup(cert_ctx);
|
||||
if (i <= 0) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY,
|
||||
PKCS7_R_CERTIFICATE_VERIFY_ERROR);
|
||||
ERR_add_error_data(2, "Verify error:",
|
||||
X509_verify_cert_error_string(j));
|
||||
goto err;
|
||||
}
|
||||
/* Check for revocation status here */
|
||||
}
|
||||
|
||||
/*
|
||||
* Performance optimization: if the content is a memory BIO then store
|
||||
* its contents in a temporary read only memory BIO. This avoids
|
||||
* potentially large numbers of slow copies of data which will occur when
|
||||
* reading from a read write memory BIO when signatures are calculated.
|
||||
*/
|
||||
|
||||
if (indata && (BIO_method_type(indata) == BIO_TYPE_MEM)) {
|
||||
char *ptr;
|
||||
long len;
|
||||
len = BIO_get_mem_data(indata, &ptr);
|
||||
tmpin = BIO_new_mem_buf(ptr, len);
|
||||
if (tmpin == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
} else
|
||||
tmpin = indata;
|
||||
|
||||
if ((p7bio = PKCS7_dataInit(p7, tmpin)) == NULL)
|
||||
goto err;
|
||||
|
||||
if (flags & PKCS7_TEXT) {
|
||||
if ((tmpout = BIO_new(BIO_s_mem())) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
BIO_set_mem_eof_return(tmpout, 0);
|
||||
} else
|
||||
tmpout = out;
|
||||
|
||||
/* We now have to 'read' from p7bio to calculate digests etc. */
|
||||
if ((buf = OPENSSL_malloc(BUFFERSIZE)) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
for (;;) {
|
||||
i = BIO_read(p7bio, buf, BUFFERSIZE);
|
||||
if (i <= 0)
|
||||
break;
|
||||
if (tmpout)
|
||||
BIO_write(tmpout, buf, i);
|
||||
}
|
||||
|
||||
if (flags & PKCS7_TEXT) {
|
||||
if (!SMIME_text(tmpout, out)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_SMIME_TEXT_ERROR);
|
||||
BIO_free(tmpout);
|
||||
goto err;
|
||||
}
|
||||
BIO_free(tmpout);
|
||||
}
|
||||
|
||||
/* Now Verify All Signatures */
|
||||
if (!(flags & PKCS7_NOSIGS))
|
||||
for (i = 0; i < sk_PKCS7_SIGNER_INFO_num(sinfos); i++) {
|
||||
si = sk_PKCS7_SIGNER_INFO_value(sinfos, i);
|
||||
signer = sk_X509_value(signers, i);
|
||||
j = PKCS7_signatureVerify(p7bio, p7, si, signer);
|
||||
if (j <= 0) {
|
||||
PKCS7err(PKCS7_F_PKCS7_VERIFY, PKCS7_R_SIGNATURE_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
|
||||
err:
|
||||
X509_STORE_CTX_free(cert_ctx);
|
||||
OPENSSL_free(buf);
|
||||
if (tmpin == indata) {
|
||||
if (indata)
|
||||
BIO_pop(p7bio);
|
||||
}
|
||||
BIO_free_all(p7bio);
|
||||
sk_X509_free(signers);
|
||||
return ret;
|
||||
}
|
||||
|
||||
STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs,
|
||||
int flags)
|
||||
{
|
||||
STACK_OF(X509) *signers;
|
||||
STACK_OF(PKCS7_SIGNER_INFO) *sinfos;
|
||||
PKCS7_SIGNER_INFO *si;
|
||||
PKCS7_ISSUER_AND_SERIAL *ias;
|
||||
X509 *signer;
|
||||
int i;
|
||||
|
||||
if (!p7) {
|
||||
PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS, PKCS7_R_INVALID_NULL_POINTER);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!PKCS7_type_is_signed(p7)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS, PKCS7_R_WRONG_CONTENT_TYPE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Collect all the signers together */
|
||||
|
||||
sinfos = PKCS7_get_signer_info(p7);
|
||||
|
||||
if (sk_PKCS7_SIGNER_INFO_num(sinfos) <= 0) {
|
||||
PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS, PKCS7_R_NO_SIGNERS);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((signers = sk_X509_new_null()) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS, ERR_R_MALLOC_FAILURE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i = 0; i < sk_PKCS7_SIGNER_INFO_num(sinfos); i++) {
|
||||
si = sk_PKCS7_SIGNER_INFO_value(sinfos, i);
|
||||
ias = si->issuer_and_serial;
|
||||
signer = NULL;
|
||||
/* If any certificates passed they take priority */
|
||||
if (certs)
|
||||
signer = X509_find_by_issuer_and_serial(certs,
|
||||
ias->issuer, ias->serial);
|
||||
if (!signer && !(flags & PKCS7_NOINTERN)
|
||||
&& p7->d.sign->cert)
|
||||
signer =
|
||||
X509_find_by_issuer_and_serial(p7->d.sign->cert,
|
||||
ias->issuer, ias->serial);
|
||||
if (!signer) {
|
||||
PKCS7err(PKCS7_F_PKCS7_GET0_SIGNERS,
|
||||
PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND);
|
||||
sk_X509_free(signers);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!sk_X509_push(signers, signer)) {
|
||||
sk_X509_free(signers);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
return signers;
|
||||
}
|
||||
|
||||
/* Build a complete PKCS#7 enveloped data */
|
||||
|
||||
PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher,
|
||||
int flags)
|
||||
{
|
||||
PKCS7 *p7;
|
||||
BIO *p7bio = NULL;
|
||||
int i;
|
||||
X509 *x509;
|
||||
if ((p7 = PKCS7_new()) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_ENCRYPT, ERR_R_MALLOC_FAILURE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!PKCS7_set_type(p7, NID_pkcs7_enveloped))
|
||||
goto err;
|
||||
if (!PKCS7_set_cipher(p7, cipher)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_ENCRYPT, PKCS7_R_ERROR_SETTING_CIPHER);
|
||||
goto err;
|
||||
}
|
||||
|
||||
for (i = 0; i < sk_X509_num(certs); i++) {
|
||||
x509 = sk_X509_value(certs, i);
|
||||
if (!PKCS7_add_recipient(p7, x509)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_ENCRYPT, PKCS7_R_ERROR_ADDING_RECIPIENT);
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
if (flags & PKCS7_STREAM)
|
||||
return p7;
|
||||
|
||||
if (PKCS7_final(p7, in, flags))
|
||||
return p7;
|
||||
|
||||
err:
|
||||
|
||||
BIO_free_all(p7bio);
|
||||
PKCS7_free(p7);
|
||||
return NULL;
|
||||
|
||||
}
|
||||
|
||||
int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags)
|
||||
{
|
||||
BIO *tmpmem;
|
||||
int ret = 0, i;
|
||||
char *buf = NULL;
|
||||
|
||||
if (!p7) {
|
||||
PKCS7err(PKCS7_F_PKCS7_DECRYPT, PKCS7_R_INVALID_NULL_POINTER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!PKCS7_type_is_enveloped(p7)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_DECRYPT, PKCS7_R_WRONG_CONTENT_TYPE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (cert && !X509_check_private_key(cert, pkey)) {
|
||||
PKCS7err(PKCS7_F_PKCS7_DECRYPT,
|
||||
PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((tmpmem = PKCS7_dataDecode(p7, pkey, NULL, cert)) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_DECRYPT, PKCS7_R_DECRYPT_ERROR);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (flags & PKCS7_TEXT) {
|
||||
BIO *tmpbuf, *bread;
|
||||
/* Encrypt BIOs can't do BIO_gets() so add a buffer BIO */
|
||||
if ((tmpbuf = BIO_new(BIO_f_buffer())) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_DECRYPT, ERR_R_MALLOC_FAILURE);
|
||||
BIO_free_all(tmpmem);
|
||||
return 0;
|
||||
}
|
||||
if ((bread = BIO_push(tmpbuf, tmpmem)) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_DECRYPT, ERR_R_MALLOC_FAILURE);
|
||||
BIO_free_all(tmpbuf);
|
||||
BIO_free_all(tmpmem);
|
||||
return 0;
|
||||
}
|
||||
ret = SMIME_text(bread, data);
|
||||
if (ret > 0 && BIO_method_type(tmpmem) == BIO_TYPE_CIPHER) {
|
||||
if (!BIO_get_cipher_status(tmpmem))
|
||||
ret = 0;
|
||||
}
|
||||
BIO_free_all(bread);
|
||||
return ret;
|
||||
}
|
||||
if ((buf = OPENSSL_malloc(BUFFERSIZE)) == NULL) {
|
||||
PKCS7err(PKCS7_F_PKCS7_DECRYPT, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
for (;;) {
|
||||
i = BIO_read(tmpmem, buf, BUFFERSIZE);
|
||||
if (i <= 0) {
|
||||
ret = 1;
|
||||
if (BIO_method_type(tmpmem) == BIO_TYPE_CIPHER) {
|
||||
if (!BIO_get_cipher_status(tmpmem))
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
if (BIO_write(data, buf, i) != i) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
err:
|
||||
OPENSSL_free(buf);
|
||||
BIO_free_all(tmpmem);
|
||||
return ret;
|
||||
}
|
156
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pkcs7err.c
vendored
Normal file
156
trunk/3rdparty/openssl-1.1-fit/crypto/pkcs7/pkcs7err.c
vendored
Normal file
|
@ -0,0 +1,156 @@
|
|||
/*
|
||||
* Generated by util/mkerr.pl DO NOT EDIT
|
||||
* Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/pkcs7err.h>
|
||||
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
|
||||
static const ERR_STRING_DATA PKCS7_str_functs[] = {
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_DO_PKCS7_SIGNED_ATTRIB, 0),
|
||||
"do_pkcs7_signed_attrib"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME, 0),
|
||||
"PKCS7_add0_attrib_signing_time"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP, 0),
|
||||
"PKCS7_add_attrib_smimecap"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_ADD_CERTIFICATE, 0),
|
||||
"PKCS7_add_certificate"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_ADD_CRL, 0), "PKCS7_add_crl"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_ADD_RECIPIENT_INFO, 0),
|
||||
"PKCS7_add_recipient_info"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_ADD_SIGNATURE, 0),
|
||||
"PKCS7_add_signature"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_ADD_SIGNER, 0), "PKCS7_add_signer"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_BIO_ADD_DIGEST, 0),
|
||||
"PKCS7_bio_add_digest"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_COPY_EXISTING_DIGEST, 0),
|
||||
"pkcs7_copy_existing_digest"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_CTRL, 0), "PKCS7_ctrl"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_DATADECODE, 0), "PKCS7_dataDecode"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_DATAFINAL, 0), "PKCS7_dataFinal"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_DATAINIT, 0), "PKCS7_dataInit"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_DATAVERIFY, 0), "PKCS7_dataVerify"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_DECRYPT, 0), "PKCS7_decrypt"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_DECRYPT_RINFO, 0),
|
||||
"pkcs7_decrypt_rinfo"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_ENCODE_RINFO, 0),
|
||||
"pkcs7_encode_rinfo"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_ENCRYPT, 0), "PKCS7_encrypt"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_FINAL, 0), "PKCS7_final"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_FIND_DIGEST, 0),
|
||||
"PKCS7_find_digest"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_GET0_SIGNERS, 0),
|
||||
"PKCS7_get0_signers"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_RECIP_INFO_SET, 0),
|
||||
"PKCS7_RECIP_INFO_set"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_SET_CIPHER, 0), "PKCS7_set_cipher"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_SET_CONTENT, 0),
|
||||
"PKCS7_set_content"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_SET_DIGEST, 0), "PKCS7_set_digest"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_SET_TYPE, 0), "PKCS7_set_type"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_SIGN, 0), "PKCS7_sign"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_SIGNATUREVERIFY, 0),
|
||||
"PKCS7_signatureVerify"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_SIGNER_INFO_SET, 0),
|
||||
"PKCS7_SIGNER_INFO_set"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_SIGNER_INFO_SIGN, 0),
|
||||
"PKCS7_SIGNER_INFO_sign"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_SIGN_ADD_SIGNER, 0),
|
||||
"PKCS7_sign_add_signer"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_SIMPLE_SMIMECAP, 0),
|
||||
"PKCS7_simple_smimecap"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, PKCS7_F_PKCS7_VERIFY, 0), "PKCS7_verify"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static const ERR_STRING_DATA PKCS7_str_reasons[] = {
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_CERTIFICATE_VERIFY_ERROR),
|
||||
"certificate verify error"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER),
|
||||
"cipher has no object identifier"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_CIPHER_NOT_INITIALIZED),
|
||||
"cipher not initialized"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_CONTENT_AND_DATA_PRESENT),
|
||||
"content and data present"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_CTRL_ERROR), "ctrl error"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_DECRYPT_ERROR), "decrypt error"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_DIGEST_FAILURE), "digest failure"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_ENCRYPTION_CTRL_FAILURE),
|
||||
"encryption ctrl failure"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE),
|
||||
"encryption not supported for this key type"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_ERROR_ADDING_RECIPIENT),
|
||||
"error adding recipient"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_ERROR_SETTING_CIPHER),
|
||||
"error setting cipher"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_INVALID_NULL_POINTER),
|
||||
"invalid null pointer"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_INVALID_SIGNED_DATA_TYPE),
|
||||
"invalid signed data type"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_CONTENT), "no content"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_DEFAULT_DIGEST),
|
||||
"no default digest"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND),
|
||||
"no matching digest type found"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE),
|
||||
"no recipient matches certificate"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_SIGNATURES_ON_DATA),
|
||||
"no signatures on data"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_NO_SIGNERS), "no signers"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE),
|
||||
"operation not supported on this type"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR),
|
||||
"pkcs7 add signature error"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_PKCS7_ADD_SIGNER_ERROR),
|
||||
"pkcs7 add signer error"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_PKCS7_DATASIGN), "pkcs7 datasign"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE),
|
||||
"private key does not match certificate"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_SIGNATURE_FAILURE),
|
||||
"signature failure"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND),
|
||||
"signer certificate not found"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_SIGNING_CTRL_FAILURE),
|
||||
"signing ctrl failure"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE),
|
||||
"signing not supported for this key type"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_SMIME_TEXT_ERROR), "smime text error"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNABLE_TO_FIND_CERTIFICATE),
|
||||
"unable to find certificate"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNABLE_TO_FIND_MEM_BIO),
|
||||
"unable to find mem bio"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST),
|
||||
"unable to find message digest"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNKNOWN_DIGEST_TYPE),
|
||||
"unknown digest type"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNKNOWN_OPERATION),
|
||||
"unknown operation"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNSUPPORTED_CIPHER_TYPE),
|
||||
"unsupported cipher type"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_UNSUPPORTED_CONTENT_TYPE),
|
||||
"unsupported content type"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_WRONG_CONTENT_TYPE),
|
||||
"wrong content type"},
|
||||
{ERR_PACK(ERR_LIB_PKCS7, 0, PKCS7_R_WRONG_PKCS7_TYPE), "wrong pkcs7 type"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
int ERR_load_PKCS7_strings(void)
|
||||
{
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
if (ERR_func_error_string(PKCS7_str_functs[0].error) == NULL) {
|
||||
ERR_load_strings_const(PKCS7_str_functs);
|
||||
ERR_load_strings_const(PKCS7_str_reasons);
|
||||
}
|
||||
#endif
|
||||
return 1;
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue