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_one(struct crypto_alg
*alg
,
74 struct crypto_user_alg
*ualg
, struct sk_buff
*skb
)
76 memcpy(&ualg
->cru_name
, &alg
->cra_name
, sizeof(ualg
->cru_name
));
77 memcpy(&ualg
->cru_driver_name
, &alg
->cra_driver_name
,
78 sizeof(ualg
->cru_driver_name
));
79 memcpy(&ualg
->cru_module_name
, module_name(alg
->cra_module
),
82 ualg
->cru_flags
= alg
->cra_flags
;
83 ualg
->cru_refcnt
= atomic_read(&alg
->cra_refcnt
);
85 NLA_PUT_U32(skb
, CRYPTOCFGA_PRIORITY_VAL
, alg
->cra_priority
);
87 if (alg
->cra_type
&& alg
->cra_type
->report
) {
88 if (alg
->cra_type
->report(skb
, alg
))
98 static int crypto_report_alg(struct crypto_alg
*alg
,
99 struct crypto_dump_info
*info
)
101 struct sk_buff
*in_skb
= info
->in_skb
;
102 struct sk_buff
*skb
= info
->out_skb
;
103 struct nlmsghdr
*nlh
;
104 struct crypto_user_alg
*ualg
;
107 nlh
= nlmsg_put(skb
, NETLINK_CB(in_skb
).pid
, info
->nlmsg_seq
,
108 CRYPTO_MSG_GETALG
, sizeof(*ualg
), info
->nlmsg_flags
);
114 ualg
= nlmsg_data(nlh
);
116 err
= crypto_report_one(alg
, ualg
, skb
);
118 nlmsg_cancel(skb
, nlh
);
128 static int crypto_report(struct sk_buff
*in_skb
, struct nlmsghdr
*in_nlh
,
129 struct nlattr
**attrs
)
131 struct crypto_user_alg
*p
= nlmsg_data(in_nlh
);
132 struct crypto_alg
*alg
;
134 struct crypto_dump_info info
;
137 if (!p
->cru_driver_name
)
140 alg
= crypto_alg_match(p
, 1);
144 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
148 info
.in_skb
= in_skb
;
150 info
.nlmsg_seq
= in_nlh
->nlmsg_seq
;
151 info
.nlmsg_flags
= 0;
153 err
= crypto_report_alg(alg
, &info
);
157 return nlmsg_unicast(crypto_nlsk
, skb
, NETLINK_CB(in_skb
).pid
);
160 static int crypto_dump_report(struct sk_buff
*skb
, struct netlink_callback
*cb
)
162 struct crypto_alg
*alg
;
163 struct crypto_dump_info info
;
171 info
.in_skb
= cb
->skb
;
173 info
.nlmsg_seq
= cb
->nlh
->nlmsg_seq
;
174 info
.nlmsg_flags
= NLM_F_MULTI
;
176 list_for_each_entry(alg
, &crypto_alg_list
, cra_list
) {
177 err
= crypto_report_alg(alg
, &info
);
188 static int crypto_dump_report_done(struct netlink_callback
*cb
)
193 static int crypto_update_alg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
194 struct nlattr
**attrs
)
196 struct crypto_alg
*alg
;
197 struct crypto_user_alg
*p
= nlmsg_data(nlh
);
198 struct nlattr
*priority
= attrs
[CRYPTOCFGA_PRIORITY_VAL
];
201 if (priority
&& !strlen(p
->cru_driver_name
))
204 alg
= crypto_alg_match(p
, 1);
208 down_write(&crypto_alg_sem
);
210 crypto_remove_spawns(alg
, &list
, NULL
);
213 alg
->cra_priority
= nla_get_u32(priority
);
215 up_write(&crypto_alg_sem
);
217 crypto_remove_final(&list
);
222 static int crypto_del_alg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
223 struct nlattr
**attrs
)
225 struct crypto_alg
*alg
;
226 struct crypto_user_alg
*p
= nlmsg_data(nlh
);
228 alg
= crypto_alg_match(p
, 1);
232 /* We can not unregister core algorithms such as aes-generic.
233 * We would loose the reference in the crypto_alg_list to this algorithm
234 * if we try to unregister. Unregistering such an algorithm without
235 * removing the module is not possible, so we restrict to crypto
236 * instances that are build from templates. */
237 if (!(alg
->cra_flags
& CRYPTO_ALG_INSTANCE
))
240 if (atomic_read(&alg
->cra_refcnt
) != 1)
243 return crypto_unregister_alg(alg
);
246 static int crypto_add_alg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
247 struct nlattr
**attrs
)
251 struct crypto_alg
*alg
;
252 struct crypto_user_alg
*p
= nlmsg_data(nlh
);
253 struct nlattr
*priority
= attrs
[CRYPTOCFGA_PRIORITY_VAL
];
255 if (strlen(p
->cru_driver_name
))
258 if (priority
&& !exact
)
261 alg
= crypto_alg_match(p
, exact
);
265 if (strlen(p
->cru_driver_name
))
266 name
= p
->cru_driver_name
;
270 alg
= crypto_alg_mod_lookup(name
, p
->cru_type
, p
->cru_mask
);
274 down_write(&crypto_alg_sem
);
277 alg
->cra_priority
= nla_get_u32(priority
);
279 up_write(&crypto_alg_sem
);
286 #define MSGSIZE(type) sizeof(struct type)
288 static const int crypto_msg_min
[CRYPTO_NR_MSGTYPES
] = {
289 [CRYPTO_MSG_NEWALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
290 [CRYPTO_MSG_DELALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
291 [CRYPTO_MSG_UPDATEALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
292 [CRYPTO_MSG_GETALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
295 static const struct nla_policy crypto_policy
[CRYPTOCFGA_MAX
+1] = {
296 [CRYPTOCFGA_PRIORITY_VAL
] = { .type
= NLA_U32
},
301 static struct crypto_link
{
302 int (*doit
)(struct sk_buff
*, struct nlmsghdr
*, struct nlattr
**);
303 int (*dump
)(struct sk_buff
*, struct netlink_callback
*);
304 int (*done
)(struct netlink_callback
*);
305 } crypto_dispatch
[CRYPTO_NR_MSGTYPES
] = {
306 [CRYPTO_MSG_NEWALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_add_alg
},
307 [CRYPTO_MSG_DELALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_del_alg
},
308 [CRYPTO_MSG_UPDATEALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_update_alg
},
309 [CRYPTO_MSG_GETALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_report
,
310 .dump
= crypto_dump_report
,
311 .done
= crypto_dump_report_done
},
314 static int crypto_user_rcv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
316 struct nlattr
*attrs
[CRYPTOCFGA_MAX
+1];
317 struct crypto_link
*link
;
320 type
= nlh
->nlmsg_type
;
321 if (type
> CRYPTO_MSG_MAX
)
324 type
-= CRYPTO_MSG_BASE
;
325 link
= &crypto_dispatch
[type
];
327 if (security_netlink_recv(skb
, CAP_NET_ADMIN
))
330 if ((type
== (CRYPTO_MSG_GETALG
- CRYPTO_MSG_BASE
) &&
331 (nlh
->nlmsg_flags
& NLM_F_DUMP
))) {
332 if (link
->dump
== NULL
)
335 return netlink_dump_start(crypto_nlsk
, skb
, nlh
,
336 link
->dump
, link
->done
, 0);
339 err
= nlmsg_parse(nlh
, crypto_msg_min
[type
], attrs
, CRYPTOCFGA_MAX
,
344 if (link
->doit
== NULL
)
347 return link
->doit(skb
, nlh
, attrs
);
350 static void crypto_netlink_rcv(struct sk_buff
*skb
)
352 mutex_lock(&crypto_cfg_mutex
);
353 netlink_rcv_skb(skb
, &crypto_user_rcv_msg
);
354 mutex_unlock(&crypto_cfg_mutex
);
357 static int __init
crypto_user_init(void)
359 crypto_nlsk
= netlink_kernel_create(&init_net
, NETLINK_CRYPTO
,
360 0, crypto_netlink_rcv
,
368 static void __exit
crypto_user_exit(void)
370 netlink_kernel_release(crypto_nlsk
);
373 module_init(crypto_user_init
);
374 module_exit(crypto_user_exit
);
375 MODULE_LICENSE("GPL");
376 MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>");
377 MODULE_DESCRIPTION("Crypto userspace configuration API");
This page took 0.041374 seconds and 6 git commands to generate.