Tests: Esys test for resubmissions
Add a test where a mock tcti continuously returns
RC_yielded responses. This tests the internal behavior
of Esys resubmissions to be exactly 5 before returning
an error to the application layer.
Signed-off-by: Andreas Fuchs <andreas.fuchs@sit.fraunhofer.de>
diff --git a/Makefile-test.am b/Makefile-test.am
index 70842fa..44ac602 100644
--- a/Makefile-test.am
+++ b/Makefile-test.am
@@ -61,7 +61,8 @@
test/unit/TPMU-marshal
if ESAPI
TESTS_UNIT += \
- test/unit/esys-context-null
+ test/unit/esys-context-null \
+ test/unit/esys-resubmissions
endif ESAPI
endif #UNIT
@@ -207,7 +208,12 @@
test_unit_esys_context_null_CFLAGS = $(CMOCKA_CFLAGS) $(TESTS_CFLAGS)
test_unit_esys_context_null_LDADD = $(CMOCKA_LIBS) $(TESTS_LDADD)
test_unit_esys_context_null_LDFLAGS = $(TESTS_LDFLAGS) -lgcrypt
-test_unit_esys_context_null_SOURCES = test/unit/esys-context-null.c
+test_unit_esys_context_null_SOURCES = test/unit/esys-context-null.c
+
+test_unit_esys_resubmissions_CFLAGS = $(CMOCKA_CFLAGS) $(TESTS_CFLAGS)
+test_unit_esys_resubmissions_LDADD = $(CMOCKA_LIBS) $(TESTS_LDADD)
+test_unit_esys_resubmissions_LDFLAGS = $(TESTS_LDFLAGS) -lgcrypt
+test_unit_esys_resubmissions_SOURCES = test/unit/esys-resubmissions.c
endif # ESAPI
endif # UNIT
diff --git a/test/unit/esys-resubmissions.c b/test/unit/esys-resubmissions.c
new file mode 100644
index 0000000..de1d3b1
--- /dev/null
+++ b/test/unit/esys-resubmissions.c
@@ -0,0 +1,444 @@
+/*******************************************************************************
+ * Copyright 2017-2018, Fraunhofer SIT sponsored by Infineon Technologies AG All
+ * rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 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 <stdarg.h>
+#include <inttypes.h>
+#include <string.h>
+
+#include <setjmp.h>
+#include <cmocka.h>
+
+#include "tss2_esys.h"
+
+#include "tss2-esys/esys_iutil.h"
+#define LOGMODULE tests
+#include "util/log.h"
+
+/**
+ * This unit test looks into a set of Esys_<cmd>() functions and tests the
+ * resubmission behaviour. The ESAPI is expected to resubmit a command for a
+ * certain number of times if the TPM return RC_YIELDED. After this number of
+ * times, the ESAPI shall not try it any further but return the TPM's error.
+ * For all these resubmissions the command must be the same as before.
+ * This shall be extended to cover all functions at some point.
+ */
+
+#define TCTI_YIELDER_MAGIC 0x5949454c44455200ULL /* 'YIELDER\0' */
+#define TCTI_YIELDER_VERSION 0x1
+
+/* Esys handles for dummy session and key objects which can be used in ESAPI test calls */
+#define DMY_TR_HANDLE_SESSION ESYS_TR_MIN_OBJECT
+#define DMY_TR_HANDLE_KEY ESYS_TR_MIN_OBJECT+1
+
+typedef struct {
+ uint64_t magic;
+ uint32_t version;
+ TSS2_TCTI_TRANSMIT_FCN transmit;
+ TSS2_TCTI_RECEIVE_FCN receive;
+ TSS2_RC(*finalize) (TSS2_TCTI_CONTEXT * tctiContext);
+ TSS2_RC(*cancel) (TSS2_TCTI_CONTEXT * tctiContext);
+ TSS2_RC(*getPollHandles) (TSS2_TCTI_CONTEXT * tctiContext,
+ TSS2_TCTI_POLL_HANDLE * handles,
+ size_t * num_handles);
+ TSS2_RC(*setLocality) (TSS2_TCTI_CONTEXT * tctiContext, uint8_t locality);
+ uint32_t count;
+ uint8_t cmd[4096];
+} TSS2_TCTI_CONTEXT_YIELDER;
+
+static TSS2_TCTI_CONTEXT_YIELDER *
+tcti_yielder_cast(TSS2_TCTI_CONTEXT * ctx)
+{
+ TSS2_TCTI_CONTEXT_YIELDER *ctxi = (TSS2_TCTI_CONTEXT_YIELDER *) ctx;
+ if (ctxi == NULL || ctxi->magic != TCTI_YIELDER_MAGIC) {
+ LOG_ERROR("Bad tcti passed.");
+ return NULL;
+ }
+ return ctxi;
+}
+
+static TSS2_RC
+tcti_yielder_transmit(TSS2_TCTI_CONTEXT * tctiContext,
+ size_t size, const uint8_t * buffer)
+{
+ TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tctiContext);
+
+ if (size > sizeof(tcti_yielder->cmd)) {
+ LOG_ERROR("Bad size value.");
+ return TSS2_TCTI_RC_INSUFFICIENT_BUFFER;
+ }
+
+ if (tcti_yielder->count != 0)
+ assert_memory_equal(&tcti_yielder->cmd[0], buffer, size);
+
+ tcti_yielder->count++;
+ memcpy(&tcti_yielder->cmd[0], buffer, size);
+
+ return TSS2_RC_SUCCESS;
+}
+
+const uint8_t yielded_response[] = {
+ 0x80, 0x01, /* TPM_ST_NO_SESSION */
+ 0x00, 0x00, 0x00, 0x0A, /* Response Size 10 */
+ 0x00, 0x00, 0x09, 0x08 /* TPM_RC_YIELDED */
+};
+
+static TSS2_RC
+tcti_yielder_receive(TSS2_TCTI_CONTEXT * tctiContext,
+ size_t * response_size,
+ uint8_t * response_buffer, int32_t timeout)
+{
+ *response_size = sizeof(yielded_response);
+ if (response_buffer != NULL)
+ memcpy(response_buffer, &yielded_response[0], sizeof(yielded_response));
+
+ return TSS2_RC_SUCCESS;
+}
+
+static void
+tcti_yielder_finalize(TSS2_TCTI_CONTEXT * tctiContext)
+{
+ memset(tctiContext, 0, sizeof(TSS2_TCTI_CONTEXT_YIELDER));
+}
+
+static TSS2_RC
+tcti_yielder_initialize(TSS2_TCTI_CONTEXT * tctiContext, size_t * contextSize)
+{
+ TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder =
+ (TSS2_TCTI_CONTEXT_YIELDER *) tctiContext;
+
+ if (tctiContext == NULL && contextSize == NULL) {
+ return TSS2_TCTI_RC_BAD_VALUE;
+ } else if (tctiContext == NULL) {
+ *contextSize = sizeof(*tcti_yielder);
+ return TSS2_RC_SUCCESS;
+ }
+
+ /* Init TCTI context */
+ memset(tcti_yielder, 0, sizeof(*tcti_yielder));
+ TSS2_TCTI_MAGIC(tctiContext) = TCTI_YIELDER_MAGIC;
+ TSS2_TCTI_VERSION(tctiContext) = TCTI_YIELDER_VERSION;
+ TSS2_TCTI_TRANSMIT(tctiContext) = tcti_yielder_transmit;
+ TSS2_TCTI_RECEIVE(tctiContext) = tcti_yielder_receive;
+ TSS2_TCTI_FINALIZE(tctiContext) = tcti_yielder_finalize;
+ TSS2_TCTI_CANCEL(tctiContext) = NULL;
+ TSS2_TCTI_GET_POLL_HANDLES(tctiContext) = NULL;
+ TSS2_TCTI_SET_LOCALITY(tctiContext) = NULL;
+ tcti_yielder->count = 0;
+
+ return TSS2_RC_SUCCESS;
+}
+
+static int
+setup(void **state)
+{
+ TSS2_RC r;
+ ESYS_CONTEXT *ectx;
+ size_t size = sizeof(TSS2_TCTI_CONTEXT_YIELDER);
+ TSS2_TCTI_CONTEXT *tcti = malloc(size);
+ ESYS_TR objectHandle;
+ RSRC_NODE_T *objectHandleNode = NULL;
+
+ r = tcti_yielder_initialize(tcti, &size);
+ if (r)
+ return (int)r;
+ r = Esys_Initialize(&ectx, tcti, NULL);
+ if (r)
+ return (int)r;
+
+ /* Create dummy object to enable usage of SAPI prepare functions in the tests */
+ objectHandle = DMY_TR_HANDLE_SESSION;
+ r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
+ if (r)
+ return (int)r;
+ objectHandleNode->rsrc.rsrcType = IESYSC_SESSION_RSRC;
+ objectHandleNode->rsrc.handle = TPM2_POLICY_SESSION_FIRST;
+ objectHandle = DMY_TR_HANDLE_KEY;
+ r = esys_CreateResourceObject(ectx, objectHandle, &objectHandleNode);
+ if (r)
+ return (int)r;
+ objectHandleNode->rsrc.rsrcType = IESYSC_KEY_RSRC;
+ objectHandleNode->rsrc.handle = TPM2_TRANSIENT_FIRST;
+
+ if (r)
+ return (int)r;
+ *state = (void *)ectx;
+ return 0;
+}
+
+static int
+teardown(void **state)
+{
+ TSS2_TCTI_CONTEXT *tcti;
+ ESYS_CONTEXT *ectx = (ESYS_CONTEXT *) * state;
+ Esys_GetTcti(ectx, &tcti);
+ Esys_Finalize(&ectx);
+ free(tcti);
+ return 0;
+}
+
+static void
+test_Startup(void **state)
+{
+ TSS2_RC r;
+ TSS2_TCTI_CONTEXT *tcti;
+ ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
+ Esys_GetTcti(esys_context, &tcti);
+ TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
+
+ TPM2_SU startupType = TPM2_SU_CLEAR;
+ r = Esys_Startup(esys_context, startupType);
+
+ assert_int_equal(r, TPM2_RC_YIELDED);
+ assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
+}
+
+static void
+test_Shutdown(void **state)
+{
+ TSS2_RC r;
+ TSS2_TCTI_CONTEXT *tcti;
+ ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
+ Esys_GetTcti(esys_context, &tcti);
+ TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
+
+ TPM2_SU shutdownType = TPM2_SU_CLEAR;
+ r = Esys_Shutdown(esys_context,
+ ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, shutdownType);
+
+ assert_int_equal(r, TPM2_RC_YIELDED);
+ assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
+}
+
+static void
+test_SelfTest(void **state)
+{
+ TSS2_RC r;
+ TSS2_TCTI_CONTEXT *tcti;
+ ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
+ Esys_GetTcti(esys_context, &tcti);
+ TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
+
+ r = Esys_SelfTest(esys_context,
+ ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, 0);
+ assert_int_equal(r, TPM2_RC_YIELDED);
+ assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
+}
+
+static void
+test_IncrementalSelfTest(void **state)
+{
+ TSS2_RC r;
+ TSS2_TCTI_CONTEXT *tcti;
+ ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
+ Esys_GetTcti(esys_context, &tcti);
+ TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
+
+ TPML_ALG toTest;
+ TPML_ALG *toDoList;
+ r = Esys_IncrementalSelfTest(esys_context,
+ ESYS_TR_NONE,
+ ESYS_TR_NONE,
+ ESYS_TR_NONE, &toTest, &toDoList);
+
+ assert_int_equal(r, TPM2_RC_YIELDED);
+ assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
+}
+
+static void
+test_GetTestResult(void **state)
+{
+ TSS2_RC r;
+ TSS2_TCTI_CONTEXT *tcti;
+ ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
+ Esys_GetTcti(esys_context, &tcti);
+ TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
+
+ TPM2B_MAX_BUFFER *outData;
+ TPM2_RC testResult;
+ r = Esys_GetTestResult(esys_context,
+ ESYS_TR_NONE,
+ ESYS_TR_NONE, ESYS_TR_NONE, &outData, &testResult);
+
+ assert_int_equal(r, TPM2_RC_YIELDED);
+ assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
+}
+
+static void
+test_StartAuthSession(void **state)
+{
+ TSS2_RC r;
+ TSS2_TCTI_CONTEXT *tcti;
+ ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
+ Esys_GetTcti(esys_context, &tcti);
+ TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
+
+ ESYS_TR tpmKey_handle = ESYS_TR_NONE;
+ ESYS_TR bind_handle = ESYS_TR_NONE;
+ TPM2B_NONCE nonceCaller = {
+ .size = 20,
+ .buffer = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
+ };
+ TPM2_SE sessionType = TPM2_SE_HMAC;
+ TPMT_SYM_DEF symmetric = {.algorithm = TPM2_ALG_AES,
+ .keyBits = {.aes = 128},
+ .mode = {.aes = TPM2_ALG_CFB}
+ };
+ TPMI_ALG_HASH authHash = TPM2_ALG_SHA1;
+ ESYS_TR sessionHandle_handle;
+ TPM2B_NONCE *nonceTPM;
+
+ r = Esys_StartAuthSession(esys_context,
+ tpmKey_handle,
+ bind_handle,
+ ESYS_TR_NONE,
+ ESYS_TR_NONE,
+ ESYS_TR_NONE,
+ &nonceCaller,
+ sessionType,
+ &symmetric,
+ authHash, &sessionHandle_handle, &nonceTPM);
+
+ assert_int_equal(r, TPM2_RC_YIELDED);
+ assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
+}
+
+static void
+test_PolicyRestart(void **state)
+{
+ TSS2_RC r;
+ TSS2_TCTI_CONTEXT *tcti;
+ ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
+ Esys_GetTcti(esys_context, &tcti);
+ TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
+
+ r = Esys_PolicyRestart(esys_context,
+ DMY_TR_HANDLE_SESSION,
+ ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE);
+
+ assert_int_equal(r, TPM2_RC_YIELDED);
+ assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
+}
+
+static void
+test_Create(void **state)
+{
+ TSS2_RC r;
+ TSS2_TCTI_CONTEXT *tcti;
+ ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
+ Esys_GetTcti(esys_context, &tcti);
+ TSS2_TCTI_CONTEXT_YIELDER *tcti_yielder = tcti_yielder_cast(tcti);
+ TPM2B_SENSITIVE_CREATE inSensitive = { 0 };
+ TPM2B_PUBLIC inPublic = {
+ .size = 0,
+ .publicArea = {
+ .type = TPM2_ALG_ECC,
+ .nameAlg = TPM2_ALG_SHA256,
+ .objectAttributes = (TPMA_OBJECT_USERWITHAUTH |
+ TPMA_OBJECT_RESTRICTED |
+ TPMA_OBJECT_SIGN_ENCRYPT |
+ TPMA_OBJECT_FIXEDTPM |
+ TPMA_OBJECT_FIXEDPARENT |
+ TPMA_OBJECT_SENSITIVEDATAORIGIN),
+ .authPolicy = {
+ .size = 0,
+ },
+ .parameters.eccDetail = {
+ .symmetric = {
+ .algorithm =
+ TPM2_ALG_NULL,
+ .keyBits.aes =
+ 128,
+ .mode.aes =
+ TPM2_ALG_ECB,
+ },
+ .scheme = {
+ .scheme =
+ TPM2_ALG_ECDSA,
+ .details = {
+ .ecdsa =
+ {.
+ hashAlg
+ =
+ TPM2_ALG_SHA256}},
+ },
+ .curveID = TPM2_ECC_NIST_P256,
+ .kdf = {
+ .scheme = TPM2_ALG_NULL,
+ .details = {}}
+ },
+ .unique.ecc = {
+ .x = {.size = 0,.buffer = {}},
+ .y = {.size = 0,.buffer = {}},
+ },
+ },
+ };
+ TPM2B_DATA outsideInfo = {
+ .size = 0,
+ .buffer = {},
+ };
+ TPML_PCR_SELECTION creationPCR = {
+ .count = 0,
+ };
+ TPM2B_PRIVATE *outPrivate;
+ TPM2B_PUBLIC *outPublic;
+ TPM2B_CREATION_DATA *creationData;
+ TPM2B_DIGEST *creationHash;
+ TPMT_TK_CREATION *creationTicket;
+
+ r = Esys_Create(esys_context,
+ DMY_TR_HANDLE_KEY,
+ ESYS_TR_PASSWORD,
+ ESYS_TR_NONE,
+ ESYS_TR_NONE,
+ &inSensitive,
+ &inPublic,
+ &outsideInfo,
+ &creationPCR,
+ &outPrivate,
+ &outPublic, &creationData, &creationHash, &creationTicket);
+
+ assert_int_equal(r, TPM2_RC_YIELDED);
+ assert_int_equal(tcti_yielder->count, 5 /* _ESYS_MAX_SUBMISSIONS */ );
+}
+
+int
+main(int argc, char *argv[])
+{
+ const struct CMUnitTest tests[] = {
+ cmocka_unit_test_setup_teardown(test_Startup, setup, teardown),
+ cmocka_unit_test_setup_teardown(test_Shutdown, setup, teardown),
+ cmocka_unit_test_setup_teardown(test_SelfTest, setup, teardown),
+ cmocka_unit_test_setup_teardown(test_IncrementalSelfTest, setup,
+ teardown),
+ cmocka_unit_test_setup_teardown(test_GetTestResult, setup, teardown),
+ cmocka_unit_test_setup_teardown(test_StartAuthSession, setup, teardown),
+ cmocka_unit_test_setup_teardown(test_PolicyRestart, setup, teardown),
+ cmocka_unit_test_setup_teardown(test_Create, setup, teardown),
+ };
+ return cmocka_run_group_tests(tests, NULL, NULL);
+}