18ff59090SHerbert Xu /* 28ff59090SHerbert Xu * algif_skcipher: User-space interface for skcipher algorithms 38ff59090SHerbert Xu * 48ff59090SHerbert Xu * This file provides the user-space API for symmetric key ciphers. 58ff59090SHerbert Xu * 68ff59090SHerbert Xu * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au> 78ff59090SHerbert Xu * 88ff59090SHerbert Xu * This program is free software; you can redistribute it and/or modify it 98ff59090SHerbert Xu * under the terms of the GNU General Public License as published by the Free 108ff59090SHerbert Xu * Software Foundation; either version 2 of the License, or (at your option) 118ff59090SHerbert Xu * any later version. 128ff59090SHerbert Xu * 13e870456dSStephan Mueller * The following concept of the memory management is used: 14e870456dSStephan Mueller * 15e870456dSStephan Mueller * The kernel maintains two SGLs, the TX SGL and the RX SGL. The TX SGL is 16e870456dSStephan Mueller * filled by user space with the data submitted via sendpage/sendmsg. Filling 17e870456dSStephan Mueller * up the TX SGL does not cause a crypto operation -- the data will only be 18e870456dSStephan Mueller * tracked by the kernel. Upon receipt of one recvmsg call, the caller must 19e870456dSStephan Mueller * provide a buffer which is tracked with the RX SGL. 20e870456dSStephan Mueller * 21e870456dSStephan Mueller * During the processing of the recvmsg operation, the cipher request is 22e870456dSStephan Mueller * allocated and prepared. As part of the recvmsg operation, the processed 23e870456dSStephan Mueller * TX buffers are extracted from the TX SGL into a separate SGL. 24e870456dSStephan Mueller * 25e870456dSStephan Mueller * After the completion of the crypto operation, the RX SGL and the cipher 26e870456dSStephan Mueller * request is released. The extracted TX SGL parts are released together with 27e870456dSStephan Mueller * the RX SGL release. 288ff59090SHerbert Xu */ 298ff59090SHerbert Xu 308ff59090SHerbert Xu #include <crypto/scatterwalk.h> 318ff59090SHerbert Xu #include <crypto/skcipher.h> 328ff59090SHerbert Xu #include <crypto/if_alg.h> 338ff59090SHerbert Xu #include <linux/init.h> 348ff59090SHerbert Xu #include <linux/list.h> 358ff59090SHerbert Xu #include <linux/kernel.h> 368ff59090SHerbert Xu #include <linux/mm.h> 378ff59090SHerbert Xu #include <linux/module.h> 388ff59090SHerbert Xu #include <linux/net.h> 398ff59090SHerbert Xu #include <net/sock.h> 408ff59090SHerbert Xu 411b784140SYing Xue static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg, 421b784140SYing Xue size_t size) 438ff59090SHerbert Xu { 448ff59090SHerbert Xu struct sock *sk = sock->sk; 458ff59090SHerbert Xu struct alg_sock *ask = alg_sk(sk); 466454c2b8SHerbert Xu struct sock *psk = ask->parent; 476454c2b8SHerbert Xu struct alg_sock *pask = alg_sk(psk); 48f8d33facSEric Biggers struct crypto_skcipher *tfm = pask->private; 490d96e4baSHerbert Xu unsigned ivsize = crypto_skcipher_ivsize(tfm); 508ff59090SHerbert Xu 512d97591eSStephan Mueller return af_alg_sendmsg(sock, msg, size, ivsize); 52a596999bSTadeusz Struk } 53a596999bSTadeusz Struk 54e870456dSStephan Mueller static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg, 55e870456dSStephan Mueller size_t ignored, int flags) 56a596999bSTadeusz Struk { 57a596999bSTadeusz Struk struct sock *sk = sock->sk; 58a596999bSTadeusz Struk struct alg_sock *ask = alg_sk(sk); 59ec69bbfbSHerbert Xu struct sock *psk = ask->parent; 60ec69bbfbSHerbert Xu struct alg_sock *pask = alg_sk(psk); 612d97591eSStephan Mueller struct af_alg_ctx *ctx = ask->private; 62f8d33facSEric Biggers struct crypto_skcipher *tfm = pask->private; 63e870456dSStephan Mueller unsigned int bs = crypto_skcipher_blocksize(tfm); 642d97591eSStephan Mueller struct af_alg_async_req *areq; 65e870456dSStephan Mueller int err = 0; 66e870456dSStephan Mueller size_t len = 0; 67ec69bbfbSHerbert Xu 6811edb555SStephan Mueller if (!ctx->used) { 6911edb555SStephan Mueller err = af_alg_wait_for_data(sk, flags); 7011edb555SStephan Mueller if (err) 7111edb555SStephan Mueller return err; 7211edb555SStephan Mueller } 7311edb555SStephan Mueller 74e870456dSStephan Mueller /* Allocate cipher request for current operation. */ 752d97591eSStephan Mueller areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) + 762d97591eSStephan Mueller crypto_skcipher_reqsize(tfm)); 772d97591eSStephan Mueller if (IS_ERR(areq)) 782d97591eSStephan Mueller return PTR_ERR(areq); 79ec69bbfbSHerbert Xu 80e870456dSStephan Mueller /* convert iovecs of output buffers into RX SGL */ 812d97591eSStephan Mueller err = af_alg_get_rsgl(sk, msg, flags, areq, -1, &len); 82a596999bSTadeusz Struk if (err) 83a596999bSTadeusz Struk goto free; 84a596999bSTadeusz Struk 85e870456dSStephan Mueller /* Process only as much RX buffers for which we have TX data */ 86e870456dSStephan Mueller if (len > ctx->used) 87e870456dSStephan Mueller len = ctx->used; 88033f46b3Stadeusz.struk@intel.com 89e870456dSStephan Mueller /* 90e870456dSStephan Mueller * If more buffers are to be expected to be processed, process only 91e870456dSStephan Mueller * full block size buffers. 92e870456dSStephan Mueller */ 93e870456dSStephan Mueller if (ctx->more || len < ctx->used) 94e870456dSStephan Mueller len -= len % bs; 95a596999bSTadeusz Struk 96e870456dSStephan Mueller /* 97e870456dSStephan Mueller * Create a per request TX SGL for this request which tracks the 98e870456dSStephan Mueller * SG entries from the global TX SGL. 99e870456dSStephan Mueller */ 1002d97591eSStephan Mueller areq->tsgl_entries = af_alg_count_tsgl(sk, len, 0); 101e870456dSStephan Mueller if (!areq->tsgl_entries) 102e870456dSStephan Mueller areq->tsgl_entries = 1; 103e870456dSStephan Mueller areq->tsgl = sock_kmalloc(sk, sizeof(*areq->tsgl) * areq->tsgl_entries, 104e870456dSStephan Mueller GFP_KERNEL); 105e870456dSStephan Mueller if (!areq->tsgl) { 106e870456dSStephan Mueller err = -ENOMEM; 107bc97e57eSHerbert Xu goto free; 108e870456dSStephan Mueller } 109e870456dSStephan Mueller sg_init_table(areq->tsgl, areq->tsgl_entries); 1102d97591eSStephan Mueller af_alg_pull_tsgl(sk, len, areq->tsgl, 0); 1118ff59090SHerbert Xu 112e870456dSStephan Mueller /* Initialize the crypto operation */ 1132d97591eSStephan Mueller skcipher_request_set_tfm(&areq->cra_u.skcipher_req, tfm); 1142d97591eSStephan Mueller skcipher_request_set_crypt(&areq->cra_u.skcipher_req, areq->tsgl, 1152d97591eSStephan Mueller areq->first_rsgl.sgl.sg, len, ctx->iv); 1164f0414e5SHerbert Xu 117e870456dSStephan Mueller if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) { 118e870456dSStephan Mueller /* AIO operation */ 1197d2c3f54SStephan Mueller sock_hold(sk); 120e870456dSStephan Mueller areq->iocb = msg->msg_iocb; 121d53c5135SStephan Mueller 122d53c5135SStephan Mueller /* Remember output size that will be generated. */ 123d53c5135SStephan Mueller areq->outlen = len; 124d53c5135SStephan Mueller 1252d97591eSStephan Mueller skcipher_request_set_callback(&areq->cra_u.skcipher_req, 126e870456dSStephan Mueller CRYPTO_TFM_REQ_MAY_SLEEP, 1272d97591eSStephan Mueller af_alg_async_cb, areq); 1282d97591eSStephan Mueller err = ctx->enc ? 1292d97591eSStephan Mueller crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) : 1302d97591eSStephan Mueller crypto_skcipher_decrypt(&areq->cra_u.skcipher_req); 1317d2c3f54SStephan Mueller 1327d2c3f54SStephan Mueller /* AIO operation in progress */ 133d53c5135SStephan Mueller if (err == -EINPROGRESS || err == -EBUSY) 1347d2c3f54SStephan Mueller return -EIOCBQUEUED; 1357d2c3f54SStephan Mueller 1367d2c3f54SStephan Mueller sock_put(sk); 137e870456dSStephan Mueller } else { 138e870456dSStephan Mueller /* Synchronous operation */ 1392d97591eSStephan Mueller skcipher_request_set_callback(&areq->cra_u.skcipher_req, 140e870456dSStephan Mueller CRYPTO_TFM_REQ_MAY_SLEEP | 141e870456dSStephan Mueller CRYPTO_TFM_REQ_MAY_BACKLOG, 1422c3f8b16SGilad Ben-Yossef crypto_req_done, &ctx->wait); 1432c3f8b16SGilad Ben-Yossef err = crypto_wait_req(ctx->enc ? 1442d97591eSStephan Mueller crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) : 1452d97591eSStephan Mueller crypto_skcipher_decrypt(&areq->cra_u.skcipher_req), 1462c3f8b16SGilad Ben-Yossef &ctx->wait); 1478ff59090SHerbert Xu } 1488ff59090SHerbert Xu 1498ff59090SHerbert Xu 150e870456dSStephan Mueller free: 1517d2c3f54SStephan Mueller af_alg_free_resources(areq); 1528ff59090SHerbert Xu 153e870456dSStephan Mueller return err ? err : len; 1548ff59090SHerbert Xu } 1558ff59090SHerbert Xu 156a596999bSTadeusz Struk static int skcipher_recvmsg(struct socket *sock, struct msghdr *msg, 157a596999bSTadeusz Struk size_t ignored, int flags) 158a596999bSTadeusz Struk { 159e870456dSStephan Mueller struct sock *sk = sock->sk; 160e870456dSStephan Mueller int ret = 0; 161e870456dSStephan Mueller 162e870456dSStephan Mueller lock_sock(sk); 163e870456dSStephan Mueller while (msg_data_left(msg)) { 164e870456dSStephan Mueller int err = _skcipher_recvmsg(sock, msg, ignored, flags); 165e870456dSStephan Mueller 166e870456dSStephan Mueller /* 167e870456dSStephan Mueller * This error covers -EIOCBQUEUED which implies that we can 168e870456dSStephan Mueller * only handle one AIO request. If the caller wants to have 169e870456dSStephan Mueller * multiple AIO requests in parallel, he must make multiple 170e870456dSStephan Mueller * separate AIO calls. 1715703c826SStephan Mueller * 1725703c826SStephan Mueller * Also return the error if no data has been processed so far. 173e870456dSStephan Mueller */ 174e870456dSStephan Mueller if (err <= 0) { 1755703c826SStephan Mueller if (err == -EIOCBQUEUED || !ret) 176e870456dSStephan Mueller ret = err; 177e870456dSStephan Mueller goto out; 178e870456dSStephan Mueller } 179e870456dSStephan Mueller 180e870456dSStephan Mueller ret += err; 181e870456dSStephan Mueller } 182e870456dSStephan Mueller 183e870456dSStephan Mueller out: 1842d97591eSStephan Mueller af_alg_wmem_wakeup(sk); 185e870456dSStephan Mueller release_sock(sk); 186e870456dSStephan Mueller return ret; 187a596999bSTadeusz Struk } 1888ff59090SHerbert Xu 1898ff59090SHerbert Xu static struct proto_ops algif_skcipher_ops = { 1908ff59090SHerbert Xu .family = PF_ALG, 1918ff59090SHerbert Xu 1928ff59090SHerbert Xu .connect = sock_no_connect, 1938ff59090SHerbert Xu .socketpair = sock_no_socketpair, 1948ff59090SHerbert Xu .getname = sock_no_getname, 1958ff59090SHerbert Xu .ioctl = sock_no_ioctl, 1968ff59090SHerbert Xu .listen = sock_no_listen, 1978ff59090SHerbert Xu .shutdown = sock_no_shutdown, 1988ff59090SHerbert Xu .getsockopt = sock_no_getsockopt, 1998ff59090SHerbert Xu .mmap = sock_no_mmap, 2008ff59090SHerbert Xu .bind = sock_no_bind, 2018ff59090SHerbert Xu .accept = sock_no_accept, 2028ff59090SHerbert Xu .setsockopt = sock_no_setsockopt, 2038ff59090SHerbert Xu 2048ff59090SHerbert Xu .release = af_alg_release, 2058ff59090SHerbert Xu .sendmsg = skcipher_sendmsg, 2062d97591eSStephan Mueller .sendpage = af_alg_sendpage, 2078ff59090SHerbert Xu .recvmsg = skcipher_recvmsg, 208*b28fc822SChristoph Hellwig .poll_mask = af_alg_poll_mask, 2098ff59090SHerbert Xu }; 2108ff59090SHerbert Xu 211a0fa2d03SHerbert Xu static int skcipher_check_key(struct socket *sock) 212a0fa2d03SHerbert Xu { 2131822793aSHerbert Xu int err = 0; 214a0fa2d03SHerbert Xu struct sock *psk; 215a0fa2d03SHerbert Xu struct alg_sock *pask; 216f8d33facSEric Biggers struct crypto_skcipher *tfm; 217a0fa2d03SHerbert Xu struct sock *sk = sock->sk; 218a0fa2d03SHerbert Xu struct alg_sock *ask = alg_sk(sk); 219a0fa2d03SHerbert Xu 2201822793aSHerbert Xu lock_sock(sk); 221a0fa2d03SHerbert Xu if (ask->refcnt) 2221822793aSHerbert Xu goto unlock_child; 223a0fa2d03SHerbert Xu 224a0fa2d03SHerbert Xu psk = ask->parent; 225a0fa2d03SHerbert Xu pask = alg_sk(ask->parent); 226a0fa2d03SHerbert Xu tfm = pask->private; 227a0fa2d03SHerbert Xu 228a0fa2d03SHerbert Xu err = -ENOKEY; 2291822793aSHerbert Xu lock_sock_nested(psk, SINGLE_DEPTH_NESTING); 230f8d33facSEric Biggers if (crypto_skcipher_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) 231a0fa2d03SHerbert Xu goto unlock; 232a0fa2d03SHerbert Xu 233a0fa2d03SHerbert Xu if (!pask->refcnt++) 234a0fa2d03SHerbert Xu sock_hold(psk); 235a0fa2d03SHerbert Xu 236a0fa2d03SHerbert Xu ask->refcnt = 1; 237a0fa2d03SHerbert Xu sock_put(psk); 238a0fa2d03SHerbert Xu 239a0fa2d03SHerbert Xu err = 0; 240a0fa2d03SHerbert Xu 241a0fa2d03SHerbert Xu unlock: 242a0fa2d03SHerbert Xu release_sock(psk); 2431822793aSHerbert Xu unlock_child: 2441822793aSHerbert Xu release_sock(sk); 245a0fa2d03SHerbert Xu 246a0fa2d03SHerbert Xu return err; 247a0fa2d03SHerbert Xu } 248a0fa2d03SHerbert Xu 249a0fa2d03SHerbert Xu static int skcipher_sendmsg_nokey(struct socket *sock, struct msghdr *msg, 250a0fa2d03SHerbert Xu size_t size) 251a0fa2d03SHerbert Xu { 252a0fa2d03SHerbert Xu int err; 253a0fa2d03SHerbert Xu 254a0fa2d03SHerbert Xu err = skcipher_check_key(sock); 255a0fa2d03SHerbert Xu if (err) 256a0fa2d03SHerbert Xu return err; 257a0fa2d03SHerbert Xu 258a0fa2d03SHerbert Xu return skcipher_sendmsg(sock, msg, size); 259a0fa2d03SHerbert Xu } 260a0fa2d03SHerbert Xu 261a0fa2d03SHerbert Xu static ssize_t skcipher_sendpage_nokey(struct socket *sock, struct page *page, 262a0fa2d03SHerbert Xu int offset, size_t size, int flags) 263a0fa2d03SHerbert Xu { 264a0fa2d03SHerbert Xu int err; 265a0fa2d03SHerbert Xu 266a0fa2d03SHerbert Xu err = skcipher_check_key(sock); 267a0fa2d03SHerbert Xu if (err) 268a0fa2d03SHerbert Xu return err; 269a0fa2d03SHerbert Xu 2702d97591eSStephan Mueller return af_alg_sendpage(sock, page, offset, size, flags); 271a0fa2d03SHerbert Xu } 272a0fa2d03SHerbert Xu 273a0fa2d03SHerbert Xu static int skcipher_recvmsg_nokey(struct socket *sock, struct msghdr *msg, 274a0fa2d03SHerbert Xu size_t ignored, int flags) 275a0fa2d03SHerbert Xu { 276a0fa2d03SHerbert Xu int err; 277a0fa2d03SHerbert Xu 278a0fa2d03SHerbert Xu err = skcipher_check_key(sock); 279a0fa2d03SHerbert Xu if (err) 280a0fa2d03SHerbert Xu return err; 281a0fa2d03SHerbert Xu 282a0fa2d03SHerbert Xu return skcipher_recvmsg(sock, msg, ignored, flags); 283a0fa2d03SHerbert Xu } 284a0fa2d03SHerbert Xu 285a0fa2d03SHerbert Xu static struct proto_ops algif_skcipher_ops_nokey = { 286a0fa2d03SHerbert Xu .family = PF_ALG, 287a0fa2d03SHerbert Xu 288a0fa2d03SHerbert Xu .connect = sock_no_connect, 289a0fa2d03SHerbert Xu .socketpair = sock_no_socketpair, 290a0fa2d03SHerbert Xu .getname = sock_no_getname, 291a0fa2d03SHerbert Xu .ioctl = sock_no_ioctl, 292a0fa2d03SHerbert Xu .listen = sock_no_listen, 293a0fa2d03SHerbert Xu .shutdown = sock_no_shutdown, 294a0fa2d03SHerbert Xu .getsockopt = sock_no_getsockopt, 295a0fa2d03SHerbert Xu .mmap = sock_no_mmap, 296a0fa2d03SHerbert Xu .bind = sock_no_bind, 297a0fa2d03SHerbert Xu .accept = sock_no_accept, 298a0fa2d03SHerbert Xu .setsockopt = sock_no_setsockopt, 299a0fa2d03SHerbert Xu 300a0fa2d03SHerbert Xu .release = af_alg_release, 301a0fa2d03SHerbert Xu .sendmsg = skcipher_sendmsg_nokey, 302a0fa2d03SHerbert Xu .sendpage = skcipher_sendpage_nokey, 303a0fa2d03SHerbert Xu .recvmsg = skcipher_recvmsg_nokey, 304*b28fc822SChristoph Hellwig .poll_mask = af_alg_poll_mask, 305a0fa2d03SHerbert Xu }; 306a0fa2d03SHerbert Xu 3078ff59090SHerbert Xu static void *skcipher_bind(const char *name, u32 type, u32 mask) 3088ff59090SHerbert Xu { 309f8d33facSEric Biggers return crypto_alloc_skcipher(name, type, mask); 3108ff59090SHerbert Xu } 3118ff59090SHerbert Xu 3128ff59090SHerbert Xu static void skcipher_release(void *private) 3138ff59090SHerbert Xu { 314f8d33facSEric Biggers crypto_free_skcipher(private); 3158ff59090SHerbert Xu } 3168ff59090SHerbert Xu 3178ff59090SHerbert Xu static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen) 3188ff59090SHerbert Xu { 319f8d33facSEric Biggers return crypto_skcipher_setkey(private, key, keylen); 3208ff59090SHerbert Xu } 3218ff59090SHerbert Xu 3228ff59090SHerbert Xu static void skcipher_sock_destruct(struct sock *sk) 3238ff59090SHerbert Xu { 3248ff59090SHerbert Xu struct alg_sock *ask = alg_sk(sk); 3252d97591eSStephan Mueller struct af_alg_ctx *ctx = ask->private; 326e870456dSStephan Mueller struct sock *psk = ask->parent; 327e870456dSStephan Mueller struct alg_sock *pask = alg_sk(psk); 328f8d33facSEric Biggers struct crypto_skcipher *tfm = pask->private; 3298ff59090SHerbert Xu 3302d97591eSStephan Mueller af_alg_pull_tsgl(sk, ctx->used, NULL, 0); 3310d96e4baSHerbert Xu sock_kzfree_s(sk, ctx->iv, crypto_skcipher_ivsize(tfm)); 3328ff59090SHerbert Xu sock_kfree_s(sk, ctx, ctx->len); 3338ff59090SHerbert Xu af_alg_release_parent(sk); 3348ff59090SHerbert Xu } 3358ff59090SHerbert Xu 336d7b65aeeSHerbert Xu static int skcipher_accept_parent_nokey(void *private, struct sock *sk) 3378ff59090SHerbert Xu { 3382d97591eSStephan Mueller struct af_alg_ctx *ctx; 3398ff59090SHerbert Xu struct alg_sock *ask = alg_sk(sk); 340f8d33facSEric Biggers struct crypto_skcipher *tfm = private; 341e870456dSStephan Mueller unsigned int len = sizeof(*ctx); 3428ff59090SHerbert Xu 3438ff59090SHerbert Xu ctx = sock_kmalloc(sk, len, GFP_KERNEL); 3448ff59090SHerbert Xu if (!ctx) 3458ff59090SHerbert Xu return -ENOMEM; 3468ff59090SHerbert Xu 347f8d33facSEric Biggers ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(tfm), 3488ff59090SHerbert Xu GFP_KERNEL); 3498ff59090SHerbert Xu if (!ctx->iv) { 3508ff59090SHerbert Xu sock_kfree_s(sk, ctx, len); 3518ff59090SHerbert Xu return -ENOMEM; 3528ff59090SHerbert Xu } 3538ff59090SHerbert Xu 354f8d33facSEric Biggers memset(ctx->iv, 0, crypto_skcipher_ivsize(tfm)); 3558ff59090SHerbert Xu 356e870456dSStephan Mueller INIT_LIST_HEAD(&ctx->tsgl_list); 3578ff59090SHerbert Xu ctx->len = len; 3588ff59090SHerbert Xu ctx->used = 0; 359af955bf1SJonathan Cameron atomic_set(&ctx->rcvused, 0); 3608ff59090SHerbert Xu ctx->more = 0; 3618ff59090SHerbert Xu ctx->merge = 0; 3628ff59090SHerbert Xu ctx->enc = 0; 3632c3f8b16SGilad Ben-Yossef crypto_init_wait(&ctx->wait); 3648ff59090SHerbert Xu 3658ff59090SHerbert Xu ask->private = ctx; 3668ff59090SHerbert Xu 3678ff59090SHerbert Xu sk->sk_destruct = skcipher_sock_destruct; 3688ff59090SHerbert Xu 3698ff59090SHerbert Xu return 0; 3708ff59090SHerbert Xu } 3718ff59090SHerbert Xu 372a0fa2d03SHerbert Xu static int skcipher_accept_parent(void *private, struct sock *sk) 373a0fa2d03SHerbert Xu { 374f8d33facSEric Biggers struct crypto_skcipher *tfm = private; 375a0fa2d03SHerbert Xu 376f8d33facSEric Biggers if (crypto_skcipher_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) 377a0fa2d03SHerbert Xu return -ENOKEY; 378a0fa2d03SHerbert Xu 379d7b65aeeSHerbert Xu return skcipher_accept_parent_nokey(private, sk); 380a0fa2d03SHerbert Xu } 381a0fa2d03SHerbert Xu 3828ff59090SHerbert Xu static const struct af_alg_type algif_type_skcipher = { 3838ff59090SHerbert Xu .bind = skcipher_bind, 3848ff59090SHerbert Xu .release = skcipher_release, 3858ff59090SHerbert Xu .setkey = skcipher_setkey, 3868ff59090SHerbert Xu .accept = skcipher_accept_parent, 387a0fa2d03SHerbert Xu .accept_nokey = skcipher_accept_parent_nokey, 3888ff59090SHerbert Xu .ops = &algif_skcipher_ops, 389a0fa2d03SHerbert Xu .ops_nokey = &algif_skcipher_ops_nokey, 3908ff59090SHerbert Xu .name = "skcipher", 3918ff59090SHerbert Xu .owner = THIS_MODULE 3928ff59090SHerbert Xu }; 3938ff59090SHerbert Xu 3948ff59090SHerbert Xu static int __init algif_skcipher_init(void) 3958ff59090SHerbert Xu { 3968ff59090SHerbert Xu return af_alg_register_type(&algif_type_skcipher); 3978ff59090SHerbert Xu } 3988ff59090SHerbert Xu 3998ff59090SHerbert Xu static void __exit algif_skcipher_exit(void) 4008ff59090SHerbert Xu { 4018ff59090SHerbert Xu int err = af_alg_unregister_type(&algif_type_skcipher); 4028ff59090SHerbert Xu BUG_ON(err); 4038ff59090SHerbert Xu } 4048ff59090SHerbert Xu 4058ff59090SHerbert Xu module_init(algif_skcipher_init); 4068ff59090SHerbert Xu module_exit(algif_skcipher_exit); 4078ff59090SHerbert Xu MODULE_LICENSE("GPL"); 408