sys/geom/eli/g_eli.c

   1 /*-
   2  * Copyright (c) 2005-2006 Pawel Jakub Dawidek <pjd@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/systm.h>
  32 #include <sys/kernel.h>
  33 #include <sys/linker.h>
  34 #include <sys/module.h>
  35 #include <sys/lock.h>
  36 #include <sys/mutex.h>
  37 #include <sys/bio.h>
  38 #include <sys/sysctl.h>
  39 #include <sys/malloc.h>
  40 #include <sys/eventhandler.h>
  41 #include <sys/kthread.h>
  42 #include <sys/proc.h>
  43 #include <sys/sched.h>
  44 #include <sys/smp.h>
  45 #include <sys/uio.h>
  46 #include <sys/vnode.h>
  47
  48 #include <vm/uma.h>
  49
  50 #include <geom/geom.h>
  51 #include <geom/eli/g_eli.h>
  52 #include <geom/eli/pkcs5v2.h>
  53
  54
  55 MALLOC_DEFINE(M_ELI, "eli data", "GEOM_ELI Data");
  56
  57 SYSCTL_DECL(_kern_geom);
  58 SYSCTL_NODE(_kern_geom, OID_AUTO, eli, CTLFLAG_RW, 0, "GEOM_ELI stuff");
  59 u_int g_eli_debug = 0;
  60 TUNABLE_INT("kern.geom.eli.debug", &g_eli_debug);
  61 SYSCTL_UINT(_kern_geom_eli, OID_AUTO, debug, CTLFLAG_RW, &g_eli_debug, 0,
  62     "Debug level");
  63 static u_int g_eli_tries = 3;
  64 TUNABLE_INT("kern.geom.eli.tries", &g_eli_tries);
  65 SYSCTL_UINT(_kern_geom_eli, OID_AUTO, tries, CTLFLAG_RW, &g_eli_tries, 0,
  66     "Number of tries for entering the passphrase");
  67 static u_int g_eli_visible_passphrase = 0;
  68 TUNABLE_INT("kern.geom.eli.visible_passphrase", &g_eli_visible_passphrase);
  69 SYSCTL_UINT(_kern_geom_eli, OID_AUTO, visible_passphrase, CTLFLAG_RW,
  70     &g_eli_visible_passphrase, 0,
  71     "Turn on echo when entering the passphrase (for debug purposes only!!)");
  72 u_int g_eli_overwrites = 5;
  73 TUNABLE_INT("kern.geom.eli.overwrites", &g_eli_overwrites);
  74 SYSCTL_UINT(_kern_geom_eli, OID_AUTO, overwrites, CTLFLAG_RW, &g_eli_overwrites,
  75     0, "Number of times on-disk keys should be overwritten when destroying them");
  76 static u_int g_eli_threads = 0;
  77 TUNABLE_INT("kern.geom.eli.threads", &g_eli_threads);
  78 SYSCTL_UINT(_kern_geom_eli, OID_AUTO, threads, CTLFLAG_RW, &g_eli_threads, 0,
  79     "Number of threads doing crypto work");
  80 u_int g_eli_batch = 0;
  81 TUNABLE_INT("kern.geom.eli.batch", &g_eli_batch);
  82 SYSCTL_UINT(_kern_geom_eli, OID_AUTO, batch, CTLFLAG_RW, &g_eli_batch, 0,
  83     "Use crypto operations batching");
  84
  85 static eventhandler_tag g_eli_pre_sync = NULL;
  86
  87 static int g_eli_destroy_geom(struct gctl_req *req, struct g_class *mp,
  88     struct g_geom *gp);
  89 static void g_eli_init(struct g_class *mp);
  90 static void g_eli_fini(struct g_class *mp);
  91
  92 static g_taste_t g_eli_taste;
  93 static g_dumpconf_t g_eli_dumpconf;
  94
  95 struct g_class g_eli_class = {
  96         .name = G_ELI_CLASS_NAME,
  97         .version = G_VERSION,
  98         .ctlreq = g_eli_config,
  99         .taste = g_eli_taste,
 100         .destroy_geom = g_eli_destroy_geom,
 101         .init = g_eli_init,
 102         .fini = g_eli_fini
 103 };
 104
 105
 106 /*
 107  * Code paths:
 108  * BIO_READ:
 109  *      g_eli_start -> g_io_request -> g_eli_read_done -> g_eli_crypto_run -> g_eli_crypto_read_done -> g_io_deliver
 110  * BIO_WRITE:
 111  *      g_eli_start -> g_eli_crypto_run -> g_eli_crypto_write_done -> g_io_request -> g_eli_write_done -> g_io_deliver
 112  */
 113
 114
 115 /*
 116  * EAGAIN from crypto(9) means, that we were probably balanced to another crypto
 117  * accelerator or something like this.
 118  * The function updates the SID and rerun the operation.
 119  */
 120 int
 121 g_eli_crypto_rerun(struct cryptop *crp)
 122 {
 123         struct g_eli_softc *sc;
 124         struct g_eli_worker *wr;
 125         struct bio *bp;
 126         int error;
 127
 128         bp = (struct bio *)crp->crp_opaque;
 129         sc = bp->bio_to->geom->softc;
 130         LIST_FOREACH(wr, &sc->sc_workers, w_next) {
 131                 if (wr->w_number == bp->bio_pflags)
 132                         break;
 133         }
 134         KASSERT(wr != NULL, ("Invalid worker (%u).", bp->bio_pflags));
 135         G_ELI_DEBUG(1, "Rerunning crypto %s request (sid: %ju -> %ju).",
 136             bp->bio_cmd == BIO_READ ? "READ" : "WRITE", (uintmax_t)wr->w_sid,
 137             (uintmax_t)crp->crp_sid);
 138         wr->w_sid = crp->crp_sid;
 139         crp->crp_etype = 0;
 140         error = crypto_dispatch(crp);
 141         if (error == 0)
 142                 return (0);
 143         G_ELI_DEBUG(1, "%s: crypto_dispatch() returned %d.", __func__, error);
 144         crp->crp_etype = error;
 145         return (error);
 146 }
 147
 148 /*
 149  * The function is called afer reading encrypted data from the provider.
 150  *
 151  * g_eli_start -> g_io_request -> G_ELI_READ_DONE -> g_eli_crypto_run -> g_eli_crypto_read_done -> g_io_deliver
 152  */
 153 void
 154 g_eli_read_done(struct bio *bp)
 155 {
 156         struct g_eli_softc *sc;
 157         struct bio *pbp;
 158
 159         G_ELI_LOGREQ(2, bp, "Request done.");
 160         pbp = bp->bio_parent;
 161         if (pbp->bio_error == 0)
 162                 pbp->bio_error = bp->bio_error;
 163         /*
 164          * Do we have all sectors already?
 165          */
 166         pbp->bio_inbed++;
 167         if (pbp->bio_inbed < pbp->bio_children)
 168                 return;
 169         g_destroy_bio(bp);
 170         if (pbp->bio_error != 0) {
 171                 G_ELI_LOGREQ(0, pbp, "%s() failed", __func__);
 172                 pbp->bio_completed = 0;
 173                 if (pbp->bio_driver2 != NULL) {
 174                         free(pbp->bio_driver2, M_ELI);
 175                         pbp->bio_driver2 = NULL;
 176                 }
 177                 g_io_deliver(pbp, pbp->bio_error);
 178                 return;
 179         }
 180         sc = pbp->bio_to->geom->softc;
 181         mtx_lock(&sc->sc_queue_mtx);
 182         bioq_insert_tail(&sc->sc_queue, pbp);
 183         mtx_unlock(&sc->sc_queue_mtx);
 184         wakeup(sc);
 185 }
 186
 187 /*
 188  * The function is called after we encrypt and write data.
 189  *
 190  * g_eli_start -> g_eli_crypto_run -> g_eli_crypto_write_done -> g_io_request -> G_ELI_WRITE_DONE -> g_io_deliver
 191  */
 192 void
 193 g_eli_write_done(struct bio *bp)
 194 {
 195         struct bio *pbp;
 196
 197         G_ELI_LOGREQ(2, bp, "Request done.");
 198         pbp = bp->bio_parent;
 199         if (pbp->bio_error == 0) {
 200                 if (bp->bio_error != 0)
 201                         pbp->bio_error = bp->bio_error;
 202         }
 203         /*
 204          * Do we have all sectors already?
 205          */
 206         pbp->bio_inbed++;
 207         if (pbp->bio_inbed < pbp->bio_children)
 208                 return;
 209         free(pbp->bio_driver2, M_ELI);
 210         pbp->bio_driver2 = NULL;
 211         if (pbp->bio_error != 0) {
 212                 G_ELI_LOGREQ(0, pbp, "Crypto WRITE request failed (error=%d).",
 213                     pbp->bio_error);
 214                 pbp->bio_completed = 0;
 215         }
 216         g_destroy_bio(bp);
 217         /*
 218          * Write is finished, send it up.
 219          */
 220         pbp->bio_completed = pbp->bio_length;
 221         g_io_deliver(pbp, pbp->bio_error);
 222 }
 223
 224 /*
 225  * This function should never be called, but GEOM made as it set ->orphan()
 226  * method for every geom.
 227  */
 228 static void
 229 g_eli_orphan_spoil_assert(struct g_consumer *cp)
 230 {
 231
 232         panic("Function %s() called for %s.", __func__, cp->geom->name);
 233 }
 234
 235 static void
 236 g_eli_orphan(struct g_consumer *cp)
 237 {
 238         struct g_eli_softc *sc;
 239
 240         g_topology_assert();
 241         sc = cp->geom->softc;
 242         if (sc == NULL)
 243                 return;
 244         g_eli_destroy(sc, 1);
 245 }
 246
 247 /*
 248  * BIO_READ : G_ELI_START -> g_io_request -> g_eli_read_done -> g_eli_crypto_run -> g_eli_crypto_read_done -> g_io_deliver
 249  * BIO_WRITE: G_ELI_START -> g_eli_crypto_run -> g_eli_crypto_write_done -> g_io_request -> g_eli_write_done -> g_io_deliver
 250  */
 251 static void
 252 g_eli_start(struct bio *bp)
 253 {
 254         struct g_eli_softc *sc;
 255         struct g_consumer *cp;
 256         struct bio *cbp;
 257
 258         sc = bp->bio_to->geom->softc;
 259         KASSERT(sc != NULL,
 260             ("Provider's error should be set (error=%d)(device=%s).",
 261             bp->bio_to->error, bp->bio_to->name));
 262         G_ELI_LOGREQ(2, bp, "Request received.");
 263
 264         switch (bp->bio_cmd) {
 265         case BIO_READ:
 266         case BIO_WRITE:
 267         case BIO_GETATTR:
 268         case BIO_FLUSH:
 269                 break;
 270         case BIO_DELETE:
 271                 /*
 272                  * We could eventually support BIO_DELETE request.
 273                  * It could be done by overwritting requested sector with
 274                  * random data g_eli_overwrites number of times.
 275                  */
 276         default:
 277                 g_io_deliver(bp, EOPNOTSUPP);
 278                 return;
 279         }
 280         cbp = g_clone_bio(bp);
 281         if (cbp == NULL) {
 282                 g_io_deliver(bp, ENOMEM);
 283                 return;
 284         }
 285         switch (bp->bio_cmd) {
 286         case BIO_READ:
 287                 if (!(sc->sc_flags & G_ELI_FLAG_AUTH)) {
 288                         bp->bio_driver2 = NULL;
 289                         cbp->bio_done = g_eli_read_done;
 290                         cp = LIST_FIRST(&sc->sc_geom->consumer);
 291                         cbp->bio_to = cp->provider;
 292                         G_ELI_LOGREQ(2, cbp, "Sending request.");
 293                         /*
 294                          * Read encrypted data from provider.
 295                          */
 296                         g_io_request(cbp, cp);
 297                         break;
 298                 }
 299                 bp->bio_pflags = 255;
 300                 /* FALLTHROUGH */
 301         case BIO_WRITE:
 302                 bp->bio_driver1 = cbp;
 303                 mtx_lock(&sc->sc_queue_mtx);
 304                 bioq_insert_tail(&sc->sc_queue, bp);
 305                 mtx_unlock(&sc->sc_queue_mtx);
 306                 wakeup(sc);
 307                 break;
 308         case BIO_GETATTR:
 309         case BIO_FLUSH:
 310                 cbp->bio_done = g_std_done;
 311                 cp = LIST_FIRST(&sc->sc_geom->consumer);
 312                 cbp->bio_to = cp->provider;
 313                 G_ELI_LOGREQ(2, cbp, "Sending request.");
 314                 g_io_request(cbp, cp);
 315                 break;
 316         }
 317 }
 318
 319 /*
 320  * This is the main function for kernel worker thread when we don't have
 321  * hardware acceleration and we have to do cryptography in software.
 322  * Dedicated thread is needed, so we don't slow down g_up/g_down GEOM
 323  * threads with crypto work.
 324  */
 325 static void
 326 g_eli_worker(void *arg)
 327 {
 328         struct g_eli_softc *sc;
 329         struct g_eli_worker *wr;
 330         struct bio *bp;
 331
 332         wr = arg;
 333         sc = wr->w_softc;
 334 #ifdef SMP
 335         /* Before sched_bind() to a CPU, wait for all CPUs to go on-line. */
 336         if (mp_ncpus > 1 && sc->sc_crypto == G_ELI_CRYPTO_SW &&
 337             g_eli_threads == 0) {
 338                 while (!smp_started)
 339                         tsleep(wr, 0, "geli:smp", hz / 4);
 340         }
 341 #endif
 342         thread_lock(curthread);
 343         sched_prio(curthread, PUSER);
 344         if (sc->sc_crypto == G_ELI_CRYPTO_SW && g_eli_threads == 0)
 345                 sched_bind(curthread, wr->w_number);
 346         thread_unlock(curthread);
 347
 348         G_ELI_DEBUG(1, "Thread %s started.", curthread->td_proc->p_comm);
 349
 350         for (;;) {
 351                 mtx_lock(&sc->sc_queue_mtx);
 352                 bp = bioq_takefirst(&sc->sc_queue);
 353                 if (bp == NULL) {
 354                         if (sc->sc_flags & G_ELI_FLAG_DESTROY) {
 355                                 LIST_REMOVE(wr, w_next);
 356                                 crypto_freesession(wr->w_sid);
 357                                 free(wr, M_ELI);
 358                                 G_ELI_DEBUG(1, "Thread %s exiting.",
 359                                     curthread->td_proc->p_comm);
 360                                 wakeup(&sc->sc_workers);
 361                                 mtx_unlock(&sc->sc_queue_mtx);
 362                                 kproc_exit(0);
 363                         }
 364                         msleep(sc, &sc->sc_queue_mtx, PDROP, "geli:w", 0);
 365                         continue;
 366                 }
 367                 mtx_unlock(&sc->sc_queue_mtx);
 368                 if (bp->bio_cmd == BIO_READ && bp->bio_pflags == 255)
 369                         g_eli_auth_read(sc, bp);
 370                 else if (sc->sc_flags & G_ELI_FLAG_AUTH)
 371                         g_eli_auth_run(wr, bp);
 372                 else
 373                         g_eli_crypto_run(wr, bp);
 374         }
 375 }
 376
 377 /*
 378  * Here we generate IV. It is unique for every sector.
 379  */
 380 void
 381 g_eli_crypto_ivgen(struct g_eli_softc *sc, off_t offset, u_char *iv,
 382     size_t size)
 383 {
 384         u_char off[8], hash[SHA256_DIGEST_LENGTH];
 385         SHA256_CTX ctx;
 386
 387         if (!(sc->sc_flags & G_ELI_FLAG_NATIVE_BYTE_ORDER))
 388                 le64enc(off, (uint64_t)offset);
 389         /* Copy precalculated SHA256 context for IV-Key. */
 390         bcopy(&sc->sc_ivctx, &ctx, sizeof(ctx));
 391         SHA256_Update(&ctx, (uint8_t *)&offset, sizeof(offset));
 392         SHA256_Final(hash, &ctx);
 393         bcopy(hash, iv, size);
 394 }
 395
 396 int
 397 g_eli_read_metadata(struct g_class *mp, struct g_provider *pp,
 398     struct g_eli_metadata *md)
 399 {
 400         struct g_geom *gp;
 401         struct g_consumer *cp;
 402         u_char *buf = NULL;
 403         int error;
 404
 405         g_topology_assert();
 406
 407         gp = g_new_geomf(mp, "eli:taste");
 408         gp->start = g_eli_start;
 409         gp->access = g_std_access;
 410         /*
 411          * g_eli_read_metadata() is always called from the event thread.
 412          * Our geom is created and destroyed in the same event, so there
 413          * could be no orphan nor spoil event in the meantime.
 414          */
 415         gp->orphan = g_eli_orphan_spoil_assert;
 416         gp->spoiled = g_eli_orphan_spoil_assert;
 417         cp = g_new_consumer(gp);
 418         error = g_attach(cp, pp);
 419         if (error != 0)
 420                 goto end;
 421         error = g_access(cp, 1, 0, 0);
 422         if (error != 0)
 423                 goto end;
 424         g_topology_unlock();
 425         buf = g_read_data(cp, pp->mediasize - pp->sectorsize, pp->sectorsize,
 426             &error);
 427         g_topology_lock();
 428         if (buf == NULL)
 429                 goto end;
 430         eli_metadata_decode(buf, md);
 431 end:
 432         if (buf != NULL)
 433                 g_free(buf);
 434         if (cp->provider != NULL) {
 435                 if (cp->acr == 1)
 436                         g_access(cp, -1, 0, 0);
 437                 g_detach(cp);
 438         }
 439         g_destroy_consumer(cp);
 440         g_destroy_geom(gp);
 441         return (error);
 442 }
 443
 444 /*
 445  * The function is called when we had last close on provider and user requested
 446  * to close it when this situation occur.
 447  */
 448 static void
 449 g_eli_last_close(struct g_eli_softc *sc)
 450 {
 451         struct g_geom *gp;
 452         struct g_provider *pp;
 453         char ppname[64];
 454         int error;
 455
 456         g_topology_assert();
 457         gp = sc->sc_geom;
 458         pp = LIST_FIRST(&gp->provider);
 459         strlcpy(ppname, pp->name, sizeof(ppname));
 460         error = g_eli_destroy(sc, 1);
 461         KASSERT(error == 0, ("Cannot detach %s on last close (error=%d).",
 462             ppname, error));
 463         G_ELI_DEBUG(0, "Detached %s on last close.", ppname);
 464 }
 465
 466 int
 467 g_eli_access(struct g_provider *pp, int dr, int dw, int de)
 468 {
 469         struct g_eli_softc *sc;
 470         struct g_geom *gp;
 471
 472         gp = pp->geom;
 473         sc = gp->softc;
 474
 475         if (dw > 0) {
 476                 if (sc->sc_flags & G_ELI_FLAG_RO) {
 477                         /* Deny write attempts. */
 478                         return (EROFS);
 479                 }
 480                 /* Someone is opening us for write, we need to remember that. */
 481                 sc->sc_flags |= G_ELI_FLAG_WOPEN;
 482                 return (0);
 483         }
 484         /* Is this the last close? */
 485         if (pp->acr + dr > 0 || pp->acw + dw > 0 || pp->ace + de > 0)
 486                 return (0);
 487
 488         /*
 489          * Automatically detach on last close if requested.
 490          */
 491         if ((sc->sc_flags & G_ELI_FLAG_RW_DETACH) ||
 492             (sc->sc_flags & G_ELI_FLAG_WOPEN)) {
 493                 g_eli_last_close(sc);
 494         }
 495         return (0);
 496 }
 497
 498 static int
 499 g_eli_cpu_is_disabled(int cpu)
 500 {
 501 #ifdef SMP
 502         return ((hlt_cpus_mask & (1 << cpu)) != 0);
 503 #else
 504         return (0);
 505 #endif
 506 }
 507
 508 struct g_geom *
 509 g_eli_create(struct gctl_req *req, struct g_class *mp, struct g_provider *bpp,
 510     const struct g_eli_metadata *md, const u_char *mkey, int nkey)
 511 {
 512         struct g_eli_softc *sc;
 513         struct g_eli_worker *wr;
 514         struct g_geom *gp;
 515         struct g_provider *pp;
 516         struct g_consumer *cp;
 517         struct cryptoini crie, cria;
 518         u_int i, threads;
 519         int error;
 520
 521         G_ELI_DEBUG(1, "Creating device %s%s.", bpp->name, G_ELI_SUFFIX);
 522
 523         gp = g_new_geomf(mp, "%s%s", bpp->name, G_ELI_SUFFIX);
 524         gp->softc = NULL;       /* for a moment */
 525
 526         sc = malloc(sizeof(*sc), M_ELI, M_WAITOK | M_ZERO);
 527         gp->start = g_eli_start;
 528         /*
 529          * Spoiling cannot happen actually, because we keep provider open for
 530          * writing all the time or provider is read-only.
 531          */
 532         gp->spoiled = g_eli_orphan_spoil_assert;
 533         gp->orphan = g_eli_orphan;
 534         gp->dumpconf = g_eli_dumpconf;
 535         /*
 536          * If detach-on-last-close feature is not enabled and we don't operate
 537          * on read-only provider, we can simply use g_std_access().
 538          */
 539         if (md->md_flags & (G_ELI_FLAG_WO_DETACH | G_ELI_FLAG_RO))
 540                 gp->access = g_eli_access;
 541         else
 542                 gp->access = g_std_access;
 543
 544         sc->sc_crypto = G_ELI_CRYPTO_SW;
 545         sc->sc_flags = md->md_flags;
 546         /* Backward compatibility. */
 547         if (md->md_version < 2)
 548                 sc->sc_flags |= G_ELI_FLAG_NATIVE_BYTE_ORDER;
 549         sc->sc_ealgo = md->md_ealgo;
 550         sc->sc_nkey = nkey;
 551         /*
 552          * Remember the keys in our softc structure.
 553          */
 554         g_eli_mkey_propagate(sc, mkey);
 555         sc->sc_ekeylen = md->md_keylen;
 556
 557         if (sc->sc_flags & G_ELI_FLAG_AUTH) {
 558                 sc->sc_akeylen = sizeof(sc->sc_akey) * 8;
 559                 sc->sc_aalgo = md->md_aalgo;
 560                 sc->sc_alen = g_eli_hashlen(sc->sc_aalgo);
 561
 562                 sc->sc_data_per_sector = bpp->sectorsize - sc->sc_alen;
 563                 /*
 564                  * Some hash functions (like SHA1 and RIPEMD160) generates hash
 565                  * which length is not multiple of 128 bits, but we want data
 566                  * length to be multiple of 128, so we can encrypt without
 567                  * padding. The line below rounds down data length to multiple
 568                  * of 128 bits.
 569                  */
 570                 sc->sc_data_per_sector -= sc->sc_data_per_sector % 16;
 571
 572                 sc->sc_bytes_per_sector =
 573                     (md->md_sectorsize - 1) / sc->sc_data_per_sector + 1;
 574                 sc->sc_bytes_per_sector *= bpp->sectorsize;
 575                 /*
 576                  * Precalculate SHA256 for HMAC key generation.
 577                  * This is expensive operation and we can do it only once now or
 578                  * for every access to sector, so now will be much better.
 579                  */
 580                 SHA256_Init(&sc->sc_akeyctx);
 581                 SHA256_Update(&sc->sc_akeyctx, sc->sc_akey,
 582                     sizeof(sc->sc_akey));
 583         }
 584
 585         /*
 586          * Precalculate SHA256 for IV generation.
 587          * This is expensive operation and we can do it only once now or for
 588          * every access to sector, so now will be much better.
 589          */
 590         SHA256_Init(&sc->sc_ivctx);
 591         SHA256_Update(&sc->sc_ivctx, sc->sc_ivkey, sizeof(sc->sc_ivkey));
 592
 593         gp->softc = sc;
 594         sc->sc_geom = gp;
 595
 596         bioq_init(&sc->sc_queue);
 597         mtx_init(&sc->sc_queue_mtx, "geli:queue", NULL, MTX_DEF);
 598
 599         pp = NULL;
 600         cp = g_new_consumer(gp);
 601         error = g_attach(cp, bpp);
 602         if (error != 0) {
 603                 if (req != NULL) {
 604                         gctl_error(req, "Cannot attach to %s (error=%d).",
 605                             bpp->name, error);
 606                 } else {
 607                         G_ELI_DEBUG(1, "Cannot attach to %s (error=%d).",
 608                             bpp->name, error);
 609                 }
 610                 goto failed;
 611         }
 612         /*
 613          * Keep provider open all the time, so we can run critical tasks,
 614          * like Master Keys deletion, without wondering if we can open
 615          * provider or not.
 616          * We don't open provider for writing only when user requested read-only
 617          * access.
 618          */
 619         if (sc->sc_flags & G_ELI_FLAG_RO)
 620                 error = g_access(cp, 1, 0, 1);
 621         else
 622                 error = g_access(cp, 1, 1, 1);
 623         if (error != 0) {
 624                 if (req != NULL) {
 625                         gctl_error(req, "Cannot access %s (error=%d).",
 626                             bpp->name, error);
 627                 } else {
 628                         G_ELI_DEBUG(1, "Cannot access %s (error=%d).",
 629                             bpp->name, error);
 630                 }
 631                 goto failed;
 632         }
 633
 634         LIST_INIT(&sc->sc_workers);
 635
 636         bzero(&crie, sizeof(crie));
 637         crie.cri_alg = sc->sc_ealgo;
 638         crie.cri_klen = sc->sc_ekeylen;
 639         crie.cri_key = sc->sc_ekey;
 640         if (sc->sc_flags & G_ELI_FLAG_AUTH) {
 641                 bzero(&cria, sizeof(cria));
 642                 cria.cri_alg = sc->sc_aalgo;
 643                 cria.cri_klen = sc->sc_akeylen;
 644                 cria.cri_key = sc->sc_akey;
 645                 crie.cri_next = &cria;
 646         }
 647
 648         threads = g_eli_threads;
 649         if (threads == 0)
 650                 threads = mp_ncpus;
 651         else if (threads > mp_ncpus) {
 652                 /* There is really no need for too many worker threads. */
 653                 threads = mp_ncpus;
 654                 G_ELI_DEBUG(0, "Reducing number of threads to %u.", threads);
 655         }
 656         for (i = 0; i < threads; i++) {
 657                 if (g_eli_cpu_is_disabled(i)) {
 658                         G_ELI_DEBUG(1, "%s: CPU %u disabled, skipping.",
 659                             bpp->name, i);
 660                         continue;
 661                 }
 662                 wr = malloc(sizeof(*wr), M_ELI, M_WAITOK | M_ZERO);
 663                 wr->w_softc = sc;
 664                 wr->w_number = i;
 665
 666                 /*
 667                  * If this is the first pass, try to get hardware support.
 668                  * Use software cryptography, if we cannot get it.
 669                  */
 670                 if (LIST_EMPTY(&sc->sc_workers)) {
 671                         error = crypto_newsession(&wr->w_sid, &crie,
 672                             CRYPTOCAP_F_HARDWARE);
 673                         if (error == 0)
 674                                 sc->sc_crypto = G_ELI_CRYPTO_HW;
 675                 }
 676                 if (sc->sc_crypto == G_ELI_CRYPTO_SW) {
 677                         error = crypto_newsession(&wr->w_sid, &crie,
 678                             CRYPTOCAP_F_SOFTWARE);
 679                 }
 680                 if (error != 0) {
 681                         free(wr, M_ELI);
 682                         if (req != NULL) {
 683                                 gctl_error(req, "Cannot set up crypto session "
 684                                     "for %s (error=%d).", bpp->name, error);
 685                         } else {
 686                                 G_ELI_DEBUG(1, "Cannot set up crypto session "
 687                                     "for %s (error=%d).", bpp->name, error);
 688                         }
 689                         goto failed;
 690                 }
 691
 692                 error = kproc_create(g_eli_worker, wr, &wr->w_proc, 0, 0,
 693                     "g_eli[%u] %s", i, bpp->name);
 694                 if (error != 0) {
 695                         crypto_freesession(wr->w_sid);
 696                         free(wr, M_ELI);
 697                         if (req != NULL) {
 698                                 gctl_error(req, "Cannot create kernel thread "
 699                                     "for %s (error=%d).", bpp->name, error);
 700                         } else {
 701                                 G_ELI_DEBUG(1, "Cannot create kernel thread "
 702                                     "for %s (error=%d).", bpp->name, error);
 703                         }
 704                         goto failed;
 705                 }
 706                 LIST_INSERT_HEAD(&sc->sc_workers, wr, w_next);
 707                 /* If we have hardware support, one thread is enough. */
 708                 if (sc->sc_crypto == G_ELI_CRYPTO_HW)
 709                         break;
 710         }
 711
 712         /*
 713          * Create decrypted provider.
 714          */
 715         pp = g_new_providerf(gp, "%s%s", bpp->name, G_ELI_SUFFIX);
 716         pp->sectorsize = md->md_sectorsize;
 717         pp->mediasize = bpp->mediasize;
 718         if (!(sc->sc_flags & G_ELI_FLAG_ONETIME))
 719                 pp->mediasize -= bpp->sectorsize;
 720         if (!(sc->sc_flags & G_ELI_FLAG_AUTH))
 721                 pp->mediasize -= (pp->mediasize % pp->sectorsize);
 722         else {
 723                 pp->mediasize /= sc->sc_bytes_per_sector;
 724                 pp->mediasize *= pp->sectorsize;
 725         }
 726
 727         g_error_provider(pp, 0);
 728
 729         G_ELI_DEBUG(0, "Device %s created.", pp->name);
 730         G_ELI_DEBUG(0, "Encryption: %s %u", g_eli_algo2str(sc->sc_ealgo),
 731             sc->sc_ekeylen);
 732         if (sc->sc_flags & G_ELI_FLAG_AUTH)
 733                 G_ELI_DEBUG(0, " Integrity: %s", g_eli_algo2str(sc->sc_aalgo));
 734         G_ELI_DEBUG(0, "    Crypto: %s",
 735             sc->sc_crypto == G_ELI_CRYPTO_SW ? "software" : "hardware");
 736         return (gp);
 737 failed:
 738         mtx_lock(&sc->sc_queue_mtx);
 739         sc->sc_flags |= G_ELI_FLAG_DESTROY;
 740         wakeup(sc);
 741         /*
 742          * Wait for kernel threads self destruction.
 743          */
 744         while (!LIST_EMPTY(&sc->sc_workers)) {
 745                 msleep(&sc->sc_workers, &sc->sc_queue_mtx, PRIBIO,
 746                     "geli:destroy", 0);
 747         }
 748         mtx_destroy(&sc->sc_queue_mtx);
 749         if (cp->provider != NULL) {
 750                 if (cp->acr == 1)
 751                         g_access(cp, -1, -1, -1);
 752                 g_detach(cp);
 753         }
 754         g_destroy_consumer(cp);
 755         g_destroy_geom(gp);
 756         bzero(sc, sizeof(*sc));
 757         free(sc, M_ELI);
 758         return (NULL);
 759 }
 760
 761 int
 762 g_eli_destroy(struct g_eli_softc *sc, boolean_t force)
 763 {
 764         struct g_geom *gp;
 765         struct g_provider *pp;
 766
 767         g_topology_assert();
 768
 769         if (sc == NULL)
 770                 return (ENXIO);
 771
 772         gp = sc->sc_geom;
 773         pp = LIST_FIRST(&gp->provider);
 774         if (pp != NULL && (pp->acr != 0 || pp->acw != 0 || pp->ace != 0)) {
 775                 if (force) {
 776                         G_ELI_DEBUG(1, "Device %s is still open, so it "
 777                             "cannot be definitely removed.", pp->name);
 778                 } else {
 779                         G_ELI_DEBUG(1,
 780                             "Device %s is still open (r%dw%de%d).", pp->name,
 781                             pp->acr, pp->acw, pp->ace);
 782                         return (EBUSY);
 783                 }
 784         }
 785
 786         mtx_lock(&sc->sc_queue_mtx);
 787         sc->sc_flags |= G_ELI_FLAG_DESTROY;
 788         wakeup(sc);
 789         while (!LIST_EMPTY(&sc->sc_workers)) {
 790                 msleep(&sc->sc_workers, &sc->sc_queue_mtx, PRIBIO,
 791                     "geli:destroy", 0);
 792         }
 793         mtx_destroy(&sc->sc_queue_mtx);
 794         gp->softc = NULL;
 795         bzero(sc, sizeof(*sc));
 796         free(sc, M_ELI);
 797
 798         if (pp == NULL || (pp->acr == 0 && pp->acw == 0 && pp->ace == 0))
 799                 G_ELI_DEBUG(0, "Device %s destroyed.", gp->name);
 800         g_wither_geom_close(gp, ENXIO);
 801
 802         return (0);
 803 }
 804
 805 static int
 806 g_eli_destroy_geom(struct gctl_req *req __unused,
 807     struct g_class *mp __unused, struct g_geom *gp)
 808 {
 809         struct g_eli_softc *sc;
 810
 811         sc = gp->softc;
 812         return (g_eli_destroy(sc, 0));
 813 }
 814
 815 static int
 816 g_eli_keyfiles_load(struct hmac_ctx *ctx, const char *provider)
 817 {
 818         u_char *keyfile, *data, *size;
 819         char *file, name[64];
 820         int i;
 821
 822         for (i = 0; ; i++) {
 823                 snprintf(name, sizeof(name), "%s:geli_keyfile%d", provider, i);
 824                 keyfile = preload_search_by_type(name);
 825                 if (keyfile == NULL)
 826                         return (i);     /* Return number of loaded keyfiles. */
 827                 data = preload_search_info(keyfile, MODINFO_ADDR);
 828                 if (data == NULL) {
 829                         G_ELI_DEBUG(0, "Cannot find key file data for %s.",
 830                             name);
 831                         return (0);
 832                 }
 833                 data = *(void **)data;
 834                 size = preload_search_info(keyfile, MODINFO_SIZE);
 835                 if (size == NULL) {
 836                         G_ELI_DEBUG(0, "Cannot find key file size for %s.",
 837                             name);
 838                         return (0);
 839                 }
 840                 file = preload_search_info(keyfile, MODINFO_NAME);
 841                 if (file == NULL) {
 842                         G_ELI_DEBUG(0, "Cannot find key file name for %s.",
 843                             name);
 844                         return (0);
 845                 }
 846                 G_ELI_DEBUG(1, "Loaded keyfile %s for %s (type: %s).", file,
 847                     provider, name);
 848                 g_eli_crypto_hmac_update(ctx, data, *(size_t *)size);
 849         }
 850 }
 851
 852 static void
 853 g_eli_keyfiles_clear(const char *provider)
 854 {
 855         u_char *keyfile, *data, *size;
 856         char name[64];
 857         int i;
 858
 859         for (i = 0; ; i++) {
 860                 snprintf(name, sizeof(name), "%s:geli_keyfile%d", provider, i);
 861                 keyfile = preload_search_by_type(name);
 862                 if (keyfile == NULL)
 863                         return;
 864                 data = preload_search_info(keyfile, MODINFO_ADDR);
 865                 size = preload_search_info(keyfile, MODINFO_SIZE);
 866                 if (data == NULL || size == NULL)
 867                         continue;
 868                 data = *(void **)data;
 869                 bzero(data, *(size_t *)size);
 870         }
 871 }
 872
 873 /*
 874  * Tasting is only made on boot.
 875  * We detect providers which should be attached before root is mounted.
 876  */
 877 static struct g_geom *
 878 g_eli_taste(struct g_class *mp, struct g_provider *pp, int flags __unused)
 879 {
 880         struct g_eli_metadata md;
 881         struct g_geom *gp;
 882         struct hmac_ctx ctx;
 883         char passphrase[256];
 884         u_char key[G_ELI_USERKEYLEN], mkey[G_ELI_DATAIVKEYLEN];
 885         u_int i, nkey, nkeyfiles, tries;
 886         int error;
 887
 888         g_trace(G_T_TOPOLOGY, "%s(%s, %s)", __func__, mp->name, pp->name);
 889         g_topology_assert();
 890
 891         if (root_mounted() || g_eli_tries == 0)
 892                 return (NULL);
 893
 894         G_ELI_DEBUG(3, "Tasting %s.", pp->name);
 895
 896         error = g_eli_read_metadata(mp, pp, &md);
 897         if (error != 0)
 898                 return (NULL);
 899         gp = NULL;
 900
 901         if (strcmp(md.md_magic, G_ELI_MAGIC) != 0)
 902                 return (NULL);
 903         if (md.md_version > G_ELI_VERSION) {
 904                 printf("geom_eli.ko module is too old to handle %s.\n",
 905                     pp->name);
 906                 return (NULL);
 907         }
 908         if (md.md_provsize != pp->mediasize)
 909                 return (NULL);
 910         /* Should we attach it on boot? */
 911         if (!(md.md_flags & G_ELI_FLAG_BOOT))
 912                 return (NULL);
 913         if (md.md_keys == 0x00) {
 914                 G_ELI_DEBUG(0, "No valid keys on %s.", pp->name);
 915                 return (NULL);
 916         }
 917         if (md.md_iterations == -1) {
 918                 /* If there is no passphrase, we try only once. */
 919                 tries = 1;
 920         } else {
 921                 /* Ask for the passphrase no more than g_eli_tries times. */
 922                 tries = g_eli_tries;
 923         }
 924
 925         for (i = 0; i < tries; i++) {
 926                 g_eli_crypto_hmac_init(&ctx, NULL, 0);
 927
 928                 /*
 929                  * Load all key files.
 930                  */
 931                 nkeyfiles = g_eli_keyfiles_load(&ctx, pp->name);
 932
 933                 if (nkeyfiles == 0 && md.md_iterations == -1) {
 934                         /*
 935                          * No key files and no passphrase, something is
 936                          * definitely wrong here.
 937                          * geli(8) doesn't allow for such situation, so assume
 938                          * that there was really no passphrase and in that case
 939                          * key files are no properly defined in loader.conf.
 940                          */
 941                         G_ELI_DEBUG(0,
 942                             "Found no key files in loader.conf for %s.",
 943                             pp->name);
 944                         return (NULL);
 945                 }
 946
 947                 /* Ask for the passphrase if defined. */
 948                 if (md.md_iterations >= 0) {
 949                         printf("Enter passphrase for %s: ", pp->name);
 950                         gets(passphrase, sizeof(passphrase),
 951                             g_eli_visible_passphrase);
 952                 }
 953
 954                 /*
 955                  * Prepare Derived-Key from the user passphrase.
 956                  */
 957                 if (md.md_iterations == 0) {
 958                         g_eli_crypto_hmac_update(&ctx, md.md_salt,
 959                             sizeof(md.md_salt));
 960                         g_eli_crypto_hmac_update(&ctx, passphrase,
 961                             strlen(passphrase));
 962                         bzero(passphrase, sizeof(passphrase));
 963                 } else if (md.md_iterations > 0) {
 964                         u_char dkey[G_ELI_USERKEYLEN];
 965
 966                         pkcs5v2_genkey(dkey, sizeof(dkey), md.md_salt,
 967                             sizeof(md.md_salt), passphrase, md.md_iterations);
 968                         bzero(passphrase, sizeof(passphrase));
 969                         g_eli_crypto_hmac_update(&ctx, dkey, sizeof(dkey));
 970                         bzero(dkey, sizeof(dkey));
 971                 }
 972
 973                 g_eli_crypto_hmac_final(&ctx, key, 0);
 974
 975                 /*
 976                  * Decrypt Master-Key.
 977                  */
 978                 error = g_eli_mkey_decrypt(&md, key, mkey, &nkey);
 979                 bzero(key, sizeof(key));
 980                 if (error == -1) {
 981                         if (i == tries - 1) {
 982                                 G_ELI_DEBUG(0,
 983                                     "Wrong key for %s. No tries left.",
 984                                     pp->name);
 985                                 g_eli_keyfiles_clear(pp->name);
 986                                 return (NULL);
 987                         }
 988                         G_ELI_DEBUG(0, "Wrong key for %s. Tries left: %u.",
 989                             pp->name, tries - i - 1);
 990                         /* Try again. */
 991                         continue;
 992                 } else if (error > 0) {
 993                         G_ELI_DEBUG(0, "Cannot decrypt Master Key for %s (error=%d).",
 994                             pp->name, error);
 995                         g_eli_keyfiles_clear(pp->name);
 996                         return (NULL);
 997                 }
 998                 G_ELI_DEBUG(1, "Using Master Key %u for %s.", nkey, pp->name);
 999                 break;
1000         }
1001
1002         /*
1003          * We have correct key, let's attach provider.
1004          */
1005         gp = g_eli_create(NULL, mp, pp, &md, mkey, nkey);
1006         bzero(mkey, sizeof(mkey));
1007         bzero(&md, sizeof(md));
1008         if (gp == NULL) {
1009                 G_ELI_DEBUG(0, "Cannot create device %s%s.", pp->name,
1010                     G_ELI_SUFFIX);
1011                 return (NULL);
1012         }
1013         return (gp);
1014 }
1015
1016 static void
1017 g_eli_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp,
1018     struct g_consumer *cp, struct g_provider *pp)
1019 {
1020         struct g_eli_softc *sc;
1021
1022         g_topology_assert();
1023         sc = gp->softc;
1024         if (sc == NULL)
1025                 return;
1026         if (pp != NULL || cp != NULL)
1027                 return; /* Nothing here. */
1028         sbuf_printf(sb, "%s<Flags>", indent);
1029         if (sc->sc_flags == 0)
1030                 sbuf_printf(sb, "NONE");
1031         else {
1032                 int first = 1;
1033
1034 #define ADD_FLAG(flag, name)    do {                                    \
1035         if (sc->sc_flags & (flag)) {                                    \
1036                 if (!first)                                             \
1037                         sbuf_printf(sb, ", ");                          \
1038                 else                                                    \
1039                         first = 0;                                      \
1040                 sbuf_printf(sb, name);                                  \
1041         }                                                               \
1042 } while (0)
1043                 ADD_FLAG(G_ELI_FLAG_NATIVE_BYTE_ORDER, "NATIVE-BYTE-ORDER");
1044                 ADD_FLAG(G_ELI_FLAG_ONETIME, "ONETIME");
1045                 ADD_FLAG(G_ELI_FLAG_BOOT, "BOOT");
1046                 ADD_FLAG(G_ELI_FLAG_WO_DETACH, "W-DETACH");
1047                 ADD_FLAG(G_ELI_FLAG_RW_DETACH, "RW-DETACH");
1048                 ADD_FLAG(G_ELI_FLAG_AUTH, "AUTH");
1049                 ADD_FLAG(G_ELI_FLAG_WOPEN, "W-OPEN");
1050                 ADD_FLAG(G_ELI_FLAG_DESTROY, "DESTROY");
1051                 ADD_FLAG(G_ELI_FLAG_RO, "READ-ONLY");
1052 #undef  ADD_FLAG
1053         }
1054         sbuf_printf(sb, "</Flags>\n");
1055
1056         if (!(sc->sc_flags & G_ELI_FLAG_ONETIME)) {
1057                 sbuf_printf(sb, "%s<UsedKey>%u</UsedKey>\n", indent,
1058                     sc->sc_nkey);
1059         }
1060         sbuf_printf(sb, "%s<Crypto>", indent);
1061         switch (sc->sc_crypto) {
1062         case G_ELI_CRYPTO_HW:
1063                 sbuf_printf(sb, "hardware");
1064                 break;
1065         case G_ELI_CRYPTO_SW:
1066                 sbuf_printf(sb, "software");
1067                 break;
1068         default:
1069                 sbuf_printf(sb, "UNKNOWN");
1070                 break;
1071         }
1072         sbuf_printf(sb, "</Crypto>\n");
1073         if (sc->sc_flags & G_ELI_FLAG_AUTH) {
1074                 sbuf_printf(sb,
1075                     "%s<AuthenticationAlgorithm>%s</AuthenticationAlgorithm>\n",
1076                     indent, g_eli_algo2str(sc->sc_aalgo));
1077         }
1078         sbuf_printf(sb, "%s<KeyLength>%u</KeyLength>\n", indent,
1079             sc->sc_ekeylen);
1080         sbuf_printf(sb, "%s<EncryptionAlgorithm>%s</EncryptionAlgorithm>\n", indent,
1081             g_eli_algo2str(sc->sc_ealgo));
1082 }
1083
1084 static void
1085 g_eli_shutdown_pre_sync(void *arg, int howto)
1086 {
1087         struct g_class *mp;
1088         struct g_geom *gp, *gp2;
1089         struct g_provider *pp;
1090         struct g_eli_softc *sc;
1091         int error;
1092
1093         mp = arg;
1094         DROP_GIANT();
1095         g_topology_lock();
1096         LIST_FOREACH_SAFE(gp, &mp->geom, geom, gp2) {
1097                 sc = gp->softc;
1098                 if (sc == NULL)
1099                         continue;
1100                 pp = LIST_FIRST(&gp->provider);
1101                 KASSERT(pp != NULL, ("No provider? gp=%p (%s)", gp, gp->name));
1102                 if (pp->acr + pp->acw + pp->ace == 0)
1103                         error = g_eli_destroy(sc, 1);
1104                 else {
1105                         sc->sc_flags |= G_ELI_FLAG_RW_DETACH;
1106                         gp->access = g_eli_access;
1107                 }
1108         }
1109         g_topology_unlock();
1110         PICKUP_GIANT();
1111 }
1112
1113 static void
1114 g_eli_init(struct g_class *mp)
1115 {
1116
1117         g_eli_pre_sync = EVENTHANDLER_REGISTER(shutdown_pre_sync,
1118             g_eli_shutdown_pre_sync, mp, SHUTDOWN_PRI_FIRST);
1119         if (g_eli_pre_sync == NULL)
1120                 G_ELI_DEBUG(0, "Warning! Cannot register shutdown event.");
1121 }
1122
1123 static void
1124 g_eli_fini(struct g_class *mp)
1125 {
1126
1127         if (g_eli_pre_sync != NULL)
1128                 EVENTHANDLER_DEREGISTER(shutdown_pre_sync, g_eli_pre_sync);
1129 }
1130
1131 DECLARE_GEOM_CLASS(g_eli_class, g_eli);
1132 MODULE_DEPEND(g_eli, crypto, 1, 1, 1);