lib/luks2/luks2_digest.c

   1 /*
   2  * LUKS - Linux Unified Key Setup v2, digest handling
   3  *
   4  * Copyright (C) 2015-2023 Red Hat, Inc. All rights reserved.
   5  * Copyright (C) 2015-2023 Milan Broz
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program 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
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "luks2_internal.h"
  23
  24 extern const digest_handler PBKDF2_digest;
  25
  26 static const digest_handler *digest_handlers[LUKS2_DIGEST_MAX] = {
  27         &PBKDF2_digest,
  28         NULL
  29 };
  30
  31 static const digest_handler *LUKS2_digest_handler_type(const char *type)
  32 {
  33         int i;
  34
  35         for (i = 0; i < LUKS2_DIGEST_MAX && digest_handlers[i]; i++) {
  36                 if (!strcmp(digest_handlers[i]->name, type))
  37                         return digest_handlers[i];
  38         }
  39
  40         return NULL;
  41 }
  42
  43 static const digest_handler *LUKS2_digest_handler(struct crypt_device *cd, int digest)
  44 {
  45         struct luks2_hdr *hdr;
  46         json_object *jobj1, *jobj2;
  47
  48         if (digest < 0)
  49                 return NULL;
  50
  51         if (!(hdr = crypt_get_hdr(cd, CRYPT_LUKS2)))
  52                 return NULL;
  53
  54         if (!(jobj1 = LUKS2_get_digest_jobj(hdr, digest)))
  55                 return NULL;
  56
  57         if (!json_object_object_get_ex(jobj1, "type", &jobj2))
  58                 return NULL;
  59
  60         return LUKS2_digest_handler_type(json_object_get_string(jobj2));
  61 }
  62
  63 static int LUKS2_digest_find_free(struct luks2_hdr *hdr)
  64 {
  65         int digest = 0;
  66
  67         while (LUKS2_get_digest_jobj(hdr, digest) && digest < LUKS2_DIGEST_MAX)
  68                 digest++;
  69
  70         return digest < LUKS2_DIGEST_MAX ? digest : -1;
  71 }
  72
  73 int LUKS2_digest_create(struct crypt_device *cd,
  74         const char *type,
  75         struct luks2_hdr *hdr,
  76         const struct volume_key *vk)
  77 {
  78         int digest;
  79         const digest_handler *dh;
  80
  81         dh = LUKS2_digest_handler_type(type);
  82         if (!dh)
  83                 return -EINVAL;
  84
  85         digest = LUKS2_digest_find_free(hdr);
  86         if (digest < 0)
  87                 return -EINVAL;
  88
  89         log_dbg(cd, "Creating new digest %d (%s).", digest, type);
  90
  91         return dh->store(cd, digest, vk->key, vk->keylength) ?: digest;
  92 }
  93
  94 int LUKS2_digest_by_keyslot(struct luks2_hdr *hdr, int keyslot)
  95 {
  96         char keyslot_name[16];
  97         json_object *jobj_digests, *jobj_digest_keyslots;
  98
  99         if (snprintf(keyslot_name, sizeof(keyslot_name), "%u", keyslot) < 1)
 100                 return -ENOMEM;
 101
 102         json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 103
 104         json_object_object_foreach(jobj_digests, key, val) {
 105                 json_object_object_get_ex(val, "keyslots", &jobj_digest_keyslots);
 106                 if (LUKS2_array_jobj(jobj_digest_keyslots, keyslot_name))
 107                         return atoi(key);
 108         }
 109
 110         return -ENOENT;
 111 }
 112
 113 int LUKS2_digest_verify_by_digest(struct crypt_device *cd,
 114         int digest,
 115         const struct volume_key *vk)
 116 {
 117         const digest_handler *h;
 118         int r;
 119
 120         h = LUKS2_digest_handler(cd, digest);
 121         if (!h)
 122                 return -EINVAL;
 123
 124         r = h->verify(cd, digest, vk->key, vk->keylength);
 125         if (r < 0) {
 126                 log_dbg(cd, "Digest %d (%s) verify failed with %d.", digest, h->name, r);
 127                 return r;
 128         }
 129
 130         return digest;
 131 }
 132
 133 int LUKS2_digest_verify(struct crypt_device *cd,
 134         struct luks2_hdr *hdr,
 135         const struct volume_key *vk,
 136         int keyslot)
 137 {
 138         int digest;
 139
 140         digest = LUKS2_digest_by_keyslot(hdr, keyslot);
 141         if (digest < 0)
 142                 return digest;
 143
 144         log_dbg(cd, "Verifying key from keyslot %d, digest %d.", keyslot, digest);
 145
 146         return LUKS2_digest_verify_by_digest(cd, digest, vk);
 147 }
 148
 149 int LUKS2_digest_dump(struct crypt_device *cd, int digest)
 150 {
 151         const digest_handler *h;
 152
 153         if (!(h = LUKS2_digest_handler(cd, digest)))
 154                 return -EINVAL;
 155
 156         return h->dump(cd, digest);
 157 }
 158
 159 int LUKS2_digest_any_matching(struct crypt_device *cd,
 160                 struct luks2_hdr *hdr,
 161                 const struct volume_key *vk)
 162 {
 163         int digest;
 164
 165         for (digest = 0; digest < LUKS2_DIGEST_MAX; digest++)
 166                 if (LUKS2_digest_verify_by_digest(cd, digest, vk) == digest)
 167                         return digest;
 168
 169         return -ENOENT;
 170 }
 171
 172 int LUKS2_digest_verify_by_segment(struct crypt_device *cd,
 173         struct luks2_hdr *hdr,
 174         int segment,
 175         const struct volume_key *vk)
 176 {
 177         return LUKS2_digest_verify_by_digest(cd, LUKS2_digest_by_segment(hdr, segment), vk);
 178 }
 179
 180 /* FIXME: segment can have more digests */
 181 int LUKS2_digest_by_segment(struct luks2_hdr *hdr, int segment)
 182 {
 183         char segment_name[16];
 184         json_object *jobj_digests, *jobj_digest_segments;
 185
 186         if (segment == CRYPT_DEFAULT_SEGMENT)
 187                 segment = LUKS2_get_default_segment(hdr);
 188
 189         json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 190
 191         if (snprintf(segment_name, sizeof(segment_name), "%u", segment) < 1)
 192                 return -EINVAL;
 193
 194         json_object_object_foreach(jobj_digests, key, val) {
 195                 json_object_object_get_ex(val, "segments", &jobj_digest_segments);
 196                 if (!LUKS2_array_jobj(jobj_digest_segments, segment_name))
 197                         continue;
 198
 199                 return atoi(key);
 200         }
 201
 202         return -ENOENT;
 203 }
 204
 205 static int assign_one_digest(struct crypt_device *cd, struct luks2_hdr *hdr,
 206                              int keyslot, int digest, int assign)
 207 {
 208         json_object *jobj1, *jobj_digest, *jobj_digest_keyslots;
 209         char num[16];
 210
 211         log_dbg(cd, "Keyslot %i %s digest %i.", keyslot, assign ? "assigned to" : "unassigned from", digest);
 212
 213         jobj_digest = LUKS2_get_digest_jobj(hdr, digest);
 214         if (!jobj_digest)
 215                 return -EINVAL;
 216
 217         json_object_object_get_ex(jobj_digest, "keyslots", &jobj_digest_keyslots);
 218         if (!jobj_digest_keyslots)
 219                 return -EINVAL;
 220
 221         if (snprintf(num, sizeof(num), "%d", keyslot) < 0)
 222                 return -EINVAL;
 223
 224         if (assign) {
 225                 jobj1 = LUKS2_array_jobj(jobj_digest_keyslots, num);
 226                 if (!jobj1)
 227                         json_object_array_add(jobj_digest_keyslots, json_object_new_string(num));
 228         } else {
 229                 jobj1 = LUKS2_array_remove(jobj_digest_keyslots, num);
 230                 if (jobj1)
 231                         json_object_object_add(jobj_digest, "keyslots", jobj1);
 232         }
 233
 234         return 0;
 235 }
 236
 237 int LUKS2_digest_assign(struct crypt_device *cd, struct luks2_hdr *hdr,
 238                         int keyslot, int digest, int assign, int commit)
 239 {
 240         json_object *jobj_digests;
 241         int r = 0;
 242
 243         if (digest == CRYPT_ANY_DIGEST) {
 244                 json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 245
 246                 json_object_object_foreach(jobj_digests, key, val) {
 247                         UNUSED(val);
 248                         r = assign_one_digest(cd, hdr, keyslot, atoi(key), assign);
 249                         if (r < 0)
 250                                 break;
 251                 }
 252         } else
 253                 r = assign_one_digest(cd, hdr, keyslot, digest, assign);
 254
 255         if (r < 0)
 256                 return r;
 257
 258         return commit ? LUKS2_hdr_write(cd, hdr) : 0;
 259 }
 260
 261 static int assign_all_segments(struct luks2_hdr *hdr, int digest, int assign)
 262 {
 263         json_object *jobj1, *jobj_digest, *jobj_digest_segments;
 264
 265         jobj_digest = LUKS2_get_digest_jobj(hdr, digest);
 266         if (!jobj_digest)
 267                 return -EINVAL;
 268
 269         json_object_object_get_ex(jobj_digest, "segments", &jobj_digest_segments);
 270         if (!jobj_digest_segments)
 271                 return -EINVAL;
 272
 273         if (assign) {
 274                 json_object_object_foreach(LUKS2_get_segments_jobj(hdr), key, value) {
 275                         UNUSED(value);
 276                         jobj1 = LUKS2_array_jobj(jobj_digest_segments, key);
 277                         if (!jobj1)
 278                                 json_object_array_add(jobj_digest_segments, json_object_new_string(key));
 279                 }
 280         } else {
 281                 jobj1 = json_object_new_array();
 282                 if (!jobj1)
 283                         return -ENOMEM;
 284                 json_object_object_add(jobj_digest, "segments", jobj1);
 285         }
 286
 287         return 0;
 288 }
 289
 290 static int assign_one_segment(struct crypt_device *cd, struct luks2_hdr *hdr,
 291                              int segment, int digest, int assign)
 292 {
 293         json_object *jobj1, *jobj_digest, *jobj_digest_segments;
 294         char num[16];
 295
 296         log_dbg(cd, "Segment %i %s digest %i.", segment, assign ? "assigned to" : "unassigned from", digest);
 297
 298         jobj_digest = LUKS2_get_digest_jobj(hdr, digest);
 299         if (!jobj_digest)
 300                 return -EINVAL;
 301
 302         json_object_object_get_ex(jobj_digest, "segments", &jobj_digest_segments);
 303         if (!jobj_digest_segments)
 304                 return -EINVAL;
 305
 306         if (snprintf(num, sizeof(num), "%d", segment) < 0)
 307                 return -EINVAL;
 308
 309         if (assign) {
 310                 jobj1 = LUKS2_array_jobj(jobj_digest_segments, num);
 311                 if (!jobj1)
 312                         json_object_array_add(jobj_digest_segments, json_object_new_string(num));
 313         } else {
 314                 jobj1 = LUKS2_array_remove(jobj_digest_segments, num);
 315                 if (jobj1)
 316                         json_object_object_add(jobj_digest, "segments", jobj1);
 317         }
 318
 319         return 0;
 320 }
 321
 322 int LUKS2_digest_segment_assign(struct crypt_device *cd, struct luks2_hdr *hdr,
 323                         int segment, int digest, int assign, int commit)
 324 {
 325         json_object *jobj_digests;
 326         int r = 0;
 327
 328         if (segment == CRYPT_DEFAULT_SEGMENT)
 329                 segment = LUKS2_get_default_segment(hdr);
 330
 331         if (digest == CRYPT_ANY_DIGEST) {
 332                 json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 333
 334                 json_object_object_foreach(jobj_digests, key, val) {
 335                         UNUSED(val);
 336                         if (segment == CRYPT_ANY_SEGMENT)
 337                                 r = assign_all_segments(hdr, atoi(key), assign);
 338                         else
 339                                 r = assign_one_segment(cd, hdr, segment, atoi(key), assign);
 340                         if (r < 0)
 341                                 break;
 342                 }
 343         } else {
 344                 if (segment == CRYPT_ANY_SEGMENT)
 345                         r = assign_all_segments(hdr, digest, assign);
 346                 else
 347                         r = assign_one_segment(cd, hdr, segment, digest, assign);
 348         }
 349
 350         if (r < 0)
 351                 return r;
 352
 353         return commit ? LUKS2_hdr_write(cd, hdr) : 0;
 354 }
 355
 356 static int digest_unused(json_object *jobj_digest)
 357 {
 358         json_object *jobj;
 359
 360         json_object_object_get_ex(jobj_digest, "segments", &jobj);
 361         if (!jobj || !json_object_is_type(jobj, json_type_array) || json_object_array_length(jobj) > 0)
 362                 return 0;
 363
 364         json_object_object_get_ex(jobj_digest, "keyslots", &jobj);
 365         if (!jobj || !json_object_is_type(jobj, json_type_array))
 366                 return 0;
 367
 368         return json_object_array_length(jobj) > 0 ? 0 : 1;
 369 }
 370
 371 void LUKS2_digests_erase_unused(struct crypt_device *cd,
 372         struct luks2_hdr *hdr)
 373 {
 374         json_object *jobj_digests;
 375
 376         json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 377         if (!jobj_digests || !json_object_is_type(jobj_digests, json_type_object))
 378                 return;
 379
 380         json_object_object_foreach(jobj_digests, key, val) {
 381                 if (digest_unused(val)) {
 382                         log_dbg(cd, "Erasing unused digest %d.", atoi(key));
 383                         json_object_object_del(jobj_digests, key);
 384                 }
 385         }
 386 }
 387
 388 /* Key description helpers */
 389 static char *get_key_description_by_digest(struct crypt_device *cd, int digest)
 390 {
 391         char *desc, digest_str[3];
 392         int r;
 393         size_t len;
 394
 395         if (!crypt_get_uuid(cd))
 396                 return NULL;
 397
 398         r = snprintf(digest_str, sizeof(digest_str), "d%u", digest);
 399         if (r < 0 || (size_t)r >= sizeof(digest_str))
 400                 return NULL;
 401
 402         /* "cryptsetup:<uuid>-<digest_str>" + \0 */
 403         len = strlen(crypt_get_uuid(cd)) + strlen(digest_str) + 13;
 404
 405         desc = malloc(len);
 406         if (!desc)
 407                return NULL;
 408
 409         r = snprintf(desc, len, "%s:%s-%s", "cryptsetup", crypt_get_uuid(cd), digest_str);
 410         if (r < 0 || (size_t)r >= len) {
 411                free(desc);
 412                return NULL;
 413         }
 414
 415         return desc;
 416 }
 417
 418 int LUKS2_key_description_by_segment(struct crypt_device *cd,
 419                 struct luks2_hdr *hdr, struct volume_key *vk, int segment)
 420 {
 421         char *desc = get_key_description_by_digest(cd, LUKS2_digest_by_segment(hdr, segment));
 422         int r;
 423
 424         r = crypt_volume_key_set_description(vk, desc);
 425         free(desc);
 426         return r;
 427 }
 428
 429 int LUKS2_volume_key_load_in_keyring_by_keyslot(struct crypt_device *cd,
 430                 struct luks2_hdr *hdr, struct volume_key *vk, int keyslot)
 431 {
 432         char *desc = get_key_description_by_digest(cd, LUKS2_digest_by_keyslot(hdr, keyslot));
 433         int r;
 434
 435         r = crypt_volume_key_set_description(vk, desc);
 436         if (!r)
 437                 r = crypt_volume_key_load_in_keyring(cd, vk);
 438
 439         free(desc);
 440         return r;
 441 }
 442
 443 int LUKS2_volume_key_load_in_keyring_by_digest(struct crypt_device *cd,
 444                 struct volume_key *vk, int digest)
 445 {
 446         char *desc = get_key_description_by_digest(cd, digest);
 447         int r;
 448
 449         r = crypt_volume_key_set_description(vk, desc);
 450         if (!r)
 451                 r = crypt_volume_key_load_in_keyring(cd, vk);
 452
 453         free(desc);
 454         return r;
 455 }