lib/crypto_backend/crypto_storage.c

   1 /*
   2  * Generic wrapper for storage encryption modes and Initial Vectors
   3  * (reimplementation of some functions from Linux dm-crypt kernel)
   4  *
   5  * Copyright (C) 2014-2023 Milan Broz
   6  *
   7  * This file is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This file is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this file; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include <strings.h>
  25 #include "bitops.h"
  26 #include "crypto_backend.h"
  27
  28 #define SECTOR_SHIFT    9
  29
  30 /*
  31  * Internal IV helper
  32  * IV documentation: https://gitlab.com/cryptsetup/cryptsetup/wikis/DMCrypt
  33  */
  34 struct crypt_sector_iv {
  35         enum { IV_NONE, IV_NULL, IV_PLAIN, IV_PLAIN64, IV_ESSIV, IV_BENBI, IV_PLAIN64BE, IV_EBOIV } type;
  36         int iv_size;
  37         char *iv;
  38         struct crypt_cipher *cipher;
  39         int shift;
  40 };
  41
  42 /* Block encryption storage context */
  43 struct crypt_storage {
  44         size_t sector_size;
  45         unsigned iv_shift;
  46         struct crypt_cipher *cipher;
  47         struct crypt_sector_iv cipher_iv;
  48 };
  49
  50 static int int_log2(unsigned int x)
  51 {
  52         int r = 0;
  53         for (x >>= 1; x > 0; x >>= 1)
  54                 r++;
  55         return r;
  56 }
  57
  58 static int crypt_sector_iv_init(struct crypt_sector_iv *ctx,
  59                          const char *cipher_name, const char *mode_name,
  60                          const char *iv_name, const void *key, size_t key_length,
  61                          size_t sector_size)
  62 {
  63         int r;
  64
  65         memset(ctx, 0, sizeof(*ctx));
  66
  67         ctx->iv_size = crypt_cipher_ivsize(cipher_name, mode_name);
  68         if (ctx->iv_size < 0 || (strcmp(mode_name, "ecb") && ctx->iv_size < 8))
  69                 return -ENOENT;
  70
  71         if (!strcmp(cipher_name, "cipher_null") ||
  72             !strcmp(mode_name, "ecb")) {
  73                 if (iv_name)
  74                         return -EINVAL;
  75                 ctx->type = IV_NONE;
  76                 ctx->iv_size = 0;
  77                 return 0;
  78         } else if (!iv_name) {
  79                 return -EINVAL;
  80         } else if (!strcasecmp(iv_name, "null")) {
  81                 ctx->type = IV_NULL;
  82         } else if (!strcasecmp(iv_name, "plain64")) {
  83                 ctx->type = IV_PLAIN64;
  84         } else if (!strcasecmp(iv_name, "plain64be")) {
  85                 ctx->type = IV_PLAIN64BE;
  86         } else if (!strcasecmp(iv_name, "plain")) {
  87                 ctx->type = IV_PLAIN;
  88         } else if (!strncasecmp(iv_name, "essiv:", 6)) {
  89                 struct crypt_hash *h = NULL;
  90                 char *hash_name = strchr(iv_name, ':');
  91                 int hash_size;
  92                 char tmp[256];
  93
  94                 if (!hash_name)
  95                         return -EINVAL;
  96
  97                 hash_size = crypt_hash_size(++hash_name);
  98                 if (hash_size < 0)
  99                         return -ENOENT;
 100
 101                 if ((unsigned)hash_size > sizeof(tmp))
 102                         return -EINVAL;
 103
 104                 if (crypt_hash_init(&h, hash_name))
 105                         return -EINVAL;
 106
 107                 r = crypt_hash_write(h, key, key_length);
 108                 if (r) {
 109                         crypt_hash_destroy(h);
 110                         return r;
 111                 }
 112
 113                 r = crypt_hash_final(h, tmp, hash_size);
 114                 crypt_hash_destroy(h);
 115                 if (r) {
 116                         crypt_backend_memzero(tmp, sizeof(tmp));
 117                         return r;
 118                 }
 119
 120                 r = crypt_cipher_init(&ctx->cipher, cipher_name, "ecb",
 121                                       tmp, hash_size);
 122                 crypt_backend_memzero(tmp, sizeof(tmp));
 123                 if (r)
 124                         return r;
 125
 126                 ctx->type = IV_ESSIV;
 127         } else if (!strncasecmp(iv_name, "benbi", 5)) {
 128                 int log = int_log2(ctx->iv_size);
 129                 if (log > SECTOR_SHIFT)
 130                         return -EINVAL;
 131
 132                 ctx->type = IV_BENBI;
 133                 ctx->shift = SECTOR_SHIFT - log;
 134         } else if (!strncasecmp(iv_name, "eboiv", 5)) {
 135                 r = crypt_cipher_init(&ctx->cipher, cipher_name, "ecb",
 136                                       key, key_length);
 137                 if (r)
 138                         return r;
 139
 140                 ctx->type = IV_EBOIV;
 141                 ctx->shift = int_log2(sector_size);
 142         } else
 143                 return -ENOENT;
 144
 145         ctx->iv = malloc(ctx->iv_size);
 146         if (!ctx->iv)
 147                 return -ENOMEM;
 148
 149         return 0;
 150 }
 151
 152 static int crypt_sector_iv_generate(struct crypt_sector_iv *ctx, uint64_t sector)
 153 {
 154         uint64_t val, *u64_iv;
 155         uint32_t *u32_iv;
 156
 157         switch (ctx->type) {
 158         case IV_NONE:
 159                 break;
 160         case IV_NULL:
 161                 memset(ctx->iv, 0, ctx->iv_size);
 162                 break;
 163         case IV_PLAIN:
 164                 memset(ctx->iv, 0, ctx->iv_size);
 165                 u32_iv = (void *)ctx->iv;
 166                 *u32_iv = cpu_to_le32(sector & 0xffffffff);
 167                 break;
 168         case IV_PLAIN64:
 169                 memset(ctx->iv, 0, ctx->iv_size);
 170                 u64_iv = (void *)ctx->iv;
 171                 *u64_iv = cpu_to_le64(sector);
 172                 break;
 173         case IV_PLAIN64BE:
 174                 memset(ctx->iv, 0, ctx->iv_size);
 175                 /* iv_size is at least of size u64; usually it is 16 bytes */
 176                 u64_iv = (void *)&ctx->iv[ctx->iv_size - sizeof(uint64_t)];
 177                 *u64_iv = cpu_to_be64(sector);
 178                 break;
 179         case IV_ESSIV:
 180                 memset(ctx->iv, 0, ctx->iv_size);
 181                 u64_iv = (void *)ctx->iv;
 182                 *u64_iv = cpu_to_le64(sector);
 183                 return crypt_cipher_encrypt(ctx->cipher,
 184                         ctx->iv, ctx->iv, ctx->iv_size, NULL, 0);
 185                 break;
 186         case IV_BENBI:
 187                 memset(ctx->iv, 0, ctx->iv_size);
 188                 val = cpu_to_be64((sector << ctx->shift) + 1);
 189                 memcpy(ctx->iv + ctx->iv_size - sizeof(val), &val, sizeof(val));
 190                 break;
 191         case IV_EBOIV:
 192                 memset(ctx->iv, 0, ctx->iv_size);
 193                 u64_iv = (void *)ctx->iv;
 194                 *u64_iv = cpu_to_le64(sector << ctx->shift);
 195                 return crypt_cipher_encrypt(ctx->cipher,
 196                         ctx->iv, ctx->iv, ctx->iv_size, NULL, 0);
 197                 break;
 198         default:
 199                 return -EINVAL;
 200         }
 201
 202         return 0;
 203 }
 204
 205 static void crypt_sector_iv_destroy(struct crypt_sector_iv *ctx)
 206 {
 207         if (ctx->type == IV_ESSIV || ctx->type == IV_EBOIV)
 208                 crypt_cipher_destroy(ctx->cipher);
 209
 210         if (ctx->iv) {
 211                 memset(ctx->iv, 0, ctx->iv_size);
 212                 free(ctx->iv);
 213         }
 214
 215         memset(ctx, 0, sizeof(*ctx));
 216 }
 217
 218 /* Block encryption storage wrappers */
 219
 220 int crypt_storage_init(struct crypt_storage **ctx,
 221                        size_t sector_size,
 222                        const char *cipher,
 223                        const char *cipher_mode,
 224                        const void *key, size_t key_length,
 225                        bool large_iv)
 226 {
 227         struct crypt_storage *s;
 228         char mode_name[64];
 229         char *cipher_iv = NULL;
 230         int r = -EIO;
 231
 232         if (sector_size < (1 << SECTOR_SHIFT) ||
 233             sector_size > (1 << (SECTOR_SHIFT + 3)) ||
 234             sector_size & (sector_size - 1))
 235                 return -EINVAL;
 236
 237         s = malloc(sizeof(*s));
 238         if (!s)
 239                 return -ENOMEM;
 240         memset(s, 0, sizeof(*s));
 241
 242         /* Remove IV if present */
 243         strncpy(mode_name, cipher_mode, sizeof(mode_name));
 244         mode_name[sizeof(mode_name) - 1] = 0;
 245         cipher_iv = strchr(mode_name, '-');
 246         if (cipher_iv) {
 247                 *cipher_iv = '\0';
 248                 cipher_iv++;
 249         }
 250
 251         r = crypt_cipher_init(&s->cipher, cipher, mode_name, key, key_length);
 252         if (r) {
 253                 crypt_storage_destroy(s);
 254                 return r;
 255         }
 256
 257         r = crypt_sector_iv_init(&s->cipher_iv, cipher, mode_name, cipher_iv, key, key_length, sector_size);
 258         if (r) {
 259                 crypt_storage_destroy(s);
 260                 return r;
 261         }
 262
 263         s->sector_size = sector_size;
 264         s->iv_shift = large_iv ? int_log2(sector_size) - SECTOR_SHIFT : 0;
 265
 266         *ctx = s;
 267         return 0;
 268 }
 269
 270 int crypt_storage_decrypt(struct crypt_storage *ctx,
 271                        uint64_t iv_offset,
 272                        uint64_t length, char *buffer)
 273 {
 274         uint64_t i;
 275         int r = 0;
 276
 277         if (length & (ctx->sector_size - 1))
 278                 return -EINVAL;
 279
 280         if (iv_offset & ((ctx->sector_size >> SECTOR_SHIFT) - 1))
 281                 return -EINVAL;
 282
 283         for (i = 0; i < length; i += ctx->sector_size) {
 284                 r = crypt_sector_iv_generate(&ctx->cipher_iv, (iv_offset + (i >> SECTOR_SHIFT)) >> ctx->iv_shift);
 285                 if (r)
 286                         break;
 287                 r = crypt_cipher_decrypt(ctx->cipher,
 288                                          &buffer[i],
 289                                          &buffer[i],
 290                                          ctx->sector_size,
 291                                          ctx->cipher_iv.iv,
 292                                          ctx->cipher_iv.iv_size);
 293                 if (r)
 294                         break;
 295         }
 296
 297         return r;
 298 }
 299
 300 int crypt_storage_encrypt(struct crypt_storage *ctx,
 301                        uint64_t iv_offset,
 302                        uint64_t length, char *buffer)
 303 {
 304         uint64_t i;
 305         int r = 0;
 306
 307         if (length & (ctx->sector_size - 1))
 308                 return -EINVAL;
 309
 310         if (iv_offset & ((ctx->sector_size >> SECTOR_SHIFT) - 1))
 311                 return -EINVAL;
 312
 313         for (i = 0; i < length; i += ctx->sector_size) {
 314                 r = crypt_sector_iv_generate(&ctx->cipher_iv, (iv_offset + (i >> SECTOR_SHIFT)) >> ctx->iv_shift);
 315                 if (r)
 316                         break;
 317                 r = crypt_cipher_encrypt(ctx->cipher,
 318                                          &buffer[i],
 319                                          &buffer[i],
 320                                          ctx->sector_size,
 321                                          ctx->cipher_iv.iv,
 322                                          ctx->cipher_iv.iv_size);
 323                 if (r)
 324                         break;
 325         }
 326
 327         return r;
 328 }
 329
 330 void crypt_storage_destroy(struct crypt_storage *ctx)
 331 {
 332         if (!ctx)
 333                 return;
 334
 335         crypt_sector_iv_destroy(&ctx->cipher_iv);
 336
 337         if (ctx->cipher)
 338                 crypt_cipher_destroy(ctx->cipher);
 339
 340         memset(ctx, 0, sizeof(*ctx));
 341         free(ctx);
 342 }
 343
 344 bool crypt_storage_kernel_only(struct crypt_storage *ctx)
 345 {
 346         return crypt_cipher_kernel_only(ctx->cipher);
 347 }