[mirror_ubuntu-bionic-kernel.git] / crypto / asymmetric_keys / pkcs7_parser.c

/* PKCS#7 parser
 *
 * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */

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