lib/luks2/luks2_digest.c

   1 /*
   2  * LUKS - Linux Unified Key Setup v2, digest handling
   3  *
   4  * Copyright (C) 2015-2021 Red Hat, Inc. All rights reserved.
   5  * Copyright (C) 2015-2021 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(struct crypt_device *cd, 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(cd, json_object_get_string(jobj2));
  61 }
  62
  63 static int LUKS2_digest_find_free(struct crypt_device *cd, 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(cd, type);
  82         if (!dh)
  83                 return -EINVAL;
  84
  85         digest = LUKS2_digest_find_free(cd, 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         struct luks2_hdr *hdr,
 115         int digest,
 116         const struct volume_key *vk)
 117 {
 118         const digest_handler *h;
 119         int r;
 120
 121         h = LUKS2_digest_handler(cd, digest);
 122         if (!h)
 123                 return -EINVAL;
 124
 125         r = h->verify(cd, digest, vk->key, vk->keylength);
 126         if (r < 0) {
 127                 log_dbg(cd, "Digest %d (%s) verify failed with %d.", digest, h->name, r);
 128                 return r;
 129         }
 130
 131         return digest;
 132 }
 133
 134 int LUKS2_digest_verify(struct crypt_device *cd,
 135         struct luks2_hdr *hdr,
 136         const struct volume_key *vk,
 137         int keyslot)
 138 {
 139         int digest;
 140
 141         digest = LUKS2_digest_by_keyslot(hdr, keyslot);
 142         if (digest < 0)
 143                 return digest;
 144
 145         log_dbg(cd, "Verifying key from keyslot %d, digest %d.", keyslot, digest);
 146
 147         return LUKS2_digest_verify_by_digest(cd, hdr, digest, vk);
 148 }
 149
 150 int LUKS2_digest_dump(struct crypt_device *cd, int digest)
 151 {
 152         const digest_handler *h;
 153
 154         if (!(h = LUKS2_digest_handler(cd, digest)))
 155                 return -EINVAL;
 156
 157         return h->dump(cd, digest);
 158 }
 159
 160 int LUKS2_digest_any_matching(struct crypt_device *cd,
 161                 struct luks2_hdr *hdr,
 162                 const struct volume_key *vk)
 163 {
 164         int digest;
 165
 166         for (digest = 0; digest < LUKS2_DIGEST_MAX; digest++)
 167                 if (LUKS2_digest_verify_by_digest(cd, hdr, digest, vk) == digest)
 168                         return digest;
 169
 170         return -ENOENT;
 171 }
 172
 173 int LUKS2_digest_verify_by_segment(struct crypt_device *cd,
 174         struct luks2_hdr *hdr,
 175         int segment,
 176         const struct volume_key *vk)
 177 {
 178         return LUKS2_digest_verify_by_digest(cd, hdr, LUKS2_digest_by_segment(hdr, segment), vk);
 179 }
 180
 181 /* FIXME: segment can have more digests */
 182 int LUKS2_digest_by_segment(struct luks2_hdr *hdr, int segment)
 183 {
 184         char segment_name[16];
 185         json_object *jobj_digests, *jobj_digest_segments;
 186
 187         if (segment == CRYPT_DEFAULT_SEGMENT)
 188                 segment = LUKS2_get_default_segment(hdr);
 189
 190         json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 191
 192         if (snprintf(segment_name, sizeof(segment_name), "%u", segment) < 1)
 193                 return -EINVAL;
 194
 195         json_object_object_foreach(jobj_digests, key, val) {
 196                 json_object_object_get_ex(val, "segments", &jobj_digest_segments);
 197                 if (!LUKS2_array_jobj(jobj_digest_segments, segment_name))
 198                         continue;
 199
 200                 return atoi(key);
 201         }
 202
 203         return -ENOENT;
 204 }
 205
 206 static int assign_one_digest(struct crypt_device *cd, struct luks2_hdr *hdr,
 207                              int keyslot, int digest, int assign)
 208 {
 209         json_object *jobj1, *jobj_digest, *jobj_digest_keyslots;
 210         char num[16];
 211
 212         log_dbg(cd, "Keyslot %i %s digest %i.", keyslot, assign ? "assigned to" : "unassigned from", digest);
 213
 214         jobj_digest = LUKS2_get_digest_jobj(hdr, digest);
 215         if (!jobj_digest)
 216                 return -EINVAL;
 217
 218         json_object_object_get_ex(jobj_digest, "keyslots", &jobj_digest_keyslots);
 219         if (!jobj_digest_keyslots)
 220                 return -EINVAL;
 221
 222         if (snprintf(num, sizeof(num), "%d", keyslot) < 0)
 223                 return -EINVAL;
 224
 225         if (assign) {
 226                 jobj1 = LUKS2_array_jobj(jobj_digest_keyslots, num);
 227                 if (!jobj1)
 228                         json_object_array_add(jobj_digest_keyslots, json_object_new_string(num));
 229         } else {
 230                 jobj1 = LUKS2_array_remove(jobj_digest_keyslots, num);
 231                 if (jobj1)
 232                         json_object_object_add(jobj_digest, "keyslots", jobj1);
 233         }
 234
 235         return 0;
 236 }
 237
 238 int LUKS2_digest_assign(struct crypt_device *cd, struct luks2_hdr *hdr,
 239                         int keyslot, int digest, int assign, int commit)
 240 {
 241         json_object *jobj_digests;
 242         int r = 0;
 243
 244         if (digest == CRYPT_ANY_DIGEST) {
 245                 json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 246
 247                 json_object_object_foreach(jobj_digests, key, val) {
 248                         UNUSED(val);
 249                         r = assign_one_digest(cd, hdr, keyslot, atoi(key), assign);
 250                         if (r < 0)
 251                                 break;
 252                 }
 253         } else
 254                 r = assign_one_digest(cd, hdr, keyslot, digest, assign);
 255
 256         if (r < 0)
 257                 return r;
 258
 259         // FIXME: do not write header in nothing changed
 260         return commit ? LUKS2_hdr_write(cd, hdr) : 0;
 261 }
 262
 263 static int assign_all_segments(struct crypt_device *cd, struct luks2_hdr *hdr,
 264                              int digest, int assign)
 265 {
 266         json_object *jobj1, *jobj_digest, *jobj_digest_segments;
 267
 268         jobj_digest = LUKS2_get_digest_jobj(hdr, digest);
 269         if (!jobj_digest)
 270                 return -EINVAL;
 271
 272         json_object_object_get_ex(jobj_digest, "segments", &jobj_digest_segments);
 273         if (!jobj_digest_segments)
 274                 return -EINVAL;
 275
 276         if (assign) {
 277                 json_object_object_foreach(LUKS2_get_segments_jobj(hdr), key, value) {
 278                         UNUSED(value);
 279                         jobj1 = LUKS2_array_jobj(jobj_digest_segments, key);
 280                         if (!jobj1)
 281                                 json_object_array_add(jobj_digest_segments, json_object_new_string(key));
 282                 }
 283         } else {
 284                 jobj1 = json_object_new_array();
 285                 if (!jobj1)
 286                         return -ENOMEM;
 287                 json_object_object_add(jobj_digest, "segments", jobj1);
 288         }
 289
 290         return 0;
 291 }
 292
 293 static int assign_one_segment(struct crypt_device *cd, struct luks2_hdr *hdr,
 294                              int segment, int digest, int assign)
 295 {
 296         json_object *jobj1, *jobj_digest, *jobj_digest_segments;
 297         char num[16];
 298
 299         log_dbg(cd, "Segment %i %s digest %i.", segment, assign ? "assigned to" : "unassigned from", digest);
 300
 301         jobj_digest = LUKS2_get_digest_jobj(hdr, digest);
 302         if (!jobj_digest)
 303                 return -EINVAL;
 304
 305         json_object_object_get_ex(jobj_digest, "segments", &jobj_digest_segments);
 306         if (!jobj_digest_segments)
 307                 return -EINVAL;
 308
 309         if (snprintf(num, sizeof(num), "%d", segment) < 0)
 310                 return -EINVAL;
 311
 312         if (assign) {
 313                 jobj1 = LUKS2_array_jobj(jobj_digest_segments, num);
 314                 if (!jobj1)
 315                         json_object_array_add(jobj_digest_segments, json_object_new_string(num));
 316         } else {
 317                 jobj1 = LUKS2_array_remove(jobj_digest_segments, num);
 318                 if (jobj1)
 319                         json_object_object_add(jobj_digest, "segments", jobj1);
 320         }
 321
 322         return 0;
 323 }
 324
 325 int LUKS2_digest_segment_assign(struct crypt_device *cd, struct luks2_hdr *hdr,
 326                         int segment, int digest, int assign, int commit)
 327 {
 328         json_object *jobj_digests;
 329         int r = 0;
 330
 331         if (segment == CRYPT_DEFAULT_SEGMENT)
 332                 segment = LUKS2_get_default_segment(hdr);
 333
 334         if (digest == CRYPT_ANY_DIGEST) {
 335                 json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 336
 337                 json_object_object_foreach(jobj_digests, key, val) {
 338                         UNUSED(val);
 339                         if (segment == CRYPT_ANY_SEGMENT)
 340                                 r = assign_all_segments(cd, hdr, atoi(key), assign);
 341                         else
 342                                 r = assign_one_segment(cd, hdr, segment, atoi(key), assign);
 343                         if (r < 0)
 344                                 break;
 345                 }
 346         } else {
 347                 if (segment == CRYPT_ANY_SEGMENT)
 348                         r = assign_all_segments(cd, hdr, digest, assign);
 349                 else
 350                         r = assign_one_segment(cd, hdr, segment, digest, assign);
 351         }
 352
 353         if (r < 0)
 354                 return r;
 355
 356         // FIXME: do not write header in nothing changed
 357         return commit ? LUKS2_hdr_write(cd, hdr) : 0;
 358 }
 359
 360 static int digest_unused(json_object *jobj_digest)
 361 {
 362         json_object *jobj;
 363
 364         json_object_object_get_ex(jobj_digest, "segments", &jobj);
 365         if (!jobj || !json_object_is_type(jobj, json_type_array) || json_object_array_length(jobj) > 0)
 366                 return 0;
 367
 368         json_object_object_get_ex(jobj_digest, "keyslots", &jobj);
 369         if (!jobj || !json_object_is_type(jobj, json_type_array))
 370                 return 0;
 371
 372         return json_object_array_length(jobj) > 0 ? 0 : 1;
 373 }
 374
 375 void LUKS2_digests_erase_unused(struct crypt_device *cd,
 376         struct luks2_hdr *hdr)
 377 {
 378         json_object *jobj_digests;
 379
 380         json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 381         if (!jobj_digests || !json_object_is_type(jobj_digests, json_type_object))
 382                 return;
 383
 384         json_object_object_foreach(jobj_digests, key, val) {
 385                 if (digest_unused(val)) {
 386                         log_dbg(cd, "Erasing unused digest %d.", atoi(key));
 387                         json_object_object_del(jobj_digests, key);
 388                 }
 389         }
 390 }
 391
 392 /* Key description helpers */
 393 static char *get_key_description_by_digest(struct crypt_device *cd, int digest)
 394 {
 395         char *desc, digest_str[3];
 396         int r;
 397         size_t len;
 398
 399         if (!crypt_get_uuid(cd))
 400                 return NULL;
 401
 402         r = snprintf(digest_str, sizeof(digest_str), "d%u", digest);
 403         if (r < 0 || (size_t)r >= sizeof(digest_str))
 404                 return NULL;
 405
 406         /* "cryptsetup:<uuid>-<digest_str>" + \0 */
 407         len = strlen(crypt_get_uuid(cd)) + strlen(digest_str) + 13;
 408
 409         desc = malloc(len);
 410         if (!desc)
 411                return NULL;
 412
 413         r = snprintf(desc, len, "%s:%s-%s", "cryptsetup", crypt_get_uuid(cd), digest_str);
 414         if (r < 0 || (size_t)r >= len) {
 415                free(desc);
 416                return NULL;
 417         }
 418
 419         return desc;
 420 }
 421
 422 int LUKS2_key_description_by_segment(struct crypt_device *cd,
 423                 struct luks2_hdr *hdr, struct volume_key *vk, int segment)
 424 {
 425         char *desc = get_key_description_by_digest(cd, LUKS2_digest_by_segment(hdr, segment));
 426         int r;
 427
 428         r = crypt_volume_key_set_description(vk, desc);
 429         free(desc);
 430         return r;
 431 }
 432
 433 int LUKS2_volume_key_load_in_keyring_by_keyslot(struct crypt_device *cd,
 434                 struct luks2_hdr *hdr, struct volume_key *vk, int keyslot)
 435 {
 436         char *desc = get_key_description_by_digest(cd, LUKS2_digest_by_keyslot(hdr, keyslot));
 437         int r;
 438
 439         r = crypt_volume_key_set_description(vk, desc);
 440         if (!r)
 441                 r = crypt_volume_key_load_in_keyring(cd, vk);
 442
 443         free(desc);
 444         return r;
 445 }
 446
 447 int LUKS2_volume_key_load_in_keyring_by_digest(struct crypt_device *cd,
 448                 struct luks2_hdr *hdr, struct volume_key *vk, int digest)
 449 {
 450         char *desc = get_key_description_by_digest(cd, digest);
 451         int r;
 452
 453         r = crypt_volume_key_set_description(vk, desc);
 454         if (!r)
 455                 r = crypt_volume_key_load_in_keyring(cd, vk);
 456
 457         free(desc);
 458         return r;
 459 }