1 /* 2 * Minimal TPM emulator for TPM test cases 3 * 4 * Copyright (c) 2018 Red Hat, Inc. 5 * 6 * Authors: 7 * Marc-André Lureau <marcandre.lureau@redhat.com> 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2 or later. 10 * See the COPYING file in the top-level directory. 11 */ 12 13 #include "qemu/osdep.h" 14 #include <glib/gstdio.h> 15 16 #include "backends/tpm/tpm_ioctl.h" 17 #include "io/channel-socket.h" 18 #include "qapi/error.h" 19 #include "qapi/qmp/qlist.h" 20 #include "qapi/qmp/qstring.h" 21 #include "tpm-emu.h" 22 23 void tpm_emu_test_wait_cond(TPMTestState *s) 24 { 25 gint64 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND; 26 27 g_mutex_lock(&s->data_mutex); 28 29 if (!s->data_cond_signal && 30 !g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) { 31 g_assert_not_reached(); 32 } 33 34 s->data_cond_signal = false; 35 36 g_mutex_unlock(&s->data_mutex); 37 } 38 39 static void tpm_emu_close_ioc(void *ioc) 40 { 41 qio_channel_close(ioc, NULL); 42 } 43 44 static void *tpm_emu_tpm_thread(void *data) 45 { 46 TPMTestState *s = data; 47 QIOChannel *ioc = s->tpm_ioc; 48 49 qtest_add_abrt_handler(tpm_emu_close_ioc, ioc); 50 51 s->tpm_msg = g_new(struct tpm_hdr, 1); 52 while (true) { 53 int minhlen = sizeof(s->tpm_msg->tag) + sizeof(s->tpm_msg->len); 54 55 if (!qio_channel_read(ioc, (char *)s->tpm_msg, minhlen, &error_abort)) { 56 break; 57 } 58 s->tpm_msg->tag = be16_to_cpu(s->tpm_msg->tag); 59 s->tpm_msg->len = be32_to_cpu(s->tpm_msg->len); 60 g_assert_cmpint(s->tpm_msg->len, >=, minhlen); 61 62 s->tpm_msg = g_realloc(s->tpm_msg, s->tpm_msg->len); 63 qio_channel_read(ioc, (char *)&s->tpm_msg->code, 64 s->tpm_msg->len - minhlen, &error_abort); 65 s->tpm_msg->code = be32_to_cpu(s->tpm_msg->code); 66 67 /* reply error */ 68 switch (s->tpm_version) { 69 case TPM_VERSION_2_0: 70 s->tpm_msg->tag = cpu_to_be16(TPM2_ST_NO_SESSIONS); 71 s->tpm_msg->len = cpu_to_be32(sizeof(struct tpm_hdr)); 72 s->tpm_msg->code = cpu_to_be32(TPM_RC_FAILURE); 73 break; 74 case TPM_VERSION_1_2: 75 s->tpm_msg->tag = cpu_to_be16(TPM_TAG_RSP_COMMAND); 76 s->tpm_msg->len = cpu_to_be32(sizeof(struct tpm_hdr)); 77 s->tpm_msg->code = cpu_to_be32(TPM_FAIL); 78 break; 79 default: 80 g_debug("unsupported TPM version %u", s->tpm_version); 81 g_assert_not_reached(); 82 } 83 qio_channel_write(ioc, (char *)s->tpm_msg, be32_to_cpu(s->tpm_msg->len), 84 &error_abort); 85 } 86 87 qtest_remove_abrt_handler(ioc); 88 g_free(s->tpm_msg); 89 s->tpm_msg = NULL; 90 object_unref(OBJECT(s->tpm_ioc)); 91 return NULL; 92 } 93 94 void *tpm_emu_ctrl_thread(void *data) 95 { 96 TPMTestState *s = data; 97 QIOChannelSocket *lioc = qio_channel_socket_new(); 98 QIOChannel *ioc; 99 100 qio_channel_socket_listen_sync(lioc, s->addr, 1, &error_abort); 101 102 g_mutex_lock(&s->data_mutex); 103 s->data_cond_signal = true; 104 g_mutex_unlock(&s->data_mutex); 105 g_cond_signal(&s->data_cond); 106 107 qio_channel_wait(QIO_CHANNEL(lioc), G_IO_IN); 108 ioc = QIO_CHANNEL(qio_channel_socket_accept(lioc, &error_abort)); 109 g_assert(ioc); 110 qtest_add_abrt_handler(tpm_emu_close_ioc, ioc); 111 112 { 113 uint32_t cmd = 0; 114 struct iovec iov = { .iov_base = &cmd, .iov_len = sizeof(cmd) }; 115 int *pfd = NULL; 116 size_t nfd = 0; 117 118 qio_channel_readv_full(ioc, &iov, 1, &pfd, &nfd, 0, &error_abort); 119 cmd = be32_to_cpu(cmd); 120 g_assert_cmpint(cmd, ==, CMD_SET_DATAFD); 121 g_assert_cmpint(nfd, ==, 1); 122 s->tpm_ioc = QIO_CHANNEL(qio_channel_socket_new_fd(*pfd, &error_abort)); 123 g_free(pfd); 124 125 cmd = 0; 126 qio_channel_write(ioc, (char *)&cmd, sizeof(cmd), &error_abort); 127 128 s->emu_tpm_thread = g_thread_new(NULL, tpm_emu_tpm_thread, s); 129 } 130 131 while (true) { 132 uint32_t cmd; 133 ssize_t ret; 134 135 ret = qio_channel_read(ioc, (char *)&cmd, sizeof(cmd), NULL); 136 if (ret <= 0) { 137 break; 138 } 139 140 cmd = be32_to_cpu(cmd); 141 switch (cmd) { 142 case CMD_GET_CAPABILITY: { 143 ptm_cap cap = cpu_to_be64(0x3fff); 144 qio_channel_write(ioc, (char *)&cap, sizeof(cap), &error_abort); 145 break; 146 } 147 case CMD_INIT: { 148 ptm_init init; 149 qio_channel_read(ioc, (char *)&init.u.req, sizeof(init.u.req), 150 &error_abort); 151 init.u.resp.tpm_result = 0; 152 qio_channel_write(ioc, (char *)&init.u.resp, sizeof(init.u.resp), 153 &error_abort); 154 break; 155 } 156 case CMD_SHUTDOWN: { 157 ptm_res res = 0; 158 qio_channel_write(ioc, (char *)&res, sizeof(res), &error_abort); 159 /* the tpm data thread is expected to finish now */ 160 g_thread_join(s->emu_tpm_thread); 161 break; 162 } 163 case CMD_STOP: { 164 ptm_res res = 0; 165 qio_channel_write(ioc, (char *)&res, sizeof(res), &error_abort); 166 break; 167 } 168 case CMD_SET_BUFFERSIZE: { 169 ptm_setbuffersize sbs; 170 qio_channel_read(ioc, (char *)&sbs.u.req, sizeof(sbs.u.req), 171 &error_abort); 172 sbs.u.resp.buffersize = sbs.u.req.buffersize ?: cpu_to_be32(4096); 173 sbs.u.resp.tpm_result = 0; 174 sbs.u.resp.minsize = cpu_to_be32(128); 175 sbs.u.resp.maxsize = cpu_to_be32(4096); 176 qio_channel_write(ioc, (char *)&sbs.u.resp, sizeof(sbs.u.resp), 177 &error_abort); 178 break; 179 } 180 case CMD_SET_LOCALITY: { 181 ptm_loc loc; 182 /* Note: this time it's not u.req / u.resp... */ 183 qio_channel_read(ioc, (char *)&loc, sizeof(loc), &error_abort); 184 g_assert_cmpint(loc.u.req.loc, ==, 0); 185 loc.u.resp.tpm_result = 0; 186 qio_channel_write(ioc, (char *)&loc, sizeof(loc), &error_abort); 187 break; 188 } 189 case CMD_GET_TPMESTABLISHED: { 190 ptm_est est = { 191 .u.resp.bit = 0, 192 }; 193 qio_channel_write(ioc, (char *)&est, sizeof(est), &error_abort); 194 break; 195 } 196 default: 197 g_debug("unimplemented %u", cmd); 198 g_assert_not_reached(); 199 } 200 } 201 202 qtest_remove_abrt_handler(ioc); 203 object_unref(OBJECT(ioc)); 204 object_unref(OBJECT(lioc)); 205 return NULL; 206 } 207 208 bool tpm_model_is_available(const char *args, const char *tpm_if) 209 { 210 QTestState *qts; 211 QDict *rsp_tpm; 212 bool ret = false; 213 214 qts = qtest_init(args); 215 if (!qts) { 216 return false; 217 } 218 219 rsp_tpm = qtest_qmp(qts, "{ 'execute': 'query-tpm'}"); 220 if (!qdict_haskey(rsp_tpm, "error")) { 221 QDict *rsp_models = qtest_qmp(qts, 222 "{ 'execute': 'query-tpm-models'}"); 223 if (qdict_haskey(rsp_models, "return")) { 224 QList *models = qdict_get_qlist(rsp_models, "return"); 225 QListEntry *e; 226 227 QLIST_FOREACH_ENTRY(models, e) { 228 QString *s = qobject_to(QString, qlist_entry_obj(e)); 229 const char *ename = qstring_get_str(s); 230 if (!strcmp(ename, tpm_if)) { 231 ret = true; 232 break; 233 } 234 } 235 } 236 qobject_unref(rsp_models); 237 } 238 qobject_unref(rsp_tpm); 239 qtest_quit(qts); 240 241 return ret; 242 } 243