linux-imx

/*

 * algif_skcipher: User-space interface for skcipher algorithms

 *

 * This file provides the user-space API for symmetric key ciphers.

 *

 * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published by the Free

 * Software Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * The following concept of the memory management is used:

 *

 * The kernel maintains two SGLs, the TX SGL and the RX SGL. The TX SGL is

 * filled by user space with the data submitted via sendpage/sendmsg. Filling

 * up the TX SGL does not cause a crypto operation -- the data will only be

 * tracked by the kernel. Upon receipt of one recvmsg call, the caller must

 * provide a buffer which is tracked with the RX SGL.

 *

 * During the processing of the recvmsg operation, the cipher request is

 * allocated and prepared. As part of the recvmsg operation, the processed

 * TX buffers are extracted from the TX SGL into a separate SGL.

 *

 * After the completion of the crypto operation, the RX SGL and the cipher

 * request is released. The extracted TX SGL parts are released together with

 * the RX SGL release.

 */

​

#include <crypto/scatterwalk.h>

#include <crypto/skcipher.h>

#include <crypto/if_alg.h>

#include <linux/init.h>

#include <linux/list.h>

#include <linux/kernel.h>

#include <linux/mm.h>

#include <linux/module.h>

#include <linux/net.h>

#include <net/sock.h>

​

static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg,

                size_t size)

{

    struct sock *sk = sock->sk;

    struct alg_sock *ask = alg_sk(sk);

    struct sock *psk = ask->parent;

    struct alg_sock *pask = alg_sk(psk);

    struct crypto_skcipher *tfm = pask->private;

    unsigned ivsize = crypto_skcipher_ivsize(tfm);

​

    return af_alg_sendmsg(sock, msg, size, ivsize);

}

​

static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg,

                 size_t ignored, int flags)

{

    struct sock *sk = sock->sk;

    struct alg_sock *ask = alg_sk(sk);

    struct sock *psk = ask->parent;

    struct alg_sock *pask = alg_sk(psk);

    struct af_alg_ctx *ctx = ask->private;

    struct crypto_skcipher *tfm = pask->private;

    unsigned int bs = crypto_skcipher_blocksize(tfm);

    struct af_alg_async_req *areq;

    int err = 0;

    size_t len = 0;

​

    if (!ctx->used) {

        err = af_alg_wait_for_data(sk, flags);

        if (err)

            return err;

    }

​

    /* Allocate cipher request for current operation. */

    areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) +

                     crypto_skcipher_reqsize(tfm));

    if (IS_ERR(areq))

        return PTR_ERR(areq);

​

    /* convert iovecs of output buffers into RX SGL */

    err = af_alg_get_rsgl(sk, msg, flags, areq, -1, &len);

    if (err)

        goto free;

​

    /* Process only as much RX buffers for which we have TX data */

    if (len > ctx->used)

        len = ctx->used;

​

    /*

     * If more buffers are to be expected to be processed, process only

     * full block size buffers.

     */