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
);
93 static int crypto_report_alg(struct crypto_alg
*alg
,
94 struct crypto_dump_info
*info
)
96 struct sk_buff
*in_skb
= info
->in_skb
;
97 struct sk_buff
*skb
= info
->out_skb
;
99 struct crypto_user_alg
*ualg
;
102 nlh
= nlmsg_put(skb
, NETLINK_CB(in_skb
).pid
, info
->nlmsg_seq
,
103 CRYPTO_MSG_GETALG
, sizeof(*ualg
), info
->nlmsg_flags
);
109 ualg
= nlmsg_data(nlh
);
111 err
= crypto_report_one(alg
, ualg
, skb
);
113 nlmsg_cancel(skb
, nlh
);
123 static int crypto_report(struct sk_buff
*in_skb
, struct nlmsghdr
*in_nlh
,
124 struct nlattr
**attrs
)
126 struct crypto_user_alg
*p
= nlmsg_data(in_nlh
);
127 struct crypto_alg
*alg
;
129 struct crypto_dump_info info
;
132 if (!p
->cru_driver_name
)
135 alg
= crypto_alg_match(p
, 1);
139 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
143 info
.in_skb
= in_skb
;
145 info
.nlmsg_seq
= in_nlh
->nlmsg_seq
;
146 info
.nlmsg_flags
= 0;
148 err
= crypto_report_alg(alg
, &info
);
152 return nlmsg_unicast(crypto_nlsk
, skb
, NETLINK_CB(in_skb
).pid
);
155 static int crypto_dump_report(struct sk_buff
*skb
, struct netlink_callback
*cb
)
157 struct crypto_alg
*alg
;
158 struct crypto_dump_info info
;
166 info
.in_skb
= cb
->skb
;
168 info
.nlmsg_seq
= cb
->nlh
->nlmsg_seq
;
169 info
.nlmsg_flags
= NLM_F_MULTI
;
171 list_for_each_entry(alg
, &crypto_alg_list
, cra_list
) {
172 err
= crypto_report_alg(alg
, &info
);
183 static int crypto_dump_report_done(struct netlink_callback
*cb
)
188 static int crypto_update_alg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
189 struct nlattr
**attrs
)
191 struct crypto_alg
*alg
;
192 struct crypto_user_alg
*p
= nlmsg_data(nlh
);
193 struct nlattr
*priority
= attrs
[CRYPTOCFGA_PRIORITY_VAL
];
196 if (priority
&& !strlen(p
->cru_driver_name
))
199 alg
= crypto_alg_match(p
, 1);
203 down_write(&crypto_alg_sem
);
205 crypto_remove_spawns(alg
, &list
, NULL
);
208 alg
->cra_priority
= nla_get_u32(priority
);
210 up_write(&crypto_alg_sem
);
212 crypto_remove_final(&list
);
217 static int crypto_del_alg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
218 struct nlattr
**attrs
)
220 struct crypto_alg
*alg
;
221 struct crypto_user_alg
*p
= nlmsg_data(nlh
);
223 alg
= crypto_alg_match(p
, 1);
227 /* We can not unregister core algorithms such as aes-generic.
228 * We would loose the reference in the crypto_alg_list to this algorithm
229 * if we try to unregister. Unregistering such an algorithm without
230 * removing the module is not possible, so we restrict to crypto
231 * instances that are build from templates. */
232 if (!(alg
->cra_flags
& CRYPTO_ALG_INSTANCE
))
235 if (atomic_read(&alg
->cra_refcnt
) != 1)
238 return crypto_unregister_alg(alg
);
241 static int crypto_add_alg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
242 struct nlattr
**attrs
)
246 struct crypto_alg
*alg
;
247 struct crypto_user_alg
*p
= nlmsg_data(nlh
);
248 struct nlattr
*priority
= attrs
[CRYPTOCFGA_PRIORITY_VAL
];
250 if (strlen(p
->cru_driver_name
))
253 if (priority
&& !exact
)
256 alg
= crypto_alg_match(p
, exact
);
260 if (strlen(p
->cru_driver_name
))
261 name
= p
->cru_driver_name
;
265 alg
= crypto_alg_mod_lookup(name
, p
->cru_type
, p
->cru_mask
);
269 down_write(&crypto_alg_sem
);
272 alg
->cra_priority
= nla_get_u32(priority
);
274 up_write(&crypto_alg_sem
);
281 #define MSGSIZE(type) sizeof(struct type)
283 static const int crypto_msg_min
[CRYPTO_NR_MSGTYPES
] = {
284 [CRYPTO_MSG_NEWALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
285 [CRYPTO_MSG_DELALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
286 [CRYPTO_MSG_UPDATEALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
287 [CRYPTO_MSG_GETALG
- CRYPTO_MSG_BASE
] = MSGSIZE(crypto_user_alg
),
290 static const struct nla_policy crypto_policy
[CRYPTOCFGA_MAX
+1] = {
291 [CRYPTOCFGA_PRIORITY_VAL
] = { .type
= NLA_U32
},
296 static struct crypto_link
{
297 int (*doit
)(struct sk_buff
*, struct nlmsghdr
*, struct nlattr
**);
298 int (*dump
)(struct sk_buff
*, struct netlink_callback
*);
299 int (*done
)(struct netlink_callback
*);
300 } crypto_dispatch
[CRYPTO_NR_MSGTYPES
] = {
301 [CRYPTO_MSG_NEWALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_add_alg
},
302 [CRYPTO_MSG_DELALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_del_alg
},
303 [CRYPTO_MSG_UPDATEALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_update_alg
},
304 [CRYPTO_MSG_GETALG
- CRYPTO_MSG_BASE
] = { .doit
= crypto_report
,
305 .dump
= crypto_dump_report
,
306 .done
= crypto_dump_report_done
},
309 static int crypto_user_rcv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
311 struct nlattr
*attrs
[CRYPTOCFGA_MAX
+1];
312 struct crypto_link
*link
;
315 type
= nlh
->nlmsg_type
;
316 if (type
> CRYPTO_MSG_MAX
)
319 type
-= CRYPTO_MSG_BASE
;
320 link
= &crypto_dispatch
[type
];
322 if (security_netlink_recv(skb
, CAP_NET_ADMIN
))
325 if ((type
== (CRYPTO_MSG_GETALG
- CRYPTO_MSG_BASE
) &&
326 (nlh
->nlmsg_flags
& NLM_F_DUMP
))) {
327 if (link
->dump
== NULL
)
330 return netlink_dump_start(crypto_nlsk
, skb
, nlh
,
331 link
->dump
, link
->done
, 0);
334 err
= nlmsg_parse(nlh
, crypto_msg_min
[type
], attrs
, CRYPTOCFGA_MAX
,
339 if (link
->doit
== NULL
)
342 return link
->doit(skb
, nlh
, attrs
);
345 static void crypto_netlink_rcv(struct sk_buff
*skb
)
347 mutex_lock(&crypto_cfg_mutex
);
348 netlink_rcv_skb(skb
, &crypto_user_rcv_msg
);
349 mutex_unlock(&crypto_cfg_mutex
);
352 static int __init
crypto_user_init(void)
354 crypto_nlsk
= netlink_kernel_create(&init_net
, NETLINK_CRYPTO
,
355 0, crypto_netlink_rcv
,
363 static void __exit
crypto_user_exit(void)
365 netlink_kernel_release(crypto_nlsk
);
368 module_init(crypto_user_init
);
369 module_exit(crypto_user_exit
);
370 MODULE_LICENSE("GPL");
371 MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>");
372 MODULE_DESCRIPTION("Crypto userspace configuration API");
This page took 0.039 seconds and 6 git commands to generate.