/*      $NetBSD: ocryptodev.c,v 1.21 2026/07/05 15:34:13 riastradh Exp $ */
/*      $FreeBSD: src/sys/opencrypto/cryptodev.c,v 1.4.2.4 2003/06/03 00:09:02 sam Exp $        */
/*      $OpenBSD: cryptodev.c,v 1.53 2002/07/10 22:21:30 mickey Exp $   */

/*-
 * Copyright (c) 2008 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Coyote Point Systems, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Copyright (c) 2001 Theo de Raadt
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Effort sponsored in part by the Defense Advanced Research Projects
 * Agency (DARPA) and Air Force Research Laboratory, Air Force
 * Materiel Command, USAF, under agreement number F30602-01-2-0537.
 *
 */

/*
 * Implement backward compatibility IOCTLs in this module.
 *
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ocryptodev.c,v 1.21 2026/07/05 15:34:13 riastradh Exp $");

#include <sys/param.h>

#include <sys/atomic.h>
#include <sys/compat_stub.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/errno.h>
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/kauth.h>
#include <sys/kmem.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/md5.h>
#include <sys/module.h>
#include <sys/poll.h>
#include <sys/pool.h>
#include <sys/sdt.h>
#include <sys/select.h>
#include <sys/sha1.h>
#include <sys/sysctl.h>
#include <sys/systm.h>

#ifdef _KERNEL_OPT
#include "opt_ocf.h"
#endif

#include <opencrypto/cryptodev.h>
#include <opencrypto/cryptodev_internal.h>
#include <opencrypto/ocryptodev.h>
#include <opencrypto/xform.h>

static int      ocryptodev_op(struct csession *, struct ocrypt_op *,
                    struct lwp *);
static int      ocryptodev_mop(struct fcrypt *, struct ocrypt_n_op *, int,
                    struct lwp *);
static int      ocryptodev_session(struct fcrypt *, struct osession_op *);
static int      ocryptodev_msession(struct fcrypt *, struct osession_n_op *,
                    int);

int
ocryptof_ioctl(struct file *fp, u_long cmd, void *data)
{
        struct fcrypt *fcr = fp->f_fcrypt;
        struct csession *cse;
        struct osession_op *osop;
        struct osession_n_op *osnop;
        struct ocrypt_op *ocop;
        struct ocrypt_mop *omop;
        struct ocrypt_n_op *ocnop;
        struct ocrypt_sgop *osgop;

        int error = 0;

        switch (cmd) {
        case OCIOCGSESSION:
                osop = (struct osession_op *)data;
                error = ocryptodev_session(fcr, osop);
                break;
        case CIOCNGSESSION:
                osgop = (struct ocrypt_sgop *)data;
                if (osgop->count <= 0 || osgop->count >
                    MIN(CRYPTODEV_OPS_MAX, SIZE_MAX/sizeof(*osnop))) {
                        error = SET_ERROR(EINVAL);
                        break;
                }
                osnop = kmem_alloc(osgop->count * sizeof(*osnop), KM_SLEEP);
                error = copyin(osgop->sessions, osnop, osgop->count *
                    sizeof(*osnop));
                if (error) {
                        goto mbail;
                }

                error = ocryptodev_msession(fcr, osnop, osgop->count);
                if (error) {
                        goto mbail;
                }

                error = copyout(osnop, osgop->sessions, osgop->count *
                    sizeof(*osnop));
mbail:
                kmem_free(osnop, osgop->count * sizeof(*osnop));
                break;
        case OCIOCCRYPT:
                ocop = (struct ocrypt_op *)data;
                cse = cryptodev_cse_find(fcr, ocop->ses);
                if (cse == NULL) {
                        DPRINTF("csefind failed\n");
                        return SET_ERROR(EINVAL);
                }
                error = ocryptodev_op(cse, ocop, curlwp);
                cryptodev_cse_free(cse);
                DPRINTF("ocryptodev_op error = %d\n", error);
                break;
        case OCIOCNCRYPTM:
                omop = (struct ocrypt_mop *)data;
                if (omop->count <= 0 || omop->count > 1) {
                        error = SET_ERROR(EINVAL);
                        break;
                }
                ocnop = kmem_alloc(omop->count * sizeof(*ocnop), KM_SLEEP);
                error = copyin(omop->reqs, ocnop, omop->count *
                    sizeof(*ocnop));
                if (error) {
                        goto nbail;
                }

                error = ocryptodev_mop(fcr, ocnop, omop->count, curlwp);
                if (error) {
                        goto nbail;
                }

                error = copyout(ocnop, omop->reqs, omop->count *
                    sizeof(*ocnop));
nbail:
                kmem_free(ocnop, omop->count * sizeof(*ocnop));
                break;
        default:
                DPRINTF("invalid ioctl cmd 0x%lx\n", cmd);
                return SET_ERROR(EINVAL);
        }
        return error;
}


static int
ocryptodev_op(struct csession *cse, struct ocrypt_op *ocop, struct lwp *l)
{
        struct crypt_op cop;

        cop.ses = ocop->ses;
        cop.op = ocop->op;
        cop.flags = ocop->flags;
        cop.len = ocop->len;
        cop.src = ocop->src;
        cop.dst = ocop->dst;
        cop.mac = ocop->mac;
        cop.iv = ocop->iv;
        cop.dst_len = 0;

        return cryptodev_op(cse, &cop, l);
};

static int 
ocryptodev_mop(struct fcrypt *fcr, struct ocrypt_n_op *ocnop, int count,
    struct lwp *l)
{
        int res;

        struct crypt_n_op cnop;

        cnop.ses = ocnop->ses;
        cnop.op = ocnop->op;
        cnop.flags = ocnop->flags;
        cnop.len = ocnop->len;
        cnop.reqid = ocnop->reqid;
        cnop.status = ocnop->status;
        cnop.opaque = ocnop->opaque;
        cnop.keylen = ocnop->keylen;
        cnop.key = ocnop->key;
        cnop.mackeylen = ocnop->mackeylen;
        cnop.mackey = ocnop->mackey;
        cnop.src = ocnop->src;
        cnop.dst = ocnop->dst;
        cnop.mac = ocnop->mac;
        cnop.iv = ocnop->iv;
        cnop.dst_len = 0;
        res = cryptodev_mop(fcr, &cnop, count, l);
        ocnop->reqid = cnop.reqid;
        ocnop->status = cnop.status;

        return res;
};


static int
ocryptodev_session(struct fcrypt *fcr, struct osession_op *osop)
{
        struct session_op sop;
        int res;

        sop.cipher = osop->cipher;
        sop.mac = osop->mac;
        sop.comp_alg = 0;
        sop.keylen = osop->keylen;
        sop.key = osop->key;
        sop.mackeylen = osop->mackeylen;
        sop.mackey = osop->mackey;
        res = cryptodev_session(fcr, &sop);
        if (res)
                return res;
        osop->ses = sop.ses;
        return 0;

}

static int
ocryptodev_msession(struct fcrypt *fcr, struct osession_n_op *osn_ops,
                   int count)
{
        int i;

        for (i = 0; i < count; i++, osn_ops++) {
                struct osession_op os_op;
                os_op.cipher =          osn_ops->cipher;
                os_op.mac =             osn_ops->mac;
                os_op.keylen =          osn_ops->keylen;
                os_op.key =             osn_ops->key;
                os_op.mackeylen =       osn_ops->mackeylen;
                os_op.mackey =          osn_ops->mackey;
                os_op.ses =             ~0;

                osn_ops->status = ocryptodev_session(fcr, &os_op);
                osn_ops->ses =          os_op.ses;
        }

        return 0;
}