sys/crypto/blake2/blake2_cryptodev.c

   1 /*-
   2  * Copyright (c) 2018 Conrad Meyer <cem@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/bus.h>
  32 #include <sys/kernel.h>
  33 #include <sys/kobj.h>
  34 #include <sys/lock.h>
  35 #include <sys/malloc.h>
  36 #include <sys/module.h>
  37 #include <sys/mutex.h>
  38 #include <sys/rwlock.h>
  39 #include <sys/smp.h>
  40
  41 #include <blake2.h>
  42
  43 #include <opencrypto/cryptodev.h>
  44 #include <cryptodev_if.h>
  45
  46 #if defined(__amd64__)
  47 #include <machine/fpu.h>
  48 #elif defined(__i386__)
  49 #include <machine/npx.h>
  50 #endif
  51
  52 struct blake2_session {
  53         size_t mlen;
  54 };
  55 CTASSERT((size_t)BLAKE2B_KEYBYTES > (size_t)BLAKE2S_KEYBYTES);
  56
  57 struct blake2_softc {
  58         bool    dying;
  59         int32_t cid;
  60         struct rwlock lock;
  61 };
  62
  63 static struct mtx_padalign *ctx_mtx;
  64 static struct fpu_kern_ctx **ctx_fpu;
  65
  66 #define ACQUIRE_CTX(i, ctx)                                     \
  67         do {                                                    \
  68                 (i) = PCPU_GET(cpuid);                          \
  69                 mtx_lock(&ctx_mtx[(i)]);                        \
  70                 (ctx) = ctx_fpu[(i)];                           \
  71         } while (0)
  72 #define RELEASE_CTX(i, ctx)                                     \
  73         do {                                                    \
  74                 mtx_unlock(&ctx_mtx[(i)]);                      \
  75                 (i) = -1;                                       \
  76                 (ctx) = NULL;                                   \
  77         } while (0)
  78
  79 static int blake2_cipher_setup(struct blake2_session *ses,
  80     const struct crypto_session_params *csp);
  81 static int blake2_cipher_process(struct blake2_session *ses,
  82     struct cryptop *crp);
  83
  84 MALLOC_DEFINE(M_BLAKE2, "blake2_data", "Blake2 Data");
  85
  86 static void
  87 blake2_identify(driver_t *drv, device_t parent)
  88 {
  89
  90         /* NB: order 10 is so we get attached after h/w devices */
  91         if (device_find_child(parent, "blaketwo", -1) == NULL &&
  92             BUS_ADD_CHILD(parent, 10, "blaketwo", -1) == 0)
  93                 panic("blaketwo: could not attach");
  94 }
  95
  96 static int
  97 blake2_probe(device_t dev)
  98 {
  99         device_set_desc(dev, "Blake2");
 100         return (0);
 101 }
 102
 103 static void
 104 blake2_cleanctx(void)
 105 {
 106         int i;
 107
 108         /* XXX - no way to return driverid */
 109         CPU_FOREACH(i) {
 110                 if (ctx_fpu[i] != NULL) {
 111                         mtx_destroy(&ctx_mtx[i]);
 112                         fpu_kern_free_ctx(ctx_fpu[i]);
 113                 }
 114                 ctx_fpu[i] = NULL;
 115         }
 116         free(ctx_mtx, M_BLAKE2);
 117         ctx_mtx = NULL;
 118         free(ctx_fpu, M_BLAKE2);
 119         ctx_fpu = NULL;
 120 }
 121
 122 static int
 123 blake2_attach(device_t dev)
 124 {
 125         struct blake2_softc *sc;
 126         int i;
 127
 128         sc = device_get_softc(dev);
 129         sc->dying = false;
 130
 131         sc->cid = crypto_get_driverid(dev, sizeof(struct blake2_session),
 132             CRYPTOCAP_F_SOFTWARE | CRYPTOCAP_F_SYNC |
 133             CRYPTOCAP_F_ACCEL_SOFTWARE);
 134         if (sc->cid < 0) {
 135                 device_printf(dev, "Could not get crypto driver id.\n");
 136                 return (ENOMEM);
 137         }
 138
 139         ctx_mtx = malloc(sizeof(*ctx_mtx) * (mp_maxid + 1), M_BLAKE2,
 140             M_WAITOK | M_ZERO);
 141         ctx_fpu = malloc(sizeof(*ctx_fpu) * (mp_maxid + 1), M_BLAKE2,
 142             M_WAITOK | M_ZERO);
 143
 144         CPU_FOREACH(i) {
 145                 ctx_fpu[i] = fpu_kern_alloc_ctx(0);
 146                 mtx_init(&ctx_mtx[i], "bl2fpumtx", NULL, MTX_DEF | MTX_NEW);
 147         }
 148
 149         rw_init(&sc->lock, "blake2_lock");
 150
 151         return (0);
 152 }
 153
 154 static int
 155 blake2_detach(device_t dev)
 156 {
 157         struct blake2_softc *sc;
 158
 159         sc = device_get_softc(dev);
 160
 161         rw_wlock(&sc->lock);
 162         sc->dying = true;
 163         rw_wunlock(&sc->lock);
 164         crypto_unregister_all(sc->cid);
 165
 166         rw_destroy(&sc->lock);
 167
 168         blake2_cleanctx();
 169
 170         return (0);
 171 }
 172
 173 static int
 174 blake2_probesession(device_t dev, const struct crypto_session_params *csp)
 175 {
 176
 177         if (csp->csp_flags != 0)
 178                 return (EINVAL);
 179         switch (csp->csp_mode) {
 180         case CSP_MODE_DIGEST:
 181                 switch (csp->csp_auth_alg) {
 182                 case CRYPTO_BLAKE2B:
 183                 case CRYPTO_BLAKE2S:
 184                         break;
 185                 default:
 186                         return (EINVAL);
 187                 }
 188                 break;
 189         default:
 190                 return (EINVAL);
 191         }
 192         return (CRYPTODEV_PROBE_ACCEL_SOFTWARE);
 193 }
 194
 195 static int
 196 blake2_newsession(device_t dev, crypto_session_t cses,
 197     const struct crypto_session_params *csp)
 198 {
 199         struct blake2_softc *sc;
 200         struct blake2_session *ses;
 201         int error;
 202
 203         sc = device_get_softc(dev);
 204
 205         ses = crypto_get_driver_session(cses);
 206
 207         rw_rlock(&sc->lock);
 208         if (sc->dying) {
 209                 rw_runlock(&sc->lock);
 210                 return (EINVAL);
 211         }
 212         rw_runlock(&sc->lock);
 213
 214         error = blake2_cipher_setup(ses, csp);
 215         if (error != 0) {
 216                 CRYPTDEB("setup failed");
 217                 return (error);
 218         }
 219
 220         return (0);
 221 }
 222
 223 static int
 224 blake2_process(device_t dev, struct cryptop *crp, int hint __unused)
 225 {
 226         struct blake2_session *ses;
 227         int error;
 228
 229         ses = crypto_get_driver_session(crp->crp_session);
 230         error = blake2_cipher_process(ses, crp);
 231
 232         crp->crp_etype = error;
 233         crypto_done(crp);
 234         return (0);
 235 }
 236
 237 static device_method_t blake2_methods[] = {
 238         DEVMETHOD(device_identify, blake2_identify),
 239         DEVMETHOD(device_probe, blake2_probe),
 240         DEVMETHOD(device_attach, blake2_attach),
 241         DEVMETHOD(device_detach, blake2_detach),
 242
 243         DEVMETHOD(cryptodev_probesession, blake2_probesession),
 244         DEVMETHOD(cryptodev_newsession, blake2_newsession),
 245         DEVMETHOD(cryptodev_process, blake2_process),
 246
 247         DEVMETHOD_END
 248 };
 249
 250 static driver_t blake2_driver = {
 251         "blaketwo",
 252         blake2_methods,
 253         sizeof(struct blake2_softc),
 254 };
 255 static devclass_t blake2_devclass;
 256
 257 DRIVER_MODULE(blake2, nexus, blake2_driver, blake2_devclass, 0, 0);
 258 MODULE_VERSION(blake2, 1);
 259 MODULE_DEPEND(blake2, crypto, 1, 1, 1);
 260
 261 static bool
 262 blake2_check_klen(const struct crypto_session_params *csp, unsigned klen)
 263 {
 264
 265         if (csp->csp_auth_alg == CRYPTO_BLAKE2S)
 266                 return (klen <= BLAKE2S_KEYBYTES);
 267         else
 268                 return (klen <= BLAKE2B_KEYBYTES);
 269 }
 270
 271 static int
 272 blake2_cipher_setup(struct blake2_session *ses,
 273     const struct crypto_session_params *csp)
 274 {
 275         int hashlen;
 276
 277         CTASSERT((size_t)BLAKE2S_OUTBYTES <= (size_t)BLAKE2B_OUTBYTES);
 278
 279         if (!blake2_check_klen(csp, csp->csp_auth_klen))
 280                 return (EINVAL);
 281
 282         if (csp->csp_auth_mlen < 0)
 283                 return (EINVAL);
 284
 285         switch (csp->csp_auth_alg) {
 286         case CRYPTO_BLAKE2S:
 287                 hashlen = BLAKE2S_OUTBYTES;
 288                 break;
 289         case CRYPTO_BLAKE2B:
 290                 hashlen = BLAKE2B_OUTBYTES;
 291                 break;
 292         default:
 293                 return (EINVAL);
 294         }
 295
 296         if (csp->csp_auth_mlen > hashlen)
 297                 return (EINVAL);
 298
 299         if (csp->csp_auth_mlen == 0)
 300                 ses->mlen = hashlen;
 301         else
 302                 ses->mlen = csp->csp_auth_mlen;
 303         return (0);
 304 }
 305
 306 static int
 307 blake2b_applicator(void *state, void *buf, u_int len)
 308 {
 309         int rc;
 310
 311         rc = blake2b_update(state, buf, len);
 312         if (rc != 0)
 313                 return (EINVAL);
 314         return (0);
 315 }
 316
 317 static int
 318 blake2s_applicator(void *state, void *buf, u_int len)
 319 {
 320         int rc;
 321
 322         rc = blake2s_update(state, buf, len);
 323         if (rc != 0)
 324                 return (EINVAL);
 325         return (0);
 326 }
 327
 328 static int
 329 blake2_cipher_process(struct blake2_session *ses, struct cryptop *crp)
 330 {
 331         union {
 332                 blake2b_state sb;
 333                 blake2s_state ss;
 334         } bctx;
 335         char res[BLAKE2B_OUTBYTES], res2[BLAKE2B_OUTBYTES];
 336         const struct crypto_session_params *csp;
 337         struct fpu_kern_ctx *ctx;
 338         const void *key;
 339         int ctxidx;
 340         bool kt;
 341         int error, rc;
 342         unsigned klen;
 343
 344         ctx = NULL;
 345         ctxidx = 0;
 346         error = EINVAL;
 347
 348         kt = is_fpu_kern_thread(0);
 349         if (!kt) {
 350                 ACQUIRE_CTX(ctxidx, ctx);
 351                 fpu_kern_enter(curthread, ctx,
 352                     FPU_KERN_NORMAL | FPU_KERN_KTHR);
 353         }
 354
 355         csp = crypto_get_params(crp->crp_session);
 356         if (crp->crp_auth_key != NULL)
 357                 key = crp->crp_auth_key;
 358         else
 359                 key = csp->csp_auth_key;
 360         klen = csp->csp_auth_klen;
 361         switch (csp->csp_auth_alg) {
 362         case CRYPTO_BLAKE2B:
 363                 if (klen > 0)
 364                         rc = blake2b_init_key(&bctx.sb, ses->mlen, key, klen);
 365                 else
 366                         rc = blake2b_init(&bctx.sb, ses->mlen);
 367                 if (rc != 0)
 368                         goto out;
 369                 error = crypto_apply(crp, crp->crp_payload_start,
 370                     crp->crp_payload_length, blake2b_applicator, &bctx.sb);
 371                 if (error != 0)
 372                         goto out;
 373                 rc = blake2b_final(&bctx.sb, res, ses->mlen);
 374                 if (rc != 0) {
 375                         error = EINVAL;
 376                         goto out;
 377                 }
 378                 break;
 379         case CRYPTO_BLAKE2S:
 380                 if (klen > 0)
 381                         rc = blake2s_init_key(&bctx.ss, ses->mlen, key, klen);
 382                 else
 383                         rc = blake2s_init(&bctx.ss, ses->mlen);
 384                 if (rc != 0)
 385                         goto out;
 386                 error = crypto_apply(crp, crp->crp_payload_start,
 387                     crp->crp_payload_length, blake2s_applicator, &bctx.ss);
 388                 if (error != 0)
 389                         goto out;
 390                 rc = blake2s_final(&bctx.ss, res, ses->mlen);
 391                 if (rc != 0) {
 392                         error = EINVAL;
 393                         goto out;
 394                 }
 395                 break;
 396         default:
 397                 panic("unreachable");
 398         }
 399
 400         if (crp->crp_op & CRYPTO_OP_VERIFY_DIGEST) {
 401                 crypto_copydata(crp, crp->crp_digest_start, ses->mlen, res2);
 402                 if (timingsafe_bcmp(res, res2, ses->mlen) != 0)
 403                         return (EBADMSG);
 404         } else
 405                 crypto_copyback(crp, crp->crp_digest_start, ses->mlen, res);
 406
 407 out:
 408         if (!kt) {
 409                 fpu_kern_leave(curthread, ctx);
 410                 RELEASE_CTX(ctxidx, ctx);
 411         }
 412         return (error);
 413 }