crypto/crypto_user_stat.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Crypto user configuration API.
   4  *
   5  * Copyright (C) 2017-2018 Corentin Labbe <clabbe@baylibre.com>
   6  *
   7  */
   8
   9 #include <linux/crypto.h>
  10 #include <linux/cryptouser.h>
  11 #include <linux/sched.h>
  12 #include <net/netlink.h>
  13 #include <net/sock.h>
  14 #include <crypto/internal/skcipher.h>
  15 #include <crypto/internal/rng.h>
  16 #include <crypto/akcipher.h>
  17 #include <crypto/kpp.h>
  18 #include <crypto/internal/cryptouser.h>
  19
  20 #include "internal.h"
  21
  22 #define null_terminated(x)      (strnlen(x, sizeof(x)) < sizeof(x))
  23
  24 struct crypto_dump_info {
  25         struct sk_buff *in_skb;
  26         struct sk_buff *out_skb;
  27         u32 nlmsg_seq;
  28         u16 nlmsg_flags;
  29 };
  30
  31 static int crypto_report_cipher(struct sk_buff *skb, struct crypto_alg *alg)
  32 {
  33         struct crypto_stat_cipher rcipher;
  34
  35         memset(&rcipher, 0, sizeof(rcipher));
  36
  37         strscpy(rcipher.type, "cipher", sizeof(rcipher.type));
  38
  39         rcipher.stat_encrypt_cnt = atomic64_read(&alg->stats.cipher.encrypt_cnt);
  40         rcipher.stat_encrypt_tlen = atomic64_read(&alg->stats.cipher.encrypt_tlen);
  41         rcipher.stat_decrypt_cnt =  atomic64_read(&alg->stats.cipher.decrypt_cnt);
  42         rcipher.stat_decrypt_tlen = atomic64_read(&alg->stats.cipher.decrypt_tlen);
  43         rcipher.stat_err_cnt =  atomic64_read(&alg->stats.cipher.err_cnt);
  44
  45         return nla_put(skb, CRYPTOCFGA_STAT_CIPHER, sizeof(rcipher), &rcipher);
  46 }
  47
  48 static int crypto_report_comp(struct sk_buff *skb, struct crypto_alg *alg)
  49 {
  50         struct crypto_stat_compress rcomp;
  51
  52         memset(&rcomp, 0, sizeof(rcomp));
  53
  54         strscpy(rcomp.type, "compression", sizeof(rcomp.type));
  55         rcomp.stat_compress_cnt = atomic64_read(&alg->stats.compress.compress_cnt);
  56         rcomp.stat_compress_tlen = atomic64_read(&alg->stats.compress.compress_tlen);
  57         rcomp.stat_decompress_cnt = atomic64_read(&alg->stats.compress.decompress_cnt);
  58         rcomp.stat_decompress_tlen = atomic64_read(&alg->stats.compress.decompress_tlen);
  59         rcomp.stat_err_cnt = atomic64_read(&alg->stats.compress.err_cnt);
  60
  61         return nla_put(skb, CRYPTOCFGA_STAT_COMPRESS, sizeof(rcomp), &rcomp);
  62 }
  63
  64 static int crypto_report_acomp(struct sk_buff *skb, struct crypto_alg *alg)
  65 {
  66         struct crypto_stat_compress racomp;
  67
  68         memset(&racomp, 0, sizeof(racomp));
  69
  70         strscpy(racomp.type, "acomp", sizeof(racomp.type));
  71         racomp.stat_compress_cnt = atomic64_read(&alg->stats.compress.compress_cnt);
  72         racomp.stat_compress_tlen = atomic64_read(&alg->stats.compress.compress_tlen);
  73         racomp.stat_decompress_cnt =  atomic64_read(&alg->stats.compress.decompress_cnt);
  74         racomp.stat_decompress_tlen = atomic64_read(&alg->stats.compress.decompress_tlen);
  75         racomp.stat_err_cnt = atomic64_read(&alg->stats.compress.err_cnt);
  76
  77         return nla_put(skb, CRYPTOCFGA_STAT_ACOMP, sizeof(racomp), &racomp);
  78 }
  79
  80 static int crypto_report_akcipher(struct sk_buff *skb, struct crypto_alg *alg)
  81 {
  82         struct crypto_stat_akcipher rakcipher;
  83
  84         memset(&rakcipher, 0, sizeof(rakcipher));
  85
  86         strscpy(rakcipher.type, "akcipher", sizeof(rakcipher.type));
  87         rakcipher.stat_encrypt_cnt = atomic64_read(&alg->stats.akcipher.encrypt_cnt);
  88         rakcipher.stat_encrypt_tlen = atomic64_read(&alg->stats.akcipher.encrypt_tlen);
  89         rakcipher.stat_decrypt_cnt = atomic64_read(&alg->stats.akcipher.decrypt_cnt);
  90         rakcipher.stat_decrypt_tlen = atomic64_read(&alg->stats.akcipher.decrypt_tlen);
  91         rakcipher.stat_sign_cnt = atomic64_read(&alg->stats.akcipher.sign_cnt);
  92         rakcipher.stat_verify_cnt = atomic64_read(&alg->stats.akcipher.verify_cnt);
  93         rakcipher.stat_err_cnt = atomic64_read(&alg->stats.akcipher.err_cnt);
  94
  95         return nla_put(skb, CRYPTOCFGA_STAT_AKCIPHER,
  96                        sizeof(rakcipher), &rakcipher);
  97 }
  98
  99 static int crypto_report_kpp(struct sk_buff *skb, struct crypto_alg *alg)
 100 {
 101         struct crypto_stat_kpp rkpp;
 102
 103         memset(&rkpp, 0, sizeof(rkpp));
 104
 105         strscpy(rkpp.type, "kpp", sizeof(rkpp.type));
 106
 107         rkpp.stat_setsecret_cnt = atomic64_read(&alg->stats.kpp.setsecret_cnt);
 108         rkpp.stat_generate_public_key_cnt = atomic64_read(&alg->stats.kpp.generate_public_key_cnt);
 109         rkpp.stat_compute_shared_secret_cnt = atomic64_read(&alg->stats.kpp.compute_shared_secret_cnt);
 110         rkpp.stat_err_cnt = atomic64_read(&alg->stats.kpp.err_cnt);
 111
 112         return nla_put(skb, CRYPTOCFGA_STAT_KPP, sizeof(rkpp), &rkpp);
 113 }
 114
 115 static int crypto_report_ahash(struct sk_buff *skb, struct crypto_alg *alg)
 116 {
 117         struct crypto_stat_hash rhash;
 118
 119         memset(&rhash, 0, sizeof(rhash));
 120
 121         strscpy(rhash.type, "ahash", sizeof(rhash.type));
 122
 123         rhash.stat_hash_cnt = atomic64_read(&alg->stats.hash.hash_cnt);
 124         rhash.stat_hash_tlen = atomic64_read(&alg->stats.hash.hash_tlen);
 125         rhash.stat_err_cnt = atomic64_read(&alg->stats.hash.err_cnt);
 126
 127         return nla_put(skb, CRYPTOCFGA_STAT_HASH, sizeof(rhash), &rhash);
 128 }
 129
 130 static int crypto_report_shash(struct sk_buff *skb, struct crypto_alg *alg)
 131 {
 132         struct crypto_stat_hash rhash;
 133
 134         memset(&rhash, 0, sizeof(rhash));
 135
 136         strscpy(rhash.type, "shash", sizeof(rhash.type));
 137
 138         rhash.stat_hash_cnt =  atomic64_read(&alg->stats.hash.hash_cnt);
 139         rhash.stat_hash_tlen = atomic64_read(&alg->stats.hash.hash_tlen);
 140         rhash.stat_err_cnt = atomic64_read(&alg->stats.hash.err_cnt);
 141
 142         return nla_put(skb, CRYPTOCFGA_STAT_HASH, sizeof(rhash), &rhash);
 143 }
 144
 145 static int crypto_report_rng(struct sk_buff *skb, struct crypto_alg *alg)
 146 {
 147         struct crypto_stat_rng rrng;
 148
 149         memset(&rrng, 0, sizeof(rrng));
 150
 151         strscpy(rrng.type, "rng", sizeof(rrng.type));
 152
 153         rrng.stat_generate_cnt = atomic64_read(&alg->stats.rng.generate_cnt);
 154         rrng.stat_generate_tlen = atomic64_read(&alg->stats.rng.generate_tlen);
 155         rrng.stat_seed_cnt = atomic64_read(&alg->stats.rng.seed_cnt);
 156         rrng.stat_err_cnt = atomic64_read(&alg->stats.rng.err_cnt);
 157
 158         return nla_put(skb, CRYPTOCFGA_STAT_RNG, sizeof(rrng), &rrng);
 159 }
 160
 161 static int crypto_reportstat_one(struct crypto_alg *alg,
 162                                  struct crypto_user_alg *ualg,
 163                                  struct sk_buff *skb)
 164 {
 165         memset(ualg, 0, sizeof(*ualg));
 166
 167         strscpy(ualg->cru_name, alg->cra_name, sizeof(ualg->cru_name));
 168         strscpy(ualg->cru_driver_name, alg->cra_driver_name,
 169                 sizeof(ualg->cru_driver_name));
 170         strscpy(ualg->cru_module_name, module_name(alg->cra_module),
 171                 sizeof(ualg->cru_module_name));
 172
 173         ualg->cru_type = 0;
 174         ualg->cru_mask = 0;
 175         ualg->cru_flags = alg->cra_flags;
 176         ualg->cru_refcnt = refcount_read(&alg->cra_refcnt);
 177
 178         if (nla_put_u32(skb, CRYPTOCFGA_PRIORITY_VAL, alg->cra_priority))
 179                 goto nla_put_failure;
 180         if (alg->cra_flags & CRYPTO_ALG_LARVAL) {
 181                 struct crypto_stat_larval rl;
 182
 183                 memset(&rl, 0, sizeof(rl));
 184                 strscpy(rl.type, "larval", sizeof(rl.type));
 185                 if (nla_put(skb, CRYPTOCFGA_STAT_LARVAL, sizeof(rl), &rl))
 186                         goto nla_put_failure;
 187                 goto out;
 188         }
 189
 190         if (alg->cra_type && alg->cra_type->report_stat) {
 191                 if (alg->cra_type->report_stat(skb, alg))
 192                         goto nla_put_failure;
 193                 goto out;
 194         }
 195
 196         switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) {
 197         case CRYPTO_ALG_TYPE_SKCIPHER:
 198                 if (crypto_report_cipher(skb, alg))
 199                         goto nla_put_failure;
 200                 break;
 201         case CRYPTO_ALG_TYPE_CIPHER:
 202                 if (crypto_report_cipher(skb, alg))
 203                         goto nla_put_failure;
 204                 break;
 205         case CRYPTO_ALG_TYPE_COMPRESS:
 206                 if (crypto_report_comp(skb, alg))
 207                         goto nla_put_failure;
 208                 break;
 209         case CRYPTO_ALG_TYPE_ACOMPRESS:
 210                 if (crypto_report_acomp(skb, alg))
 211                         goto nla_put_failure;
 212                 break;
 213         case CRYPTO_ALG_TYPE_SCOMPRESS:
 214                 if (crypto_report_acomp(skb, alg))
 215                         goto nla_put_failure;
 216                 break;
 217         case CRYPTO_ALG_TYPE_AKCIPHER:
 218                 if (crypto_report_akcipher(skb, alg))
 219                         goto nla_put_failure;
 220                 break;
 221         case CRYPTO_ALG_TYPE_KPP:
 222                 if (crypto_report_kpp(skb, alg))
 223                         goto nla_put_failure;
 224                 break;
 225         case CRYPTO_ALG_TYPE_AHASH:
 226                 if (crypto_report_ahash(skb, alg))
 227                         goto nla_put_failure;
 228                 break;
 229         case CRYPTO_ALG_TYPE_HASH:
 230                 if (crypto_report_shash(skb, alg))
 231                         goto nla_put_failure;
 232                 break;
 233         case CRYPTO_ALG_TYPE_RNG:
 234                 if (crypto_report_rng(skb, alg))
 235                         goto nla_put_failure;
 236                 break;
 237         default:
 238                 pr_err("ERROR: Unhandled alg %d in %s\n",
 239                        alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL),
 240                        __func__);
 241         }
 242
 243 out:
 244         return 0;
 245
 246 nla_put_failure:
 247         return -EMSGSIZE;
 248 }
 249
 250 static int crypto_reportstat_alg(struct crypto_alg *alg,
 251                                  struct crypto_dump_info *info)
 252 {
 253         struct sk_buff *in_skb = info->in_skb;
 254         struct sk_buff *skb = info->out_skb;
 255         struct nlmsghdr *nlh;
 256         struct crypto_user_alg *ualg;
 257         int err = 0;
 258
 259         nlh = nlmsg_put(skb, NETLINK_CB(in_skb).portid, info->nlmsg_seq,
 260                         CRYPTO_MSG_GETSTAT, sizeof(*ualg), info->nlmsg_flags);
 261         if (!nlh) {
 262                 err = -EMSGSIZE;
 263                 goto out;
 264         }
 265
 266         ualg = nlmsg_data(nlh);
 267
 268         err = crypto_reportstat_one(alg, ualg, skb);
 269         if (err) {
 270                 nlmsg_cancel(skb, nlh);
 271                 goto out;
 272         }
 273
 274         nlmsg_end(skb, nlh);
 275
 276 out:
 277         return err;
 278 }
 279
 280 int crypto_reportstat(struct sk_buff *in_skb, struct nlmsghdr *in_nlh,
 281                       struct nlattr **attrs)
 282 {
 283         struct net *net = sock_net(in_skb->sk);
 284         struct crypto_user_alg *p = nlmsg_data(in_nlh);
 285         struct crypto_alg *alg;
 286         struct sk_buff *skb;
 287         struct crypto_dump_info info;
 288         int err;
 289
 290         if (!null_terminated(p->cru_name) || !null_terminated(p->cru_driver_name))
 291                 return -EINVAL;
 292
 293         alg = crypto_alg_match(p, 0);
 294         if (!alg)
 295                 return -ENOENT;
 296
 297         err = -ENOMEM;
 298         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 299         if (!skb)
 300                 goto drop_alg;
 301
 302         info.in_skb = in_skb;
 303         info.out_skb = skb;
 304         info.nlmsg_seq = in_nlh->nlmsg_seq;
 305         info.nlmsg_flags = 0;
 306
 307         err = crypto_reportstat_alg(alg, &info);
 308
 309 drop_alg:
 310         crypto_mod_put(alg);
 311
 312         if (err) {
 313                 kfree_skb(skb);
 314                 return err;
 315         }
 316
 317         return nlmsg_unicast(net->crypto_nlsk, skb, NETLINK_CB(in_skb).portid);
 318 }
 319
 320 MODULE_LICENSE("GPL");