2 * Crypto user configuration API.
4 * Copyright (C) 2011 secunet Security Networks AG
5 * Copyright (C) 2011 Steffen Klassert <steffen.klassert@secunet.com>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms and conditions of the GNU General Public License,
9 * version 2, as published by the Free Software Foundation.
11 * This program is distributed in the hope it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21 #include <linux/module.h>
22 #include <linux/crypto.h>
23 #include <linux/cryptouser.h>
24 #include <net/netlink.h>
25 #include <linux/security.h>
26 #include <net/net_namespace.h>
29 DEFINE_MUTEX(crypto_cfg_mutex
);
31 /* The crypto netlink socket */
32 static struct sock
*crypto_nlsk
;
34 struct crypto_dump_info
{
35 struct sk_buff
*in_skb
;
36 struct sk_buff
*out_skb
;
41 static struct crypto_alg
*crypto_alg_match(struct crypto_user_alg
*p
, int exact
)
44 struct crypto_alg
*q
, *alg
= NULL
;
46 down_read(&crypto_alg_sem
);
48 if (list_empty(&crypto_alg_list
))
51 list_for_each_entry(q
, &crypto_alg_list
, cra_list
) {
53 if ((q
->cra_flags
^ p
->cru_type
) & p
->cru_mask
)
56 if (strlen(p
->cru_driver_name
))
57 match
= !strcmp(q
->cra_driver_name
,
60 match
= !strcmp(q
->cra_name
, p
->cru_name
);
68 up_read(&crypto_alg_sem
);
73 static int crypto_report_cipher(struct sk_buff
*skb
, struct crypto_alg
*alg
)
75 struct crypto_report_cipher rcipher
;
77 snprintf(rcipher
.type
, CRYPTO_MAX_ALG_NAME
, "%s", "cipher");
79 rcipher
.blocksize
= alg
->cra_blocksize
;
80 rcipher
.min_keysize
= alg
->cra_cipher
.cia_min_keysize
;
81 rcipher
.max_keysize
= alg
->cra_cipher
.cia_max_keysize
;
83 NLA_PUT(skb
, CRYPTOCFGA_REPORT_CIPHER
,
84 sizeof(struct crypto_report_cipher
), &rcipher
);
92 static int crypto_report_one(struct crypto_alg
*alg
,
93 struct crypto_user_alg
*ualg
, struct sk_buff
*skb
)
95 memcpy(&ualg
->cru_name
, &alg
->cra_name
, sizeof(ualg
->cru_name
));
96 memcpy(&ualg
->cru_driver_name
, &alg
->cra_driver_name
,
97 sizeof(ualg
->cru_driver_name
));
98 memcpy(&ualg
->cru_module_name
, module_name(alg
->cra_module
),
101 ualg
->cru_flags
= alg
->cra_flags
;
102 ualg
->cru_refcnt
= atomic_read(&alg
->cra_refcnt
);
104 NLA_PUT_U32(skb
, CRYPTOCFGA_PRIORITY_VAL
, alg
->cra_priority
);
106 if (alg
->cra_flags
& CRYPTO_ALG_LARVAL
) {
107 struct crypto_report_larval rl
;
109 snprintf(rl
.type
, CRYPTO_MAX_ALG_NAME
, "%s", "larval");
111 NLA_PUT(skb
, CRYPTOCFGA_REPORT_LARVAL
,
112 sizeof(struct crypto_report_larval
), &rl
);
117 if (alg
->cra_type
&& alg
->cra_type
->report
) {
118 if (alg
->cra_type
->report(skb
, alg
))
119 goto nla_put_failure
;
124 switch (alg
->cra_flags
& (CRYPTO_ALG_TYPE_MASK
| CRYPTO_ALG_LARVAL
)) {
125 case CRYPTO_ALG_TYPE_CIPHER
:
126 if (crypto_report_cipher(skb
, alg
))
127 goto nla_put_failure
;
139 static int crypto_report_alg(struct crypto_alg
*alg
,
140 struct crypto_dump_info
*info
)
142 struct sk_buff
*in_skb
= info
->in_skb
;
143 struct sk_buff
*skb
= info
->out_skb
;
144 struct nlmsghdr
*nlh
;
145 struct crypto_user_alg
*ualg
;
148 nlh
= nlmsg_put(skb
, NETLINK_CB(in_skb
).pid
, info
->nlmsg_seq
,
149 CRYPTO_MSG_GETALG
, sizeof(*ualg
), info
->nlmsg_flags
);
155 ualg
= nlmsg_data(nlh
);
157 err
= crypto_report_one(alg
, ualg
, skb
);
159 nlmsg_cancel(skb
, nlh
);
169 static int crypto_report(struct sk_buff
*in_skb
, struct nlmsghdr
*in_nlh
,
170 struct nlattr
**attrs
)
172 struct crypto_user_alg
*p
= nlmsg_data(in_nlh
);
173 struct crypto_alg
*alg
;
175 struct crypto_dump_info info
;
178 if (!p
->cru_driver_name
)
181 alg
= crypto_alg_match(p
, 1);
185 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
189 info
.in_skb
= in_skb
;
191 info
.nlmsg_seq
= in_nlh
->nlmsg_seq
;
192 info
.nlmsg_flags
= 0;
194 err
= crypto_report_alg(alg
, &info
);
198 return nlmsg_unicast(crypto_nlsk
, skb
, NETLINK_CB(in_skb
).pid
);
201 static int crypto_dump_report(struct sk_buff
*skb
, struct netlink_callback
*cb
)
203 struct crypto_alg
*alg
;
204 struct crypto_dump_info info
;
212 info
.in_skb
= cb
->skb
;
214 info
.nlmsg_seq
= cb
->nlh
->nlmsg_seq
;
215 info
.nlmsg_flags
= NLM_F_MULTI
;
217 list_for_each_entry(alg
, &crypto_alg_list
, cra_list
) {
218 err
= crypto_report_alg(alg
, &info
);
229 static int crypto_dump_report_done(struct netlink_callback
*cb
)
234 static int crypto_update_alg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
235 struct nlattr
**attrs
)
237 struct crypto_alg
*alg
;
238 struct crypto_user_alg
*p
= nlmsg_data(nlh
);
239 struct nlattr
*priority
= attrs
[CRYPTOCFGA_PRIORITY_VAL
];
242 if (priority
&& !strlen(p
->cru_driver_name
))
245 alg
= crypto_alg_match(p
, 1);
249 down_write(&crypto_alg_sem
);
251 crypto_remove_spawns(alg
, &list
, NULL
);
254 alg
->cra_priority
= nla_get_u32(priority
);
256 up_write(&crypto_alg_sem
);
258 crypto_remove_final(&list
);
263 static int crypto_del_alg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
264 struct nlattr
**attrs
)
266 struct crypto_alg
*alg
;
267 struct crypto_user_alg
*p
= nlmsg_data(nlh
);
269 alg
= crypto_alg_match(p
, 1);
273 /* We can not unregister core algorithms such as aes-generic.
274 * We would loose the reference in the crypto_alg_list to this algorithm
275 * if we try to unregister. Unregistering such an algorithm without
276 * removing the module is not possible, so we restrict to crypto
277 * instances that are build from templates. */
278 if (!(alg
->cra_flags
& CRYPTO_ALG_INSTANCE
))
281 if (atomic_read(&alg
->cra_refcnt
) != 1)
284 return crypto_unregister_alg(alg
);
287 static int crypto_add_alg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
288 struct nlattr
**attrs
)
292 struct crypto_alg
*alg
;
293 struct crypto_user_alg
*p
= nlmsg_data(nlh
);
294 struct nlattr
*priority
= attrs
[CRYPTOCFGA_PRIORITY_VAL
];
296 if (strlen(p
->cru_driver_name
))
299 if (priority
&& !exact
)
302 alg
= crypto_alg_match(p
, exact
);
306 if (strlen(p
->cru_driver_name
))
307 name
= p
->cru_driver_name
;
311 alg
= crypto_alg_mod_lookup(name
, p
->cru_type
, p
->cru_mask
);
315 down_write(&crypto_alg_sem
);
318 alg
->cra_priority
= nla_get_u32(priority
);
320 up_write(&crypto_alg_sem
);
327 #define MSGSIZE(type) sizeof(struct type)
329 static const int crypto_msg_min
[CRYPTO_NR_MSGTYPES
] = {
330 [CRYPTO_MSG_NEWALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
331 [CRYPTO_MSG_DELALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
332 [CRYPTO_MSG_UPDATEALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
333 [CRYPTO_MSG_GETALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
336 static const struct nla_policy crypto_policy
[CRYPTOCFGA_MAX
+1] = {
337 [CRYPTOCFGA_PRIORITY_VAL
] = { .type
= NLA_U32
},
342 static struct crypto_link
{
343 int (*doit
)(struct sk_buff
*, struct nlmsghdr
*, struct nlattr
**);
344 int (*dump
)(struct sk_buff
*, struct netlink_callback
*);
345 int (*done
)(struct netlink_callback
*);
346 } crypto_dispatch
[CRYPTO_NR_MSGTYPES
] = {
347 [CRYPTO_MSG_NEWALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_add_alg
},
348 [CRYPTO_MSG_DELALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_del_alg
},
349 [CRYPTO_MSG_UPDATEALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_update_alg
},
350 [CRYPTO_MSG_GETALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_report
,
351 .dump
= crypto_dump_report
,
352 .done
= crypto_dump_report_done
},
355 static int crypto_user_rcv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
357 struct nlattr
*attrs
[CRYPTOCFGA_MAX
+1];
358 struct crypto_link
*link
;
361 type
= nlh
->nlmsg_type
;
362 if (type
> CRYPTO_MSG_MAX
)
365 type
-= CRYPTO_MSG_BASE
;
366 link
= &crypto_dispatch
[type
];
368 if (security_netlink_recv(skb
, CAP_NET_ADMIN
))
371 if ((type
== (CRYPTO_MSG_GETALG
- CRYPTO_MSG_BASE
) &&
372 (nlh
->nlmsg_flags
& NLM_F_DUMP
))) {
373 if (link
->dump
== NULL
)
376 return netlink_dump_start(crypto_nlsk
, skb
, nlh
,
377 link
->dump
, link
->done
, 0);
380 err
= nlmsg_parse(nlh
, crypto_msg_min
[type
], attrs
, CRYPTOCFGA_MAX
,
385 if (link
->doit
== NULL
)
388 return link
->doit(skb
, nlh
, attrs
);
391 static void crypto_netlink_rcv(struct sk_buff
*skb
)
393 mutex_lock(&crypto_cfg_mutex
);
394 netlink_rcv_skb(skb
, &crypto_user_rcv_msg
);
395 mutex_unlock(&crypto_cfg_mutex
);
398 static int __init
crypto_user_init(void)
400 crypto_nlsk
= netlink_kernel_create(&init_net
, NETLINK_CRYPTO
,
401 0, crypto_netlink_rcv
,
409 static void __exit
crypto_user_exit(void)
411 netlink_kernel_release(crypto_nlsk
);
414 module_init(crypto_user_init
);
415 module_exit(crypto_user_exit
);
416 MODULE_LICENSE("GPL");
417 MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>");
418 MODULE_DESCRIPTION("Crypto userspace configuration API");