src/cryptsetup/cryptsetup-tokens/cryptsetup-token-systemd-tpm2.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <errno.h>
   4 #include <libcryptsetup.h>
   5
   6 #include "cryptsetup-token.h"
   7 #include "cryptsetup-token-util.h"
   8 #include "hexdecoct.h"
   9 #include "json.h"
  10 #include "luks2-tpm2.h"
  11 #include "memory-util.h"
  12 #include "strv.h"
  13 #include "tpm2-util.h"
  14 #include "version.h"
  15
  16 #define TOKEN_NAME "systemd-tpm2"
  17 #define TOKEN_VERSION_MAJOR "1"
  18 #define TOKEN_VERSION_MINOR "0"
  19
  20 /* for libcryptsetup debug purpose */
  21 _public_ const char *cryptsetup_token_version(void) {
  22
  23         return TOKEN_VERSION_MAJOR "." TOKEN_VERSION_MINOR " systemd-v" STRINGIFY(PROJECT_VERSION) " (" GIT_VERSION ")";
  24 }
  25
  26 static int log_debug_open_error(struct crypt_device *cd, int r) {
  27         if (r == -EAGAIN)
  28                 return crypt_log_debug_errno(cd, r, "TPM2 device not found.");
  29         if (r == -ENXIO)
  30                 return crypt_log_debug_errno(cd, r, "No matching TPM2 token data found.");
  31
  32         return crypt_log_debug_errno(cd, r, TOKEN_NAME " open failed: %m.");
  33 }
  34
  35 _public_ int cryptsetup_token_open_pin(
  36                 struct crypt_device *cd, /* is always LUKS2 context */
  37                 int token /* is always >= 0 */,
  38                 const char *pin,
  39                 size_t pin_size,
  40                 char **ret_password, /* freed by cryptsetup_token_buffer_free */
  41                 size_t *ret_password_len,
  42                 void *usrptr /* plugin defined parameter passed to crypt_activate_by_token*() API */) {
  43
  44         _cleanup_(erase_and_freep) char *base64_encoded = NULL, *pin_string = NULL;
  45         _cleanup_free_ void *blob = NULL, *pubkey = NULL, *policy_hash = NULL;
  46         size_t blob_size, policy_hash_size, decrypted_key_size, pubkey_size;
  47         _cleanup_(erase_and_freep) void *decrypted_key = NULL;
  48         _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
  49         uint32_t hash_pcr_mask, pubkey_pcr_mask;
  50         systemd_tpm2_plugin_params params = {
  51                 .search_pcr_mask = UINT32_MAX
  52         };
  53         uint16_t pcr_bank, primary_alg;
  54         TPM2Flags flags = 0;
  55         const char *json;
  56         int r;
  57
  58         assert(token >= 0);
  59         assert(!pin || pin_size > 0);
  60         assert(ret_password);
  61         assert(ret_password_len);
  62
  63         /* This must not fail at this moment (internal error) */
  64         r = crypt_token_json_get(cd, token, &json);
  65         assert(token == r);
  66         assert(json);
  67
  68         r = crypt_normalize_pin(pin, pin_size, &pin_string);
  69         if (r < 0)
  70                 return crypt_log_debug_errno(cd, r, "Can not normalize PIN: %m");
  71
  72         if (usrptr)
  73                 params = *(systemd_tpm2_plugin_params *)usrptr;
  74
  75         r = json_parse(json, 0, &v, NULL, NULL);
  76         if (r < 0)
  77                 return crypt_log_debug_errno(cd, r, "Failed to parse token JSON data: %m");
  78
  79         r = tpm2_parse_luks2_json(
  80                         v,
  81                         NULL,
  82                         &hash_pcr_mask,
  83                         &pcr_bank,
  84                         &pubkey,
  85                         &pubkey_size,
  86                         &pubkey_pcr_mask,
  87                         &primary_alg,
  88                         &blob,
  89                         &blob_size,
  90                         &policy_hash,
  91                         &policy_hash_size,
  92                         &flags);
  93         if (r < 0)
  94                 return log_debug_open_error(cd, r);
  95
  96         if (params.search_pcr_mask != UINT32_MAX && hash_pcr_mask != params.search_pcr_mask)
  97                 return crypt_log_debug_errno(cd, ENXIO, "PCR mask doesn't match expectation (%" PRIu32 " vs. %" PRIu32 ")", hash_pcr_mask, params.search_pcr_mask);
  98
  99         r = acquire_luks2_key(
 100                         params.device,
 101                         hash_pcr_mask,
 102                         pcr_bank,
 103                         pubkey, pubkey_size,
 104                         pubkey_pcr_mask,
 105                         params.signature_path,
 106                         pin_string,
 107                         primary_alg,
 108                         blob,
 109                         blob_size,
 110                         policy_hash,
 111                         policy_hash_size,
 112                         flags,
 113                         &decrypted_key,
 114                         &decrypted_key_size);
 115         if (r < 0)
 116                 return log_debug_open_error(cd, r);
 117
 118         /* Before using this key as passphrase we base64 encode it, for compat with homed */
 119         r = base64mem(decrypted_key, decrypted_key_size, &base64_encoded);
 120         if (r < 0)
 121                 return log_debug_open_error(cd, r);
 122
 123         /* free'd automatically by libcryptsetup */
 124         *ret_password_len = strlen(base64_encoded);
 125         *ret_password = TAKE_PTR(base64_encoded);
 126
 127         return 0;
 128 }
 129
 130 /*
 131  * This function is called from within following libcryptsetup calls
 132  * provided conditions further below are met:
 133  *
 134  * crypt_activate_by_token(), crypt_activate_by_token_type(type == 'systemd-tpm2'):
 135  *
 136  * - token is assigned to at least one luks2 keyslot eligible to activate LUKS2 device
 137  *   (alternatively: name is set to null, flags contains CRYPT_ACTIVATE_ALLOW_UNBOUND_KEY
 138  *    and token is assigned to at least single keyslot).
 139  *
 140  * - if plugin defines validate function (see cryptsetup_token_validate below) it must have
 141  *   passed the check (aka return 0)
 142  */
 143 _public_ int cryptsetup_token_open(
 144                 struct crypt_device *cd, /* is always LUKS2 context */
 145                 int token /* is always >= 0 */,
 146                 char **ret_password, /* freed by cryptsetup_token_buffer_free */
 147                 size_t *ret_password_len,
 148                 void *usrptr /* plugin defined parameter passed to crypt_activate_by_token*() API */) {
 149
 150         return cryptsetup_token_open_pin(cd, token, NULL, 0, ret_password, ret_password_len, usrptr);
 151 }
 152
 153 /*
 154  * libcryptsetup callback for memory deallocation of 'password' parameter passed in
 155  * any crypt_token_open_* plugin function
 156  */
 157 _public_ void cryptsetup_token_buffer_free(void *buffer, size_t buffer_len) {
 158         erase_and_free(buffer);
 159 }
 160
 161 /*
 162  * prints systemd-tpm2 token content in crypt_dump().
 163  * 'type' and 'keyslots' fields are printed by libcryptsetup
 164  */
 165 _public_ void cryptsetup_token_dump(
 166                 struct crypt_device *cd /* is always LUKS2 context */,
 167                 const char *json /* validated 'systemd-tpm2' token if cryptsetup_token_validate is defined */) {
 168
 169         _cleanup_free_ char *hash_pcrs_str = NULL, *pubkey_pcrs_str = NULL, *blob_str = NULL, *policy_hash_str = NULL, *pubkey_str = NULL;
 170         _cleanup_free_ void *blob = NULL, *pubkey = NULL, *policy_hash = NULL;
 171         _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
 172         size_t blob_size, policy_hash_size, pubkey_size;
 173         uint32_t hash_pcr_mask, pubkey_pcr_mask;
 174         uint16_t pcr_bank, primary_alg;
 175         TPM2Flags flags = 0;
 176         int r;
 177
 178         assert(json);
 179
 180         r = json_parse(json, 0, &v, NULL, NULL);
 181         if (r < 0)
 182                 return (void) crypt_log_debug_errno(cd, r, "Failed to parse " TOKEN_NAME " JSON object: %m");
 183
 184         r = tpm2_parse_luks2_json(
 185                         v,
 186                         NULL,
 187                         &hash_pcr_mask,
 188                         &pcr_bank,
 189                         &pubkey,
 190                         &pubkey_size,
 191                         &pubkey_pcr_mask,
 192                         &primary_alg,
 193                         &blob,
 194                         &blob_size,
 195                         &policy_hash,
 196                         &policy_hash_size,
 197                         &flags);
 198         if (r < 0)
 199                 return (void) crypt_log_debug_errno(cd, r, "Failed to parse " TOKEN_NAME " JSON fields: %m");
 200
 201         r = pcr_mask_to_string(hash_pcr_mask, &hash_pcrs_str);
 202         if (r < 0)
 203                 return (void) crypt_log_debug_errno(cd, r, "Cannot format PCR hash mask: %m");
 204
 205         r = pcr_mask_to_string(pubkey_pcr_mask, &pubkey_pcrs_str);
 206         if (r < 0)
 207                 return (void) crypt_log_debug_errno(cd, r, "Cannot format PCR hash mask: %m");
 208
 209         r = crypt_dump_buffer_to_hex_string(blob, blob_size, &blob_str);
 210         if (r < 0)
 211                 return (void) crypt_log_debug_errno(cd, r, "Can not dump " TOKEN_NAME " content: %m");
 212
 213         r = crypt_dump_buffer_to_hex_string(pubkey, pubkey_size, &pubkey_str);
 214         if (r < 0)
 215                 return (void) crypt_log_debug_errno(cd, r, "Can not dump " TOKEN_NAME " content: %m");
 216
 217         r = crypt_dump_buffer_to_hex_string(policy_hash, policy_hash_size, &policy_hash_str);
 218         if (r < 0)
 219                 return (void) crypt_log_debug_errno(cd, r, "Can not dump " TOKEN_NAME " content: %m");
 220
 221         crypt_log(cd, "\ttpm2-hash-pcrs:   %s\n", strna(hash_pcrs_str));
 222         crypt_log(cd, "\ttpm2-pcr-bank:    %s\n", strna(tpm2_pcr_bank_to_string(pcr_bank)));
 223         crypt_log(cd, "\ttpm2-pubkey:" CRYPT_DUMP_LINE_SEP "%s\n", pubkey_str);
 224         crypt_log(cd, "\ttpm2-pubkey-pcrs: %s\n", strna(pubkey_pcrs_str));
 225         crypt_log(cd, "\ttpm2-primary-alg: %s\n", strna(tpm2_primary_alg_to_string(primary_alg)));
 226         crypt_log(cd, "\ttpm2-blob:        %s\n", blob_str);
 227         crypt_log(cd, "\ttpm2-policy-hash:" CRYPT_DUMP_LINE_SEP "%s\n", policy_hash_str);
 228         crypt_log(cd, "\ttpm2-pin:         %s\n", true_false(flags & TPM2_FLAGS_USE_PIN));
 229 }
 230
 231 /*
 232  * Note:
 233  *   If plugin is available in library path, it's called in before following libcryptsetup calls:
 234  *
 235  *   crypt_token_json_set, crypt_dump, any crypt_activate_by_token_* flavour
 236  */
 237 _public_ int cryptsetup_token_validate(
 238                 struct crypt_device *cd, /* is always LUKS2 context */
 239                 const char *json /* contains valid 'type' and 'keyslots' fields. 'type' is 'systemd-tpm2' */) {
 240
 241         int r;
 242         JsonVariant *w, *e;
 243         _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
 244
 245         assert(json);
 246
 247         r = json_parse(json, 0, &v, NULL, NULL);
 248         if (r < 0)
 249                 return crypt_log_debug_errno(cd, r, "Could not parse " TOKEN_NAME " json object: %m");
 250
 251         w = json_variant_by_key(v, "tpm2-pcrs");
 252         if (!w || !json_variant_is_array(w)) {
 253                 crypt_log_debug(cd, "TPM2 token data lacks 'tpm2-pcrs' field.");
 254                 return 1;
 255         }
 256
 257         JSON_VARIANT_ARRAY_FOREACH(e, w) {
 258                 uint64_t u;
 259
 260                 if (!json_variant_is_number(e)) {
 261                         crypt_log_debug(cd, "TPM2 PCR is not a number.");
 262                         return 1;
 263                 }
 264
 265                 u = json_variant_unsigned(e);
 266                 if (u >= TPM2_PCRS_MAX) {
 267                         crypt_log_debug(cd, "TPM2 PCR number out of range.");
 268                         return 1;
 269                 }
 270         }
 271
 272         /* The bank field is optional, since it was added in systemd 250 only. Before the bank was hardcoded
 273          * to SHA256. */
 274         w = json_variant_by_key(v, "tpm2-pcr-bank");
 275         if (w) {
 276                 /* The PCR bank field is optional */
 277
 278                 if (!json_variant_is_string(w)) {
 279                         crypt_log_debug(cd, "TPM2 PCR bank is not a string.");
 280                         return 1;
 281                 }
 282
 283                 if (tpm2_pcr_bank_from_string(json_variant_string(w)) < 0) {
 284                         crypt_log_debug(cd, "TPM2 PCR bank invalid or not supported: %s.", json_variant_string(w));
 285                         return 1;
 286                 }
 287         }
 288
 289         /* The primary key algorithm field is optional, since it was also added in systemd 250 only. Before
 290          * the algorithm was hardcoded to ECC. */
 291         w = json_variant_by_key(v, "tpm2-primary-alg");
 292         if (w) {
 293                 /* The primary key algorithm is optional */
 294
 295                 if (!json_variant_is_string(w)) {
 296                         crypt_log_debug(cd, "TPM2 primary key algorithm is not a string.");
 297                         return 1;
 298                 }
 299
 300                 if (tpm2_primary_alg_from_string(json_variant_string(w)) < 0) {
 301                         crypt_log_debug(cd, "TPM2 primary key algorithm invalid or not supported: %s", json_variant_string(w));
 302                         return 1;
 303                 }
 304         }
 305
 306         w = json_variant_by_key(v, "tpm2-blob");
 307         if (!w || !json_variant_is_string(w)) {
 308                 crypt_log_debug(cd, "TPM2 token data lacks 'tpm2-blob' field.");
 309                 return 1;
 310         }
 311
 312         r = unbase64mem(json_variant_string(w), SIZE_MAX, NULL, NULL);
 313         if (r < 0)
 314                 return crypt_log_debug_errno(cd, r, "Invalid base64 data in 'tpm2-blob' field: %m");
 315
 316         w = json_variant_by_key(v, "tpm2-policy-hash");
 317         if (!w || !json_variant_is_string(w)) {
 318                 crypt_log_debug(cd, "TPM2 token data lacks 'tpm2-policy-hash' field.");
 319                 return 1;
 320         }
 321
 322         r = unhexmem(json_variant_string(w), SIZE_MAX, NULL, NULL);
 323         if (r < 0)
 324                 return crypt_log_debug_errno(cd, r, "Invalid base64 data in 'tpm2-policy-hash' field: %m");
 325
 326         w = json_variant_by_key(v, "tpm2-pin");
 327         if (w) {
 328                 if (!json_variant_is_boolean(w)) {
 329                         crypt_log_debug(cd, "TPM2 PIN policy is not a boolean.");
 330                         return 1;
 331                 }
 332         }
 333
 334         return 0;
 335 }