/* * OpenConnect (SSL + DTLS) VPN client * * Copyright © 2012 Free Software Foundation. * Copyright © 2008-2012 Intel Corporation. * Copyright © 2015-2016 Red Hat, Inc. * * Author: David Woodhouse * Author: Nikos Mavrogiannopoulos * * GnuTLS is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program. If not, see * */ /* * TPM code based on client-tpm.c from * Carolin Latze and Tobias Soder */ #include #include #include #include #include "gnutls_int.h" #ifdef HAVE_TROUSERS #include "errors.h" #include #include #include #include #include #include #include #include #include typedef char *(*Trspi_Error_Layer_func)(TSS_RESULT); typedef char *(*Trspi_Error_String_func)(TSS_RESULT); typedef TSS_RESULT (*Trspi_Error_Code_func)(TSS_RESULT); typedef TSS_RESULT (*Tspi_Context_CloseObject_func)(TSS_HCONTEXT, TSS_HOBJECT); typedef TSS_RESULT (*Tspi_Context_Close_func)(TSS_HCONTEXT); typedef TSS_RESULT (*Tspi_Context_CreateObject_func)(TSS_HCONTEXT, TSS_FLAG, TSS_FLAG, TSS_HOBJECT*); typedef TSS_RESULT (*Tspi_Context_FreeMemory_func)(TSS_HCONTEXT, BYTE*); typedef TSS_RESULT (*Tspi_Context_GetTpmObject_func)(TSS_HCONTEXT, TSS_HTPM*); typedef TSS_RESULT (*Tspi_Context_LoadKeyByUUID_func)(TSS_HCONTEXT, TSS_FLAG, TSS_UUID, TSS_HKEY*); typedef TSS_RESULT (*Tspi_Context_RegisterKey_func)(TSS_HCONTEXT, TSS_HKEY, TSS_FLAG, TSS_UUID, TSS_FLAG, TSS_UUID); typedef TSS_RESULT (*Tspi_Context_UnregisterKey_func)(TSS_HCONTEXT, TSS_FLAG, TSS_UUID, TSS_HKEY*); typedef TSS_RESULT (*Tspi_Key_CreateKey_func)(TSS_HKEY, TSS_HKEY, TSS_HPCRS); typedef TSS_RESULT (*Tspi_Hash_SetHashValue_func)(TSS_HHASH, UINT32, BYTE*); typedef TSS_RESULT (*Tspi_Hash_Sign_func)(TSS_HHASH, TSS_HKEY, UINT32*, BYTE**); typedef TSS_RESULT (*Tspi_Policy_SetSecret_func)(TSS_HPOLICY, TSS_FLAG, UINT32, BYTE*); typedef TSS_RESULT (*Tspi_Context_Create_func)(TSS_HCONTEXT*); typedef TSS_RESULT (*Tspi_Context_Connect_func)(TSS_HCONTEXT, TSS_UNICODE*); typedef TSS_RESULT (*Tspi_GetPolicyObject_func)(TSS_HOBJECT, TSS_FLAG, TSS_HPOLICY*); typedef TSS_RESULT (*Tspi_DecodeBER_TssBlob_func)(UINT32, BYTE*, UINT32*, UINT32*, BYTE*); typedef TSS_RESULT (*Tspi_Context_LoadKeyByBlob_func)(TSS_HCONTEXT, TSS_HKEY, UINT32, BYTE*, TSS_HKEY*); typedef TSS_RESULT (*Tspi_Policy_AssignToObject_func)(TSS_HPOLICY, TSS_HOBJECT); typedef TSS_RESULT (*Tspi_GetAttribData_func)(TSS_HOBJECT, TSS_FLAG, TSS_FLAG, UINT32*, BYTE**); typedef TSS_RESULT (*Tspi_GetAttribUint32_func)(TSS_HOBJECT, TSS_FLAG, TSS_FLAG, UINT32*); typedef TSS_RESULT (*Tspi_TPM_StirRandom_func)(TSS_HTPM, UINT32, BYTE*); typedef TSS_RESULT (*Tspi_SetAttribUint32_func)(TSS_HOBJECT, TSS_FLAG, TSS_FLAG, UINT32); typedef TSS_RESULT (*Tspi_EncodeDER_TssBlob_func)(UINT32, BYTE*, UINT32, UINT32*, BYTE*); typedef TSS_RESULT (*Tspi_Context_GetRegisteredKeysByUUID2_func)(TSS_HCONTEXT, TSS_FLAG, TSS_UUID*, UINT32*, TSS_KM_KEYINFO2**); static Tspi_Context_CloseObject_func pTspi_Context_CloseObject; static Tspi_Context_Close_func pTspi_Context_Close; static Tspi_Context_CreateObject_func pTspi_Context_CreateObject; static Tspi_Context_FreeMemory_func pTspi_Context_FreeMemory; static Tspi_Context_GetTpmObject_func pTspi_Context_GetTpmObject; static Tspi_Context_LoadKeyByUUID_func pTspi_Context_LoadKeyByUUID; static Tspi_Context_RegisterKey_func pTspi_Context_RegisterKey; static Tspi_Context_UnregisterKey_func pTspi_Context_UnregisterKey; static Tspi_Key_CreateKey_func pTspi_Key_CreateKey; static Tspi_Hash_SetHashValue_func pTspi_Hash_SetHashValue; static Tspi_Hash_Sign_func pTspi_Hash_Sign; static Tspi_Policy_SetSecret_func pTspi_Policy_SetSecret; static Tspi_Context_Create_func pTspi_Context_Create; static Tspi_Context_Connect_func pTspi_Context_Connect; static Tspi_GetPolicyObject_func pTspi_GetPolicyObject; static Tspi_DecodeBER_TssBlob_func pTspi_DecodeBER_TssBlob; static Tspi_Context_LoadKeyByBlob_func pTspi_Context_LoadKeyByBlob; static Tspi_Policy_AssignToObject_func pTspi_Policy_AssignToObject; static Tspi_GetAttribData_func pTspi_GetAttribData; static Tspi_GetAttribUint32_func pTspi_GetAttribUint32; static Tspi_Context_GetTpmObject_func pTspi_Context_GetTpmObject; static Tspi_TPM_StirRandom_func pTspi_TPM_StirRandom; static Tspi_SetAttribUint32_func pTspi_SetAttribUint32; static Tspi_EncodeDER_TssBlob_func pTspi_EncodeDER_TssBlob; static Tspi_Context_GetRegisteredKeysByUUID2_func pTspi_Context_GetRegisteredKeysByUUID2; static Trspi_Error_Layer_func pTrspi_Error_Layer; static Trspi_Error_String_func pTrspi_Error_String; static Trspi_Error_Code_func pTrspi_Error_Code; static void *tpm_dl = NULL; #define _DLSYM(dl, sym) \ p##sym = dlsym(dl, #sym); \ if (p##sym == NULL) { \ dlclose(dl); \ dl = NULL; \ return -1; \ } static int check_init(void) { if (tpm_dl == NULL) { tpm_dl = dlopen(TROUSERS_LIB, RTLD_LAZY); if (tpm_dl == NULL) { _gnutls_debug_log("couldn't open %s\n", TROUSERS_LIB); return -1; } _DLSYM(tpm_dl,Tspi_Context_CloseObject); _DLSYM(tpm_dl,Tspi_Context_Close); _DLSYM(tpm_dl,Tspi_Context_CreateObject); _DLSYM(tpm_dl,Tspi_Context_FreeMemory); _DLSYM(tpm_dl,Tspi_Context_GetTpmObject); _DLSYM(tpm_dl,Tspi_Context_LoadKeyByUUID); _DLSYM(tpm_dl,Tspi_Context_RegisterKey); _DLSYM(tpm_dl,Tspi_Context_UnregisterKey); _DLSYM(tpm_dl,Tspi_Key_CreateKey); _DLSYM(tpm_dl,Tspi_Hash_SetHashValue); _DLSYM(tpm_dl,Tspi_Hash_Sign); _DLSYM(tpm_dl,Tspi_Policy_SetSecret); _DLSYM(tpm_dl,Tspi_Context_Create); _DLSYM(tpm_dl,Tspi_Context_Connect); _DLSYM(tpm_dl,Tspi_GetPolicyObject); _DLSYM(tpm_dl,Tspi_DecodeBER_TssBlob); _DLSYM(tpm_dl,Tspi_Context_LoadKeyByBlob); _DLSYM(tpm_dl,Tspi_Policy_AssignToObject); _DLSYM(tpm_dl,Tspi_GetAttribData); _DLSYM(tpm_dl,Tspi_GetAttribUint32); _DLSYM(tpm_dl,Tspi_Context_GetTpmObject); _DLSYM(tpm_dl,Tspi_TPM_StirRandom); _DLSYM(tpm_dl,Tspi_SetAttribUint32); _DLSYM(tpm_dl,Tspi_EncodeDER_TssBlob); _DLSYM(tpm_dl,Tspi_Context_GetRegisteredKeysByUUID2); _DLSYM(tpm_dl,Trspi_Error_Layer); _DLSYM(tpm_dl,Trspi_Error_String); _DLSYM(tpm_dl,Trspi_Error_Code); } return 0; } #define CHECK_INIT \ if (check_init() < 0) return gnutls_assert_val(GNUTLS_E_TPM_NO_LIB) #define CHECK_INIT_VOID \ if (check_init() < 0) return void _gnutls_tpm_global_deinit(void) { if (tpm_dl) { dlclose(tpm_dl); tpm_dl = NULL; } } struct tpm_ctx_st { TSS_HCONTEXT tpm_ctx; TSS_HKEY tpm_key; TSS_HPOLICY tpm_key_policy; TSS_HKEY srk; TSS_HPOLICY srk_policy; }; struct tpm_key_list_st { UINT32 size; TSS_KM_KEYINFO2 *ki; TSS_HCONTEXT tpm_ctx; }; static void tpm_close_session(struct tpm_ctx_st *s); static int import_tpm_key(gnutls_privkey_t pkey, const gnutls_datum_t * fdata, gnutls_tpmkey_fmt_t format, TSS_UUID * uuid, TSS_FLAG storage_type, const char *srk_password, const char *key_password); static int encode_tpmkey_url(char **url, const TSS_UUID * uuid, TSS_FLAG storage); /* TPM URL format: (draft-mavrogiannopoulos-tpmuri-01) * * tpmkey:file=/path/to/file * tpmkey:uuid=7f468c16-cb7f-11e1-824d-b3a4f4b20343;storage=user * tpmkey:uuid=7f468c16-cb7f-11e1-824d-b3a4f4b20343;storage=system * */ static int tss_err_pwd(TSS_RESULT err, int pwd_error) { _gnutls_debug_log("TPM (%s) error: %s (%x)\n", pTrspi_Error_Layer(err), pTrspi_Error_String(err), (unsigned int) pTrspi_Error_Code(err)); switch (ERROR_LAYER(err)) { case TSS_LAYER_TPM: switch (ERROR_CODE(err)) { case TPM_E_AUTHFAIL: return pwd_error; case TPM_E_NOSRK: return GNUTLS_E_TPM_UNINITIALIZED; default: return gnutls_assert_val(GNUTLS_E_TPM_ERROR); } case TSS_LAYER_TCS: case TSS_LAYER_TSP: switch (ERROR_CODE(err)) { case TSS_E_COMM_FAILURE: case TSS_E_NO_CONNECTION: case TSS_E_CONNECTION_FAILED: case TSS_E_CONNECTION_BROKEN: return GNUTLS_E_TPM_SESSION_ERROR; case TSS_E_PS_KEY_NOTFOUND: return GNUTLS_E_TPM_KEY_NOT_FOUND; default: return gnutls_assert_val(GNUTLS_E_TPM_ERROR); } default: return gnutls_assert_val(GNUTLS_E_TPM_ERROR); } } #define tss_err(x) tss_err_pwd(x, GNUTLS_E_TPM_SRK_PASSWORD_ERROR) #define tss_err_key(x) tss_err_pwd(x, GNUTLS_E_TPM_KEY_PASSWORD_ERROR) static void tpm_deinit_fn(gnutls_privkey_t key, void *_s) { struct tpm_ctx_st *s = _s; pTspi_Context_CloseObject(s->tpm_ctx, s->tpm_key_policy); pTspi_Context_CloseObject(s->tpm_ctx, s->tpm_key); tpm_close_session(s); gnutls_free(s); } static int tpm_sign_fn(gnutls_privkey_t key, void *_s, const gnutls_datum_t * data, gnutls_datum_t * sig) { struct tpm_ctx_st *s = _s; TSS_HHASH hash; int err; _gnutls_debug_log("TPM sign function called for %u bytes.\n", data->size); err = pTspi_Context_CreateObject(s->tpm_ctx, TSS_OBJECT_TYPE_HASH, TSS_HASH_OTHER, &hash); if (err) { gnutls_assert(); _gnutls_debug_log("Failed to create TPM hash object: %s\n", pTrspi_Error_String(err)); return GNUTLS_E_PK_SIGN_FAILED; } err = pTspi_Hash_SetHashValue(hash, data->size, data->data); if (err) { gnutls_assert(); _gnutls_debug_log ("Failed to set value in TPM hash object: %s\n", pTrspi_Error_String(err)); pTspi_Context_CloseObject(s->tpm_ctx, hash); return GNUTLS_E_PK_SIGN_FAILED; } err = pTspi_Hash_Sign(hash, s->tpm_key, &sig->size, &sig->data); pTspi_Context_CloseObject(s->tpm_ctx, hash); if (err) { if (s->tpm_key_policy || err != TPM_E_AUTHFAIL) _gnutls_debug_log ("TPM hash signature failed: %s\n", pTrspi_Error_String(err)); if (err == TPM_E_AUTHFAIL) return GNUTLS_E_TPM_KEY_PASSWORD_ERROR; else return GNUTLS_E_PK_SIGN_FAILED; } return 0; } static const unsigned char nullpass[20]; static const gnutls_datum_t nulldata = { (void *) nullpass, 20 }; const TSS_UUID srk_uuid = TSS_UUID_SRK; static int tpm_pin(struct pin_info_st *pin_info, const TSS_UUID * uuid, TSS_FLAG storage, char *pin, unsigned int pin_size, unsigned int attempts) { unsigned int flags = 0; const char *label; char *url = NULL; int ret; if (attempts > 0) flags |= GNUTLS_PIN_WRONG; if (uuid) { if (memcmp(uuid, &srk_uuid, sizeof(TSS_UUID)) == 0) { label = "SRK"; ret = encode_tpmkey_url(&url, uuid, storage); if (ret < 0) return gnutls_assert_val(ret); } else { label = "TPM"; ret = encode_tpmkey_url(&url, uuid, storage); if (ret < 0) return gnutls_assert_val(ret); } } else label = "unknown"; ret = _gnutls_retrieve_pin(pin_info, url, label, flags, pin, pin_size); if (ret < 0) { gnutls_assert(); goto cleanup; } ret = 0; cleanup: gnutls_free(url); return ret; } static TSS_RESULT myTspi_Policy_SetSecret(TSS_HPOLICY hPolicy, UINT32 ulSecretLength, BYTE * rgbSecret) { if (rgbSecret == NULL) { /* Well known NULL key */ return pTspi_Policy_SetSecret(hPolicy, TSS_SECRET_MODE_SHA1, sizeof(nullpass), (BYTE *) nullpass); } else { /* key is given */ return pTspi_Policy_SetSecret(hPolicy, TSS_SECRET_MODE_PLAIN, ulSecretLength, rgbSecret); } } #define SAFE_LEN(x) (x==NULL?0:strlen(x)) static int tpm_open_session(struct tpm_ctx_st *s, const char *_srk_password, unsigned allow_invalid_pass) { int err, ret; char *password = NULL; err = pTspi_Context_Create(&s->tpm_ctx); if (err) { gnutls_assert(); return tss_err(err); } if (_srk_password != NULL) { gnutls_datum_t pout; ret = _gnutls_utf8_password_normalize(_srk_password, strlen(_srk_password), &pout, allow_invalid_pass); if (ret < 0) { gnutls_assert(); goto out_tspi_ctx; } password = (char*)pout.data; } err = pTspi_Context_Connect(s->tpm_ctx, NULL); if (err) { gnutls_assert(); ret = tss_err(err); goto out_tspi_ctx; } err = pTspi_Context_LoadKeyByUUID(s->tpm_ctx, TSS_PS_TYPE_SYSTEM, srk_uuid, &s->srk); if (err) { gnutls_assert(); ret = tss_err(err); goto out_tspi_ctx; } err = pTspi_GetPolicyObject(s->srk, TSS_POLICY_USAGE, &s->srk_policy); if (err) { gnutls_assert(); ret = tss_err(err); goto out_srk; } err = myTspi_Policy_SetSecret(s->srk_policy, SAFE_LEN(password), (BYTE *) password); if (err) { gnutls_assert(); ret = tss_err(err); goto out_srkpol; } gnutls_free(password); return 0; out_srkpol: pTspi_Context_CloseObject(s->tpm_ctx, s->srk_policy); s->srk_policy = 0; out_srk: pTspi_Context_CloseObject(s->tpm_ctx, s->srk); s->srk = 0; out_tspi_ctx: pTspi_Context_Close(s->tpm_ctx); s->tpm_ctx = 0; gnutls_free(password); return ret; } static void tpm_close_session(struct tpm_ctx_st *s) { pTspi_Context_CloseObject(s->tpm_ctx, s->srk_policy); s->srk_policy = 0; pTspi_Context_CloseObject(s->tpm_ctx, s->srk); s->srk = 0; pTspi_Context_Close(s->tpm_ctx); s->tpm_ctx = 0; } static int import_tpm_key_cb(gnutls_privkey_t pkey, const gnutls_datum_t * fdata, gnutls_tpmkey_fmt_t format, TSS_UUID * uuid, TSS_FLAG storage, const char *srk_password, const char *key_password) { unsigned int attempts = 0; char pin1[GNUTLS_PKCS11_MAX_PIN_LEN]; char pin2[GNUTLS_PKCS11_MAX_PIN_LEN]; int ret, ret2; do { ret = import_tpm_key(pkey, fdata, format, uuid, storage, srk_password, key_password); if (attempts > 3) break; if (ret == GNUTLS_E_TPM_SRK_PASSWORD_ERROR) { ret2 = tpm_pin(&pkey->pin, &srk_uuid, storage, pin1, sizeof(pin1), attempts++); if (ret2 < 0) { gnutls_assert(); return GNUTLS_E_TPM_SRK_PASSWORD_ERROR; } srk_password = pin1; } if (ret == GNUTLS_E_TPM_KEY_PASSWORD_ERROR) { ret2 = tpm_pin(&pkey->pin, uuid, storage, pin2, sizeof(pin2), attempts++); if (ret2 < 0) { gnutls_assert(); return GNUTLS_E_TPM_KEY_PASSWORD_ERROR; } key_password = pin2; } } while (ret == GNUTLS_E_TPM_KEY_PASSWORD_ERROR || ret == GNUTLS_E_TPM_SRK_PASSWORD_ERROR); if (ret < 0) gnutls_assert(); return ret; } static int load_key(TSS_HCONTEXT tpm_ctx, TSS_HKEY srk, const gnutls_datum_t * fdata, gnutls_tpmkey_fmt_t format, TSS_HKEY * tpm_key) { int ret, err; gnutls_datum_t asn1 = { NULL, 0 }; if (format == GNUTLS_TPMKEY_FMT_CTK_PEM) { gnutls_datum_t td; ret = gnutls_pem_base64_decode2("TSS KEY BLOB", fdata, &asn1); if (ret) { gnutls_assert(); _gnutls_debug_log ("Error decoding TSS key blob: %s\n", gnutls_strerror(ret)); return ret; } ret = _gnutls_x509_decode_string(ASN1_ETYPE_OCTET_STRING, asn1.data, asn1.size, &td, 0); if (ret < 0) { gnutls_assert(); goto cleanup; } gnutls_free(asn1.data); asn1.data = td.data; asn1.size = td.size; } else { /* DER */ UINT32 tint2; UINT32 type; asn1.size = fdata->size; asn1.data = gnutls_malloc(asn1.size); if (asn1.data == NULL) { gnutls_assert(); return GNUTLS_E_MEMORY_ERROR; } tint2 = asn1.size; err = pTspi_DecodeBER_TssBlob(fdata->size, fdata->data, &type, &tint2, asn1.data); if (err != 0) { gnutls_assert(); ret = tss_err(err); goto cleanup; } asn1.size = tint2; } /* ... we get it here instead. */ err = pTspi_Context_LoadKeyByBlob(tpm_ctx, srk, asn1.size, asn1.data, tpm_key); if (err != 0) { gnutls_assert(); ret = tss_err(err); goto cleanup; } ret = 0; cleanup: gnutls_free(asn1.data); return ret; } static int import_tpm_key(gnutls_privkey_t pkey, const gnutls_datum_t * fdata, gnutls_tpmkey_fmt_t format, TSS_UUID * uuid, TSS_FLAG storage, const char *srk_password, const char *_key_password) { int err, ret; struct tpm_ctx_st *s; gnutls_datum_t tmp_sig; char *key_password = NULL; uint32_t authusage; s = gnutls_malloc(sizeof(*s)); if (s == NULL) { gnutls_assert(); return GNUTLS_E_MEMORY_ERROR; } if (_key_password != NULL) { gnutls_datum_t pout; ret = _gnutls_utf8_password_normalize(_key_password, strlen(_key_password), &pout, 1); if (ret < 0) { gnutls_assert(); goto out_ctx; } key_password = (char*)pout.data; } /* normalization of srk_password happens in tpm_open_session() */ ret = tpm_open_session(s, srk_password, 1); if (ret < 0) { gnutls_assert(); goto out_ctx; } if (fdata != NULL) { ret = load_key(s->tpm_ctx, s->srk, fdata, format, &s->tpm_key); if (ret < 0) { gnutls_assert(); goto out_session; } } else if (uuid) { err = pTspi_Context_LoadKeyByUUID(s->tpm_ctx, storage, *uuid, &s->tpm_key); if (err) { gnutls_assert(); ret = tss_err(err); goto out_session; } } else { gnutls_assert(); ret = GNUTLS_E_INVALID_REQUEST; goto out_session; } err = pTspi_GetAttribUint32(s->tpm_key, TSS_TSPATTRIB_KEY_INFO, TSS_TSPATTRIB_KEYINFO_AUTHUSAGE, &authusage); if (err) { gnutls_assert(); ret = tss_err(err); goto out_session; } if (authusage) { if (!_key_password) { ret = GNUTLS_E_TPM_KEY_PASSWORD_ERROR; goto out_session; } err = pTspi_Context_CreateObject(s->tpm_ctx, TSS_OBJECT_TYPE_POLICY, TSS_POLICY_USAGE, &s->tpm_key_policy); if (err) { gnutls_assert(); ret = tss_err(err); goto out_key; } err = pTspi_Policy_AssignToObject(s->tpm_key_policy, s->tpm_key); if (err) { gnutls_assert(); ret = tss_err(err); goto out_key_policy; } err = myTspi_Policy_SetSecret(s->tpm_key_policy, SAFE_LEN(key_password), (void *) key_password); if (err) { gnutls_assert(); ret = tss_err_key(err); goto out_key_policy; } } ret = gnutls_privkey_import_ext2(pkey, GNUTLS_PK_RSA, s, tpm_sign_fn, NULL, tpm_deinit_fn, 0); if (ret < 0) { gnutls_assert(); goto out_session; } ret = gnutls_privkey_sign_data(pkey, GNUTLS_DIG_SHA1, 0, &nulldata, &tmp_sig); if (ret < 0) { gnutls_assert(); goto out_session; } gnutls_free(key_password); return 0; out_key_policy: pTspi_Context_CloseObject(s->tpm_ctx, s->tpm_key_policy); s->tpm_key_policy = 0; out_key: pTspi_Context_CloseObject(s->tpm_ctx, s->tpm_key); s->tpm_key = 0; out_session: _gnutls_privkey_cleanup(pkey); tpm_close_session(s); out_ctx: gnutls_free(s); gnutls_free(key_password); return ret; } /** * gnutls_privkey_import_tpm_raw: * @pkey: The private key * @fdata: The TPM key to be imported * @format: The format of the private key * @srk_password: The password for the SRK key (optional) * @key_password: A password for the key (optional) * @flags: should be zero * * This function will import the given private key to the abstract * #gnutls_privkey_t type. * * With respect to passwords the same as in gnutls_privkey_import_tpm_url() apply. * * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a * negative error value. * * Since: 3.1.0 * **/ int gnutls_privkey_import_tpm_raw(gnutls_privkey_t pkey, const gnutls_datum_t * fdata, gnutls_tpmkey_fmt_t format, const char *srk_password, const char *key_password, unsigned int flags) { CHECK_INIT; if (flags & GNUTLS_PRIVKEY_DISABLE_CALLBACKS) return import_tpm_key(pkey, fdata, format, NULL, 0, srk_password, key_password); else return import_tpm_key_cb(pkey, fdata, format, NULL, 0, srk_password, key_password); } struct tpmkey_url_st { char *filename; TSS_UUID uuid; TSS_FLAG storage; unsigned int uuid_set; }; static void clear_tpmkey_url(struct tpmkey_url_st *s) { gnutls_free(s->filename); memset(s, 0, sizeof(*s)); } static int unescape_string(char *output, const char *input, size_t * size, char terminator) { gnutls_buffer_st str; int ret = 0; char *p; int len; _gnutls_buffer_init(&str); /* find terminator */ p = strchr(input, terminator); if (p != NULL) len = p - input; else len = strlen(input); ret = _gnutls_buffer_append_data(&str, input, len); if (ret < 0) { gnutls_assert(); return ret; } ret = _gnutls_buffer_unescape(&str); if (ret < 0) { gnutls_assert(); return ret; } ret = _gnutls_buffer_append_data(&str, "", 1); if (ret < 0) { gnutls_assert(); return ret; } ret = _gnutls_buffer_pop_data(&str, output, str.length); if (ret < 0) { gnutls_assert(); return ret; } _gnutls_buffer_clear(&str); return ret; } #define UUID_SIZE 16 static int randomize_uuid(TSS_UUID * uuid) { uint8_t raw_uuid[16]; int ret; ret = gnutls_rnd(GNUTLS_RND_NONCE, raw_uuid, sizeof(raw_uuid)); if (ret < 0) return gnutls_assert_val(ret); /* mark it as random uuid */ raw_uuid[6] &= 0x0f; raw_uuid[6] |= 0x40; raw_uuid[8] &= 0x0f; raw_uuid[8] |= 0x80; memcpy(&uuid->ulTimeLow, raw_uuid, 4); memcpy(&uuid->usTimeMid, &raw_uuid[4], 2); memcpy(&uuid->usTimeHigh, &raw_uuid[6], 2); uuid->bClockSeqHigh = raw_uuid[8]; uuid->bClockSeqLow = raw_uuid[9]; memcpy(&uuid->rgbNode, &raw_uuid[10], 6); return 0; } static int encode_tpmkey_url(char **url, const TSS_UUID * uuid, TSS_FLAG storage) { uint8_t u1[UUID_SIZE]; gnutls_buffer_st buf; gnutls_datum_t dret; int ret; _gnutls_buffer_init(&buf); memcpy(u1, &uuid->ulTimeLow, 4); memcpy(&u1[4], &uuid->usTimeMid, 2); memcpy(&u1[6], &uuid->usTimeHigh, 2); u1[8] = uuid->bClockSeqHigh; u1[9] = uuid->bClockSeqLow; memcpy(&u1[10], uuid->rgbNode, 6); ret = _gnutls_buffer_append_str(&buf, "tpmkey:uuid="); if (ret < 0) { gnutls_assert(); goto cleanup; } ret = _gnutls_buffer_append_printf(&buf, "%.2x%.2x%.2x%.2x-%.2x%.2x-%.2x%.2x-%.2x%.2x-%.2x%.2x%.2x%.2x%.2x%.2x", (unsigned int) u1[0], (unsigned int) u1[1], (unsigned int) u1[2], (unsigned int) u1[3], (unsigned int) u1[4], (unsigned int) u1[5], (unsigned int) u1[6], (unsigned int) u1[7], (unsigned int) u1[8], (unsigned int) u1[9], (unsigned int) u1[10], (unsigned int) u1[11], (unsigned int) u1[12], (unsigned int) u1[13], (unsigned int) u1[14], (unsigned int) u1[15]); if (ret < 0) { gnutls_assert(); goto cleanup; } ret = _gnutls_buffer_append_printf(&buf, ";storage=%s", (storage == TSS_PS_TYPE_USER) ? "user" : "system"); if (ret < 0) { gnutls_assert(); goto cleanup; } ret = _gnutls_buffer_to_datum(&buf, &dret, 1); if (ret < 0) { gnutls_assert(); goto cleanup; } *url = (char *) dret.data; return 0; cleanup: _gnutls_buffer_clear(&buf); return ret; } static int decode_tpmkey_url(const char *url, struct tpmkey_url_st *s) { char *p; size_t size; int ret; unsigned int i, j; if (strstr(url, "tpmkey:") == NULL) return gnutls_assert_val(GNUTLS_E_PARSING_ERROR); memset(s, 0, sizeof(*s)); p = strstr(url, "file="); if (p != NULL) { p += sizeof("file=") - 1; size = strlen(p); s->filename = gnutls_malloc(size + 1); if (s->filename == NULL) return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR); ret = unescape_string(s->filename, p, &size, ';'); if (ret < 0) { gnutls_assert(); goto cleanup; } s->filename[size] = 0; } else if ((p = strstr(url, "uuid=")) != NULL) { char tmp_uuid[33]; uint8_t raw_uuid[16]; gnutls_datum_t tmp; p += sizeof("uuid=") - 1; size = strlen(p); for (j = i = 0; i < size; i++) { if (j == sizeof(tmp_uuid) - 1) { break; } if (c_isalnum(p[i])) tmp_uuid[j++] = p[i]; } tmp_uuid[j] = 0; tmp.data = (void*)tmp_uuid; tmp.size = strlen(tmp_uuid); size = sizeof(raw_uuid); ret = gnutls_hex_decode(&tmp, raw_uuid, &size); if (ret < 0) { gnutls_assert(); goto cleanup; } memcpy(&s->uuid.ulTimeLow, raw_uuid, 4); memcpy(&s->uuid.usTimeMid, &raw_uuid[4], 2); memcpy(&s->uuid.usTimeHigh, &raw_uuid[6], 2); s->uuid.bClockSeqHigh = raw_uuid[8]; s->uuid.bClockSeqLow = raw_uuid[9]; memcpy(&s->uuid.rgbNode, &raw_uuid[10], 6); s->uuid_set = 1; } else { return gnutls_assert_val(GNUTLS_E_PARSING_ERROR); } if (strstr(url, "storage=user") != NULL) s->storage = TSS_PS_TYPE_USER; else s->storage = TSS_PS_TYPE_SYSTEM; return 0; cleanup: clear_tpmkey_url(s); return ret; } /** * gnutls_privkey_import_tpm_url: * @pkey: The private key * @url: The URL of the TPM key to be imported * @srk_password: The password for the SRK key (optional) * @key_password: A password for the key (optional) * @flags: One of the GNUTLS_PRIVKEY_* flags * * This function will import the given private key to the abstract * #gnutls_privkey_t type. * * Note that unless %GNUTLS_PRIVKEY_DISABLE_CALLBACKS * is specified, if incorrect (or NULL) passwords are given * the PKCS11 callback functions will be used to obtain the * correct passwords. Otherwise if the SRK password is wrong * %GNUTLS_E_TPM_SRK_PASSWORD_ERROR is returned and if the key password * is wrong or not provided then %GNUTLS_E_TPM_KEY_PASSWORD_ERROR * is returned. * * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a * negative error value. * * Since: 3.1.0 * **/ int gnutls_privkey_import_tpm_url(gnutls_privkey_t pkey, const char *url, const char *srk_password, const char *key_password, unsigned int flags) { struct tpmkey_url_st durl; gnutls_datum_t fdata = { NULL, 0 }; int ret; CHECK_INIT; ret = decode_tpmkey_url(url, &durl); if (ret < 0) return gnutls_assert_val(ret); if (durl.filename) { ret = gnutls_load_file(durl.filename, &fdata); if (ret < 0) { gnutls_assert(); _gnutls_debug_log("Error loading %s\n", durl.filename); goto cleanup; } ret = gnutls_privkey_import_tpm_raw(pkey, &fdata, GNUTLS_TPMKEY_FMT_CTK_PEM, srk_password, key_password, flags); if (ret == GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR) ret = gnutls_privkey_import_tpm_raw(pkey, &fdata, GNUTLS_TPMKEY_FMT_RAW, srk_password, key_password, flags); if (ret < 0) { gnutls_assert(); goto cleanup; } } else if (durl.uuid_set) { if (flags & GNUTLS_PRIVKEY_DISABLE_CALLBACKS) ret = import_tpm_key(pkey, NULL, 0, &durl.uuid, durl.storage, srk_password, key_password); else ret = import_tpm_key_cb(pkey, NULL, 0, &durl.uuid, durl.storage, srk_password, key_password); if (ret < 0) { gnutls_assert(); goto cleanup; } } ret = 0; cleanup: gnutls_free(fdata.data); clear_tpmkey_url(&durl); return ret; } /* reads the RSA public key from the given TSS key. * If psize is non-null it contains the total size of the parameters * in bytes */ static int read_pubkey(gnutls_pubkey_t pub, TSS_HKEY key_ctx, size_t * psize) { void *tdata; UINT32 tint; TSS_RESULT tssret; gnutls_datum_t m, e; int ret; /* read the public key */ tssret = pTspi_GetAttribData(key_ctx, TSS_TSPATTRIB_RSAKEY_INFO, TSS_TSPATTRIB_KEYINFO_RSA_MODULUS, &tint, (void *) &tdata); if (tssret != 0) { gnutls_assert(); return tss_err(tssret); } m.data = tdata; m.size = tint; tssret = pTspi_GetAttribData(key_ctx, TSS_TSPATTRIB_RSAKEY_INFO, TSS_TSPATTRIB_KEYINFO_RSA_EXPONENT, &tint, (void *) &tdata); if (tssret != 0) { gnutls_assert(); pTspi_Context_FreeMemory(key_ctx, m.data); return tss_err(tssret); } e.data = tdata; e.size = tint; ret = gnutls_pubkey_import_rsa_raw(pub, &m, &e); pTspi_Context_FreeMemory(key_ctx, m.data); pTspi_Context_FreeMemory(key_ctx, e.data); if (ret < 0) return gnutls_assert_val(ret); if (psize) *psize = e.size + m.size; return 0; } static int import_tpm_pubkey(gnutls_pubkey_t pkey, const gnutls_datum_t * fdata, gnutls_tpmkey_fmt_t format, TSS_UUID * uuid, TSS_FLAG storage, const char *srk_password) { int err, ret; struct tpm_ctx_st s; ret = tpm_open_session(&s, srk_password, 1); if (ret < 0) return gnutls_assert_val(ret); if (fdata != NULL) { ret = load_key(s.tpm_ctx, s.srk, fdata, format, &s.tpm_key); if (ret < 0) { gnutls_assert(); goto out_session; } } else if (uuid) { err = pTspi_Context_LoadKeyByUUID(s.tpm_ctx, storage, *uuid, &s.tpm_key); if (err) { gnutls_assert(); ret = tss_err(err); goto out_session; } } else { gnutls_assert(); ret = GNUTLS_E_INVALID_REQUEST; goto out_session; } ret = read_pubkey(pkey, s.tpm_key, NULL); if (ret < 0) { gnutls_assert(); goto out_session; } ret = 0; out_session: tpm_close_session(&s); return ret; } static int import_tpm_pubkey_cb(gnutls_pubkey_t pkey, const gnutls_datum_t * fdata, gnutls_tpmkey_fmt_t format, TSS_UUID * uuid, TSS_FLAG storage, const char *srk_password) { unsigned int attempts = 0; char pin1[GNUTLS_PKCS11_MAX_PIN_LEN]; int ret, sret; do { ret = import_tpm_pubkey(pkey, fdata, format, uuid, storage, srk_password); if (attempts > 3) break; if (ret == GNUTLS_E_TPM_SRK_PASSWORD_ERROR) { sret = tpm_pin(&pkey->pin, &srk_uuid, storage, pin1, sizeof(pin1), attempts++); if (sret < 0) { gnutls_assert(); return GNUTLS_E_TPM_SRK_PASSWORD_ERROR; } srk_password = pin1; } } while (ret == GNUTLS_E_TPM_SRK_PASSWORD_ERROR); if (ret < 0) gnutls_assert(); return ret; } /** * gnutls_pubkey_import_tpm_raw: * @pkey: The public key * @fdata: The TPM key to be imported * @format: The format of the private key * @srk_password: The password for the SRK key (optional) * @flags: One of the GNUTLS_PUBKEY_* flags * * This function will import the public key from the provided TPM key * structure. * * With respect to passwords the same as in * gnutls_pubkey_import_tpm_url() apply. * * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a * negative error value. * * Since: 3.1.0 **/ int gnutls_pubkey_import_tpm_raw(gnutls_pubkey_t pkey, const gnutls_datum_t * fdata, gnutls_tpmkey_fmt_t format, const char *srk_password, unsigned int flags) { CHECK_INIT; if (flags & GNUTLS_PUBKEY_DISABLE_CALLBACKS) return import_tpm_pubkey_cb(pkey, fdata, format, NULL, 0, srk_password); else return import_tpm_pubkey(pkey, fdata, format, NULL, 0, srk_password); } /** * gnutls_pubkey_import_tpm_url: * @pkey: The public key * @url: The URL of the TPM key to be imported * @srk_password: The password for the SRK key (optional) * @flags: should be zero * * This function will import the given private key to the abstract * #gnutls_privkey_t type. * * Note that unless %GNUTLS_PUBKEY_DISABLE_CALLBACKS * is specified, if incorrect (or NULL) passwords are given * the PKCS11 callback functions will be used to obtain the * correct passwords. Otherwise if the SRK password is wrong * %GNUTLS_E_TPM_SRK_PASSWORD_ERROR is returned. * * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a * negative error value. * * Since: 3.1.0 * **/ int gnutls_pubkey_import_tpm_url(gnutls_pubkey_t pkey, const char *url, const char *srk_password, unsigned int flags) { struct tpmkey_url_st durl; gnutls_datum_t fdata = { NULL, 0 }; int ret; CHECK_INIT; ret = decode_tpmkey_url(url, &durl); if (ret < 0) return gnutls_assert_val(ret); if (durl.filename) { ret = gnutls_load_file(durl.filename, &fdata); if (ret < 0) { gnutls_assert(); goto cleanup; } ret = gnutls_pubkey_import_tpm_raw(pkey, &fdata, GNUTLS_TPMKEY_FMT_CTK_PEM, srk_password, flags); if (ret == GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR) ret = gnutls_pubkey_import_tpm_raw(pkey, &fdata, GNUTLS_TPMKEY_FMT_RAW, srk_password, flags); if (ret < 0) { gnutls_assert(); goto cleanup; } } else if (durl.uuid_set) { if (flags & GNUTLS_PUBKEY_DISABLE_CALLBACKS) ret = import_tpm_pubkey(pkey, NULL, 0, &durl.uuid, durl.storage, srk_password); else ret = import_tpm_pubkey_cb(pkey, NULL, 0, &durl.uuid, durl.storage, srk_password); if (ret < 0) { gnutls_assert(); goto cleanup; } } ret = 0; cleanup: gnutls_free(fdata.data); clear_tpmkey_url(&durl); return ret; } /** * gnutls_tpm_privkey_generate: * @pk: the public key algorithm * @bits: the security bits * @srk_password: a password to protect the exported key (optional) * @key_password: the password for the TPM (optional) * @format: the format of the private key * @pub_format: the format of the public key * @privkey: the generated key * @pubkey: the corresponding public key (may be null) * @flags: should be a list of GNUTLS_TPM_* flags * * This function will generate a private key in the TPM * chip. The private key will be generated within the chip * and will be exported in a wrapped with TPM's master key * form. Furthermore the wrapped key can be protected with * the provided @password. * * Note that bits in TPM is quantized value. If the input value * is not one of the allowed values, then it will be quantized to * one of 512, 1024, 2048, 4096, 8192 and 16384. * * Allowed flags are: * * %GNUTLS_TPM_KEY_SIGNING: Generate a signing key instead of a legacy, * * %GNUTLS_TPM_REGISTER_KEY: Register the generate key in TPM. In that * case @privkey would contain a URL with the UUID. * * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a * negative error value. * * Since: 3.1.0 **/ int gnutls_tpm_privkey_generate(gnutls_pk_algorithm_t pk, unsigned int bits, const char *srk_password, const char *key_password, gnutls_tpmkey_fmt_t format, gnutls_x509_crt_fmt_t pub_format, gnutls_datum_t * privkey, gnutls_datum_t * pubkey, unsigned int flags) { TSS_FLAG tpm_flags = TSS_KEY_VOLATILE; TSS_HKEY key_ctx; TSS_RESULT tssret; int ret; void *tdata; UINT32 tint; gnutls_datum_t tmpkey = { NULL, 0 }; TSS_HPOLICY key_policy; gnutls_pubkey_t pub; struct tpm_ctx_st s; TSS_FLAG storage_type; TSS_HTPM htpm; uint8_t buf[32]; CHECK_INIT; privkey->data = NULL; if (pubkey != NULL) pubkey->data = NULL; if (flags & GNUTLS_TPM_KEY_SIGNING) tpm_flags |= TSS_KEY_TYPE_SIGNING; else tpm_flags |= TSS_KEY_TYPE_LEGACY; if (flags & GNUTLS_TPM_KEY_USER) storage_type = TSS_PS_TYPE_USER; else storage_type = TSS_PS_TYPE_SYSTEM; if (bits <= 512) tpm_flags |= TSS_KEY_SIZE_512; else if (bits <= 1024) tpm_flags |= TSS_KEY_SIZE_1024; else if (bits <= 2048) tpm_flags |= TSS_KEY_SIZE_2048; else if (bits <= 4096) tpm_flags |= TSS_KEY_SIZE_4096; else if (bits <= 8192) tpm_flags |= TSS_KEY_SIZE_8192; else tpm_flags |= TSS_KEY_SIZE_16384; ret = tpm_open_session(&s, srk_password, 0); if (ret < 0) return gnutls_assert_val(ret); /* put some randomness into TPM. * Let's not trust it completely. */ tssret = pTspi_Context_GetTpmObject(s.tpm_ctx, &htpm); if (tssret != 0) { gnutls_assert(); ret = tss_err(tssret); goto err_cc; } ret = gnutls_rnd(GNUTLS_RND_RANDOM, buf, sizeof(buf)); if (ret < 0) { gnutls_assert(); goto err_cc; } tssret = pTspi_TPM_StirRandom(htpm, sizeof(buf), buf); if (tssret) { gnutls_assert(); } tssret = pTspi_Context_CreateObject(s.tpm_ctx, TSS_OBJECT_TYPE_RSAKEY, tpm_flags, &key_ctx); if (tssret != 0) { gnutls_assert(); ret = tss_err(tssret); goto err_cc; } tssret = pTspi_SetAttribUint32(key_ctx, TSS_TSPATTRIB_KEY_INFO, TSS_TSPATTRIB_KEYINFO_SIGSCHEME, TSS_SS_RSASSAPKCS1V15_DER); if (tssret != 0) { gnutls_assert(); ret = tss_err(tssret); goto err_sa; } /* set the password of the actual key */ if (key_password) { gnutls_datum_t pout; char *password = NULL; tssret = pTspi_GetPolicyObject(key_ctx, TSS_POLICY_USAGE, &key_policy); if (tssret != 0) { gnutls_assert(); ret = tss_err(tssret); goto err_sa; } ret = _gnutls_utf8_password_normalize(key_password, strlen(key_password), &pout, 0); if (ret < 0) { gnutls_assert(); goto err_sa; } password = (char*)pout.data; tssret = myTspi_Policy_SetSecret(key_policy, SAFE_LEN(password), (void *)password); gnutls_free(password); if (tssret != 0) { gnutls_assert(); ret = tss_err(tssret); goto err_sa; } } tssret = pTspi_Key_CreateKey(key_ctx, s.srk, 0); if (tssret != 0) { gnutls_assert(); ret = tss_err(tssret); goto err_sa; } if (flags & GNUTLS_TPM_REGISTER_KEY) { TSS_UUID key_uuid; ret = randomize_uuid(&key_uuid); if (ret < 0) { gnutls_assert(); goto err_sa; } tssret = pTspi_Context_RegisterKey(s.tpm_ctx, key_ctx, storage_type, key_uuid, TSS_PS_TYPE_SYSTEM, srk_uuid); if (tssret != 0) { gnutls_assert(); ret = tss_err(tssret); goto err_sa; } ret = encode_tpmkey_url((char **) &privkey->data, &key_uuid, storage_type); if (ret < 0) { TSS_HKEY tkey; pTspi_Context_UnregisterKey(s.tpm_ctx, storage_type, key_uuid, &tkey); gnutls_assert(); goto err_sa; } privkey->size = strlen((char *) privkey->data); } else { /* get the key as blob */ tssret = pTspi_GetAttribData(key_ctx, TSS_TSPATTRIB_KEY_BLOB, TSS_TSPATTRIB_KEYBLOB_BLOB, &tint, (void *) &tdata); if (tssret != 0) { gnutls_assert(); ret = tss_err(tssret); goto err_sa; } if (format == GNUTLS_TPMKEY_FMT_CTK_PEM) { ret = _gnutls_x509_encode_string (ASN1_ETYPE_OCTET_STRING, tdata, tint, &tmpkey); if (ret < 0) { gnutls_assert(); goto cleanup; } ret = _gnutls_fbase64_encode("TSS KEY BLOB", tmpkey.data, tmpkey.size, privkey); if (ret < 0) { gnutls_assert(); goto cleanup; } } else { UINT32 tint2; tmpkey.size = tint + 32; /* spec says no more than 20 */ tmpkey.data = gnutls_malloc(tmpkey.size); if (tmpkey.data == NULL) { gnutls_assert(); ret = GNUTLS_E_MEMORY_ERROR; goto cleanup; } tint2 = tmpkey.size; tssret = pTspi_EncodeDER_TssBlob(tint, tdata, TSS_BLOB_TYPE_PRIVATEKEY, &tint2, tmpkey.data); if (tssret != 0) { gnutls_assert(); ret = tss_err(tssret); goto cleanup; } tmpkey.size = tint2; privkey->data = tmpkey.data; privkey->size = tmpkey.size; tmpkey.data = NULL; } } /* read the public key */ if (pubkey != NULL) { size_t psize = 0; ret = gnutls_pubkey_init(&pub); if (ret < 0) { gnutls_assert(); goto privkey_cleanup; } ret = read_pubkey(pub, key_ctx, &psize); if (ret < 0) { gnutls_assert(); goto privkey_cleanup; } psize += 512; pubkey->data = gnutls_malloc(psize); if (pubkey->data == NULL) { gnutls_assert(); ret = GNUTLS_E_MEMORY_ERROR; goto pubkey_cleanup; } ret = gnutls_pubkey_export(pub, pub_format, pubkey->data, &psize); if (ret < 0) { gnutls_assert(); goto pubkey_cleanup; } pubkey->size = psize; gnutls_pubkey_deinit(pub); } ret = 0; goto cleanup; pubkey_cleanup: gnutls_pubkey_deinit(pub); privkey_cleanup: gnutls_free(privkey->data); cleanup: gnutls_free(tmpkey.data); err_sa: pTspi_Context_CloseObject(s.tpm_ctx, key_ctx); err_cc: tpm_close_session(&s); return ret; } /** * gnutls_tpm_key_list_deinit: * @list: a list of the keys * * This function will deinitialize the list of stored keys in the TPM. * * Since: 3.1.0 **/ void gnutls_tpm_key_list_deinit(gnutls_tpm_key_list_t list) { CHECK_INIT_VOID; if (list->tpm_ctx != 0) pTspi_Context_Close(list->tpm_ctx); gnutls_free(list); } /** * gnutls_tpm_key_list_get_url: * @list: a list of the keys * @idx: The index of the key (starting from zero) * @url: The URL to be returned * @flags: should be zero * * This function will return for each given index a URL of * the corresponding key. * If the provided index is out of bounds then %GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE * is returned. * * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a * negative error value. * * Since: 3.1.0 **/ int gnutls_tpm_key_list_get_url(gnutls_tpm_key_list_t list, unsigned int idx, char **url, unsigned int flags) { CHECK_INIT; if (idx >= list->size) return gnutls_assert_val (GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE); return encode_tpmkey_url(url, &list->ki[idx].keyUUID, list->ki[idx].persistentStorageType); } /** * gnutls_tpm_get_registered: * @list: a list to store the keys * * This function will get a list of stored keys in the TPM. The uuid * of those keys * * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a * negative error value. * * Since: 3.1.0 **/ int gnutls_tpm_get_registered(gnutls_tpm_key_list_t * list) { TSS_RESULT tssret; int ret; CHECK_INIT; *list = gnutls_calloc(1, sizeof(struct tpm_key_list_st)); if (*list == NULL) return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR); tssret = pTspi_Context_Create(&(*list)->tpm_ctx); if (tssret) { gnutls_assert(); ret = tss_err(tssret); goto cleanup; } tssret = pTspi_Context_Connect((*list)->tpm_ctx, NULL); if (tssret) { gnutls_assert(); ret = tss_err(tssret); goto cleanup; } tssret = pTspi_Context_GetRegisteredKeysByUUID2((*list)->tpm_ctx, TSS_PS_TYPE_SYSTEM, NULL, &(*list)->size, &(*list)->ki); if (tssret) { gnutls_assert(); ret = tss_err(tssret); goto cleanup; } return 0; cleanup: gnutls_tpm_key_list_deinit(*list); return ret; } /** * gnutls_tpm_privkey_delete: * @url: the URL describing the key * @srk_password: a password for the SRK key * * This function will unregister the private key from the TPM * chip. * * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a * negative error value. * * Since: 3.1.0 **/ int gnutls_tpm_privkey_delete(const char *url, const char *srk_password) { struct tpm_ctx_st s; struct tpmkey_url_st durl; TSS_RESULT tssret; TSS_HKEY tkey; int ret; CHECK_INIT; ret = decode_tpmkey_url(url, &durl); if (ret < 0) return gnutls_assert_val(ret); if (durl.uuid_set == 0) return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); ret = tpm_open_session(&s, srk_password, 1); if (ret < 0) return gnutls_assert_val(ret); tssret = pTspi_Context_UnregisterKey(s.tpm_ctx, durl.storage, durl.uuid, &tkey); if (tssret != 0) { gnutls_assert(); ret = tss_err(tssret); goto err_cc; } ret = 0; err_cc: tpm_close_session(&s); return ret; } #else /* HAVE_TROUSERS */ int gnutls_privkey_import_tpm_raw(gnutls_privkey_t pkey, const gnutls_datum_t * fdata, gnutls_tpmkey_fmt_t format, const char *srk_password, const char *key_password, unsigned int flags) { return GNUTLS_E_UNIMPLEMENTED_FEATURE; } int gnutls_privkey_import_tpm_url(gnutls_privkey_t pkey, const char *url, const char *srk_password, const char *key_password, unsigned int flags) { return GNUTLS_E_UNIMPLEMENTED_FEATURE; } int gnutls_pubkey_import_tpm_raw(gnutls_pubkey_t pkey, const gnutls_datum_t * fdata, gnutls_tpmkey_fmt_t format, const char *srk_password, unsigned int flags) { return GNUTLS_E_UNIMPLEMENTED_FEATURE; } int gnutls_pubkey_import_tpm_url(gnutls_pubkey_t pkey, const char *url, const char *srk_password, unsigned int flags) { return GNUTLS_E_UNIMPLEMENTED_FEATURE; } int gnutls_tpm_privkey_generate(gnutls_pk_algorithm_t pk, unsigned int bits, const char *srk_password, const char *key_password, gnutls_tpmkey_fmt_t format, gnutls_x509_crt_fmt_t pub_format, gnutls_datum_t * privkey, gnutls_datum_t * pubkey, unsigned int flags) { return GNUTLS_E_UNIMPLEMENTED_FEATURE; } void gnutls_tpm_key_list_deinit(gnutls_tpm_key_list_t list) { return; } int gnutls_tpm_key_list_get_url(gnutls_tpm_key_list_t list, unsigned int idx, char **url, unsigned int flags) { return GNUTLS_E_UNIMPLEMENTED_FEATURE; } int gnutls_tpm_get_registered(gnutls_tpm_key_list_t * list) { return GNUTLS_E_UNIMPLEMENTED_FEATURE; } int gnutls_tpm_privkey_delete(const char *url, const char *srk_password) { return GNUTLS_E_UNIMPLEMENTED_FEATURE; } #endif /* HAVE_TROUSERS */