lib/luks2/luks2_digest.c

   1 /*
   2  * LUKS - Linux Unified Key Setup v2, digest handling
   3  *
   4  * Copyright (C) 2015-2020 Red Hat, Inc. All rights reserved.
   5  * Copyright (C) 2015-2020 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         snprintf(num, sizeof(num), "%d", keyslot);
 223         if (assign) {
 224                 jobj1 = LUKS2_array_jobj(jobj_digest_keyslots, num);
 225                 if (!jobj1)
 226                         json_object_array_add(jobj_digest_keyslots, json_object_new_string(num));
 227         } else {
 228                 jobj1 = LUKS2_array_remove(jobj_digest_keyslots, num);
 229                 if (jobj1)
 230                         json_object_object_add(jobj_digest, "keyslots", jobj1);
 231         }
 232
 233         return 0;
 234 }
 235
 236 int LUKS2_digest_assign(struct crypt_device *cd, struct luks2_hdr *hdr,
 237                         int keyslot, int digest, int assign, int commit)
 238 {
 239         json_object *jobj_digests;
 240         int r = 0;
 241
 242         if (digest == CRYPT_ANY_DIGEST) {
 243                 json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 244
 245                 json_object_object_foreach(jobj_digests, key, val) {
 246                         UNUSED(val);
 247                         r = assign_one_digest(cd, hdr, keyslot, atoi(key), assign);
 248                         if (r < 0)
 249                                 break;
 250                 }
 251         } else
 252                 r = assign_one_digest(cd, hdr, keyslot, digest, assign);
 253
 254         if (r < 0)
 255                 return r;
 256
 257         // FIXME: do not write header in nothing changed
 258         return commit ? LUKS2_hdr_write(cd, hdr) : 0;
 259 }
 260
 261 static int assign_all_segments(struct crypt_device *cd, struct luks2_hdr *hdr,
 262                              int digest, int assign)
 263 {
 264         json_object *jobj1, *jobj_digest, *jobj_digest_segments;
 265
 266         jobj_digest = LUKS2_get_digest_jobj(hdr, digest);
 267         if (!jobj_digest)
 268                 return -EINVAL;
 269
 270         json_object_object_get_ex(jobj_digest, "segments", &jobj_digest_segments);
 271         if (!jobj_digest_segments)
 272                 return -EINVAL;
 273
 274         if (assign) {
 275                 json_object_object_foreach(LUKS2_get_segments_jobj(hdr), key, value) {
 276                         UNUSED(value);
 277                         jobj1 = LUKS2_array_jobj(jobj_digest_segments, key);
 278                         if (!jobj1)
 279                                 json_object_array_add(jobj_digest_segments, json_object_new_string(key));
 280                 }
 281         } else {
 282                 jobj1 = json_object_new_array();
 283                 if (!jobj1)
 284                         return -ENOMEM;
 285                 json_object_object_add(jobj_digest, "segments", jobj1);
 286         }
 287
 288         return 0;
 289 }
 290
 291 static int assign_one_segment(struct crypt_device *cd, struct luks2_hdr *hdr,
 292                              int segment, int digest, int assign)
 293 {
 294         json_object *jobj1, *jobj_digest, *jobj_digest_segments;
 295         char num[16];
 296
 297         log_dbg(cd, "Segment %i %s digest %i.", segment, assign ? "assigned to" : "unassigned from", digest);
 298
 299         jobj_digest = LUKS2_get_digest_jobj(hdr, digest);
 300         if (!jobj_digest)
 301                 return -EINVAL;
 302
 303         json_object_object_get_ex(jobj_digest, "segments", &jobj_digest_segments);
 304         if (!jobj_digest_segments)
 305                 return -EINVAL;
 306
 307         snprintf(num, sizeof(num), "%d", segment);
 308         if (assign) {
 309                 jobj1 = LUKS2_array_jobj(jobj_digest_segments, num);
 310                 if (!jobj1)
 311                         json_object_array_add(jobj_digest_segments, json_object_new_string(num));
 312         } else {
 313                 jobj1 = LUKS2_array_remove(jobj_digest_segments, num);
 314                 if (jobj1)
 315                         json_object_object_add(jobj_digest, "segments", jobj1);
 316         }
 317
 318         return 0;
 319 }
 320
 321 int LUKS2_digest_segment_assign(struct crypt_device *cd, struct luks2_hdr *hdr,
 322                         int segment, int digest, int assign, int commit)
 323 {
 324         json_object *jobj_digests;
 325         int r = 0;
 326
 327         if (segment == CRYPT_DEFAULT_SEGMENT)
 328                 segment = LUKS2_get_default_segment(hdr);
 329
 330         if (digest == CRYPT_ANY_DIGEST) {
 331                 json_object_object_get_ex(hdr->jobj, "digests", &jobj_digests);
 332
 333                 json_object_object_foreach(jobj_digests, key, val) {
 334                         UNUSED(val);
 335                         if (segment == CRYPT_ANY_SEGMENT)
 336                                 r = assign_all_segments(cd, hdr, atoi(key), assign);
 337                         else
 338                                 r = assign_one_segment(cd, hdr, segment, atoi(key), assign);
 339                         if (r < 0)
 340                                 break;
 341                 }
 342         } else {
 343                 if (segment == CRYPT_ANY_SEGMENT)
 344                         r = assign_all_segments(cd, hdr, digest, assign);
 345                 else
 346                         r = assign_one_segment(cd, hdr, segment, digest, assign);
 347         }
 348
 349         if (r < 0)
 350                 return r;
 351
 352         // FIXME: do not write header in nothing changed
 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 luks2_hdr *hdr, 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 }