Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/crypto/af_alg.c

  1 /*
  2  * af_alg: User-space algorithm interface
  3  *
  4  * This file provides the user-space API for algorithms.
  5  *
  6  * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
  7  *
  8  * This program is free software; you can redistribute it and/or modify it
  9  * under the terms of the GNU General Public License as published by the Free
 10  * Software Foundation; either version 2 of the License, or (at your option)
 11  * any later version.
 12  *
 13  */
 14 
 15 #include <linux/atomic.h>
 16 #include <crypto/if_alg.h>
 17 #include <linux/crypto.h>
 18 #include <linux/init.h>
 19 #include <linux/kernel.h>
 20 #include <linux/list.h>
 21 #include <linux/module.h>
 22 #include <linux/net.h>
 23 #include <linux/rwsem.h>
 24 #include <linux/security.h>
 25 
 26 struct alg_type_list {
 27         const struct af_alg_type *type;
 28         struct list_head list;
 29 };
 30 
 31 static atomic_long_t alg_memory_allocated;
 32 
 33 static struct proto alg_proto = {
 34         .name                   = "ALG",
 35         .owner                  = THIS_MODULE,
 36         .memory_allocated       = &alg_memory_allocated,
 37         .obj_size               = sizeof(struct alg_sock),
 38 };
 39 
 40 static LIST_HEAD(alg_types);
 41 static DECLARE_RWSEM(alg_types_sem);
 42 
 43 static const struct af_alg_type *alg_get_type(const char *name)
 44 {
 45         const struct af_alg_type *type = ERR_PTR(-ENOENT);
 46         struct alg_type_list *node;
 47 
 48         down_read(&alg_types_sem);
 49         list_for_each_entry(node, &alg_types, list) {
 50                 if (strcmp(node->type->name, name))
 51                         continue;
 52 
 53                 if (try_module_get(node->type->owner))
 54                         type = node->type;
 55                 break;
 56         }
 57         up_read(&alg_types_sem);
 58 
 59         return type;
 60 }
 61 
 62 int af_alg_register_type(const struct af_alg_type *type)
 63 {
 64         struct alg_type_list *node;
 65         int err = -EEXIST;
 66 
 67         down_write(&alg_types_sem);
 68         list_for_each_entry(node, &alg_types, list) {
 69                 if (!strcmp(node->type->name, type->name))
 70                         goto unlock;
 71         }
 72 
 73         node = kmalloc(sizeof(*node), GFP_KERNEL);
 74         err = -ENOMEM;
 75         if (!node)
 76                 goto unlock;
 77 
 78         type->ops->owner = THIS_MODULE;
 79         if (type->ops_nokey)
 80                 type->ops_nokey->owner = THIS_MODULE;
 81         node->type = type;
 82         list_add(&node->list, &alg_types);
 83         err = 0;
 84 
 85 unlock:
 86         up_write(&alg_types_sem);
 87 
 88         return err;
 89 }
 90 EXPORT_SYMBOL_GPL(af_alg_register_type);
 91 
 92 int af_alg_unregister_type(const struct af_alg_type *type)
 93 {
 94         struct alg_type_list *node;
 95         int err = -ENOENT;
 96 
 97         down_write(&alg_types_sem);
 98         list_for_each_entry(node, &alg_types, list) {
 99                 if (strcmp(node->type->name, type->name))
100                         continue;
101 
102                 list_del(&node->list);
103                 kfree(node);
104                 err = 0;
105                 break;
106         }
107         up_write(&alg_types_sem);
108 
109         return err;
110 }
111 EXPORT_SYMBOL_GPL(af_alg_unregister_type);
112 
113 static void alg_do_release(const struct af_alg_type *type, void *private)
114 {
115         if (!type)
116                 return;
117 
118         type->release(private);
119         module_put(type->owner);
120 }
121 
122 int af_alg_release(struct socket *sock)
123 {
124         if (sock->sk)
125                 sock_put(sock->sk);
126         return 0;
127 }
128 EXPORT_SYMBOL_GPL(af_alg_release);
129 
130 void af_alg_release_parent(struct sock *sk)
131 {
132         struct alg_sock *ask = alg_sk(sk);
133         unsigned int nokey = ask->nokey_refcnt;
134         bool last = nokey && !ask->refcnt;
135 
136         sk = ask->parent;
137         ask = alg_sk(sk);
138 
139         lock_sock(sk);
140         ask->nokey_refcnt -= nokey;
141         if (!last)
142                 last = !--ask->refcnt;
143         release_sock(sk);
144 
145         if (last)
146                 sock_put(sk);
147 }
148 EXPORT_SYMBOL_GPL(af_alg_release_parent);
149 
150 static int alg_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
151 {
152         const u32 forbidden = CRYPTO_ALG_INTERNAL;
153         struct sock *sk = sock->sk;
154         struct alg_sock *ask = alg_sk(sk);
155         struct sockaddr_alg *sa = (void *)uaddr;
156         const struct af_alg_type *type;
157         void *private;
158         int err;
159 
160         if (sock->state == SS_CONNECTED)
161                 return -EINVAL;
162 
163         if (addr_len != sizeof(*sa))
164                 return -EINVAL;
165 
166         sa->salg_type[sizeof(sa->salg_type) - 1] = 0;
167         sa->salg_name[sizeof(sa->salg_name) - 1] = 0;
168 
169         type = alg_get_type(sa->salg_type);
170         if (IS_ERR(type) && PTR_ERR(type) == -ENOENT) {
171                 request_module("algif-%s", sa->salg_type);
172                 type = alg_get_type(sa->salg_type);
173         }
174 
175         if (IS_ERR(type))
176                 return PTR_ERR(type);
177 
178         private = type->bind(sa->salg_name,
179                              sa->salg_feat & ~forbidden,
180                              sa->salg_mask & ~forbidden);
181         if (IS_ERR(private)) {
182                 module_put(type->owner);
183                 return PTR_ERR(private);
184         }
185 
186         err = -EBUSY;
187         lock_sock(sk);
188         if (ask->refcnt | ask->nokey_refcnt)
189                 goto unlock;
190 
191         swap(ask->type, type);
192         swap(ask->private, private);
193 
194         err = 0;
195 
196 unlock:
197         release_sock(sk);
198 
199         alg_do_release(type, private);
200 
201         return err;
202 }
203 
204 static int alg_setkey(struct sock *sk, char __user *ukey,
205                       unsigned int keylen)
206 {
207         struct alg_sock *ask = alg_sk(sk);
208         const struct af_alg_type *type = ask->type;
209         u8 *key;
210         int err;
211 
212         key = sock_kmalloc(sk, keylen, GFP_KERNEL);
213         if (!key)
214                 return -ENOMEM;
215 
216         err = -EFAULT;
217         if (copy_from_user(key, ukey, keylen))
218                 goto out;
219 
220         err = type->setkey(ask->private, key, keylen);
221 
222 out:
223         sock_kzfree_s(sk, key, keylen);
224 
225         return err;
226 }
227 
228 static int alg_setsockopt(struct socket *sock, int level, int optname,
229                           char __user *optval, unsigned int optlen)
230 {
231         struct sock *sk = sock->sk;
232         struct alg_sock *ask = alg_sk(sk);
233         const struct af_alg_type *type;
234         int err = -EBUSY;
235 
236         lock_sock(sk);
237         if (ask->refcnt)
238                 goto unlock;
239 
240         type = ask->type;
241 
242         err = -ENOPROTOOPT;
243         if (level != SOL_ALG || !type)
244                 goto unlock;
245 
246         switch (optname) {
247         case ALG_SET_KEY:
248                 if (sock->state == SS_CONNECTED)
249                         goto unlock;
250                 if (!type->setkey)
251                         goto unlock;
252 
253                 err = alg_setkey(sk, optval, optlen);
254                 break;
255         case ALG_SET_AEAD_AUTHSIZE:
256                 if (sock->state == SS_CONNECTED)
257                         goto unlock;
258                 if (!type->setauthsize)
259                         goto unlock;
260                 err = type->setauthsize(ask->private, optlen);
261         }
262 
263 unlock:
264         release_sock(sk);
265 
266         return err;
267 }
268 
269 int af_alg_accept(struct sock *sk, struct socket *newsock)
270 {
271         struct alg_sock *ask = alg_sk(sk);
272         const struct af_alg_type *type;
273         struct sock *sk2;
274         unsigned int nokey;
275         int err;
276 
277         lock_sock(sk);
278         type = ask->type;
279 
280         err = -EINVAL;
281         if (!type)
282                 goto unlock;
283 
284         sk2 = sk_alloc(sock_net(sk), PF_ALG, GFP_KERNEL, &alg_proto, 0);
285         err = -ENOMEM;
286         if (!sk2)
287                 goto unlock;
288 
289         sock_init_data(newsock, sk2);
290         sock_graft(sk2, newsock);
291         security_sk_clone(sk, sk2);
292 
293         err = type->accept(ask->private, sk2);
294 
295         nokey = err == -ENOKEY;
296         if (nokey && type->accept_nokey)
297                 err = type->accept_nokey(ask->private, sk2);
298 
299         if (err)
300                 goto unlock;
301 
302         sk2->sk_family = PF_ALG;
303 
304         if (nokey || !ask->refcnt++)
305                 sock_hold(sk);
306         ask->nokey_refcnt += nokey;
307         alg_sk(sk2)->parent = sk;
308         alg_sk(sk2)->type = type;
309         alg_sk(sk2)->nokey_refcnt = nokey;
310 
311         newsock->ops = type->ops;
312         newsock->state = SS_CONNECTED;
313 
314         if (nokey)
315                 newsock->ops = type->ops_nokey;
316 
317         err = 0;
318 
319 unlock:
320         release_sock(sk);
321 
322         return err;
323 }
324 EXPORT_SYMBOL_GPL(af_alg_accept);
325 
326 static int alg_accept(struct socket *sock, struct socket *newsock, int flags)
327 {
328         return af_alg_accept(sock->sk, newsock);
329 }
330 
331 static const struct proto_ops alg_proto_ops = {
332         .family         =       PF_ALG,
333         .owner          =       THIS_MODULE,
334 
335         .connect        =       sock_no_connect,
336         .socketpair     =       sock_no_socketpair,
337         .getname        =       sock_no_getname,
338         .ioctl          =       sock_no_ioctl,
339         .listen         =       sock_no_listen,
340         .shutdown       =       sock_no_shutdown,
341         .getsockopt     =       sock_no_getsockopt,
342         .mmap           =       sock_no_mmap,
343         .sendpage       =       sock_no_sendpage,
344         .sendmsg        =       sock_no_sendmsg,
345         .recvmsg        =       sock_no_recvmsg,
346         .poll           =       sock_no_poll,
347 
348         .bind           =       alg_bind,
349         .release        =       af_alg_release,
350         .setsockopt     =       alg_setsockopt,
351         .accept         =       alg_accept,
352 };
353 
354 static void alg_sock_destruct(struct sock *sk)
355 {
356         struct alg_sock *ask = alg_sk(sk);
357 
358         alg_do_release(ask->type, ask->private);
359 }
360 
361 static int alg_create(struct net *net, struct socket *sock, int protocol,
362                       int kern)
363 {
364         struct sock *sk;
365         int err;
366 
367         if (sock->type != SOCK_SEQPACKET)
368                 return -ESOCKTNOSUPPORT;
369         if (protocol != 0)
370                 return -EPROTONOSUPPORT;
371 
372         err = -ENOMEM;
373         sk = sk_alloc(net, PF_ALG, GFP_KERNEL, &alg_proto, kern);
374         if (!sk)
375                 goto out;
376 
377         sock->ops = &alg_proto_ops;
378         sock_init_data(sock, sk);
379 
380         sk->sk_family = PF_ALG;
381         sk->sk_destruct = alg_sock_destruct;
382 
383         return 0;
384 out:
385         return err;
386 }
387 
388 static const struct net_proto_family alg_family = {
389         .family =       PF_ALG,
390         .create =       alg_create,
391         .owner  =       THIS_MODULE,
392 };
393 
394 int af_alg_make_sg(struct af_alg_sgl *sgl, struct iov_iter *iter, int len)
395 {
396         size_t off;
397         ssize_t n;
398         int npages, i;
399 
400         n = iov_iter_get_pages(iter, sgl->pages, len, ALG_MAX_PAGES, &off);
401         if (n < 0)
402                 return n;
403 
404         npages = (off + n + PAGE_SIZE - 1) >> PAGE_SHIFT;
405         if (WARN_ON(npages == 0))
406                 return -EINVAL;
407         /* Add one extra for linking */
408         sg_init_table(sgl->sg, npages + 1);
409 
410         for (i = 0, len = n; i < npages; i++) {
411                 int plen = min_t(int, len, PAGE_SIZE - off);
412 
413                 sg_set_page(sgl->sg + i, sgl->pages[i], plen, off);
414 
415                 off = 0;
416                 len -= plen;
417         }
418         sg_mark_end(sgl->sg + npages - 1);
419         sgl->npages = npages;
420 
421         return n;
422 }
423 EXPORT_SYMBOL_GPL(af_alg_make_sg);
424 
425 void af_alg_link_sg(struct af_alg_sgl *sgl_prev, struct af_alg_sgl *sgl_new)
426 {
427         sg_unmark_end(sgl_prev->sg + sgl_prev->npages - 1);
428         sg_chain(sgl_prev->sg, sgl_prev->npages + 1, sgl_new->sg);
429 }
430 EXPORT_SYMBOL_GPL(af_alg_link_sg);
431 
432 void af_alg_free_sg(struct af_alg_sgl *sgl)
433 {
434         int i;
435 
436         for (i = 0; i < sgl->npages; i++)
437                 put_page(sgl->pages[i]);
438 }
439 EXPORT_SYMBOL_GPL(af_alg_free_sg);
440 
441 int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con)
442 {
443         struct cmsghdr *cmsg;
444 
445         for_each_cmsghdr(cmsg, msg) {
446                 if (!CMSG_OK(msg, cmsg))
447                         return -EINVAL;
448                 if (cmsg->cmsg_level != SOL_ALG)
449                         continue;
450 
451                 switch (cmsg->cmsg_type) {
452                 case ALG_SET_IV:
453                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(*con->iv)))
454                                 return -EINVAL;
455                         con->iv = (void *)CMSG_DATA(cmsg);
456                         if (cmsg->cmsg_len < CMSG_LEN(con->iv->ivlen +
457                                                       sizeof(*con->iv)))
458                                 return -EINVAL;
459                         break;
460 
461                 case ALG_SET_OP:
462                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
463                                 return -EINVAL;
464                         con->op = *(u32 *)CMSG_DATA(cmsg);
465                         break;
466 
467                 case ALG_SET_AEAD_ASSOCLEN:
468                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
469                                 return -EINVAL;
470                         con->aead_assoclen = *(u32 *)CMSG_DATA(cmsg);
471                         break;
472 
473                 default:
474                         return -EINVAL;
475                 }
476         }
477 
478         return 0;
479 }
480 EXPORT_SYMBOL_GPL(af_alg_cmsg_send);
481 
482 int af_alg_wait_for_completion(int err, struct af_alg_completion *completion)
483 {
484         switch (err) {
485         case -EINPROGRESS:
486         case -EBUSY:
487                 wait_for_completion(&completion->completion);
488                 reinit_completion(&completion->completion);
489                 err = completion->err;
490                 break;
491         };
492 
493         return err;
494 }
495 EXPORT_SYMBOL_GPL(af_alg_wait_for_completion);
496 
497 void af_alg_complete(struct crypto_async_request *req, int err)
498 {
499         struct af_alg_completion *completion = req->data;
500 
501         if (err == -EINPROGRESS)
502                 return;
503 
504         completion->err = err;
505         complete(&completion->completion);
506 }
507 EXPORT_SYMBOL_GPL(af_alg_complete);
508 
509 static int __init af_alg_init(void)
510 {
511         int err = proto_register(&alg_proto, 0);
512 
513         if (err)
514                 goto out;
515 
516         err = sock_register(&alg_family);
517         if (err != 0)
518                 goto out_unregister_proto;
519 
520 out:
521         return err;
522 
523 out_unregister_proto:
524         proto_unregister(&alg_proto);
525         goto out;
526 }
527 
528 static void __exit af_alg_exit(void)
529 {
530         sock_unregister(PF_ALG);
531         proto_unregister(&alg_proto);
532 }
533 
534 module_init(af_alg_init);
535 module_exit(af_alg_exit);
536 MODULE_LICENSE("GPL");
537 MODULE_ALIAS_NETPROTO(AF_ALG);
538 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us