tests/qtest/tpm-util.c

/*
 * QTest TPM utilities
 *
 * Copyright (c) 2018 IBM Corporation
 * Copyright (c) 2018 Red Hat, Inc.
 *
 * Authors:
 *   Stefan Berger <stefanb@linux.vnet.ibm.com>
 *   Marc-André Lureau <marcandre.lureau@redhat.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */

#include "qemu/osdep.h"
#include <glib/gstdio.h>
#include "qemu/bswap.h"

#include "hw/acpi/tpm.h"
#include "libqtest.h"
#include "tpm-util.h"
#include "qobject/qdict.h"

#define CRB_ADDR_START (TPM_CRB_ADDR_BASE + A_CRB_CTRL_START)
#define CRB_ADDR_CTRL_STS (TPM_CRB_ADDR_BASE + A_CRB_CTRL_STS)
#define CRB_ADDR_CTRL_CMD_SIZE \
    (TPM_CRB_ADDR_BASE + A_CRB_CTRL_CMD_SIZE)

#define CRB_START_INVOKE  (1 << 0)
#define CRB_START_RSP_RETRY (1 << 1)
#define CRB_START_NEXT_CHUNK (1 << 2)

void tpm_wait_till_bit_clear(QTestState *s, uint64_t addr, uint32_t mask)
{
    uint32_t sts;
    uint64_t end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;

    while (true) {
        sts = qtest_readl(s, addr);
        if ((sts & mask) == 0) {
            break;
        }
        if (g_get_monotonic_time() >= end_time) {
            g_assert_cmphex(sts & mask, ==, 0);
            break;
        }
    }
}

void tpm_util_crb_transfer(QTestState *s,
                           const unsigned char *req, size_t req_size,
                           unsigned char *rsp, size_t rsp_size)
{
    uint32_t tpm_sts;
    uint64_t caddr = qtest_readq(s, TPM_CRB_ADDR_BASE + A_CRB_CTRL_CMD_LADDR);
    uint64_t raddr = qtest_readq(s, TPM_CRB_ADDR_BASE + A_CRB_CTRL_RSP_ADDR);

    qtest_writeb(s, TPM_CRB_ADDR_BASE + A_CRB_LOC_CTRL, 1);

    qtest_memwrite(s, caddr, req, req_size);

    qtest_writel(s, CRB_ADDR_START, CRB_START_INVOKE);
    tpm_wait_till_bit_clear(s, CRB_ADDR_START, CRB_START_INVOKE);

    tpm_sts = qtest_readl(s, CRB_ADDR_CTRL_STS);
    g_assert_cmpint(tpm_sts & 1, ==, 0);

    qtest_memread(s, raddr, rsp, rsp_size);
}

void tpm_util_crb_chunk_transfer(QTestState *s,
                                 const unsigned char *req, size_t req_size,
                                 unsigned char *rsp, size_t rsp_size)
{
    uint32_t tpm_sts;
    size_t chunk_size;
    unsigned char header[10];
    uint32_t actual_response_size = 0;

    uint64_t caddr = qtest_readq(s, TPM_CRB_ADDR_BASE + A_CRB_CTRL_CMD_LADDR);
    uint64_t raddr = qtest_readq(s, TPM_CRB_ADDR_BASE + A_CRB_CTRL_RSP_ADDR);
    uint32_t crb_ctrl_cmd_size = qtest_readl(s, CRB_ADDR_CTRL_CMD_SIZE);

    chunk_size = crb_ctrl_cmd_size;

    qtest_writeb(s, TPM_CRB_ADDR_BASE + A_CRB_LOC_CTRL, 1);

    for (size_t i = 0; i < req_size; i += chunk_size) {
        bool last_chunk = false;
        size_t current_chunk_size = chunk_size;

        if (i + chunk_size > req_size) {
            last_chunk = true;
            current_chunk_size = req_size - i;
        }

        qtest_memwrite(s, caddr, req + i, current_chunk_size);

        if (last_chunk) {
            qtest_writel(s, CRB_ADDR_START, CRB_START_INVOKE);
            tpm_wait_till_bit_clear(s, CRB_ADDR_START, CRB_START_INVOKE);
        } else {
            qtest_writel(s, CRB_ADDR_START, CRB_START_NEXT_CHUNK);
            tpm_wait_till_bit_clear(s, CRB_ADDR_START, CRB_START_NEXT_CHUNK);
        }
    }
    tpm_sts = qtest_readl(s, CRB_ADDR_CTRL_STS);
    g_assert_cmpint(tpm_sts & 1, ==, 0);

    /*
     * Read response in chunks
     */

    qtest_memread(s, raddr, header, sizeof(header));
    actual_response_size = ldl_be_p(&header[2]);

    if (actual_response_size > rsp_size) {
        actual_response_size = rsp_size;
    }

    for (size_t i = 0; i < actual_response_size; i += chunk_size) {
        size_t to_read = i + chunk_size > actual_response_size
                       ? actual_response_size - i
                       : chunk_size;
        if (i > 0) {
            qtest_writel(s, CRB_ADDR_START, CRB_START_NEXT_CHUNK);
            tpm_wait_till_bit_clear(s, CRB_ADDR_START, CRB_START_NEXT_CHUNK);
        }
        qtest_memread(s, raddr, rsp + i, to_read);
    }
}

void tpm_util_startup(QTestState *s, tx_func *tx)
{
    unsigned char buffer[1024];
    static const unsigned char tpm_startup[] = {
        0x80, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00,
        0x01, 0x44, 0x00, 0x00
    };
    static const unsigned char tpm_startup_resp[] = {
        0x80, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
        0x00, 0x00
    };

    tx(s, tpm_startup, sizeof(tpm_startup), buffer, sizeof(buffer));

    g_assert_cmpmem(buffer, sizeof(tpm_startup_resp),
                    tpm_startup_resp, sizeof(tpm_startup_resp));
}

void tpm_util_pcrextend(QTestState *s, tx_func *tx)
{
    unsigned char buffer[1024];
    static const unsigned char tpm_pcrextend[] = {
        0x80, 0x02, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00,
        0x01, 0x82, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
        0x00, 0x09, 0x40, 0x00, 0x00, 0x09, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
        0x0b, 0x74, 0x65, 0x73, 0x74, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00
    };

    static const unsigned char tpm_pcrextend_resp[] = {
        0x80, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x01, 0x00, 0x00
    };

    tx(s, tpm_pcrextend, sizeof(tpm_pcrextend), buffer, sizeof(buffer));

    g_assert_cmpmem(buffer, sizeof(tpm_pcrextend_resp),
                    tpm_pcrextend_resp, sizeof(tpm_pcrextend_resp));
}

void tpm_util_pcrread(QTestState *s, tx_func *tx,
                      const unsigned char *exp_resp, size_t exp_resp_size)
{
    unsigned char buffer[1024];
    static const unsigned char tpm_pcrread[] = {
        0x80, 0x01, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
        0x01, 0x7e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b,
        0x03, 0x00, 0x04, 0x00
    };

    tx(s, tpm_pcrread, sizeof(tpm_pcrread), buffer, sizeof(buffer));

    /* skip pcrUpdateCounter (14th byte) in comparison */
    g_assert(exp_resp_size >= 15);
    g_assert_cmpmem(buffer, 13, exp_resp, 13);
    g_assert_cmpmem(&buffer[14], exp_resp_size - 14,
                    &exp_resp[14], exp_resp_size - 14);
}

bool tpm_util_swtpm_has_tpm2(void)
{
    bool has_tpm2 = false;
    char *out = NULL;
    static const char *argv[] = {
        "swtpm", "socket", "--help", NULL
    };

    if (!g_spawn_sync(NULL /* working_dir */,
                      (char **)argv,
                      NULL /* envp */,
                      G_SPAWN_SEARCH_PATH,
                      NULL /* child_setup */,
                      NULL /* user_data */,
                      &out,
                      NULL /* err */,
                      NULL /* exit_status */,
                      NULL)) {
        return false;
    }

    if (strstr(out, "--tpm2")) {
        has_tpm2 = true;
    }

    g_free(out);
    return has_tpm2;
}

gboolean tpm_util_swtpm_start(const char *path, GPid *pid,
                              SocketAddress **addr, GError **error)
{
    char *swtpm_argv_tpmstate = g_strdup_printf("dir=%s", path);
    char *swtpm_argv_ctrl = g_strdup_printf("type=unixio,path=%s/sock",
                                            path);
    gchar *swtpm_argv[] = {
        g_strdup("swtpm"), g_strdup("socket"),
        g_strdup("--tpmstate"), swtpm_argv_tpmstate,
        g_strdup("--ctrl"), swtpm_argv_ctrl,
        g_strdup("--tpm2"),
        NULL
    };
    gboolean succ;
    unsigned i;

    *addr = g_new0(SocketAddress, 1);
    (*addr)->type = SOCKET_ADDRESS_TYPE_UNIX;
    (*addr)->u.q_unix.path = g_build_filename(path, "sock", NULL);

    succ = g_spawn_async(NULL, swtpm_argv, NULL, G_SPAWN_SEARCH_PATH,
                         NULL, NULL, pid, error);

    for (i = 0; swtpm_argv[i]; i++) {
        g_free(swtpm_argv[i]);
    }

    return succ;
}

void tpm_util_swtpm_kill(GPid pid)
{
    int n;

    if (!pid) {
        return;
    }

    g_spawn_close_pid(pid);

    n = kill(pid, 0);
    if (n < 0) {
        return;
    }

    kill(pid, SIGKILL);
}

void tpm_util_migrate(QTestState *who, const char *uri)
{
    QDict *rsp;

    rsp = qtest_qmp(who,
                    "{ 'execute': 'migrate', 'arguments': { 'uri': %s } }",
                    uri);
    g_assert(qdict_haskey(rsp, "return"));
    qobject_unref(rsp);
}

void tpm_util_wait_for_migration_complete(QTestState *who)
{
    while (true) {
        QDict *rsp;
        QDict *rsp_return;
        bool completed;
        const char *status;

        rsp = qtest_qmp(who, "{ 'execute': 'query-migrate' }");
        g_assert(qdict_haskey(rsp, "return"));
        rsp_return = qdict_get_qdict(rsp, "return");

        g_assert(!qdict_haskey(rsp_return, "error"));
        status = qdict_get_str(rsp_return, "status");
        completed = strcmp(status, "completed") == 0;
        g_assert_cmpstr(status, !=,  "failed");
        qobject_unref(rsp);
        if (completed) {
            return;
        }
        usleep(1000);
    }
}

void tpm_util_migration_start_qemu(QTestState **src_qemu,
                                   QTestState **dst_qemu,
                                   SocketAddress *src_tpm_addr,
                                   SocketAddress *dst_tpm_addr,
                                   const char *miguri,
                                   const char *ifmodel,
                                   const char *machine_options)
{
    char *src_qemu_args, *dst_qemu_args;

    src_qemu_args = g_strdup_printf(
        "%s "
        "-chardev socket,id=chr,path=%s "
        "-tpmdev emulator,id=tpm0,chardev=chr "
        "-device %s,tpmdev=tpm0 ",
        machine_options ? : "", src_tpm_addr->u.q_unix.path, ifmodel);

    *src_qemu = qtest_init(src_qemu_args);

    dst_qemu_args = g_strdup_printf(
        "%s "
        "-chardev socket,id=chr,path=%s "
        "-tpmdev emulator,id=tpm0,chardev=chr "
        "-device %s,tpmdev=tpm0 "
        "-incoming %s",
        machine_options ? : "",
        dst_tpm_addr->u.q_unix.path,
        ifmodel, miguri);

    *dst_qemu = qtest_init(dst_qemu_args);

    g_free(src_qemu_args);
    g_free(dst_qemu_args);
}

/* Remove directory with remainders of swtpm */
void tpm_util_rmdir(const char *path)
{
    char *filename;
    int ret;

    filename = g_strdup_printf("%s/tpm2-00.permall", path);
    g_unlink(filename);
    g_free(filename);

    filename = g_strdup_printf("%s/.lock", path);
    g_unlink(filename);
    g_free(filename);

    ret = g_rmdir(path);
    g_assert(!ret);
}