2019-05-29 23:57:49 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2011-09-27 05:23:50 +00:00
|
|
|
/*
|
|
|
|
|
* Crypto user configuration API.
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2011 secunet Security Networks AG
|
|
|
|
|
* Copyright (C) 2011 Steffen Klassert <steffen.klassert@secunet.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/crypto.h>
|
|
|
|
|
#include <linux/cryptouser.h>
|
2012-03-29 07:03:47 +00:00
|
|
|
#include <linux/sched.h>
|
2011-09-27 05:23:50 +00:00
|
|
|
#include <linux/security.h>
|
2019-07-09 11:11:24 +00:00
|
|
|
#include <net/netlink.h>
|
2011-09-27 05:23:50 +00:00
|
|
|
#include <net/net_namespace.h>
|
2019-07-09 11:11:24 +00:00
|
|
|
#include <net/sock.h>
|
2012-03-29 07:03:47 +00:00
|
|
|
#include <crypto/internal/skcipher.h>
|
2015-06-21 11:11:45 +00:00
|
|
|
#include <crypto/internal/rng.h>
|
2015-06-16 17:30:55 +00:00
|
|
|
#include <crypto/akcipher.h>
|
2016-06-22 16:49:13 +00:00
|
|
|
#include <crypto/kpp.h>
|
2018-09-19 10:10:54 +00:00
|
|
|
#include <crypto/internal/cryptouser.h>
|
2012-03-29 07:03:47 +00:00
|
|
|
|
2011-09-27 05:23:50 +00:00
|
|
|
#include "internal.h"
|
|
|
|
|
|
2013-02-05 17:19:15 +00:00
|
|
|
#define null_terminated(x) (strnlen(x, sizeof(x)) < sizeof(x))
|
|
|
|
|
|
2012-08-28 13:46:54 +00:00
|
|
|
static DEFINE_MUTEX(crypto_cfg_mutex);
|
2011-09-27 05:23:50 +00:00
|
|
|
|
|
|
|
|
struct crypto_dump_info {
|
|
|
|
|
struct sk_buff *in_skb;
|
|
|
|
|
struct sk_buff *out_skb;
|
|
|
|
|
u32 nlmsg_seq;
|
|
|
|
|
u16 nlmsg_flags;
|
|
|
|
|
};
|
|
|
|
|
|
2018-09-19 10:10:54 +00:00
|
|
|
struct crypto_alg *crypto_alg_match(struct crypto_user_alg *p, int exact)
|
2011-09-27 05:23:50 +00:00
|
|
|
{
|
|
|
|
|
struct crypto_alg *q, *alg = NULL;
|
|
|
|
|
|
|
|
|
|
down_read(&crypto_alg_sem);
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(q, &crypto_alg_list, cra_list) {
|
2011-10-21 12:37:10 +00:00
|
|
|
int match = 0;
|
2011-09-27 05:23:50 +00:00
|
|
|
|
2019-07-02 21:17:00 +00:00
|
|
|
if (crypto_is_larval(q))
|
|
|
|
|
continue;
|
|
|
|
|
|
2011-09-27 05:23:50 +00:00
|
|
|
if ((q->cra_flags ^ p->cru_type) & p->cru_mask)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (strlen(p->cru_driver_name))
|
|
|
|
|
match = !strcmp(q->cra_driver_name,
|
|
|
|
|
p->cru_driver_name);
|
|
|
|
|
else if (!exact)
|
|
|
|
|
match = !strcmp(q->cra_name, p->cru_name);
|
|
|
|
|
|
2015-04-07 13:27:01 +00:00
|
|
|
if (!match)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (unlikely(!crypto_mod_get(q)))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
alg = q;
|
|
|
|
|
break;
|
2011-09-27 05:23:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
up_read(&crypto_alg_sem);
|
|
|
|
|
|
|
|
|
|
return alg;
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-27 05:48:01 +00:00
|
|
|
static int crypto_report_cipher(struct sk_buff *skb, struct crypto_alg *alg)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_report_cipher rcipher;
|
|
|
|
|
|
2018-11-03 21:56:03 +00:00
|
|
|
memset(&rcipher, 0, sizeof(rcipher));
|
|
|
|
|
|
|
|
|
|
strscpy(rcipher.type, "cipher", sizeof(rcipher.type));
|
2011-09-27 05:48:01 +00:00
|
|
|
|
|
|
|
|
rcipher.blocksize = alg->cra_blocksize;
|
|
|
|
|
rcipher.min_keysize = alg->cra_cipher.cia_min_keysize;
|
|
|
|
|
rcipher.max_keysize = alg->cra_cipher.cia_max_keysize;
|
|
|
|
|
|
2018-11-03 21:56:03 +00:00
|
|
|
return nla_put(skb, CRYPTOCFGA_REPORT_CIPHER,
|
|
|
|
|
sizeof(rcipher), &rcipher);
|
2011-09-27 05:48:01 +00:00
|
|
|
}
|
|
|
|
|
|
2011-09-27 05:48:48 +00:00
|
|
|
static int crypto_report_comp(struct sk_buff *skb, struct crypto_alg *alg)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_report_comp rcomp;
|
|
|
|
|
|
2018-11-03 21:56:03 +00:00
|
|
|
memset(&rcomp, 0, sizeof(rcomp));
|
|
|
|
|
|
|
|
|
|
strscpy(rcomp.type, "compression", sizeof(rcomp.type));
|
2011-09-27 05:48:48 +00:00
|
|
|
|
2018-11-03 21:56:03 +00:00
|
|
|
return nla_put(skb, CRYPTOCFGA_REPORT_COMPRESS, sizeof(rcomp), &rcomp);
|
2011-09-27 05:48:48 +00:00
|
|
|
}
|
|
|
|
|
|
2011-09-27 05:23:50 +00:00
|
|
|
static int crypto_report_one(struct crypto_alg *alg,
|
|
|
|
|
struct crypto_user_alg *ualg, struct sk_buff *skb)
|
|
|
|
|
{
|
2018-11-03 21:56:03 +00:00
|
|
|
memset(ualg, 0, sizeof(*ualg));
|
|
|
|
|
|
|
|
|
|
strscpy(ualg->cru_name, alg->cra_name, sizeof(ualg->cru_name));
|
|
|
|
|
strscpy(ualg->cru_driver_name, alg->cra_driver_name,
|
2013-02-05 17:19:13 +00:00
|
|
|
sizeof(ualg->cru_driver_name));
|
2018-11-03 21:56:03 +00:00
|
|
|
strscpy(ualg->cru_module_name, module_name(alg->cra_module),
|
2013-02-05 17:19:13 +00:00
|
|
|
sizeof(ualg->cru_module_name));
|
|
|
|
|
|
|
|
|
|
ualg->cru_type = 0;
|
|
|
|
|
ualg->cru_mask = 0;
|
2011-09-27 05:23:50 +00:00
|
|
|
ualg->cru_flags = alg->cra_flags;
|
2017-12-29 16:00:46 +00:00
|
|
|
ualg->cru_refcnt = refcount_read(&alg->cra_refcnt);
|
2011-09-27 05:23:50 +00:00
|
|
|
|
2012-04-02 00:19:05 +00:00
|
|
|
if (nla_put_u32(skb, CRYPTOCFGA_PRIORITY_VAL, alg->cra_priority))
|
|
|
|
|
goto nla_put_failure;
|
2011-09-27 05:25:05 +00:00
|
|
|
if (alg->cra_flags & CRYPTO_ALG_LARVAL) {
|
|
|
|
|
struct crypto_report_larval rl;
|
|
|
|
|
|
2018-11-03 21:56:03 +00:00
|
|
|
memset(&rl, 0, sizeof(rl));
|
|
|
|
|
strscpy(rl.type, "larval", sizeof(rl.type));
|
|
|
|
|
if (nla_put(skb, CRYPTOCFGA_REPORT_LARVAL, sizeof(rl), &rl))
|
2012-04-02 00:19:05 +00:00
|
|
|
goto nla_put_failure;
|
2011-09-27 05:25:05 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-27 05:24:29 +00:00
|
|
|
if (alg->cra_type && alg->cra_type->report) {
|
|
|
|
|
if (alg->cra_type->report(skb, alg))
|
|
|
|
|
goto nla_put_failure;
|
2011-09-27 05:48:01 +00:00
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) {
|
|
|
|
|
case CRYPTO_ALG_TYPE_CIPHER:
|
|
|
|
|
if (crypto_report_cipher(skb, alg))
|
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
2011-09-27 05:48:48 +00:00
|
|
|
break;
|
|
|
|
|
case CRYPTO_ALG_TYPE_COMPRESS:
|
|
|
|
|
if (crypto_report_comp(skb, alg))
|
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
2011-09-27 05:48:01 +00:00
|
|
|
break;
|
2011-09-27 05:24:29 +00:00
|
|
|
}
|
|
|
|
|
|
2011-09-27 05:25:05 +00:00
|
|
|
out:
|
2011-09-27 05:23:50 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
nla_put_failure:
|
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_report_alg(struct crypto_alg *alg,
|
|
|
|
|
struct crypto_dump_info *info)
|
|
|
|
|
{
|
|
|
|
|
struct sk_buff *in_skb = info->in_skb;
|
|
|
|
|
struct sk_buff *skb = info->out_skb;
|
|
|
|
|
struct nlmsghdr *nlh;
|
|
|
|
|
struct crypto_user_alg *ualg;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
2012-09-07 20:12:54 +00:00
|
|
|
nlh = nlmsg_put(skb, NETLINK_CB(in_skb).portid, info->nlmsg_seq,
|
2011-09-27 05:23:50 +00:00
|
|
|
CRYPTO_MSG_GETALG, sizeof(*ualg), info->nlmsg_flags);
|
|
|
|
|
if (!nlh) {
|
|
|
|
|
err = -EMSGSIZE;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ualg = nlmsg_data(nlh);
|
|
|
|
|
|
|
|
|
|
err = crypto_report_one(alg, ualg, skb);
|
|
|
|
|
if (err) {
|
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nlmsg_end(skb, nlh);
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_report(struct sk_buff *in_skb, struct nlmsghdr *in_nlh,
|
|
|
|
|
struct nlattr **attrs)
|
|
|
|
|
{
|
2019-07-09 11:11:24 +00:00
|
|
|
struct net *net = sock_net(in_skb->sk);
|
2011-09-27 05:23:50 +00:00
|
|
|
struct crypto_user_alg *p = nlmsg_data(in_nlh);
|
|
|
|
|
struct crypto_alg *alg;
|
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
struct crypto_dump_info info;
|
|
|
|
|
int err;
|
|
|
|
|
|
2013-02-05 17:19:15 +00:00
|
|
|
if (!null_terminated(p->cru_name) || !null_terminated(p->cru_driver_name))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2014-11-20 04:44:32 +00:00
|
|
|
alg = crypto_alg_match(p, 0);
|
2011-09-27 05:23:50 +00:00
|
|
|
if (!alg)
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
2015-04-07 13:27:01 +00:00
|
|
|
err = -ENOMEM;
|
2018-01-25 10:06:02 +00:00
|
|
|
skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
|
2011-09-27 05:23:50 +00:00
|
|
|
if (!skb)
|
2015-04-07 13:27:01 +00:00
|
|
|
goto drop_alg;
|
2011-09-27 05:23:50 +00:00
|
|
|
|
|
|
|
|
info.in_skb = in_skb;
|
|
|
|
|
info.out_skb = skb;
|
|
|
|
|
info.nlmsg_seq = in_nlh->nlmsg_seq;
|
|
|
|
|
info.nlmsg_flags = 0;
|
|
|
|
|
|
|
|
|
|
err = crypto_report_alg(alg, &info);
|
2015-04-07 13:27:01 +00:00
|
|
|
|
|
|
|
|
drop_alg:
|
|
|
|
|
crypto_mod_put(alg);
|
|
|
|
|
|
2019-10-04 19:29:16 +00:00
|
|
|
if (err) {
|
|
|
|
|
kfree_skb(skb);
|
2011-09-27 05:23:50 +00:00
|
|
|
return err;
|
2019-10-04 19:29:16 +00:00
|
|
|
}
|
2011-09-27 05:23:50 +00:00
|
|
|
|
2019-07-09 11:11:24 +00:00
|
|
|
return nlmsg_unicast(net->crypto_nlsk, skb, NETLINK_CB(in_skb).portid);
|
2011-09-27 05:23:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_dump_report(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
|
{
|
2018-12-06 23:55:41 +00:00
|
|
|
const size_t start_pos = cb->args[0];
|
|
|
|
|
size_t pos = 0;
|
2011-09-27 05:23:50 +00:00
|
|
|
struct crypto_dump_info info;
|
2018-12-06 23:55:41 +00:00
|
|
|
struct crypto_alg *alg;
|
|
|
|
|
int res;
|
2011-09-27 05:23:50 +00:00
|
|
|
|
|
|
|
|
info.in_skb = cb->skb;
|
|
|
|
|
info.out_skb = skb;
|
|
|
|
|
info.nlmsg_seq = cb->nlh->nlmsg_seq;
|
|
|
|
|
info.nlmsg_flags = NLM_F_MULTI;
|
|
|
|
|
|
2018-12-06 23:55:41 +00:00
|
|
|
down_read(&crypto_alg_sem);
|
2011-09-27 05:23:50 +00:00
|
|
|
list_for_each_entry(alg, &crypto_alg_list, cra_list) {
|
2018-12-06 23:55:41 +00:00
|
|
|
if (pos >= start_pos) {
|
|
|
|
|
res = crypto_report_alg(alg, &info);
|
|
|
|
|
if (res == -EMSGSIZE)
|
|
|
|
|
break;
|
|
|
|
|
if (res)
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
pos++;
|
2011-09-27 05:23:50 +00:00
|
|
|
}
|
2018-12-06 23:55:41 +00:00
|
|
|
cb->args[0] = pos;
|
|
|
|
|
res = skb->len;
|
2011-09-27 05:23:50 +00:00
|
|
|
out:
|
2018-12-06 23:55:41 +00:00
|
|
|
up_read(&crypto_alg_sem);
|
|
|
|
|
return res;
|
2011-09-27 05:23:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_dump_report_done(struct netlink_callback *cb)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_update_alg(struct sk_buff *skb, struct nlmsghdr *nlh,
|
|
|
|
|
struct nlattr **attrs)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_alg *alg;
|
|
|
|
|
struct crypto_user_alg *p = nlmsg_data(nlh);
|
|
|
|
|
struct nlattr *priority = attrs[CRYPTOCFGA_PRIORITY_VAL];
|
|
|
|
|
LIST_HEAD(list);
|
|
|
|
|
|
2014-06-08 02:44:40 +00:00
|
|
|
if (!netlink_capable(skb, CAP_NET_ADMIN))
|
2014-05-08 13:58:12 +00:00
|
|
|
return -EPERM;
|
|
|
|
|
|
2013-02-05 17:19:15 +00:00
|
|
|
if (!null_terminated(p->cru_name) || !null_terminated(p->cru_driver_name))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2011-09-27 05:23:50 +00:00
|
|
|
if (priority && !strlen(p->cru_driver_name))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
alg = crypto_alg_match(p, 1);
|
|
|
|
|
if (!alg)
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
|
|
down_write(&crypto_alg_sem);
|
|
|
|
|
|
|
|
|
|
crypto_remove_spawns(alg, &list, NULL);
|
|
|
|
|
|
|
|
|
|
if (priority)
|
|
|
|
|
alg->cra_priority = nla_get_u32(priority);
|
|
|
|
|
|
|
|
|
|
up_write(&crypto_alg_sem);
|
|
|
|
|
|
2015-04-07 13:27:01 +00:00
|
|
|
crypto_mod_put(alg);
|
2011-09-27 05:23:50 +00:00
|
|
|
crypto_remove_final(&list);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_del_alg(struct sk_buff *skb, struct nlmsghdr *nlh,
|
|
|
|
|
struct nlattr **attrs)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_alg *alg;
|
|
|
|
|
struct crypto_user_alg *p = nlmsg_data(nlh);
|
2015-04-07 13:27:01 +00:00
|
|
|
int err;
|
2011-09-27 05:23:50 +00:00
|
|
|
|
2014-06-08 02:44:40 +00:00
|
|
|
if (!netlink_capable(skb, CAP_NET_ADMIN))
|
2014-05-08 13:58:12 +00:00
|
|
|
return -EPERM;
|
|
|
|
|
|
2013-02-05 17:19:15 +00:00
|
|
|
if (!null_terminated(p->cru_name) || !null_terminated(p->cru_driver_name))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2011-09-27 05:23:50 +00:00
|
|
|
alg = crypto_alg_match(p, 1);
|
|
|
|
|
if (!alg)
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
|
|
/* We can not unregister core algorithms such as aes-generic.
|
|
|
|
|
* We would loose the reference in the crypto_alg_list to this algorithm
|
|
|
|
|
* if we try to unregister. Unregistering such an algorithm without
|
|
|
|
|
* removing the module is not possible, so we restrict to crypto
|
|
|
|
|
* instances that are build from templates. */
|
2015-04-07 13:27:01 +00:00
|
|
|
err = -EINVAL;
|
2011-09-27 05:23:50 +00:00
|
|
|
if (!(alg->cra_flags & CRYPTO_ALG_INSTANCE))
|
2015-04-07 13:27:01 +00:00
|
|
|
goto drop_alg;
|
2011-09-27 05:23:50 +00:00
|
|
|
|
2015-04-07 13:27:01 +00:00
|
|
|
err = -EBUSY;
|
2017-12-29 16:00:46 +00:00
|
|
|
if (refcount_read(&alg->cra_refcnt) > 2)
|
2015-04-07 13:27:01 +00:00
|
|
|
goto drop_alg;
|
2011-09-27 05:23:50 +00:00
|
|
|
|
2019-12-15 23:51:19 +00:00
|
|
|
crypto_unregister_instance((struct crypto_instance *)alg);
|
|
|
|
|
err = 0;
|
2015-04-07 13:27:01 +00:00
|
|
|
|
|
|
|
|
drop_alg:
|
|
|
|
|
crypto_mod_put(alg);
|
|
|
|
|
return err;
|
2011-09-27 05:23:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int crypto_add_alg(struct sk_buff *skb, struct nlmsghdr *nlh,
|
|
|
|
|
struct nlattr **attrs)
|
|
|
|
|
{
|
2012-01-29 22:39:22 +00:00
|
|
|
int exact = 0;
|
2011-09-27 05:23:50 +00:00
|
|
|
const char *name;
|
|
|
|
|
struct crypto_alg *alg;
|
|
|
|
|
struct crypto_user_alg *p = nlmsg_data(nlh);
|
|
|
|
|
struct nlattr *priority = attrs[CRYPTOCFGA_PRIORITY_VAL];
|
|
|
|
|
|
2014-06-08 02:44:40 +00:00
|
|
|
if (!netlink_capable(skb, CAP_NET_ADMIN))
|
2014-05-08 13:58:12 +00:00
|
|
|
return -EPERM;
|
|
|
|
|
|
2013-02-05 17:19:15 +00:00
|
|
|
if (!null_terminated(p->cru_name) || !null_terminated(p->cru_driver_name))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2011-09-27 05:23:50 +00:00
|
|
|
if (strlen(p->cru_driver_name))
|
|
|
|
|
exact = 1;
|
|
|
|
|
|
|
|
|
|
if (priority && !exact)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
alg = crypto_alg_match(p, exact);
|
2015-04-07 13:27:01 +00:00
|
|
|
if (alg) {
|
|
|
|
|
crypto_mod_put(alg);
|
2011-09-27 05:23:50 +00:00
|
|
|
return -EEXIST;
|
2015-04-07 13:27:01 +00:00
|
|
|
}
|
2011-09-27 05:23:50 +00:00
|
|
|
|
|
|
|
|
if (strlen(p->cru_driver_name))
|
|
|
|
|
name = p->cru_driver_name;
|
|
|
|
|
else
|
|
|
|
|
name = p->cru_name;
|
|
|
|
|
|
2016-07-12 05:17:49 +00:00
|
|
|
alg = crypto_alg_mod_lookup(name, p->cru_type, p->cru_mask);
|
2011-09-27 05:23:50 +00:00
|
|
|
if (IS_ERR(alg))
|
|
|
|
|
return PTR_ERR(alg);
|
|
|
|
|
|
|
|
|
|
down_write(&crypto_alg_sem);
|
|
|
|
|
|
|
|
|
|
if (priority)
|
|
|
|
|
alg->cra_priority = nla_get_u32(priority);
|
|
|
|
|
|
|
|
|
|
up_write(&crypto_alg_sem);
|
|
|
|
|
|
|
|
|
|
crypto_mod_put(alg);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-21 11:11:45 +00:00
|
|
|
static int crypto_del_rng(struct sk_buff *skb, struct nlmsghdr *nlh,
|
|
|
|
|
struct nlattr **attrs)
|
|
|
|
|
{
|
|
|
|
|
if (!netlink_capable(skb, CAP_NET_ADMIN))
|
|
|
|
|
return -EPERM;
|
|
|
|
|
return crypto_del_default_rng();
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-27 05:23:50 +00:00
|
|
|
#define MSGSIZE(type) sizeof(struct type)
|
|
|
|
|
|
|
|
|
|
static const int crypto_msg_min[CRYPTO_NR_MSGTYPES] = {
|
|
|
|
|
[CRYPTO_MSG_NEWALG - CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
|
|
|
|
|
[CRYPTO_MSG_DELALG - CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
|
|
|
|
|
[CRYPTO_MSG_UPDATEALG - CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
|
2016-06-22 18:29:37 +00:00
|
|
|
[CRYPTO_MSG_GETALG - CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
|
2015-06-21 11:11:45 +00:00
|
|
|
[CRYPTO_MSG_DELRNG - CRYPTO_MSG_BASE] = 0,
|
2018-09-19 10:10:54 +00:00
|
|
|
[CRYPTO_MSG_GETSTAT - CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
|
2011-09-27 05:23:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct nla_policy crypto_policy[CRYPTOCFGA_MAX+1] = {
|
|
|
|
|
[CRYPTOCFGA_PRIORITY_VAL] = { .type = NLA_U32},
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#undef MSGSIZE
|
|
|
|
|
|
2013-02-24 13:09:12 +00:00
|
|
|
static const struct crypto_link {
|
2011-09-27 05:23:50 +00:00
|
|
|
int (*doit)(struct sk_buff *, struct nlmsghdr *, struct nlattr **);
|
|
|
|
|
int (*dump)(struct sk_buff *, struct netlink_callback *);
|
|
|
|
|
int (*done)(struct netlink_callback *);
|
|
|
|
|
} crypto_dispatch[CRYPTO_NR_MSGTYPES] = {
|
|
|
|
|
[CRYPTO_MSG_NEWALG - CRYPTO_MSG_BASE] = { .doit = crypto_add_alg},
|
|
|
|
|
[CRYPTO_MSG_DELALG - CRYPTO_MSG_BASE] = { .doit = crypto_del_alg},
|
|
|
|
|
[CRYPTO_MSG_UPDATEALG - CRYPTO_MSG_BASE] = { .doit = crypto_update_alg},
|
|
|
|
|
[CRYPTO_MSG_GETALG - CRYPTO_MSG_BASE] = { .doit = crypto_report,
|
|
|
|
|
.dump = crypto_dump_report,
|
|
|
|
|
.done = crypto_dump_report_done},
|
2015-06-21 11:11:45 +00:00
|
|
|
[CRYPTO_MSG_DELRNG - CRYPTO_MSG_BASE] = { .doit = crypto_del_rng },
|
2018-12-13 08:36:37 +00:00
|
|
|
[CRYPTO_MSG_GETSTAT - CRYPTO_MSG_BASE] = { .doit = crypto_reportstat},
|
2011-09-27 05:23:50 +00:00
|
|
|
};
|
|
|
|
|
|
2017-04-12 12:34:04 +00:00
|
|
|
static int crypto_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
|
|
|
|
|
struct netlink_ext_ack *extack)
|
2011-09-27 05:23:50 +00:00
|
|
|
{
|
2019-07-09 11:11:24 +00:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2011-09-27 05:23:50 +00:00
|
|
|
struct nlattr *attrs[CRYPTOCFGA_MAX+1];
|
2013-02-24 13:09:12 +00:00
|
|
|
const struct crypto_link *link;
|
2011-09-27 05:23:50 +00:00
|
|
|
int type, err;
|
|
|
|
|
|
|
|
|
|
type = nlh->nlmsg_type;
|
|
|
|
|
if (type > CRYPTO_MSG_MAX)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
type -= CRYPTO_MSG_BASE;
|
|
|
|
|
link = &crypto_dispatch[type];
|
|
|
|
|
|
|
|
|
|
if ((type == (CRYPTO_MSG_GETALG - CRYPTO_MSG_BASE) &&
|
|
|
|
|
(nlh->nlmsg_flags & NLM_F_DUMP))) {
|
2012-03-29 07:04:46 +00:00
|
|
|
struct crypto_alg *alg;
|
2018-12-06 23:55:41 +00:00
|
|
|
unsigned long dump_alloc = 0;
|
2012-03-29 07:04:46 +00:00
|
|
|
|
2011-09-27 05:23:50 +00:00
|
|
|
if (link->dump == NULL)
|
|
|
|
|
return -EINVAL;
|
2012-03-29 07:04:46 +00:00
|
|
|
|
2016-02-01 13:27:30 +00:00
|
|
|
down_read(&crypto_alg_sem);
|
2012-03-29 07:04:46 +00:00
|
|
|
list_for_each_entry(alg, &crypto_alg_list, cra_list)
|
|
|
|
|
dump_alloc += CRYPTO_REPORT_MAXSIZE;
|
2018-12-06 23:55:41 +00:00
|
|
|
up_read(&crypto_alg_sem);
|
2012-03-29 07:04:46 +00:00
|
|
|
|
2012-02-24 14:30:15 +00:00
|
|
|
{
|
|
|
|
|
struct netlink_dump_control c = {
|
|
|
|
|
.dump = link->dump,
|
|
|
|
|
.done = link->done,
|
2018-12-06 23:55:41 +00:00
|
|
|
.min_dump_alloc = min(dump_alloc, 65535UL),
|
2012-02-24 14:30:15 +00:00
|
|
|
};
|
2019-07-09 11:11:24 +00:00
|
|
|
err = netlink_dump_start(net->crypto_nlsk, skb, nlh, &c);
|
2012-02-24 14:30:15 +00:00
|
|
|
}
|
2016-02-01 13:27:30 +00:00
|
|
|
|
|
|
|
|
return err;
|
2011-09-27 05:23:50 +00:00
|
|
|
}
|
|
|
|
|
|
netlink: make validation more configurable for future strictness
We currently have two levels of strict validation:
1) liberal (default)
- undefined (type >= max) & NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
- garbage at end of message accepted
2) strict (opt-in)
- NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
Split out parsing strictness into four different options:
* TRAILING - check that there's no trailing data after parsing
attributes (in message or nested)
* MAXTYPE - reject attrs > max known type
* UNSPEC - reject attributes with NLA_UNSPEC policy entries
* STRICT_ATTRS - strictly validate attribute size
The default for future things should be *everything*.
The current *_strict() is a combination of TRAILING and MAXTYPE,
and is renamed to _deprecated_strict().
The current regular parsing has none of this, and is renamed to
*_parse_deprecated().
Additionally it allows us to selectively set one of the new flags
even on old policies. Notably, the UNSPEC flag could be useful in
this case, since it can be arranged (by filling in the policy) to
not be an incompatible userspace ABI change, but would then going
forward prevent forgetting attribute entries. Similar can apply
to the POLICY flag.
We end up with the following renames:
* nla_parse -> nla_parse_deprecated
* nla_parse_strict -> nla_parse_deprecated_strict
* nlmsg_parse -> nlmsg_parse_deprecated
* nlmsg_parse_strict -> nlmsg_parse_deprecated_strict
* nla_parse_nested -> nla_parse_nested_deprecated
* nla_validate_nested -> nla_validate_nested_deprecated
Using spatch, of course:
@@
expression TB, MAX, HEAD, LEN, POL, EXT;
@@
-nla_parse(TB, MAX, HEAD, LEN, POL, EXT)
+nla_parse_deprecated(TB, MAX, HEAD, LEN, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression TB, MAX, NLA, POL, EXT;
@@
-nla_parse_nested(TB, MAX, NLA, POL, EXT)
+nla_parse_nested_deprecated(TB, MAX, NLA, POL, EXT)
@@
expression START, MAX, POL, EXT;
@@
-nla_validate_nested(START, MAX, POL, EXT)
+nla_validate_nested_deprecated(START, MAX, POL, EXT)
@@
expression NLH, HDRLEN, MAX, POL, EXT;
@@
-nlmsg_validate(NLH, HDRLEN, MAX, POL, EXT)
+nlmsg_validate_deprecated(NLH, HDRLEN, MAX, POL, EXT)
For this patch, don't actually add the strict, non-renamed versions
yet so that it breaks compile if I get it wrong.
Also, while at it, make nla_validate and nla_parse go down to a
common __nla_validate_parse() function to avoid code duplication.
Ultimately, this allows us to have very strict validation for every
new caller of nla_parse()/nlmsg_parse() etc as re-introduced in the
next patch, while existing things will continue to work as is.
In effect then, this adds fully strict validation for any new command.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-04-26 12:07:28 +00:00
|
|
|
err = nlmsg_parse_deprecated(nlh, crypto_msg_min[type], attrs,
|
|
|
|
|
CRYPTOCFGA_MAX, crypto_policy, extack);
|
2016-06-23 10:06:02 +00:00
|
|
|
if (err < 0)
|
|
|
|
|
return err;
|
2011-09-27 05:23:50 +00:00
|
|
|
|
|
|
|
|
if (link->doit == NULL)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
return link->doit(skb, nlh, attrs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void crypto_netlink_rcv(struct sk_buff *skb)
|
|
|
|
|
{
|
|
|
|
|
mutex_lock(&crypto_cfg_mutex);
|
|
|
|
|
netlink_rcv_skb(skb, &crypto_user_rcv_msg);
|
|
|
|
|
mutex_unlock(&crypto_cfg_mutex);
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-09 11:11:24 +00:00
|
|
|
static int __net_init crypto_netlink_init(struct net *net)
|
2011-09-27 05:23:50 +00:00
|
|
|
{
|
2012-06-29 06:15:21 +00:00
|
|
|
struct netlink_kernel_cfg cfg = {
|
|
|
|
|
.input = crypto_netlink_rcv,
|
|
|
|
|
};
|
|
|
|
|
|
2019-07-09 11:11:24 +00:00
|
|
|
net->crypto_nlsk = netlink_kernel_create(net, NETLINK_CRYPTO, &cfg);
|
|
|
|
|
return net->crypto_nlsk == NULL ? -ENOMEM : 0;
|
|
|
|
|
}
|
2011-09-27 05:23:50 +00:00
|
|
|
|
2019-07-09 11:11:24 +00:00
|
|
|
static void __net_exit crypto_netlink_exit(struct net *net)
|
|
|
|
|
{
|
|
|
|
|
netlink_kernel_release(net->crypto_nlsk);
|
|
|
|
|
net->crypto_nlsk = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct pernet_operations crypto_netlink_net_ops = {
|
|
|
|
|
.init = crypto_netlink_init,
|
|
|
|
|
.exit = crypto_netlink_exit,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int __init crypto_user_init(void)
|
|
|
|
|
{
|
|
|
|
|
return register_pernet_subsys(&crypto_netlink_net_ops);
|
2011-09-27 05:23:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __exit crypto_user_exit(void)
|
|
|
|
|
{
|
2019-07-09 11:11:24 +00:00
|
|
|
unregister_pernet_subsys(&crypto_netlink_net_ops);
|
2011-09-27 05:23:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module_init(crypto_user_init);
|
|
|
|
|
module_exit(crypto_user_exit);
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>");
|
|
|
|
|
MODULE_DESCRIPTION("Crypto userspace configuration API");
|
2014-11-24 16:12:45 +00:00
|
|
|
MODULE_ALIAS("net-pf-16-proto-21");
|