[linux-block.git] / crypto / asymmetric_keys / pkcs7_parser.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* PKCS#7 parser
 *
 * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */

#define pr_fmt(fmt) "PKCS7: "fmt
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/export.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/oid_registry.h>
#include <crypto/public_key.h>
#include "pkcs7_parser.h"
#include "pkcs7.asn1.h"

MODULE_DESCRIPTION("PKCS#7 parser");
MODULE_AUTHOR("Red Hat, Inc.");
MODULE_LICENSE("GPL");

struct pkcs7_parse_context {
	struct pkcs7_message	*msg;		/* Message being constructed */
	struct pkcs7_signed_info *sinfo;	/* SignedInfo being constructed */
	struct pkcs7_signed_info **ppsinfo;
	struct x509_certificate *certs;		/* Certificate cache */
	struct x509_certificate **ppcerts;
	unsigned long	data;			/* Start of data */
	enum OID	last_oid;		/* Last OID encountered */
	unsigned	x509_index;
	unsigned	sinfo_index;
	const void	*raw_serial;
	unsigned	raw_serial_size;
	unsigned	raw_issuer_size;
	const void	*raw_issuer;
	const void	*raw_skid;
	unsigned	raw_skid_size;
	bool		expect_skid;
};

/*
 * Free a signed information block.
 */
static void pkcs7_free_signed_info(struct pkcs7_signed_info *sinfo)
{
	if (sinfo) {
		public_key_signature_free(sinfo->sig);
		kfree(sinfo);
	}
}

/**
 * pkcs7_free_message - Free a PKCS#7 message
 * @pkcs7: The PKCS#7 message to free
 */
void pkcs7_free_message(struct pkcs7_message *pkcs7)
{
	struct x509_certificate *cert;
	struct pkcs7_signed_info *sinfo;

	if (pkcs7) {
		while (pkcs7->certs) {
			cert = pkcs7->certs;
			pkcs7->certs = cert->next;
			x509_free_certificate(cert);
		}
		while (pkcs7->crl) {
			cert = pkcs7->crl;
			pkcs7->crl = cert->next;
			x509_free_certificate(cert);
		}
		while (pkcs7->signed_infos) {
			sinfo = pkcs7->signed_infos;
			pkcs7->signed_infos = sinfo->next;
			pkcs7_free_signed_info(sinfo);
		}
		kfree(pkcs7);
	}
}
EXPORT_SYMBOL_GPL(pkcs7_free_message);

/*
 * Check authenticatedAttributes are provided or not provided consistently.
 */
static int pkcs7_check_authattrs(struct pkcs7_message *msg)
{
	struct pkcs7_signed_info *sinfo;
	bool want = false;

	sinfo = msg->signed_infos;
	if (!sinfo)
		goto inconsistent;

	if (sinfo->authattrs) {
		want = true;
		msg->have_authattrs = true;
	}

	for (sinfo = sinfo->next; sinfo; sinfo = sinfo->next)
		if (!!sinfo->authattrs != want)
			goto inconsistent;
	return 0;

inconsistent:
	pr_warn("Inconsistently supplied authAttrs\n");
	return -EINVAL;
}

/**
 * pkcs7_parse_message - Parse a PKCS#7 message
 * @data: The raw binary ASN.1 encoded message to be parsed
 * @datalen: The size of the encoded message
 */
struct pkcs7_message *pkcs7_parse_message(const void *data, size_t datalen)
{
	struct pkcs7_parse_context *ctx;
	struct pkcs7_message *msg = ERR_PTR(-ENOMEM);
	int ret;

	ctx = kzalloc(sizeof(struct pkcs7_parse_context), GFP_KERNEL);
	if (!ctx)
		goto out_no_ctx;
	ctx->msg = kzalloc(sizeof(struct pkcs7_message), GFP_KERNEL);
	if (!ctx->msg)
		goto out_no_msg;
	ctx->sinfo = kzalloc(sizeof(struct pkcs7_signed_info), GFP_KERNEL);
	if (!ctx->sinfo)
		goto out_no_sinfo;
	ctx->sinfo->sig = kzalloc(sizeof(struct public_key_signature),
				  GFP_KERNEL);
	if (!ctx->sinfo->sig)
		goto out_no_sig;

	ctx->data = (unsigned long)data;
	ctx->ppcerts = &ctx->certs;
	ctx->ppsinfo = &ctx->msg->signed_infos;

	/* Attempt to decode the signature */
	ret = asn1_ber_decoder(&pkcs7_decoder, ctx, data, datalen);
	if (ret < 0) {
		msg = ERR_PTR(ret);
		goto out;
	}

	ret = pkcs7_check_authattrs(ctx->msg);
	if (ret < 0) {
		msg = ERR_PTR(ret);
		goto out;
	}

	msg = ctx->msg;
	ctx->msg = NULL;

out:
	while (ctx->certs) {
		struct x509_certificate *cert = ctx->certs;
		ctx->certs = cert->next;
		x509_free_certificate(cert);
	}
out_no_sig:
	pkcs7_free_signed_info(ctx->sinfo);
out_no_sinfo:
	pkcs7_free_message(ctx->msg);
out_no_msg:
	kfree(ctx);
out_no_ctx:
	return msg;
}
EXPORT_SYMBOL_GPL(pkcs7_parse_message);

/**
 * pkcs7_get_content_data - Get access to the PKCS#7 content
 * @pkcs7: The preparsed PKCS#7 message to access
 * @_data: Place to return a pointer to the data
 * @_data_len: Place to return the data length
 * @_headerlen: Size of ASN.1 header not included in _data
 *
 * Get access to the data content of the PKCS#7 message.  The size of the
 * header of the ASN.1 object that contains it is also provided and can be used
 * to adjust *_data and *_data_len to get the entire object.
 *
 * Returns -ENODATA if the data object was missing from the message.
 */
int pkcs7_get_content_data(const struct pkcs7_message *pkcs7,
			   const void **_data, size_t *_data_len,
			   size_t *_headerlen)
{
	if (!pkcs7->data)
		return -ENODATA;

	*_data = pkcs7->data;
	*_data_len = pkcs7->data_len;
	if (_headerlen)
		*_headerlen = pkcs7->data_hdrlen;
	return 0;
}
EXPORT_SYMBOL_GPL(pkcs7_get_content_data);

/*
 * Note an OID when we find one for later processing when we know how
 * to interpret it.
 */
int pkcs7_note_OID(void *context, size_t hdrlen,
		   unsigned char tag,
		   const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;

	ctx->last_oid = look_up_OID(value, vlen);
	if (ctx->last_oid == OID__NR) {
		char buffer[50];
		sprint_oid(value, vlen, buffer, sizeof(buffer));
		printk("PKCS7: Unknown OID: [%lu] %s\n",
		       (unsigned long)value - ctx->data, buffer);
	}
	return 0;
}

/*
 * Note the digest algorithm for the signature.
 */
int pkcs7_sig_note_digest_algo(void *context, size_t hdrlen,
			       unsigned char tag,
			       const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;

	switch (ctx->last_oid) {
	case OID_md4:
		ctx->sinfo->sig->hash_algo = "md4";
		break;
	case OID_md5:
		ctx->sinfo->sig->hash_algo = "md5";
		break;
	case OID_sha1:
		ctx->sinfo->sig->hash_algo = "sha1";
		break;
	case OID_sha256:
		ctx->sinfo->sig->hash_algo = "sha256";
		break;
	case OID_sha384:
		ctx->sinfo->sig->hash_algo = "sha384";
		break;
	case OID_sha512:
		ctx->sinfo->sig->hash_algo = "sha512";
		break;
	case OID_sha224:
		ctx->sinfo->sig->hash_algo = "sha224";
		break;
	case OID_sm3:
		ctx->sinfo->sig->hash_algo = "sm3";
		break;
	case OID_gost2012Digest256:
		ctx->sinfo->sig->hash_algo = "streebog256";
		break;
	case OID_gost2012Digest512:
		ctx->sinfo->sig->hash_algo = "streebog512";
		break;
	default:
		printk("Unsupported digest algo: %u\n", ctx->last_oid);
		return -ENOPKG;
	}
	return 0;
}

/*
 * Note the public key algorithm for the signature.
 */
int pkcs7_sig_note_pkey_algo(void *context, size_t hdrlen,
			     unsigned char tag,
			     const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;

	switch (ctx->last_oid) {
	case OID_rsaEncryption:
		ctx->sinfo->sig->pkey_algo = "rsa";
		ctx->sinfo->sig->encoding = "pkcs1";
		break;
	case OID_id_ecdsa_with_sha1:
	case OID_id_ecdsa_with_sha224:
	case OID_id_ecdsa_with_sha256:
	case OID_id_ecdsa_with_sha384:
	case OID_id_ecdsa_with_sha512:
		ctx->sinfo->sig->pkey_algo = "ecdsa";
		ctx->sinfo->sig->encoding = "x962";
		break;
	case OID_SM2_with_SM3:
		ctx->sinfo->sig->pkey_algo = "sm2";
		ctx->sinfo->sig->encoding = "raw";
		break;
	case OID_gost2012PKey256:
	case OID_gost2012PKey512:
		ctx->sinfo->sig->pkey_algo = "ecrdsa";
		ctx->sinfo->sig->encoding = "raw";
		break;
	default:
		printk("Unsupported pkey algo: %u\n", ctx->last_oid);
		return -ENOPKG;
	}
	return 0;
}

/*
 * We only support signed data [RFC2315 sec 9].
 */
int pkcs7_check_content_type(void *context, size_t hdrlen,
			     unsigned char tag,
			     const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;

	if (ctx->last_oid != OID_signed_data) {
		pr_warn("Only support pkcs7_signedData type\n");
		return -EINVAL;
	}

	return 0;
}

/*
 * Note the SignedData version
 */
int pkcs7_note_signeddata_version(void *context, size_t hdrlen,
				  unsigned char tag,
				  const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;
	unsigned version;

	if (vlen != 1)
		goto unsupported;

	ctx->msg->version = version = *(const u8 *)value;
	switch (version) {
	case 1:
		/* PKCS#7 SignedData [RFC2315 sec 9.1]
		 * CMS ver 1 SignedData [RFC5652 sec 5.1]
		 */
		break;
	case 3:
		/* CMS ver 3 SignedData [RFC2315 sec 5.1] */
		break;
	default:
		goto unsupported;
	}

	return 0;

unsupported:
	pr_warn("Unsupported SignedData version\n");
	return -EINVAL;
}

/*
 * Note the SignerInfo version
 */
int pkcs7_note_signerinfo_version(void *context, size_t hdrlen,
				  unsigned char tag,
				  const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;
	unsigned version;

	if (vlen != 1)
		goto unsupported;

	version = *(const u8 *)value;
	switch (version) {
	case 1:
		/* PKCS#7 SignerInfo [RFC2315 sec 9.2]
		 * CMS ver 1 SignerInfo [RFC5652 sec 5.3]
		 */
		if (ctx->msg->version != 1)
			goto version_mismatch;
		ctx->expect_skid = false;
		break;
	case 3:
		/* CMS ver 3 SignerInfo [RFC2315 sec 5.3] */
		if (ctx->msg->version == 1)
			goto version_mismatch;
		ctx->expect_skid = true;
		break;
	default:
		goto unsupported;
	}

	return 0;

unsupported:
	pr_warn("Unsupported SignerInfo version\n");
	return -EINVAL;
version_mismatch:
	pr_warn("SignedData-SignerInfo version mismatch\n");
	return -EBADMSG;
}

/*
 * Extract a certificate and store it in the context.
 */
int pkcs7_extract_cert(void *context, size_t hdrlen,
		       unsigned char tag,
		       const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;
	struct x509_certificate *x509;

	if (tag != ((ASN1_UNIV << 6) | ASN1_CONS_BIT | ASN1_SEQ)) {
		pr_debug("Cert began with tag %02x at %lu\n",
			 tag, (unsigned long)ctx - ctx->data);
		return -EBADMSG;
	}

	/* We have to correct for the header so that the X.509 parser can start
	 * from the beginning.  Note that since X.509 stipulates DER, there
	 * probably shouldn't be an EOC trailer - but it is in PKCS#7 (which
	 * stipulates BER).
	 */
	value -= hdrlen;
	vlen += hdrlen;

	if (((u8*)value)[1] == 0x80)
		vlen += 2; /* Indefinite length - there should be an EOC */

	x509 = x509_cert_parse(value, vlen);
	if (IS_ERR(x509))
		return PTR_ERR(x509);

	x509->index = ++ctx->x509_index;
	pr_debug("Got cert %u for %s\n", x509->index, x509->subject);
	pr_debug("- fingerprint %*phN\n", x509->id->len, x509->id->data);

	*ctx->ppcerts = x509;
	ctx->ppcerts = &x509->next;
	return 0;
}

/*
 * Save the certificate list
 */
int pkcs7_note_certificate_list(void *context, size_t hdrlen,
				unsigned char tag,
				const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;

	pr_devel("Got cert list (%02x)\n", tag);

	*ctx->ppcerts = ctx->msg->certs;
	ctx->msg->certs = ctx->certs;
	ctx->certs = NULL;
	ctx->ppcerts = &ctx->certs;
	return 0;
}

/*
 * Note the content type.
 */
int pkcs7_note_content(void *context, size_t hdrlen,
		       unsigned char tag,
		       const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;

	if (ctx->last_oid != OID_data &&
	    ctx->last_oid != OID_msIndirectData) {
		pr_warn("Unsupported data type %d\n", ctx->last_oid);
		return -EINVAL;
	}

	ctx->msg->data_type = ctx->last_oid;
	return 0;
}

/*
 * Extract the data from the message and store that and its content type OID in
 * the context.
 */
int pkcs7_note_data(void *context, size_t hdrlen,
		    unsigned char tag,
		    const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;

	pr_debug("Got data\n");

	ctx->msg->data = value;
	ctx->msg->data_len = vlen;
	ctx->msg->data_hdrlen = hdrlen;
	return 0;
}

/*
 * Parse authenticated attributes.
 */
int pkcs7_sig_note_authenticated_attr(void *context, size_t hdrlen,
				      unsigned char tag,
				      const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;
	struct pkcs7_signed_info *sinfo = ctx->sinfo;
	enum OID content_type;

	pr_devel("AuthAttr: %02x %zu [%*ph]\n", tag, vlen, (unsigned)vlen, value);

	switch (ctx->last_oid) {
	case OID_contentType:
		if (__test_and_set_bit(sinfo_has_content_type, &sinfo->aa_set))
			goto repeated;
		content_type = look_up_OID(value, vlen);
		if (content_type != ctx->msg->data_type) {
			pr_warn("Mismatch between global data type (%d) and sinfo %u (%d)\n",
				ctx->msg->data_type, sinfo->index,
				content_type);
			return -EBADMSG;
		}
		return 0;

	case OID_signingTime:
		if (__test_and_set_bit(sinfo_has_signing_time, &sinfo->aa_set))
			goto repeated;
		/* Should we check that the signing time is consistent
		 * with the signer's X.509 cert?
		 */
		return x509_decode_time(&sinfo->signing_time,
					hdrlen, tag, value, vlen);

	case OID_messageDigest:
		if (__test_and_set_bit(sinfo_has_message_digest, &sinfo->aa_set))
			goto repeated;
		if (tag != ASN1_OTS)
			return -EBADMSG;
		sinfo->msgdigest = value;
		sinfo->msgdigest_len = vlen;
		return 0;

	case OID_smimeCapabilites:
		if (__test_and_set_bit(sinfo_has_smime_caps, &sinfo->aa_set))
			goto repeated;
		if (ctx->msg->data_type != OID_msIndirectData) {
			pr_warn("S/MIME Caps only allowed with Authenticode\n");
			return -EKEYREJECTED;
		}
		return 0;

		/* Microsoft SpOpusInfo seems to be contain cont[0] 16-bit BE
		 * char URLs and cont[1] 8-bit char URLs.
		 *
		 * Microsoft StatementType seems to contain a list of OIDs that
		 * are also used as extendedKeyUsage types in X.509 certs.
		 */
	case OID_msSpOpusInfo:
		if (__test_and_set_bit(sinfo_has_ms_opus_info, &sinfo->aa_set))
			goto repeated;
		goto authenticode_check;
	case OID_msStatementType:
		if (__test_and_set_bit(sinfo_has_ms_statement_type, &sinfo->aa_set))
			goto repeated;
	authenticode_check:
		if (ctx->msg->data_type != OID_msIndirectData) {
			pr_warn("Authenticode AuthAttrs only allowed with Authenticode\n");
			return -EKEYREJECTED;
		}
		/* I'm not sure how to validate these */
		return 0;
	default:
		return 0;
	}

repeated:
	/* We permit max one item per AuthenticatedAttribute and no repeats */
	pr_warn("Repeated/multivalue AuthAttrs not permitted\n");
	return -EKEYREJECTED;
}

/*
 * Note the set of auth attributes for digestion purposes [RFC2315 sec 9.3]
 */
int pkcs7_sig_note_set_of_authattrs(void *context, size_t hdrlen,
				    unsigned char tag,
				    const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;
	struct pkcs7_signed_info *sinfo = ctx->sinfo;

	if (!test_bit(sinfo_has_content_type, &sinfo->aa_set) ||
	    !test_bit(sinfo_has_message_digest, &sinfo->aa_set)) {
		pr_warn("Missing required AuthAttr\n");
		return -EBADMSG;
	}

	if (ctx->msg->data_type != OID_msIndirectData &&
	    test_bit(sinfo_has_ms_opus_info, &sinfo->aa_set)) {
		pr_warn("Unexpected Authenticode AuthAttr\n");
		return -EBADMSG;
	}

	/* We need to switch the 'CONT 0' to a 'SET OF' when we digest */
	sinfo->authattrs = value - (hdrlen - 1);
	sinfo->authattrs_len = vlen + (hdrlen - 1);
	return 0;
}

/*
 * Note the issuing certificate serial number
 */
int pkcs7_sig_note_serial(void *context, size_t hdrlen,
			  unsigned char tag,
			  const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;
	ctx->raw_serial = value;
	ctx->raw_serial_size = vlen;
	return 0;
}

/*
 * Note the issuer's name
 */
int pkcs7_sig_note_issuer(void *context, size_t hdrlen,
			  unsigned char tag,
			  const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;
	ctx->raw_issuer = value;
	ctx->raw_issuer_size = vlen;
	return 0;
}

/*
 * Note the issuing cert's subjectKeyIdentifier
 */
int pkcs7_sig_note_skid(void *context, size_t hdrlen,
			unsigned char tag,
			const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;

	pr_devel("SKID: %02x %zu [%*ph]\n", tag, vlen, (unsigned)vlen, value);

	ctx->raw_skid = value;
	ctx->raw_skid_size = vlen;
	return 0;
}

/*
 * Note the signature data
 */
int pkcs7_sig_note_signature(void *context, size_t hdrlen,
			     unsigned char tag,
			     const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;

	ctx->sinfo->sig->s = kmemdup(value, vlen, GFP_KERNEL);
	if (!ctx->sinfo->sig->s)
		return -ENOMEM;

	ctx->sinfo->sig->s_size = vlen;
	return 0;
}

/*
 * Note a signature information block
 */
int pkcs7_note_signed_info(void *context, size_t hdrlen,
			   unsigned char tag,
			   const void *value, size_t vlen)
{
	struct pkcs7_parse_context *ctx = context;
	struct pkcs7_signed_info *sinfo = ctx->sinfo;
	struct asymmetric_key_id *kid;

	if (ctx->msg->data_type == OID_msIndirectData && !sinfo->authattrs) {
		pr_warn("Authenticode requires AuthAttrs\n");
		return -EBADMSG;
	}

	/* Generate cert issuer + serial number key ID */
	if (!ctx->expect_skid) {
		kid = asymmetric_key_generate_id(ctx->raw_serial,
						 ctx->raw_serial_size,
						 ctx->raw_issuer,
						 ctx->raw_issuer_size);
	} else {
		kid = asymmetric_key_generate_id(ctx->raw_skid,
						 ctx->raw_skid_size,
						 "", 0);
	}
	if (IS_ERR(kid))
		return PTR_ERR(kid);

	pr_devel("SINFO KID: %u [%*phN]\n", kid->len, kid->len, kid->data);

	sinfo->sig->auth_ids[0] = kid;
	sinfo->index = ++ctx->sinfo_index;
	*ctx->ppsinfo = sinfo;
	ctx->ppsinfo = &sinfo->next;
	ctx->sinfo = kzalloc(sizeof(struct pkcs7_signed_info), GFP_KERNEL);
	if (!ctx->sinfo)
		return -ENOMEM;
	ctx->sinfo->sig = kzalloc(sizeof(struct public_key_signature),
				  GFP_KERNEL);
	if (!ctx->sinfo->sig)
		return -ENOMEM;
	return 0;
}
Commit	Line	Data
b4d0d230	1	// SPDX-License-Identifier: GPL-2.0-or-later
2e3fadbf DH	2	/* PKCS#7 parser
	3	*
	4	* Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells (dhowells@redhat.com)
2e3fadbf DH	6	*/
	7
	8	#define pr_fmt(fmt) "PKCS7: "fmt
	9	#include <linux/kernel.h>
1e684d38	10	#include <linux/module.h>
2e3fadbf DH	11	#include <linux/export.h>
	12	#include <linux/slab.h>
	13	#include <linux/err.h>
	14	#include <linux/oid_registry.h>
db6c43bd	15	#include <crypto/public_key.h>
2e3fadbf	16	#include "pkcs7_parser.h"
4fa8bc94	17	#include "pkcs7.asn1.h"
2e3fadbf	18
1e684d38 DH	19	MODULE_DESCRIPTION("PKCS#7 parser");
	20	MODULE_AUTHOR("Red Hat, Inc.");
	21	MODULE_LICENSE("GPL");
	22
2e3fadbf DH	23	struct pkcs7_parse_context {
	24	struct pkcs7_message msg; / Message being constructed */
	25	struct pkcs7_signed_info sinfo; / SignedInfo being constructed */
	26	struct pkcs7_signed_info **ppsinfo;
	27	struct x509_certificate certs; / Certificate cache */
	28	struct x509_certificate **ppcerts;
	29	unsigned long data; /* Start of data */
	30	enum OID last_oid; /* Last OID encountered */
	31	unsigned x509_index;
	32	unsigned sinfo_index;
46963b77 DH	33	const void *raw_serial;
	34	unsigned raw_serial_size;
	35	unsigned raw_issuer_size;
	36	const void *raw_issuer;
60d65cac DH	37	const void *raw_skid;
	38	unsigned raw_skid_size;
	39	bool expect_skid;
2e3fadbf DH	40	};
2e3fadbf DH	41
3cd0920c DH	42	/*
	43	* Free a signed information block.
	44	*/
	45	static void pkcs7_free_signed_info(struct pkcs7_signed_info *sinfo)
	46	{
	47	if (sinfo) {
566a117a	48	public_key_signature_free(sinfo->sig);
3cd0920c DH	49	kfree(sinfo);
	50	}
	51	}
	52
2e3fadbf DH	53	/**
	54	* pkcs7_free_message - Free a PKCS#7 message
	55	* @pkcs7: The PKCS#7 message to free
	56	*/
	57	void pkcs7_free_message(struct pkcs7_message *pkcs7)
	58	{
	59	struct x509_certificate *cert;
	60	struct pkcs7_signed_info *sinfo;
	61
	62	if (pkcs7) {
	63	while (pkcs7->certs) {
	64	cert = pkcs7->certs;
	65	pkcs7->certs = cert->next;
	66	x509_free_certificate(cert);
	67	}
	68	while (pkcs7->crl) {
	69	cert = pkcs7->crl;
	70	pkcs7->crl = cert->next;
	71	x509_free_certificate(cert);
	72	}
	73	while (pkcs7->signed_infos) {
	74	sinfo = pkcs7->signed_infos;
	75	pkcs7->signed_infos = sinfo->next;
3cd0920c	76	pkcs7_free_signed_info(sinfo);
2e3fadbf DH	77	}
	78	kfree(pkcs7);
	79	}
	80	}
	81	EXPORT_SYMBOL_GPL(pkcs7_free_message);
	82
99db4435 DH	83	/*
	84	* Check authenticatedAttributes are provided or not provided consistently.
	85	*/
	86	static int pkcs7_check_authattrs(struct pkcs7_message *msg)
	87	{
	88	struct pkcs7_signed_info *sinfo;
06aae592	89	bool want = false;
99db4435 DH	90
99db4435 DH	91	sinfo = msg->signed_infos;
68a1fdbb ES	92	if (!sinfo)
	93	goto inconsistent;
	94
99db4435 DH	95	if (sinfo->authattrs) {
	96	want = true;
	97	msg->have_authattrs = true;
	98	}
	99
	100	for (sinfo = sinfo->next; sinfo; sinfo = sinfo->next)
	101	if (!!sinfo->authattrs != want)
	102	goto inconsistent;
	103	return 0;
	104
	105	inconsistent:
	106	pr_warn("Inconsistently supplied authAttrs\n");
	107	return -EINVAL;
	108	}
	109
2e3fadbf DH	110	/**
	111	* pkcs7_parse_message - Parse a PKCS#7 message
	112	* @data: The raw binary ASN.1 encoded message to be parsed
	113	* @datalen: The size of the encoded message
	114	*/
	115	struct pkcs7_message pkcs7_parse_message(const void data, size_t datalen)
	116	{
	117	struct pkcs7_parse_context *ctx;
cecf5d2e DH	118	struct pkcs7_message *msg = ERR_PTR(-ENOMEM);
cecf5d2e DH	119	int ret;
2e3fadbf	120
2e3fadbf DH	121	ctx = kzalloc(sizeof(struct pkcs7_parse_context), GFP_KERNEL);
2e3fadbf DH	122	if (!ctx)
cecf5d2e DH	123	goto out_no_ctx;
	124	ctx->msg = kzalloc(sizeof(struct pkcs7_message), GFP_KERNEL);
	125	if (!ctx->msg)
	126	goto out_no_msg;
2e3fadbf DH	127	ctx->sinfo = kzalloc(sizeof(struct pkcs7_signed_info), GFP_KERNEL);
2e3fadbf DH	128	if (!ctx->sinfo)
cecf5d2e	129	goto out_no_sinfo;
566a117a DH	130	ctx->sinfo->sig = kzalloc(sizeof(struct public_key_signature),
	131	GFP_KERNEL);
	132	if (!ctx->sinfo->sig)
	133	goto out_no_sig;
2e3fadbf	134
2e3fadbf DH	135	ctx->data = (unsigned long)data;
	136	ctx->ppcerts = &ctx->certs;
	137	ctx->ppsinfo = &ctx->msg->signed_infos;
	138
	139	/* Attempt to decode the signature */
	140	ret = asn1_ber_decoder(&pkcs7_decoder, ctx, data, datalen);
cecf5d2e DH	141	if (ret < 0) {
	142	msg = ERR_PTR(ret);
	143	goto out;
	144	}
	145
99db4435	146	ret = pkcs7_check_authattrs(ctx->msg);
8ecb506d EB	147	if (ret < 0) {
8ecb506d EB	148	msg = ERR_PTR(ret);
99db4435	149	goto out;
8ecb506d	150	}
99db4435	151
cecf5d2e DH	152	msg = ctx->msg;
cecf5d2e DH	153	ctx->msg = NULL;
2e3fadbf	154
cecf5d2e	155	out:
2e3fadbf DH	156	while (ctx->certs) {
	157	struct x509_certificate *cert = ctx->certs;
	158	ctx->certs = cert->next;
	159	x509_free_certificate(cert);
	160	}
566a117a	161	out_no_sig:
3cd0920c	162	pkcs7_free_signed_info(ctx->sinfo);
cecf5d2e DH	163	out_no_sinfo:
	164	pkcs7_free_message(ctx->msg);
	165	out_no_msg:
2e3fadbf	166	kfree(ctx);
cecf5d2e	167	out_no_ctx:
2e3fadbf	168	return msg;
2e3fadbf DH	169	}
	170	EXPORT_SYMBOL_GPL(pkcs7_parse_message);
	171
	172	/**
	173	* pkcs7_get_content_data - Get access to the PKCS#7 content
	174	* @pkcs7: The preparsed PKCS#7 message to access
	175	* @_data: Place to return a pointer to the data
	176	* @_data_len: Place to return the data length
e68503bd	177	* @_headerlen: Size of ASN.1 header not included in _data
2e3fadbf	178	*
e68503bd DH	179	* Get access to the data content of the PKCS#7 message. The size of the
	180	* header of the ASN.1 object that contains it is also provided and can be used
	181	* to adjust _data and _data_len to get the entire object.
	182	*
	183	* Returns -ENODATA if the data object was missing from the message.
2e3fadbf DH	184	*/
	185	int pkcs7_get_content_data(const struct pkcs7_message *pkcs7,
	186	const void *_data, size_t _data_len,
e68503bd	187	size_t *_headerlen)
2e3fadbf	188	{
2e3fadbf DH	189	if (!pkcs7->data)
	190	return -ENODATA;
	191
e68503bd DH	192	*_data = pkcs7->data;
	193	*_data_len = pkcs7->data_len;
	194	if (_headerlen)
	195	*_headerlen = pkcs7->data_hdrlen;
2e3fadbf DH	196	return 0;
	197	}
	198	EXPORT_SYMBOL_GPL(pkcs7_get_content_data);
	199
	200	/*
	201	* Note an OID when we find one for later processing when we know how
	202	* to interpret it.
	203	*/
	204	int pkcs7_note_OID(void *context, size_t hdrlen,
	205	unsigned char tag,
	206	const void *value, size_t vlen)
	207	{
	208	struct pkcs7_parse_context *ctx = context;
	209
	210	ctx->last_oid = look_up_OID(value, vlen);
	211	if (ctx->last_oid == OID__NR) {
	212	char buffer[50];
	213	sprint_oid(value, vlen, buffer, sizeof(buffer));
	214	printk("PKCS7: Unknown OID: [%lu] %s\n",
	215	(unsigned long)value - ctx->data, buffer);
	216	}
	217	return 0;
	218	}
	219
	220	/*
	221	* Note the digest algorithm for the signature.
	222	*/
	223	int pkcs7_sig_note_digest_algo(void *context, size_t hdrlen,
	224	unsigned char tag,
	225	const void *value, size_t vlen)
	226	{
	227	struct pkcs7_parse_context *ctx = context;
	228
	229	switch (ctx->last_oid) {
	230	case OID_md4:
566a117a	231	ctx->sinfo->sig->hash_algo = "md4";
2e3fadbf DH	232	break;
2e3fadbf DH	233	case OID_md5:
566a117a	234	ctx->sinfo->sig->hash_algo = "md5";
2e3fadbf DH	235	break;
2e3fadbf DH	236	case OID_sha1:
566a117a	237	ctx->sinfo->sig->hash_algo = "sha1";
2e3fadbf DH	238	break;
2e3fadbf DH	239	case OID_sha256:
566a117a	240	ctx->sinfo->sig->hash_algo = "sha256";
2e3fadbf	241	break;
07f081fb	242	case OID_sha384:
566a117a	243	ctx->sinfo->sig->hash_algo = "sha384";
07f081fb DH	244	break;
07f081fb DH	245	case OID_sha512:
566a117a	246	ctx->sinfo->sig->hash_algo = "sha512";
07f081fb DH	247	break;
07f081fb DH	248	case OID_sha224:
566a117a DH	249	ctx->sinfo->sig->hash_algo = "sha224";
566a117a DH	250	break;
3fb8e3f5 TZ	251	case OID_sm3:
	252	ctx->sinfo->sig->hash_algo = "sm3";
	253	break;
d35f42ca EK	254	case OID_gost2012Digest256:
	255	ctx->sinfo->sig->hash_algo = "streebog256";
	256	break;
	257	case OID_gost2012Digest512:
	258	ctx->sinfo->sig->hash_algo = "streebog512";
	259	break;
2e3fadbf DH	260	default:
	261	printk("Unsupported digest algo: %u\n", ctx->last_oid);
	262	return -ENOPKG;
	263	}
	264	return 0;
	265	}
	266
	267	/*
	268	* Note the public key algorithm for the signature.
	269	*/
	270	int pkcs7_sig_note_pkey_algo(void *context, size_t hdrlen,
	271	unsigned char tag,
	272	const void *value, size_t vlen)
	273	{
	274	struct pkcs7_parse_context *ctx = context;
	275
	276	switch (ctx->last_oid) {
	277	case OID_rsaEncryption:
566a117a	278	ctx->sinfo->sig->pkey_algo = "rsa";
03988490	279	ctx->sinfo->sig->encoding = "pkcs1";
2e3fadbf	280	break;
a4aed36e SB	281	case OID_id_ecdsa_with_sha1:
	282	case OID_id_ecdsa_with_sha224:
	283	case OID_id_ecdsa_with_sha256:
	284	case OID_id_ecdsa_with_sha384:
	285	case OID_id_ecdsa_with_sha512:
	286	ctx->sinfo->sig->pkey_algo = "ecdsa";
	287	ctx->sinfo->sig->encoding = "x962";
	288	break;
3fb8e3f5 TZ	289	case OID_SM2_with_SM3:
	290	ctx->sinfo->sig->pkey_algo = "sm2";
	291	ctx->sinfo->sig->encoding = "raw";
	292	break;
d35f42ca EK	293	case OID_gost2012PKey256:
	294	case OID_gost2012PKey512:
	295	ctx->sinfo->sig->pkey_algo = "ecrdsa";
	296	ctx->sinfo->sig->encoding = "raw";
	297	break;
2e3fadbf DH	298	default:
	299	printk("Unsupported pkey algo: %u\n", ctx->last_oid);
	300	return -ENOPKG;
	301	}
	302	return 0;
	303	}
	304
2c7fd367 DH	305	/*
	306	* We only support signed data [RFC2315 sec 9].
	307	*/
	308	int pkcs7_check_content_type(void *context, size_t hdrlen,
	309	unsigned char tag,
	310	const void *value, size_t vlen)
	311	{
	312	struct pkcs7_parse_context *ctx = context;
	313
	314	if (ctx->last_oid != OID_signed_data) {
	315	pr_warn("Only support pkcs7_signedData type\n");
	316	return -EINVAL;
	317	}
	318
	319	return 0;
	320	}
	321
	322	/*
	323	* Note the SignedData version
	324	*/
	325	int pkcs7_note_signeddata_version(void *context, size_t hdrlen,
	326	unsigned char tag,
	327	const void *value, size_t vlen)
	328	{
60d65cac	329	struct pkcs7_parse_context *ctx = context;
2c7fd367 DH	330	unsigned version;
	331
	332	if (vlen != 1)
	333	goto unsupported;
	334
60d65cac	335	ctx->msg->version = version = (const u8 )value;
2c7fd367 DH	336	switch (version) {
2c7fd367 DH	337	case 1:
60d65cac DH	338	/* PKCS#7 SignedData [RFC2315 sec 9.1]
	339	* CMS ver 1 SignedData [RFC5652 sec 5.1]
	340	*/
	341	break;
	342	case 3:
	343	/* CMS ver 3 SignedData [RFC2315 sec 5.1] */
2c7fd367 DH	344	break;
	345	default:
	346	goto unsupported;
	347	}
	348
	349	return 0;
	350
	351	unsupported:
	352	pr_warn("Unsupported SignedData version\n");
	353	return -EINVAL;
	354	}
	355
	356	/*
	357	* Note the SignerInfo version
	358	*/
	359	int pkcs7_note_signerinfo_version(void *context, size_t hdrlen,
	360	unsigned char tag,
	361	const void *value, size_t vlen)
	362	{
60d65cac	363	struct pkcs7_parse_context *ctx = context;
2c7fd367 DH	364	unsigned version;
	365
	366	if (vlen != 1)
	367	goto unsupported;
	368
	369	version = (const u8 )value;
	370	switch (version) {
	371	case 1:
60d65cac DH	372	/* PKCS#7 SignerInfo [RFC2315 sec 9.2]
	373	* CMS ver 1 SignerInfo [RFC5652 sec 5.3]
	374	*/
	375	if (ctx->msg->version != 1)
	376	goto version_mismatch;
	377	ctx->expect_skid = false;
	378	break;
	379	case 3:
	380	/* CMS ver 3 SignerInfo [RFC2315 sec 5.3] */
	381	if (ctx->msg->version == 1)
	382	goto version_mismatch;
	383	ctx->expect_skid = true;
2c7fd367 DH	384	break;
	385	default:
	386	goto unsupported;
	387	}
	388
	389	return 0;
	390
	391	unsupported:
	392	pr_warn("Unsupported SignerInfo version\n");
	393	return -EINVAL;
60d65cac DH	394	version_mismatch:
	395	pr_warn("SignedData-SignerInfo version mismatch\n");
	396	return -EBADMSG;
2c7fd367 DH	397	}
2c7fd367 DH	398
2e3fadbf DH	399	/*
	400	* Extract a certificate and store it in the context.
	401	*/
	402	int pkcs7_extract_cert(void *context, size_t hdrlen,
	403	unsigned char tag,
	404	const void *value, size_t vlen)
	405	{
	406	struct pkcs7_parse_context *ctx = context;
	407	struct x509_certificate *x509;
	408
	409	if (tag != ((ASN1_UNIV << 6) \| ASN1_CONS_BIT \| ASN1_SEQ)) {
	410	pr_debug("Cert began with tag %02x at %lu\n",
	411	tag, (unsigned long)ctx - ctx->data);
	412	return -EBADMSG;
	413	}
	414
	415	/* We have to correct for the header so that the X.509 parser can start
	416	* from the beginning. Note that since X.509 stipulates DER, there
	417	* probably shouldn't be an EOC trailer - but it is in PKCS#7 (which
	418	* stipulates BER).
	419	*/
	420	value -= hdrlen;
	421	vlen += hdrlen;
	422
	423	if (((u8*)value)[1] == 0x80)
	424	vlen += 2; /* Indefinite length - there should be an EOC */
	425
	426	x509 = x509_cert_parse(value, vlen);
	427	if (IS_ERR(x509))
	428	return PTR_ERR(x509);
	429
2e3fadbf	430	x509->index = ++ctx->x509_index;
46963b77 DH	431	pr_debug("Got cert %u for %s\n", x509->index, x509->subject);
	432	pr_debug("- fingerprint %*phN\n", x509->id->len, x509->id->data);
	433
2e3fadbf DH	434	*ctx->ppcerts = x509;
	435	ctx->ppcerts = &x509->next;
	436	return 0;
	437	}
	438
	439	/*
	440	* Save the certificate list
	441	*/
	442	int pkcs7_note_certificate_list(void *context, size_t hdrlen,
	443	unsigned char tag,
	444	const void *value, size_t vlen)
	445	{
	446	struct pkcs7_parse_context *ctx = context;
	447
	448	pr_devel("Got cert list (%02x)\n", tag);
	449
	450	*ctx->ppcerts = ctx->msg->certs;
	451	ctx->msg->certs = ctx->certs;
	452	ctx->certs = NULL;
	453	ctx->ppcerts = &ctx->certs;
	454	return 0;
	455	}
	456
99db4435 DH	457	/*
	458	* Note the content type.
	459	*/
	460	int pkcs7_note_content(void *context, size_t hdrlen,
	461	unsigned char tag,
	462	const void *value, size_t vlen)
	463	{
	464	struct pkcs7_parse_context *ctx = context;
	465
	466	if (ctx->last_oid != OID_data &&
	467	ctx->last_oid != OID_msIndirectData) {
	468	pr_warn("Unsupported data type %d\n", ctx->last_oid);
	469	return -EINVAL;
	470	}
	471
	472	ctx->msg->data_type = ctx->last_oid;
	473	return 0;
	474	}
	475
2e3fadbf DH	476	/*
	477	* Extract the data from the message and store that and its content type OID in
	478	* the context.
	479	*/
	480	int pkcs7_note_data(void *context, size_t hdrlen,
	481	unsigned char tag,
	482	const void *value, size_t vlen)
	483	{
	484	struct pkcs7_parse_context *ctx = context;
	485
	486	pr_debug("Got data\n");
	487
	488	ctx->msg->data = value;
	489	ctx->msg->data_len = vlen;
	490	ctx->msg->data_hdrlen = hdrlen;
2e3fadbf DH	491	return 0;
	492	}
	493
	494	/*
99db4435	495	* Parse authenticated attributes.
2e3fadbf DH	496	*/
	497	int pkcs7_sig_note_authenticated_attr(void *context, size_t hdrlen,
	498	unsigned char tag,
	499	const void *value, size_t vlen)
	500	{
	501	struct pkcs7_parse_context *ctx = context;
99db4435 DH	502	struct pkcs7_signed_info *sinfo = ctx->sinfo;
99db4435 DH	503	enum OID content_type;
2e3fadbf DH	504
	505	pr_devel("AuthAttr: %02x %zu [%*ph]\n", tag, vlen, (unsigned)vlen, value);
	506
	507	switch (ctx->last_oid) {
99db4435 DH	508	case OID_contentType:
	509	if (__test_and_set_bit(sinfo_has_content_type, &sinfo->aa_set))
	510	goto repeated;
	511	content_type = look_up_OID(value, vlen);
	512	if (content_type != ctx->msg->data_type) {
	513	pr_warn("Mismatch between global data type (%d) and sinfo %u (%d)\n",
	514	ctx->msg->data_type, sinfo->index,
	515	content_type);
	516	return -EBADMSG;
	517	}
	518	return 0;
	519
	520	case OID_signingTime:
	521	if (__test_and_set_bit(sinfo_has_signing_time, &sinfo->aa_set))
	522	goto repeated;
	523	/* Should we check that the signing time is consistent
	524	* with the signer's X.509 cert?
	525	*/
	526	return x509_decode_time(&sinfo->signing_time,
	527	hdrlen, tag, value, vlen);
	528
2e3fadbf	529	case OID_messageDigest:
99db4435 DH	530	if (__test_and_set_bit(sinfo_has_message_digest, &sinfo->aa_set))
99db4435 DH	531	goto repeated;
2e3fadbf DH	532	if (tag != ASN1_OTS)
2e3fadbf DH	533	return -EBADMSG;
99db4435 DH	534	sinfo->msgdigest = value;
	535	sinfo->msgdigest_len = vlen;
	536	return 0;
	537
	538	case OID_smimeCapabilites:
	539	if (__test_and_set_bit(sinfo_has_smime_caps, &sinfo->aa_set))
	540	goto repeated;
	541	if (ctx->msg->data_type != OID_msIndirectData) {
	542	pr_warn("S/MIME Caps only allowed with Authenticode\n");
	543	return -EKEYREJECTED;
	544	}
	545	return 0;
	546
	547	/* Microsoft SpOpusInfo seems to be contain cont[0] 16-bit BE
	548	* char URLs and cont[1] 8-bit char URLs.
	549	*
	550	* Microsoft StatementType seems to contain a list of OIDs that
	551	* are also used as extendedKeyUsage types in X.509 certs.
	552	*/
	553	case OID_msSpOpusInfo:
	554	if (__test_and_set_bit(sinfo_has_ms_opus_info, &sinfo->aa_set))
	555	goto repeated;
	556	goto authenticode_check;
	557	case OID_msStatementType:
	558	if (__test_and_set_bit(sinfo_has_ms_statement_type, &sinfo->aa_set))
	559	goto repeated;
	560	authenticode_check:
	561	if (ctx->msg->data_type != OID_msIndirectData) {
	562	pr_warn("Authenticode AuthAttrs only allowed with Authenticode\n");
	563	return -EKEYREJECTED;
	564	}
	565	/* I'm not sure how to validate these */
2e3fadbf DH	566	return 0;
	567	default:
	568	return 0;
	569	}
99db4435 DH	570
	571	repeated:
	572	/* We permit max one item per AuthenticatedAttribute and no repeats */
	573	pr_warn("Repeated/multivalue AuthAttrs not permitted\n");
	574	return -EKEYREJECTED;
2e3fadbf DH	575	}
	576
	577	/*
2c7fd367	578	* Note the set of auth attributes for digestion purposes [RFC2315 sec 9.3]
2e3fadbf DH	579	*/
	580	int pkcs7_sig_note_set_of_authattrs(void *context, size_t hdrlen,
	581	unsigned char tag,
	582	const void *value, size_t vlen)
	583	{
	584	struct pkcs7_parse_context *ctx = context;
99db4435 DH	585	struct pkcs7_signed_info *sinfo = ctx->sinfo;
	586
	587	if (!test_bit(sinfo_has_content_type, &sinfo->aa_set) \|\|
7ee7014d	588	!test_bit(sinfo_has_message_digest, &sinfo->aa_set)) {
99db4435 DH	589	pr_warn("Missing required AuthAttr\n");
	590	return -EBADMSG;
	591	}
	592
	593	if (ctx->msg->data_type != OID_msIndirectData &&
	594	test_bit(sinfo_has_ms_opus_info, &sinfo->aa_set)) {
	595	pr_warn("Unexpected Authenticode AuthAttr\n");
	596	return -EBADMSG;
	597	}
2e3fadbf DH	598
2e3fadbf DH	599	/* We need to switch the 'CONT 0' to a 'SET OF' when we digest */
99db4435 DH	600	sinfo->authattrs = value - (hdrlen - 1);
99db4435 DH	601	sinfo->authattrs_len = vlen + (hdrlen - 1);
2e3fadbf DH	602	return 0;
	603	}
	604
	605	/*
	606	* Note the issuing certificate serial number
	607	*/
	608	int pkcs7_sig_note_serial(void *context, size_t hdrlen,
	609	unsigned char tag,
	610	const void *value, size_t vlen)
	611	{
	612	struct pkcs7_parse_context *ctx = context;
46963b77 DH	613	ctx->raw_serial = value;
46963b77 DH	614	ctx->raw_serial_size = vlen;
2e3fadbf DH	615	return 0;
	616	}
	617
	618	/*
	619	* Note the issuer's name
	620	*/
	621	int pkcs7_sig_note_issuer(void *context, size_t hdrlen,
	622	unsigned char tag,
	623	const void *value, size_t vlen)
	624	{
	625	struct pkcs7_parse_context *ctx = context;
46963b77 DH	626	ctx->raw_issuer = value;
46963b77 DH	627	ctx->raw_issuer_size = vlen;
2e3fadbf DH	628	return 0;
	629	}
	630
60d65cac DH	631	/*
	632	* Note the issuing cert's subjectKeyIdentifier
	633	*/
	634	int pkcs7_sig_note_skid(void *context, size_t hdrlen,
	635	unsigned char tag,
	636	const void *value, size_t vlen)
	637	{
	638	struct pkcs7_parse_context *ctx = context;
	639
	640	pr_devel("SKID: %02x %zu [%*ph]\n", tag, vlen, (unsigned)vlen, value);
	641
	642	ctx->raw_skid = value;
	643	ctx->raw_skid_size = vlen;
	644	return 0;
	645	}
	646
2e3fadbf DH	647	/*
	648	* Note the signature data
	649	*/
	650	int pkcs7_sig_note_signature(void *context, size_t hdrlen,
	651	unsigned char tag,
	652	const void *value, size_t vlen)
	653	{
	654	struct pkcs7_parse_context *ctx = context;
2e3fadbf	655
566a117a DH	656	ctx->sinfo->sig->s = kmemdup(value, vlen, GFP_KERNEL);
566a117a DH	657	if (!ctx->sinfo->sig->s)
2e3fadbf DH	658	return -ENOMEM;
2e3fadbf DH	659
566a117a	660	ctx->sinfo->sig->s_size = vlen;
2e3fadbf DH	661	return 0;
	662	}
	663
	664	/*
	665	* Note a signature information block
	666	*/
	667	int pkcs7_note_signed_info(void *context, size_t hdrlen,
	668	unsigned char tag,
	669	const void *value, size_t vlen)
	670	{
	671	struct pkcs7_parse_context *ctx = context;
46963b77 DH	672	struct pkcs7_signed_info *sinfo = ctx->sinfo;
	673	struct asymmetric_key_id *kid;
	674
99db4435 DH	675	if (ctx->msg->data_type == OID_msIndirectData && !sinfo->authattrs) {
	676	pr_warn("Authenticode requires AuthAttrs\n");
	677	return -EBADMSG;
	678	}
	679
46963b77	680	/* Generate cert issuer + serial number key ID */
60d65cac DH	681	if (!ctx->expect_skid) {
	682	kid = asymmetric_key_generate_id(ctx->raw_serial,
	683	ctx->raw_serial_size,
	684	ctx->raw_issuer,
	685	ctx->raw_issuer_size);
	686	} else {
	687	kid = asymmetric_key_generate_id(ctx->raw_skid,
	688	ctx->raw_skid_size,
	689	"", 0);
	690	}
46963b77 DH	691	if (IS_ERR(kid))
	692	return PTR_ERR(kid);
	693
60d65cac DH	694	pr_devel("SINFO KID: %u [%*phN]\n", kid->len, kid->len, kid->data);
60d65cac DH	695
566a117a	696	sinfo->sig->auth_ids[0] = kid;
46963b77 DH	697	sinfo->index = ++ctx->sinfo_index;
	698	*ctx->ppsinfo = sinfo;
	699	ctx->ppsinfo = &sinfo->next;
2e3fadbf DH	700	ctx->sinfo = kzalloc(sizeof(struct pkcs7_signed_info), GFP_KERNEL);
	701	if (!ctx->sinfo)
	702	return -ENOMEM;
566a117a DH	703	ctx->sinfo->sig = kzalloc(sizeof(struct public_key_signature),
	704	GFP_KERNEL);
	705	if (!ctx->sinfo->sig)
	706	return -ENOMEM;
2e3fadbf DH	707	return 0;
2e3fadbf DH	708	}