certs/blacklist.c

   1 /* System hash blacklist.
   2  *
   3  * Copyright (C) 2016 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) "blacklist: "fmt
  13 #include <linux/module.h>
  14 #include <linux/slab.h>
  15 #include <linux/key.h>
  16 #include <linux/key-type.h>
  17 #include <linux/sched.h>
  18 #include <linux/ctype.h>
  19 #include <linux/err.h>
  20 #include <linux/seq_file.h>
  21 #include <keys/system_keyring.h>
  22 #include "blacklist.h"
  23
  24 static struct key *blacklist_keyring;
  25
  26 /*
  27  * The description must be a type prefix, a colon and then an even number of
  28  * hex digits.  The hash is kept in the description.
  29  */
  30 static int blacklist_vet_description(const char *desc)
  31 {
  32         int n = 0;
  33
  34         if (*desc == ':')
  35                 return -EINVAL;
  36         for (; *desc; desc++)
  37                 if (*desc == ':')
  38                         goto found_colon;
  39         return -EINVAL;
  40
  41 found_colon:
  42         desc++;
  43         for (; *desc; desc++) {
  44                 if (!isxdigit(*desc))
  45                         return -EINVAL;
  46                 n++;
  47         }
  48
  49         if (n == 0 || n & 1)
  50                 return -EINVAL;
  51         return 0;
  52 }
  53
  54 /*
  55  * The hash to be blacklisted is expected to be in the description.  There will
  56  * be no payload.
  57  */
  58 static int blacklist_preparse(struct key_preparsed_payload *prep)
  59 {
  60         if (prep->datalen > 0)
  61                 return -EINVAL;
  62         return 0;
  63 }
  64
  65 static void blacklist_free_preparse(struct key_preparsed_payload *prep)
  66 {
  67 }
  68
  69 static void blacklist_describe(const struct key *key, struct seq_file *m)
  70 {
  71         seq_puts(m, key->description);
  72 }
  73
  74 static struct key_type key_type_blacklist = {
  75         .name                   = "blacklist",
  76         .vet_description        = blacklist_vet_description,
  77         .preparse               = blacklist_preparse,
  78         .free_preparse          = blacklist_free_preparse,
  79         .instantiate            = generic_key_instantiate,
  80         .describe               = blacklist_describe,
  81 };
  82
  83 /**
  84  * mark_hash_blacklisted - Add a hash to the system blacklist
  85  * @hash - The hash as a hex string with a type prefix (eg. "tbs:23aa429783")
  86  */
  87 int mark_hash_blacklisted(const char *hash)
  88 {
  89         key_ref_t key;
  90
  91         key = key_create_or_update(make_key_ref(blacklist_keyring, true),
  92                                    "blacklist",
  93                                    hash,
  94                                    NULL,
  95                                    0,
  96                                    &internal_key_acl,
  97                                    KEY_ALLOC_NOT_IN_QUOTA |
  98                                    KEY_ALLOC_BUILT_IN);
  99         if (IS_ERR(key)) {
 100                 pr_err("Problem blacklisting hash (%ld)\n", PTR_ERR(key));
 101                 return PTR_ERR(key);
 102         }
 103         return 0;
 104 }
 105
 106 /**
 107  * is_hash_blacklisted - Determine if a hash is blacklisted
 108  * @hash: The hash to be checked as a binary blob
 109  * @hash_len: The length of the binary hash
 110  * @type: Type of hash
 111  */
 112 int is_hash_blacklisted(const u8 *hash, size_t hash_len, const char *type)
 113 {
 114         key_ref_t kref;
 115         size_t type_len = strlen(type);
 116         char *buffer, *p;
 117         int ret = 0;
 118
 119         buffer = kmalloc(type_len + 1 + hash_len * 2 + 1, GFP_KERNEL);
 120         if (!buffer)
 121                 return -ENOMEM;
 122         p = memcpy(buffer, type, type_len);
 123         p += type_len;
 124         *p++ = ':';
 125         bin2hex(p, hash, hash_len);
 126         p += hash_len * 2;
 127         *p = 0;
 128
 129         kref = keyring_search(make_key_ref(blacklist_keyring, true),
 130                               &key_type_blacklist, buffer, false);
 131         if (!IS_ERR(kref)) {
 132                 key_ref_put(kref);
 133                 ret = -EKEYREJECTED;
 134         }
 135
 136         kfree(buffer);
 137         return ret;
 138 }
 139 EXPORT_SYMBOL_GPL(is_hash_blacklisted);
 140
 141 /*
 142  * Initialise the blacklist
 143  */
 144 static int __init blacklist_init(void)
 145 {
 146         const char *const *bl;
 147
 148         if (register_key_type(&key_type_blacklist) < 0)
 149                 panic("Can't allocate system blacklist key type\n");
 150
 151         blacklist_keyring =
 152                 keyring_alloc(".blacklist",
 153                               KUIDT_INIT(0), KGIDT_INIT(0),
 154                               current_cred(),
 155                               &internal_keyring_acl,
 156                               KEY_ALLOC_NOT_IN_QUOTA |
 157                               KEY_FLAG_KEEP,
 158                               NULL, NULL);
 159         if (IS_ERR(blacklist_keyring))
 160                 panic("Can't allocate system blacklist keyring\n");
 161
 162         for (bl = blacklist_hashes; *bl; bl++)
 163                 if (mark_hash_blacklisted(*bl) < 0)
 164                         pr_err("- blacklisting failed\n");
 165         return 0;
 166 }
 167
 168 /*
 169  * Must be initialised before we try and load the keys into the keyring.
 170  */
 171 device_initcall(blacklist_init);