4021

pending completion

Build # 4021

Build Type

Pull #701

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/stefanberger/swtpm/commit/<a class=hub.com/stefanberger/swtpm/commit/<a class="double-link" href="https://git"><a class=hub.com/stefanberger/swtpm/commit/<a class="double-link" href="https://git"><a class=hub.com/stefanberger/swtpm/commit/e36c7a1a7d6eb84dd7f522e9b778e17b5c24bc38">e36c7a1a7">&lt;a href=&quot;https://github.com/stefanberger/swtpm/commit/</a><a class="double-link" href="https://github.com/stefanberger/swtpm/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/stefanberger/swtpm/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/stefanberger/swtpm/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/stefanberger/swtpm/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/stefanberger/swtpm/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/stefanberger/swtpm/commit/e36c7a1a7d6eb84dd7f522e9b778e17b5c24bc38">e36c7a1a7</a><a href="https://github.com/stefanberger/swtpm/commit/e36c7a1a7d6eb84dd7f522e9b778e17b5c24bc38">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/stefanberger/swtpm/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/stefanberger/swtpm/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/stefanberger/swtpm/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/stefanberger/swtpm/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/stefanberger/swtpm/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/stefanberger/swtpm/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/stefanberger/swtpm/commit/e36c7a1a7d6eb84dd7f522e9b778e17b5c24bc38&quot;&gt;e36c7a1a7&lt;/a&gt;&lt;a href=&quot;https://github.com/stefanberger/swtpm/commit/e36c7a1a7d6eb84... (continued)

Pull Request Pull Request #701: Send a TPM2_Shutdown before TPMLIB_Terminate() in case client did not send it

Run Details

56 of 56 new or added lines in 5 files covered. (100.0%)

6202 of 8265 relevant lines covered (75.04%)

15506.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.16

/src/swtpm/tpmlib.c

/*
 * tpm_funcs.c -- interface with libtpms
 *
 * (c) Copyright IBM Corporation 2015.
 *
 * Author: Stefan Berger <stefanb@us.ibm.com>
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * Neither the names of the IBM Corporation nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"

#include "sys_dependencies.h"

#include <assert.h>
#include <string.h>
#include <stdlib.h>

#include <libtpms/tpm_library.h>
#include <libtpms/tpm_error.h>
#include <libtpms/tpm_nvfilename.h>
#include <libtpms/tpm_memory.h>

#include "tpmlib.h"
#include "logging.h"
#include "tpm_ioctl.h"
#include "swtpm_nvstore.h"
#include "locality.h"
#ifdef WITH_VTPM_PROXY
#include "vtpm_proxy.h"
#endif
#include "utils.h"
#include "compiler_dependencies.h"
#include "swtpm_utils.h"
#include "fips.h"

/*
 * convert the blobtype integer into a string that libtpms
 * understands
 */
const char *tpmlib_get_blobname(uint32_t blobtype)
{
    switch (blobtype) {
    case PTM_BLOB_TYPE_PERMANENT:
        return TPM_PERMANENT_ALL_NAME;
    case PTM_BLOB_TYPE_VOLATILE:
        return TPM_VOLATILESTATE_NAME;
    case PTM_BLOB_TYPE_SAVESTATE:
        return TPM_SAVESTATE_NAME;
    default:
        return NULL;
    }
}

TPM_RESULT tpmlib_register_callbacks(struct libtpms_callbacks *cbs)
{
    TPM_RESULT res;

    if ((res = TPMLIB_RegisterCallbacks(cbs)) != TPM_SUCCESS) {
        logprintf(STDERR_FILENO,
                  "Error: Could not register the callbacks.\n");
    }
    return res;
}

TPM_RESULT tpmlib_choose_tpm_version(TPMLIB_TPMVersion tpmversion)
{
    TPM_RESULT res;

    if ((res = TPMLIB_ChooseTPMVersion(tpmversion)) != TPM_SUCCESS) {
        const char *version = "TPM 1.2";

        if (tpmversion == TPMLIB_TPM_VERSION_2)
            version = "TPM 2";
        logprintf(STDERR_FILENO,
                  "Error: %s is not supported by libtpms.\n", version);
    }
    return res;
}

TPM_RESULT tpmlib_start(uint32_t flags, TPMLIB_TPMVersion tpmversion)
{
    TPM_RESULT res;

    if ((res = tpmlib_choose_tpm_version(tpmversion)) != TPM_SUCCESS)
        return res;

    if ((res = TPMLIB_MainInit()) != TPM_SUCCESS) {
        logprintf(STDERR_FILENO,
                  "Error: Could not initialize libtpms.\n");
        return res;
    }

    if (flags & PTM_INIT_FLAG_DELETE_VOLATILE) {
        uint32_t tpm_number = 0;
        char *name = TPM_VOLATILESTATE_NAME;
        res = SWTPM_NVRAM_DeleteName(tpm_number,
                                     name,
                                     FALSE);
        if (res != TPM_SUCCESS) {
            logprintf(STDERR_FILENO,
                      "Error: Could not delete the volatile "
                      "state of the TPM.\n");
            goto error_terminate;
        }
    }

    if (fips_mode_enabled() && fips_mode_disable() < 0)
        goto error_terminate;

    return TPM_SUCCESS;

error_terminate:
    TPMLIB_Terminate();

    return res;
}

int tpmlib_get_tpm_property(enum TPMLIB_TPMProperty prop)
{
    int result = 0;
    TPM_RESULT res;

    res = TPMLIB_GetTPMProperty(prop, &result);

    assert(res == TPM_SUCCESS);

    return result;
}

uint32_t tpmlib_get_cmd_ordinal(const unsigned char *request, size_t req_len)
{
    struct tpm_req_header *hdr;

    if (req_len < sizeof(struct tpm_req_header))
        return TPM_ORDINAL_NONE;

    hdr = (struct tpm_req_header *)request;
    return be32toh(hdr->ordinal);
}

bool tpmlib_is_request_cancelable(TPMLIB_TPMVersion tpmversion,
                                  const unsigned char *request, size_t req_len)
{

    uint32_t ordinal = tpmlib_get_cmd_ordinal(request, req_len);

    if (ordinal == TPM_ORDINAL_NONE)
        return false;

    if (tpmversion == TPMLIB_TPM_VERSION_2)
        return (ordinal == TPMLIB_TPM2_CC_CreatePrimary ||
                ordinal == TPMLIB_TPM2_CC_Create);

    return (ordinal == TPMLIB_TPM_ORD_TakeOwnership ||
            ordinal == TPMLIB_TPM_ORD_CreateWrapKey);
}

static void tpmlib_write_error_response(unsigned char **rbuffer,
                                        uint32_t *rlength,
                                        uint32_t *rTotal,
                                        TPM_RESULT errcode,
                                        TPMLIB_TPMVersion tpmversion)
{
    struct tpm_resp_header errresp = {
        .tag = (tpmversion == TPMLIB_TPM_VERSION_2)
               ? htobe16(0x8001)
               : htobe16(0xc4),
        .size = htobe32(sizeof(errresp)),
        .errcode = htobe32(errcode),
    };

    if (*rbuffer == NULL ||
        *rTotal < sizeof(errresp)) {
        free(*rbuffer);

        *rbuffer = malloc(sizeof(errresp));
        if (*rbuffer)
            *rTotal = sizeof(errresp);
        else
            *rTotal = 0;
    }
    if (*rbuffer) {
        *rlength = sizeof(errresp);
        memcpy(*rbuffer, &errresp, sizeof(errresp));
    }
}

void tpmlib_write_fatal_error_response(unsigned char **rbuffer,
                                       uint32_t *rlength,
                                       uint32_t *rTotal,
                                       TPMLIB_TPMVersion tpmversion)
{
    TPM_RESULT errcode = (tpmversion == TPMLIB_TPM_VERSION_2)
                         ? TPM_RC_FAILURE
                         : TPM_FAIL;

    tpmlib_write_error_response(rbuffer, rlength, rTotal, errcode,
                                tpmversion);
}

void tpmlib_write_locality_error_response(unsigned char **rbuffer,
                                          uint32_t *rlength,
                                          uint32_t *rTotal,
                                          TPMLIB_TPMVersion tpmversion)
{
    TPM_RESULT errcode = (tpmversion == TPMLIB_TPM_VERSION_2)
                         ? TPM_RC_LOCALITY
                         : TPM_BAD_LOCALITY;

    tpmlib_write_error_response(rbuffer, rlength, rTotal, errcode,
                                tpmversion);
}

void tpmlib_write_success_response(unsigned char **rbuffer,
                                   uint32_t *rlength,
                                   uint32_t *rTotal,
                                   TPMLIB_TPMVersion tpmversion)
{
    tpmlib_write_error_response(rbuffer, rlength, rTotal, 0,
                                tpmversion);
}

#ifdef WITH_VTPM_PROXY
static void tpmlib_write_shortmsg_error_response(unsigned char **rbuffer,
                                                 uint32_t *rlength,
                                                 uint32_t *rTotal,
                                                 TPMLIB_TPMVersion tpmversion)
{
    TPM_RESULT errcode = (tpmversion == TPMLIB_TPM_VERSION_2)
                         ? TPM_RC_INSUFFICIENT
                         : TPM_BAD_PARAM_SIZE;

    tpmlib_write_error_response(rbuffer, rlength, rTotal, errcode,
                                tpmversion);
}

static TPM_RESULT tpmlib_process_setlocality(unsigned char **rbuffer,
                                             uint32_t *rlength,
                                             uint32_t *rTotal,
                                             unsigned char *command,
                                             uint32_t command_length,
                                             TPMLIB_TPMVersion tpmversion,
                                             uint32_t locality_flags,
                                             TPM_MODIFIER_INDICATOR *locality)
{
    TPM_MODIFIER_INDICATOR new_locality;

    if (command_length >= sizeof(struct tpm_req_header) + sizeof(char)) {
        if (!(locality_flags & LOCALITY_FLAG_ALLOW_SETLOCALITY)) {
            /* SETLOCALITY command is not allowed */
            tpmlib_write_fatal_error_response(rbuffer,
                                              rlength, rTotal,
                                              tpmversion);
        } else {
            new_locality = command[sizeof(struct tpm_req_header)];
            if (new_locality >=5 ||
                (new_locality == 4 &&
                 locality_flags & LOCALITY_FLAG_REJECT_LOCALITY_4)) {
                tpmlib_write_locality_error_response(rbuffer,
                                                     rlength, rTotal,
                                                    tpmversion);
            } else {
                tpmlib_write_success_response(rbuffer,
                                              rlength, rTotal,
                                              tpmversion);
                *locality = new_locality;
            }
        }
    } else {
        tpmlib_write_shortmsg_error_response(rbuffer,
                                             rlength, rTotal,
                                             tpmversion);
    }
    return TPM_SUCCESS;
}

TPM_RESULT tpmlib_process(unsigned char **rbuffer,
                          uint32_t *rlength,
                          uint32_t *rTotal,
                          unsigned char *command,
                          uint32_t command_length,
                          uint32_t locality_flags,
                          TPM_MODIFIER_INDICATOR *locality,
                          TPMLIB_TPMVersion tpmversion)
{
    /* process those commands we need to handle, e.g. SetLocality */
    struct tpm_req_header *req = (struct tpm_req_header *)command;
    uint32_t ordinal;

    if (command_length < sizeof(*req)) {
        tpmlib_write_shortmsg_error_response(rbuffer,
                                             rlength, rTotal,
                                             tpmversion);
        return TPM_SUCCESS;
    }

    ordinal = be32toh(req->ordinal);

    switch (tpmversion) {
    case TPMLIB_TPM_VERSION_1_2:
        switch (ordinal) {
        case TPM_CC_SET_LOCALITY:
            return tpmlib_process_setlocality(rbuffer, rlength, rTotal,
                                              command, command_length,
                                              tpmversion, locality_flags,
                                              locality);
        }
        break;

    case TPMLIB_TPM_VERSION_2:
        switch (ordinal) {
        case TPM2_CC_SET_LOCALITY:
            return tpmlib_process_setlocality(rbuffer, rlength, rTotal,
                                              command, command_length,
                                              tpmversion, locality_flags,
                                              locality);
        }
        break;
    }
    return TPM_SUCCESS;
}

#else

TPM_RESULT tpmlib_process(unsigned char **rbuffer SWTPM_ATTR_UNUSED,
                          uint32_t *rlength SWTPM_ATTR_UNUSED,
                          uint32_t *rTotal SWTPM_ATTR_UNUSED,
                          unsigned char *command SWTPM_ATTR_UNUSED,
                          uint32_t command_length SWTPM_ATTR_UNUSED,
                          uint32_t locality_flags SWTPM_ATTR_UNUSED,
                          TPM_MODIFIER_INDICATOR *locality SWTPM_ATTR_UNUSED,
                          TPMLIB_TPMVersion tpmversion SWTPM_ATTR_UNUSED)
{
    return TPM_SUCCESS;
}

#endif /* WITH_VTPM_PROXY */

enum TPMLIB_StateType tpmlib_blobtype_to_statetype(uint32_t blobtype)
{
    switch (blobtype) {
    case PTM_BLOB_TYPE_PERMANENT:
        return TPMLIB_STATE_PERMANENT;
    case PTM_BLOB_TYPE_VOLATILE:
        return TPMLIB_STATE_VOLATILE;
    case PTM_BLOB_TYPE_SAVESTATE:
        return TPMLIB_STATE_SAVE_STATE;
    }
    return 0;
}

/*
 * tpmlib_handle_tcg_tpm2_cmd_header
 *
 * Determine whether the given byte stream is a raw TPM 2 command or
 * whether it has a tcg_tpm2_cmd_header prefixed and if so return
 * the offset after the header where the actual command is. In all
 * other cases return 0.
 */
off_t tpmlib_handle_tcg_tpm2_cmd_header(const unsigned char *command,
                                        uint32_t command_length,
                                        TPM_MODIFIER_INDICATOR *locality)
{
    struct tpm_req_header *hdr = (struct tpm_req_header *)command;
    struct tpm2_send_command_prefix *tcgprefix;
    off_t ret = 0;

    /* return 0 for short packets or plain TPM 2 command */
    if (command_length < sizeof(*hdr) ||
        be16toh(hdr->tag) == TPM2_ST_NO_SESSION ||
        be16toh(hdr->tag) == TPM2_ST_SESSIONS ||
        command_length < sizeof(*tcgprefix))
        return 0;

    tcgprefix = (struct tpm2_send_command_prefix *)command;
    if (be32toh(tcgprefix->cmd) == TPM2_SEND_COMMAND) {
        ret = sizeof(*tcgprefix);
        *locality = tcgprefix->locality;
    }

    return ret;
}

/*
 * Create a Startup command with the given startupType for the
 * given TPM version.
 */
uint32_t tpmlib_create_startup_cmd(uint16_t startupType,
                                   TPMLIB_TPMVersion tpmversion,
                                   unsigned char *buffer,
                                   uint32_t buffersize)
{
    struct tpm_startup ts;
    uint32_t tocopy = min(sizeof(ts), buffersize);

    ts.hdr.size = htobe32(sizeof(ts));

    switch (tpmversion) {
    case TPMLIB_TPM_VERSION_1_2:
        ts.hdr.tag = htobe16(TPM_TAG_RQU_COMMAND);
        ts.hdr.ordinal = htobe32(TPMLIB_TPM_ORD_Startup);
        ts.startupType = htobe16(startupType);
        break;
    case TPMLIB_TPM_VERSION_2:
        ts.hdr.tag = htobe16(TPM2_ST_NO_SESSION);
        ts.hdr.ordinal = htobe32(TPMLIB_TPM2_CC_Startup);
        switch (startupType) {
        case TPM_ST_CLEAR:
            ts.startupType = htobe16(TPM2_SU_CLEAR);
            break;
        case TPM_ST_STATE:
            ts.startupType = htobe16(TPM2_SU_STATE);
            break;
        case TPM_ST_DEACTIVATED:
            tocopy = 0;
            logprintf(STDERR_FILENO,
                      "TPM 2 does not support startup deactivated.\n");
            break;
        default:
            tocopy = 0;
            logprintf(STDERR_FILENO,
                      "%s: internal error; unsupported startup type for TPM 2\n", __func__);
            break;
        }
        break;
    default:
        tocopy = 0;
        logprintf(STDERR_FILENO,
                  "%s: internal error; invalid TPM version\n", __func__);
        break;
    }

    if (tocopy)
        memcpy(buffer, &ts, tocopy);
    return tocopy;
}

/*
 * tpmlib_maybe_send_tpm2_shutdown: Send a TPM2_Shutdown() if necesssary
 *
 * @tpmversion: version of TPM
 * @lastCommand: last command that was sent to the TPM 2 before
 *               this will be updated if TPM2_Shutdown was sent
 *
 * Send a TPM2_Shutdown(SU_STATE) to a TPM 2 if the last-processed command was
 * not TPM2_Shutdown. If the command fails, send TPM2_Shutdown(SU_CLEAR).
 */
void tpmlib_maybe_send_tpm2_shutdown(TPMLIB_TPMVersion tpmversion,
                                     uint32_t *lastCommand)
{
    TPM_RESULT res;
    unsigned char *rbuffer = NULL;
    uint32_t rlength = 0;
    uint32_t rTotal = 0;
    struct tpm2_shutdown {
        struct tpm_req_header hdr;
        uint16_t shutdownType;
    } tpm2_shutdown = {
        .hdr = {
            .tag = htobe16(TPM2_ST_NO_SESSION),
            .size = htobe32(sizeof(tpm2_shutdown)),
            .ordinal = htobe32(TPMLIB_TPM2_CC_Shutdown),
        },
    };
    uint16_t shutdownTypes[2] = {
        TPM2_SU_STATE, TPM2_SU_CLEAR,
    };
    struct tpm_resp_header *rsp;
    uint32_t errcode;
    size_t i;

    /* Only send TPM2_Shutdown for a TPM 2 and only if TPM2_Shutdown()
     * was not already sent. Send a TPM2_Shutdown(SU_STATE) first since
     * this is preserves additional state that will not matter if the
     * VM starts with TPM2_Startup(SU_CLEAR). Only if this command fails
     * send TPM2_Shutdown(SU_CLEAR).
     */
    if (tpmversion != TPMLIB_TPM_VERSION_2 ||
        *lastCommand == TPMLIB_TPM2_CC_Shutdown)
        return;

    for (i = 0; i < ARRAY_LEN(shutdownTypes); i++) {
#if 0
        logprintf(STDERR_FILENO,
                  "Need to send TPM2_Shutdown(%s); previous command: 0x08x\n",
                  shutdownTypes[i] == TPM2_SU_STATE ? "SU_STATE" : "SU_CLEAR",
                  *lastCommand);
#endif
        tpm2_shutdown.shutdownType = htobe16(shutdownTypes[i]);

        res = TPMLIB_Process(&rbuffer, &rlength, &rTotal,
                             (unsigned char *)&tpm2_shutdown,
                             sizeof(tpm2_shutdown));

        if (res || rlength < sizeof(struct tpm_resp_header))
            continue;
        rsp = (struct tpm_resp_header *)rbuffer;

        errcode = be32toh(rsp->errcode);
        if (errcode == TPM_SUCCESS) {
            *lastCommand = TPMLIB_TPM2_CC_Shutdown;
            break;
        } else if (errcode == TPM_RC_INITIALIZE) {
            /* TPM not initialized by TPM2_Startup - won't work */
            break;
        }
    }
    free(rbuffer);
}

1	/*
2	* tpm_funcs.c -- interface with libtpms
3	*
4	* (c) Copyright IBM Corporation 2015.
5	*
6	* Author: Stefan Berger <stefanb@us.ibm.com>
7	*
8	* All rights reserved.
9	*
10	* Redistribution and use in source and binary forms, with or without
11	* modification, are permitted provided that the following conditions are
12	* met:
13	*
14	* Redistributions of source code must retain the above copyright notice,
15	* this list of conditions and the following disclaimer.
16	*
17	* Redistributions in binary form must reproduce the above copyright
18	* notice, this list of conditions and the following disclaimer in the
19	* documentation and/or other materials provided with the distribution.
20	*
21	* Neither the names of the IBM Corporation nor the names of its
22	* contributors may be used to endorse or promote products derived from
23	* this software without specific prior written permission.
24	*
25	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29	* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36	*/
37
38	#include "config.h"
39
40	#include "sys_dependencies.h"
41
42	#include <assert.h>
43	#include <string.h>
44	#include <stdlib.h>
45
46	#include <libtpms/tpm_library.h>
47	#include <libtpms/tpm_error.h>
48	#include <libtpms/tpm_nvfilename.h>
49	#include <libtpms/tpm_memory.h>
50
51	#include "tpmlib.h"
52	#include "logging.h"
53	#include "tpm_ioctl.h"
54	#include "swtpm_nvstore.h"
55	#include "locality.h"
56	#ifdef WITH_VTPM_PROXY
57	#include "vtpm_proxy.h"
58	#endif
59	#include "utils.h"
60	#include "compiler_dependencies.h"
61	#include "swtpm_utils.h"
62	#include "fips.h"
63
64	/*
65	* convert the blobtype integer into a string that libtpms
66	* understands
67	*/
68	const char *tpmlib_get_blobname(uint32_t blobtype)	199✔
69	{
70	switch (blobtype) {	199✔
71	case PTM_BLOB_TYPE_PERMANENT:
72	return TPM_PERMANENT_ALL_NAME;
73	case PTM_BLOB_TYPE_VOLATILE:	123✔
74	return TPM_VOLATILESTATE_NAME;	123✔
75	case PTM_BLOB_TYPE_SAVESTATE:	14✔
76	return TPM_SAVESTATE_NAME;	14✔
77	default:	×
78	return NULL;	×
79	}
80	}
81
82	TPM_RESULT tpmlib_register_callbacks(struct libtpms_callbacks *cbs)	394✔
83	{
84	TPM_RESULT res;
85
86	if ((res = TPMLIB_RegisterCallbacks(cbs)) != TPM_SUCCESS) {	394✔
87	logprintf(STDERR_FILENO,	×
88	"Error: Could not register the callbacks.\n");
89	}
90	return res;	394✔
91	}
92
93	TPM_RESULT tpmlib_choose_tpm_version(TPMLIB_TPMVersion tpmversion)	6,512✔
94	{
95	TPM_RESULT res;
96
97	if ((res = TPMLIB_ChooseTPMVersion(tpmversion)) != TPM_SUCCESS) {	6,512✔
98	const char *version = "TPM 1.2";	×
99
100	if (tpmversion == TPMLIB_TPM_VERSION_2)	×
101	version = "TPM 2";	×
102	logprintf(STDERR_FILENO,	×
103	"Error: %s is not supported by libtpms.\n", version);
104	}
105	return res;	6,512✔
106	}
107
108	TPM_RESULT tpmlib_start(uint32_t flags, TPMLIB_TPMVersion tpmversion)	6,031✔
109	{
110	TPM_RESULT res;
111
112	if ((res = tpmlib_choose_tpm_version(tpmversion)) != TPM_SUCCESS)	6,031✔
113	return res;
114
115	if ((res = TPMLIB_MainInit()) != TPM_SUCCESS) {	6,031✔
116	logprintf(STDERR_FILENO,	20✔
117	"Error: Could not initialize libtpms.\n");
118	return res;	20✔
119	}
120
121	if (flags & PTM_INIT_FLAG_DELETE_VOLATILE) {	6,011✔
122	uint32_t tpm_number = 0;	5,907✔
123	char *name = TPM_VOLATILESTATE_NAME;	5,907✔
124	res = SWTPM_NVRAM_DeleteName(tpm_number,	5,907✔
125	name,
126	FALSE);
127	if (res != TPM_SUCCESS) {	5,907✔
128	logprintf(STDERR_FILENO,	×
129	"Error: Could not delete the volatile "
130	"state of the TPM.\n");
131	goto error_terminate;	×
132	}
133	}
134
135	if (fips_mode_enabled() && fips_mode_disable() < 0)	6,011✔
136	goto error_terminate;
137
138	return TPM_SUCCESS;
139
140	error_terminate:	×
141	TPMLIB_Terminate();	×
142
143	return res;	×
144	}
145
146	int tpmlib_get_tpm_property(enum TPMLIB_TPMProperty prop)	284✔
147	{
148	int result = 0;	284✔
149	TPM_RESULT res;
150
151	res = TPMLIB_GetTPMProperty(prop, &result);	284✔
152
153	assert(res == TPM_SUCCESS);	284✔
154
155	return result;	284✔
156	}
157
158	uint32_t tpmlib_get_cmd_ordinal(const unsigned char *request, size_t req_len)	21,465✔
159	{
160	struct tpm_req_header *hdr;
161
162	if (req_len < sizeof(struct tpm_req_header))	21,465✔
163	return TPM_ORDINAL_NONE;
164
165	hdr = (struct tpm_req_header *)request;	21,465✔
166	return be32toh(hdr->ordinal);	42,930✔
167	}
168
169	bool tpmlib_is_request_cancelable(TPMLIB_TPMVersion tpmversion,	324✔
170	const unsigned char *request, size_t req_len)
171	{
172
173	uint32_t ordinal = tpmlib_get_cmd_ordinal(request, req_len);	324✔
174
175	if (ordinal == TPM_ORDINAL_NONE)	324✔
176	return false;
177
178	if (tpmversion == TPMLIB_TPM_VERSION_2)	324✔
179	return (ordinal == TPMLIB_TPM2_CC_CreatePrimary \|\|	348✔
180	ordinal == TPMLIB_TPM2_CC_Create);	174✔
181
182	return (ordinal == TPMLIB_TPM_ORD_TakeOwnership \|\|	300✔
183	ordinal == TPMLIB_TPM_ORD_CreateWrapKey);	150✔
184	}
185
186	static void tpmlib_write_error_response(unsigned char **rbuffer,	25✔
187	uint32_t *rlength,
188	uint32_t *rTotal,
189	TPM_RESULT errcode,
190	TPMLIB_TPMVersion tpmversion)
191	{
192	struct tpm_resp_header errresp = {	100✔
193	.tag = (tpmversion == TPMLIB_TPM_VERSION_2)
194	? htobe16(0x8001)
195	: htobe16(0xc4),	13✔
196	.size = htobe32(sizeof(errresp)),	25✔
197	.errcode = htobe32(errcode),	25✔
198	};
199
200	if (*rbuffer == NULL \|\|	30✔
201	*rTotal < sizeof(errresp)) {	5✔
202	free(*rbuffer);	20✔
203
204	*rbuffer = malloc(sizeof(errresp));	20✔
205	if (*rbuffer)	20✔
206	*rTotal = sizeof(errresp);	20✔
207	else
208	*rTotal = 0;	×
209	}
210	if (*rbuffer) {	25✔
211	*rlength = sizeof(errresp);	25✔
212	memcpy(*rbuffer, &errresp, sizeof(errresp));	25✔
213	}
214	}	25✔
215
216	void tpmlib_write_fatal_error_response(unsigned char **rbuffer,	23✔
217	uint32_t *rlength,
218	uint32_t *rTotal,
219	TPMLIB_TPMVersion tpmversion)
220	{
221	TPM_RESULT errcode = (tpmversion == TPMLIB_TPM_VERSION_2)	23✔
222	? TPM_RC_FAILURE
223	: TPM_FAIL;	23✔
224
225	tpmlib_write_error_response(rbuffer, rlength, rTotal, errcode,	23✔
226	tpmversion);
227	}	23✔
228
229	void tpmlib_write_locality_error_response(unsigned char **rbuffer,	×
230	uint32_t *rlength,
231	uint32_t *rTotal,
232	TPMLIB_TPMVersion tpmversion)
233	{
234	TPM_RESULT errcode = (tpmversion == TPMLIB_TPM_VERSION_2)	×
235	? TPM_RC_LOCALITY
236	: TPM_BAD_LOCALITY;	×
237
238	tpmlib_write_error_response(rbuffer, rlength, rTotal, errcode,	×
239	tpmversion);
240	}
241
242	void tpmlib_write_success_response(unsigned char **rbuffer,	2✔
243	uint32_t *rlength,
244	uint32_t *rTotal,
245	TPMLIB_TPMVersion tpmversion)
246	{
247	tpmlib_write_error_response(rbuffer, rlength, rTotal, 0,	2✔
248	tpmversion);
249	}	2✔
250
251	#ifdef WITH_VTPM_PROXY
252	static void tpmlib_write_shortmsg_error_response(unsigned char **rbuffer,
253	uint32_t *rlength,
254	uint32_t *rTotal,
255	TPMLIB_TPMVersion tpmversion)
256	{
257	TPM_RESULT errcode = (tpmversion == TPMLIB_TPM_VERSION_2)	×
258	? TPM_RC_INSUFFICIENT
259	: TPM_BAD_PARAM_SIZE;	×
260
261	tpmlib_write_error_response(rbuffer, rlength, rTotal, errcode,	×
262	tpmversion);
263	}
264
265	static TPM_RESULT tpmlib_process_setlocality(unsigned char **rbuffer,	2✔
266	uint32_t *rlength,
267	uint32_t *rTotal,
268	unsigned char *command,
269	uint32_t command_length,
270	TPMLIB_TPMVersion tpmversion,
271	uint32_t locality_flags,
272	TPM_MODIFIER_INDICATOR *locality)
273	{
274	TPM_MODIFIER_INDICATOR new_locality;
275
276	if (command_length >= sizeof(struct tpm_req_header) + sizeof(char)) {	2✔
277	if (!(locality_flags & LOCALITY_FLAG_ALLOW_SETLOCALITY)) {	2✔
278	/* SETLOCALITY command is not allowed */
279	tpmlib_write_fatal_error_response(rbuffer,	×
280	rlength, rTotal,
281	tpmversion);
282	} else {
283	new_locality = command[sizeof(struct tpm_req_header)];	2✔
284	if (new_locality >=5 \|\|	2✔
285	(new_locality == 4 &&	×
286	locality_flags & LOCALITY_FLAG_REJECT_LOCALITY_4)) {	×
287	tpmlib_write_locality_error_response(rbuffer,	×
288	rlength, rTotal,
289	tpmversion);
290	} else {
291	tpmlib_write_success_response(rbuffer,	2✔
292	rlength, rTotal,
293	tpmversion);
294	*locality = new_locality;	2✔
295	}
296	}
297	} else {
298	tpmlib_write_shortmsg_error_response(rbuffer,
299	rlength, rTotal,
300	tpmversion);
301	}
302	return TPM_SUCCESS;	2✔
303	}
304
305	TPM_RESULT tpmlib_process(unsigned char **rbuffer,	21,053✔
306	uint32_t *rlength,
307	uint32_t *rTotal,
308	unsigned char *command,
309	uint32_t command_length,
310	uint32_t locality_flags,
311	TPM_MODIFIER_INDICATOR *locality,
312	TPMLIB_TPMVersion tpmversion)
313	{
314	/* process those commands we need to handle, e.g. SetLocality */
315	struct tpm_req_header req = (struct tpm_req_header )command;	21,053✔
316	uint32_t ordinal;
317
318	if (command_length < sizeof(*req)) {	21,053✔
319	tpmlib_write_shortmsg_error_response(rbuffer,	×
320	rlength, rTotal,
321	tpmversion);
322	return TPM_SUCCESS;	×
323	}
324
325	ordinal = be32toh(req->ordinal);	42,106✔
326
327	switch (tpmversion) {	21,053✔
328	case TPMLIB_TPM_VERSION_1_2:	12,264✔
329	switch (ordinal) {	12,264✔
330	case TPM_CC_SET_LOCALITY:	1✔
331	return tpmlib_process_setlocality(rbuffer, rlength, rTotal,	1✔
332	command, command_length,
333	tpmversion, locality_flags,
334	locality);
335	}
336	break;
337
338	case TPMLIB_TPM_VERSION_2:	8,789✔
339	switch (ordinal) {	8,789✔
340	case TPM2_CC_SET_LOCALITY:	1✔
341	return tpmlib_process_setlocality(rbuffer, rlength, rTotal,	1✔
342	command, command_length,
343	tpmversion, locality_flags,
344	locality);
345	}
346	break;
347	}
348	return TPM_SUCCESS;
349	}
350
351	#else
352
353	TPM_RESULT tpmlib_process(unsigned char **rbuffer SWTPM_ATTR_UNUSED,
354	uint32_t *rlength SWTPM_ATTR_UNUSED,
355	uint32_t *rTotal SWTPM_ATTR_UNUSED,
356	unsigned char *command SWTPM_ATTR_UNUSED,
357	uint32_t command_length SWTPM_ATTR_UNUSED,
358	uint32_t locality_flags SWTPM_ATTR_UNUSED,
359	TPM_MODIFIER_INDICATOR *locality SWTPM_ATTR_UNUSED,
360	TPMLIB_TPMVersion tpmversion SWTPM_ATTR_UNUSED)
361	{
362	return TPM_SUCCESS;
363	}
364
365	#endif /* WITH_VTPM_PROXY */
366
367	enum TPMLIB_StateType tpmlib_blobtype_to_statetype(uint32_t blobtype)	91✔
368	{
369	switch (blobtype) {
370	case PTM_BLOB_TYPE_PERMANENT:
371	return TPMLIB_STATE_PERMANENT;
372	case PTM_BLOB_TYPE_VOLATILE:
373	return TPMLIB_STATE_VOLATILE;
374	case PTM_BLOB_TYPE_SAVESTATE:
375	return TPMLIB_STATE_SAVE_STATE;
376	}
377	return 0;
378	}
379
380	/*
381	* tpmlib_handle_tcg_tpm2_cmd_header
382	*
383	* Determine whether the given byte stream is a raw TPM 2 command or
384	* whether it has a tcg_tpm2_cmd_header prefixed and if so return
385	* the offset after the header where the actual command is. In all
386	* other cases return 0.
387	*/
388	off_t tpmlib_handle_tcg_tpm2_cmd_header(const unsigned char *command,	8,622✔
389	uint32_t command_length,
390	TPM_MODIFIER_INDICATOR *locality)
391	{
392	struct tpm_req_header hdr = (struct tpm_req_header )command;	8,622✔
393	struct tpm2_send_command_prefix *tcgprefix;
394	off_t ret = 0;	8,622✔
395
396	/* return 0 for short packets or plain TPM 2 command */
397	if (command_length < sizeof(*hdr) \|\|	17,244✔
398	be16toh(hdr->tag) == TPM2_ST_NO_SESSION \|\|	16,428✔
399	be16toh(hdr->tag) == TPM2_ST_SESSIONS \|\|	7,806✔
400	command_length < sizeof(*tcgprefix))
401	return 0;
402
403	tcgprefix = (struct tpm2_send_command_prefix *)command;	5,379✔
404	if (be32toh(tcgprefix->cmd) == TPM2_SEND_COMMAND) {	10,758✔
405	ret = sizeof(*tcgprefix);	5,379✔
406	*locality = tcgprefix->locality;	5,379✔
407	}
408
409	return ret;
410	}
411
412	/*
413	* Create a Startup command with the given startupType for the
414	* given TPM version.
415	*/
416	uint32_t tpmlib_create_startup_cmd(uint16_t startupType,	88✔
417	TPMLIB_TPMVersion tpmversion,
418	unsigned char *buffer,
419	uint32_t buffersize)
420	{
421	struct tpm_startup ts;
422	uint32_t tocopy = min(sizeof(ts), buffersize);	88✔
423
424	ts.hdr.size = htobe32(sizeof(ts));	88✔
425
426	switch (tpmversion) {	88✔
427	case TPMLIB_TPM_VERSION_1_2:
428	ts.hdr.tag = htobe16(TPM_TAG_RQU_COMMAND);	28✔
429	ts.hdr.ordinal = htobe32(TPMLIB_TPM_ORD_Startup);	28✔
430	ts.startupType = htobe16(startupType);	28✔
431	break;	28✔
432	case TPMLIB_TPM_VERSION_2:
433	ts.hdr.tag = htobe16(TPM2_ST_NO_SESSION);	60✔
434	ts.hdr.ordinal = htobe32(TPMLIB_TPM2_CC_Startup);	60✔
435	switch (startupType) {	60✔
436	case TPM_ST_CLEAR:
437	ts.startupType = htobe16(TPM2_SU_CLEAR);	60✔
438	break;	60✔
439	case TPM_ST_STATE:
440	ts.startupType = htobe16(TPM2_SU_STATE);	×
441	break;	×
442	case TPM_ST_DEACTIVATED:	×
443	tocopy = 0;	×
444	logprintf(STDERR_FILENO,	×
445	"TPM 2 does not support startup deactivated.\n");
446	break;
447	default:	×
448	tocopy = 0;	×
449	logprintf(STDERR_FILENO,	×
450	"%s: internal error; unsupported startup type for TPM 2\n", __func__);
451	break;
452	}
453	break;
454	default:	×
455	tocopy = 0;	×
456	logprintf(STDERR_FILENO,	×
457	"%s: internal error; invalid TPM version\n", __func__);
458	break;
459	}
460
461	if (tocopy)	88✔
462	memcpy(buffer, &ts, tocopy);	88✔
463	return tocopy;	88✔
464	}
465
466	/*
467	* tpmlib_maybe_send_tpm2_shutdown: Send a TPM2_Shutdown() if necesssary
468	*
469	* @tpmversion: version of TPM
470	* @lastCommand: last command that was sent to the TPM 2 before
471	* this will be updated if TPM2_Shutdown was sent
472	*
473	* Send a TPM2_Shutdown(SU_STATE) to a TPM 2 if the last-processed command was
474	* not TPM2_Shutdown. If the command fails, send TPM2_Shutdown(SU_CLEAR).
475	*/
476	void tpmlib_maybe_send_tpm2_shutdown(TPMLIB_TPMVersion tpmversion,	12✔
477	uint32_t *lastCommand)
478	{
479	TPM_RESULT res;
480	unsigned char *rbuffer = NULL;	12✔
481	uint32_t rlength = 0;	12✔
482	uint32_t rTotal = 0;	12✔
483	struct tpm2_shutdown {
484	struct tpm_req_header hdr;
485	uint16_t shutdownType;
486	} tpm2_shutdown = {	48✔
487	.hdr = {
488	.tag = htobe16(TPM2_ST_NO_SESSION),	12✔
489	.size = htobe32(sizeof(tpm2_shutdown)),	12✔
490	.ordinal = htobe32(TPMLIB_TPM2_CC_Shutdown),	12✔
491	},
492	};
493	uint16_t shutdownTypes[2] = {	12✔
494	TPM2_SU_STATE, TPM2_SU_CLEAR,
495	};
496	struct tpm_resp_header *rsp;
497	uint32_t errcode;
498	size_t i;
499
500	/* Only send TPM2_Shutdown for a TPM 2 and only if TPM2_Shutdown()
501	* was not already sent. Send a TPM2_Shutdown(SU_STATE) first since
502	* this is preserves additional state that will not matter if the
503	* VM starts with TPM2_Startup(SU_CLEAR). Only if this command fails
504	* send TPM2_Shutdown(SU_CLEAR).
505	*/
506	if (tpmversion != TPMLIB_TPM_VERSION_2 \|\|	24✔
507	*lastCommand == TPMLIB_TPM2_CC_Shutdown)	12✔
508	return;	×
509
510	for (i = 0; i < ARRAY_LEN(shutdownTypes); i++) {	×
511	#if 0
512	logprintf(STDERR_FILENO,
513	"Need to send TPM2_Shutdown(%s); previous command: 0x08x\n",
514	shutdownTypes[i] == TPM2_SU_STATE ? "SU_STATE" : "SU_CLEAR",
515	*lastCommand);
516	#endif
517	tpm2_shutdown.shutdownType = htobe16(shutdownTypes[i]);	12✔
518
519	res = TPMLIB_Process(&rbuffer, &rlength, &rTotal,	12✔
520	(unsigned char *)&tpm2_shutdown,
521	sizeof(tpm2_shutdown));
522
523	if (res \|\| rlength < sizeof(struct tpm_resp_header))	12✔
524	continue;	×
525	rsp = (struct tpm_resp_header *)rbuffer;	12✔
526
527	errcode = be32toh(rsp->errcode);	24✔
528	if (errcode == TPM_SUCCESS) {	12✔
529	*lastCommand = TPMLIB_TPM2_CC_Shutdown;	12✔
530	break;	12✔
531	} else if (errcode == TPM_RC_INITIALIZE) {	×
532	/* TPM not initialized by TPM2_Startup - won't work */
533	break;
534	}
535	}
536	free(rbuffer);	12✔
537	}

stefanberger / swtpm / 4021

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous