Add X.509 CRL support

index 4c3f645065a4..5b118acbdbeb 100644
@@ -1039,6 +1039,8 @@ static struct element *parse_type(struct token **_cursor, struct token *end,
 			if (cursor >= end)
 				goto overrun_error;
 			element->children = parse_type(&cursor, end, NULL);
+			element->flags |= element->children->flags & ELEMENT_SKIPPABLE;
+			element->children->flags &= ~ELEMENT_SKIPPABLE;
 		} else {
 			element->children = parse_compound(&cursor, end, 0);
 		}

@@ -1056,6 +1058,8 @@ static struct element *parse_type(struct token **_cursor, struct token *end,
 			if (cursor >= end)
 				goto parse_error;
 			element->children = parse_type(&cursor, end, NULL);
+			element->flags |= element->children->flags & ELEMENT_SKIPPABLE;
+			element->children->flags &= ~ELEMENT_SKIPPABLE;
 		} else {
 			element->children = parse_compound(&cursor, end, 1);
 		}

@@ -1522,7 +1526,13 @@ static void render_element(FILE *out, struct element *e, struct element *tag)
 	/* Deal with compound types */
 	switch (e->compound) {
 	case TYPE_REF:
-		render_element(out, e->type->type->element, tag);
+		if (skippable && !tag) {
+			struct element tmp = { .flags = ELEMENT_SKIPPABLE };
+
+			render_element(out, e->type->type->element, &tmp);
+		} else {
+			render_element(out, e->type->type->element, tag);
+		}
 		if (e->action)
 			render_opcode(out, "ASN1_OP_%sACT,\n",
 				      skippable ? "MAYBE_" : "");

index fa561c12eabf..7c61e4014527 100644
@@ -32,6 +32,7 @@
 
 static const char tbs_prefix[] = "tbs";
 static const char bin_prefix[] = "bin";
+static const char crl_prefix[] = "crl";
 
 static struct key *blacklist_keyring;
 

@@ -46,16 +47,16 @@ extern __initconst const unsigned long revocation_certificate_list_size;
  */
 static int blacklist_vet_description(const char *desc)
 {
-	int i, prefix_len, tbs_step = 0, bin_step = 0;
+	int i, prefix_len, tbs_step = 0, bin_step = 0, crl_step = 0;
 
 	/* The following algorithm only works if prefix lengths match. */
-	BUILD_BUG_ON(sizeof(tbs_prefix) != sizeof(bin_prefix));
+	BUILD_BUG_ON(sizeof(tbs_prefix) != sizeof(bin_prefix) ||
+		     sizeof(tbs_prefix) != sizeof(crl_prefix));
 	prefix_len = sizeof(tbs_prefix) - 1;
 	for (i = 0; *desc; desc++, i++) {
 		if (*desc == ':') {
-			if (tbs_step == prefix_len)
-				goto found_colon;
-			if (bin_step == prefix_len)
+			if (tbs_step == prefix_len || bin_step == prefix_len ||
+			    crl_step == prefix_len)
 				goto found_colon;
 			return -EINVAL;
 		}

@@ -65,6 +66,8 @@ static int blacklist_vet_description(const char *desc)
 			tbs_step++;
 		if (*desc == bin_prefix[i])
 			bin_step++;
+		if (*desc == crl_prefix[i])
+			crl_step++;
 	}
 	return -EINVAL;
 

@@ -160,6 +163,10 @@ static char *get_raw_hash(const u8 *hash, size_t hash_len,
 		type_len = sizeof(bin_prefix) - 1;
 		type_prefix = bin_prefix;
 		break;
+	case BLACKLIST_HASH_X509_CRL:
+		type_len = sizeof(crl_prefix) - 1;
+		type_prefix = crl_prefix;
+		break;
 	default:
 		WARN_ON_ONCE(1);
 		return ERR_PTR(-EINVAL);

148 lines not on this page · raw message

93 lines not on this page · raw message

index b7aeebdddb36..13cc0bc3d7e2 100644
@@ -46,6 +46,22 @@ struct x509_certificate {
 /*
  * x509_cert_parser.c
  */
+struct x509_crl_context {
+	const void *raw_issuer;
+	size_t raw_issuer_size;
+	struct list_head revoked_list;
+	bool indirect_crl;
+	u8 crl_reason;
+};
+
+struct x509_revoked_entry {
+	struct list_head list;
+	u8 *serial;
+	size_t serial_size;
+	const void *raw_issuer;      /* for indirect */
+	size_t raw_issuer_size;
+};
+
 extern void x509_free_certificate(struct x509_certificate *cert);
 DEFINE_FREE(x509_free_certificate, struct x509_certificate *,
 	    if (!IS_ERR(_T)) x509_free_certificate(_T))

@@ -53,6 +69,8 @@ extern struct x509_certificate *x509_cert_parse(const void *data, size_t datalen
 extern int x509_decode_time(time64_t *_t,  size_t hdrlen,
 			    unsigned char tag,
 			    const unsigned char *value, size_t vlen);
+struct x509_crl_context *x509_crl_parse(const void *data, size_t datalen);
+void x509_crl_free(struct x509_crl_context *ctx);
 
 /*
  * x509_public_key.c

index 25cf8ac7f257..598b94455b8d 100644
@@ -15,6 +15,7 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/string.h>
+#include <crypto/sha2.h>
 #include "asymmetric_keys.h"
 #include "x509_parser.h"
 

@@ -90,6 +91,26 @@ int x509_get_sig_params(struct x509_certificate *cert)
 	if (ret < 0)
 		goto error_2;
 
+	/* Check CRL blacklist (hash of serial + issuer) */
+	if (!cert->blacklisted && cert->raw_serial && cert->raw_issuer) {
+		struct asymmetric_key_id *kid;
+
+		kid = asymmetric_key_generate_id(cert->raw_serial, cert->raw_serial_size,
+						 cert->raw_issuer, cert->raw_issuer_size);
+		if (!IS_ERR(kid)) {
+			u8 digest[SHA256_DIGEST_SIZE];
+
+			sha256(kid->data, kid->len, digest);
+			ret = is_hash_blacklisted(digest, SHA256_DIGEST_SIZE,
+						  BLACKLIST_HASH_X509_CRL);
+			if (ret == -EKEYREJECTED) {
+				pr_err("Cert is CRL-blacklisted\n");
+				cert->blacklisted = true;
+			}
+			kfree(kid);
+		}
+	}
+
 error_2:
 	kfree(desc);
 error:

index 1b91c8f98688..635644c8dcf1 100644
@@ -86,6 +86,9 @@ extern struct key *find_asymmetric_key(struct key *keyring,
 
 int x509_load_certificate_list(const u8 cert_list[], const unsigned long list_size,
 			       const struct key *keyring);
+#ifdef CONFIG_SYSTEM_BLACKLIST_KEYRING
+int x509_load_crl_list(const u8 crl_list[], const unsigned long list_size);
+#endif
 
 /*
  * The payload is at the discretion of the subtype.

index a6c2897bcc63..01f832160e27 100644
@@ -15,6 +15,8 @@ enum blacklist_hash_type {
 	BLACKLIST_HASH_X509_TBS = 1,
 	/* Raw data hash */
 	BLACKLIST_HASH_BINARY = 2,
+	/* Hash = serial + issuer */
+	BLACKLIST_HASH_X509_CRL = 3,
 };
 
 #ifdef CONFIG_SYSTEM_TRUSTED_KEYRING

index ebce402854de..d63be17387d3 100644
@@ -150,6 +150,10 @@ enum OID {
 	OID_id_ml_dsa_65,			/* 2.16.840.1.101.3.4.3.18 */
 	OID_id_ml_dsa_87,			/* 2.16.840.1.101.3.4.3.19 */
 
+	OID_id_ce_issuingDistributionPoint,	/* 2.5.29.28 */
+	OID_id_ce_certificateIssuer,		/* 2.5.29.29 */
+	OID_id_ce_cRLReason,			/* 2.5.29.21 */
+
 	OID__NR
 };
 

index 76b61f36c082..39ef4cf4b05d 100644
@@ -907,14 +907,24 @@ struct x509_crl_context *x509_crl_parse(const void *data, size_t datalen)
 	if (ret < 0)
 		return ERR_PTR(ret);
 
+	/*
+	 * Extract signature parameters (sig->s, sig->digest, etc.)
+	 * This does what we previously tried to do manually.
+	 */
+	ret = x509_get_sig_params(cert);
+	if (ret < 0)
+		return ERR_PTR(ret);
+
 	/* Transfer parsed data to crl_context */
 	INIT_LIST_HEAD(&crl_ctx->revoked_list);
 	crl_ctx->indirect_crl = ctx->indirect_crl;
 	crl_ctx->raw_issuer = cert->raw_issuer;
 	crl_ctx->raw_issuer_size = cert->raw_issuer_size;
+	crl_ctx->sig = cert->sig;
 	list_splice(&ctx->revoked_list, &crl_ctx->revoked_list);
 
 	/* Detach pointers from cert before auto-free */
+	cert->sig = NULL;
 	cert->raw_issuer = NULL;
 	cert->raw_serial = NULL;
 

@@ -930,6 +940,7 @@ void x509_crl_free(struct x509_crl_context *ctx)
 		kfree(entry->serial);
 		kfree(entry);
 	}
+	public_key_signature_free(ctx->sig);
 	kfree(ctx);
 }
 

index 344e6bf31612..7c1a098b2ecb 100644
@@ -6,6 +6,7 @@
 #include <keys/system_keyring.h>
 #include <linux/slab.h>
 #include <crypto/sha2.h>
+#include <crypto/public_key.h>
 #include "x509_parser.h"
 
 int x509_load_certificate_list(const u8 cert_list[],

@@ -74,7 +75,30 @@ static const void *crl_entry_issuer(const struct x509_crl_context *crl,
 	return crl->raw_issuer;
 }
 
-int x509_load_crl_list(const u8 crl_list[], const unsigned long list_size)
+static int x509_crl_verify_signature(struct x509_crl_context *crl_ctx,
+				     const struct key *keyring)
+{
+	struct key *key;
+	int ret = -ENOKEY;
+
+	if (!crl_ctx->raw_issuer || !crl_ctx->sig)
+		return -ENOKEY;
+
+	key = find_asymmetric_key(keyring,
+				  crl_ctx->sig->auth_ids[0],
+				  crl_ctx->sig->auth_ids[1],
+				  crl_ctx->sig->auth_ids[2],
+				  false);
+	if (IS_ERR(key))
+		return PTR_ERR(key);
+
+	ret = verify_signature(key, crl_ctx->sig);
+	key_put(key);
+	return ret;
+}
+
+int x509_load_crl_list(const u8 crl_list[], const unsigned long list_size,
+		       const struct key *keyring)
 {
 	const u8 *p = crl_list, *end = p + list_size;
 

@@ -107,6 +131,11 @@ int x509_load_crl_list(const u8 crl_list[], const unsigned long list_size)
 			pr_err("Problem parsing CRL (%ld)\n", PTR_ERR(crl_ctx));
 			goto next_crl;
 		}
+		if (keyring && x509_crl_verify_signature(crl_ctx, keyring) < 0) {
+			pr_warn("CRL signature verification failed, skipping\n");
+			x509_crl_free(crl_ctx);
+			goto next_crl;
+		}
 		list_for_each_entry_safe(entry, tmp, &crl_ctx->revoked_list, list) {
 			struct asymmetric_key_id *kid;
 			const void *issuer;

index 13cc0bc3d7e2..7c48ccb1008c 100644
@@ -49,9 +49,9 @@ struct x509_certificate {
 struct x509_crl_context {
 	const void *raw_issuer;
 	size_t raw_issuer_size;
+	struct public_key_signature *sig;
 	struct list_head revoked_list;
 	bool indirect_crl;
-	u8 crl_reason;
 };
 
 struct x509_revoked_entry {

index 635644c8dcf1..db586a4c2981 100644
@@ -87,7 +87,8 @@ extern struct key *find_asymmetric_key(struct key *keyring,
 int x509_load_certificate_list(const u8 cert_list[], const unsigned long list_size,
 			       const struct key *keyring);
 #ifdef CONFIG_SYSTEM_BLACKLIST_KEYRING
-int x509_load_crl_list(const u8 crl_list[], const unsigned long list_size);
+int x509_load_crl_list(const u8 crl_list[], const unsigned long list_size,
+		       const struct key *keyring);
 #endif
 
 /*