Setup TPM2-Plugin build environment

Add initial codes to build TPM2-plugin shared lib

Issue-ID: AAF-94
Change-Id: I96dee3699aa250b69350d6f01401f3831cf515f7
Signed-off-by: NingSun <ning.sun@intel.com>

1 files changed, 636 insertions, 0 deletions

diff --git a/TPM2-Plugin/lib/files.c b/TPM2-Plugin/lib/files.c
new file mode 100644
index 0000000..e2e41f4
--- /dev/null
+++ b/TPM2-Plugin/lib/files.c
@@ -0,0 +1,636 @@
+//**********************************************************************;
+// Copyright (c) 2017, Intel Corporation
+// 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.
+//
+// 3. Neither the name of Intel 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 <errno.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#include <sapi/tpm20.h>
+#include <sapi/tss2_mu.h>
+
+#include "files.h"
+#include "log.h"
+#include "tpm2_util.h"
+
+bool files_get_file_size(FILE *fp, unsigned long *file_size, const char *path) {
+
+    long current = ftell(fp);
+    if (current < 0) {
+        if (path) {
+            LOG_ERR("Error getting current file offset for file \"%s\" error: %s", path, strerror(errno));
+        }
+        return false;
+    }
+
+    int rc = fseek(fp, 0, SEEK_END);
+    if (rc < 0) {
+        if (path) {
+            LOG_ERR("Error seeking to end of file \"%s\" error: %s", path, strerror(errno));
+        }
+        return false;
+    }
+
+    long size = ftell(fp);
+    if (size < 0) {
+        if (path) {
+            LOG_ERR("ftell on file \"%s\" failed: %s", path, strerror(errno));
+        }
+        return false;
+    }
+
+    rc = fseek(fp, current, SEEK_SET);
+    if (rc < 0) {
+        if (path) {
+            LOG_ERR("Could not restore initial stream position for file \"%s\" failed: %s", path, strerror(errno));
+        }
+        return false;
+    }
+
+    /* size cannot be negative at this point */
+    *file_size = (unsigned long)size;
+    return true;
+}
+
+static bool read_bytes_from_file(FILE *f, UINT8 *buf, UINT16 *size,
+                                 const char *path) {
+    unsigned long file_size;
+    bool result = files_get_file_size(f, &file_size, path);
+    if (!result) {
+        /* get_file_size() logs errors */
+        return false;
+    }
+
+    /* max is bounded on UINT16 */
+    if (file_size > *size) {
+        if (path) {
+            LOG_ERR(
+                    "File \"%s\" size is larger than buffer, got %lu expected less than %u",
+                    path, file_size, *size);
+        }
+        return false;
+    }
+
+    result = files_read_bytes(f, buf, file_size);
+    if (!result) {
+        if (path) {
+            LOG_ERR("Could not read data from file \"%s\"", path);
+        }
+        return false;
+    }
+
+    *size = file_size;
+
+    return true;
+}
+
+bool files_load_bytes_from_path(const char *path, UINT8 *buf, UINT16 *size) {
+    if (!buf || !size || !path) {
+        return false;
+    }
+
+    FILE *f = fopen(path, "rb");
+    if (!f) {
+        LOG_ERR("Could not open file \"%s\" error %s", path, strerror(errno));
+        return false;
+    }
+
+    bool result = read_bytes_from_file(f, buf, size, path);
+
+    fclose(f);
+    return result;
+}
+
+bool files_save_bytes_to_file(const char *path, UINT8 *buf, UINT16 size) {
+
+    if (!path || !buf) {
+        return false;
+    }
+
+    FILE *fp = fopen(path, "wb+");
+    if (!fp) {
+        LOG_ERR("Could not open file \"%s\", error: %s", path, strerror(errno));
+        return false;
+    }
+
+    bool result = files_write_bytes(fp, buf, size);
+    if (!result) {
+        LOG_ERR("Could not write data to file \"%s\"", path);
+    }
+    fclose(fp);
+    return result;
+}
+
+/*
+ * Current version to write TPMS_CONTEXT to disk.
+ */
+#define CONTEXT_VERSION 1
+
+bool files_save_tpm_context_to_file(TSS2_SYS_CONTEXT *sysContext, TPM2_HANDLE handle,
+        FILE *stream) {
+
+    TPMS_CONTEXT context;
+
+    TSS2_RC rval = Tss2_Sys_ContextSave(sysContext, handle, &context);
+    if (rval != TPM2_RC_SUCCESS) {
+        LOG_PERR(Tss2_Sys_ContextSave, rval);
+        return false;
+    }
+
+    /*
+     * Saving the TPMS_CONTEXT structure to disk, format:
+     * TPM2.0-TOOLS HEADER
+     * U32 hiearchy
+     * U32 savedHandle
+     * U64 sequence
+     * U16 contextBlobLength
+     * BYTE[] contextBlob
+     */
+    bool result = files_write_header(stream, CONTEXT_VERSION);
+    if (!result) {
+        LOG_ERR("Could not write context file header");
+        goto out;
+    }
+
+    // UINT32
+    result = files_write_32(stream, context.hierarchy);
+    if (!result) {
+        LOG_ERR("Could not write hierarchy");
+        goto out;
+    }
+
+    result = files_write_32(stream, context.savedHandle);
+    if (!result) {
+        LOG_ERR("Could not write savedHandle");
+        goto out;
+    }
+
+    // UINT64
+    result = files_write_64(stream, context.sequence);
+    if (!result) {
+        LOG_ERR("Could not write sequence");
+        goto out;
+    }
+
+    // U16 LENGTH
+    result = files_write_16(stream, context.contextBlob.size);
+    if (!result) {
+        LOG_ERR("Could not write contextBob size");
+        goto out;
+    }
+
+    // BYTE[] contextBlob
+    result = files_write_bytes(stream, context.contextBlob.buffer,
+            context.contextBlob.size);
+    if (!result) {
+        LOG_ERR("Could not write contextBlob buffer");
+    }
+    /* result is set by file_write_bytes() */
+
+out:
+    return result;
+}
+
+bool files_save_tpm_context_to_path(TSS2_SYS_CONTEXT *sysContext, TPM2_HANDLE handle,
+        const char *path) {
+
+    FILE *f = fopen(path, "w+b");
+    if (!f) {
+        LOG_ERR("Error opening file \"%s\" due to error: %s", path,
+                strerror(errno));
+        return false;
+    }
+
+    bool result = files_save_tpm_context_to_file(sysContext, handle, f);
+    fclose(f);
+    return result;
+}
+
+
+bool files_load_tpm_context_from_file(TSS2_SYS_CONTEXT *sapi_context,
+        TPM2_HANDLE *handle, FILE *fstream) {
+
+    TSS2_RC rval;
+
+    /*
+     * Reading the TPMS_CONTEXT structure to disk, format:
+     * TPM2.0-TOOLS HEADER
+     * U32 hiearchy
+     * U32 savedHandle
+     * U64 sequence
+     * U16 contextBlobLength
+     * BYTE[] contextBlob
+     */
+    UINT32 version;
+    TPMS_CONTEXT context;
+    bool result = files_read_header(fstream, &version);
+    if (!result) {
+        LOG_WARN(
+            "The loaded tpm context does not appear to be in the proper format,"
+            "assuming old format, this will be converted on the next save.");
+        rewind(fstream);
+        result = files_read_bytes(fstream, (UINT8 *) &context, sizeof(context));
+        if (!result) {
+            LOG_ERR("Could not load tpm context file");
+            goto out;
+        }
+        /* Success load the context into the TPM */
+        goto load_to_tpm;
+    }
+
+    if (version != CONTEXT_VERSION) {
+        LOG_ERR("Unsupported context file format version found, got: %"PRIu32,
+                version);
+        result = false;
+        goto out;
+    }
+
+    result = files_read_32(fstream, &context.hierarchy);
+    if (!result) {
+        LOG_ERR("Error reading hierarchy!");
+        goto out;
+    }
+
+    result = files_read_32(fstream, &context.savedHandle);
+    if (!result) {
+        LOG_ERR("Error reading savedHandle!");
+        goto out;
+    }
+
+    result = files_read_64(fstream, &context.sequence);
+    if (!result) {
+        LOG_ERR("Error reading sequence!");
+        goto out;
+    }
+
+    result = files_read_16(fstream, &context.contextBlob.size);
+    if (!result) {
+        LOG_ERR("Error reading contextBlob.size!");
+        goto out;
+    }
+
+    if (context.contextBlob.size > sizeof(context.contextBlob.buffer)) {
+        LOG_ERR(
+                "Size mismatch found on contextBlob, got %"PRIu16" expected less than or equal to %zu",
+                context.contextBlob.size,
+                sizeof(context.contextBlob.buffer));
+        result = false;
+        goto out;
+    }
+
+    result = files_read_bytes(fstream, context.contextBlob.buffer,
+            context.contextBlob.size);
+    if (!result) {
+        LOG_ERR("Error reading contextBlob.size!");
+        goto out;
+    }
+
+load_to_tpm:
+    rval = Tss2_Sys_ContextLoad(sapi_context, &context, handle);
+    if (rval != TPM2_RC_SUCCESS) {
+        LOG_PERR(Tss2_Sys_ContextLoad, rval);
+        result = false;
+        goto out;
+    }
+
+    result = true;
+
+out:
+    return result;
+}
+
+bool files_load_tpm_context_from_path(TSS2_SYS_CONTEXT *sapi_context,
+        TPM2_HANDLE *handle, const char *path) {
+
+    FILE *f = fopen(path, "rb");
+    if (!f) {
+        LOG_ERR("Error opening file \"%s\" due to error: %s", path,
+                strerror(errno));
+        return false;
+    }
+
+    bool result = files_load_tpm_context_from_file(sapi_context, handle, f);
+
+    fclose(f);
+    return result;
+}
+
+bool files_does_file_exist(const char *path) {
+
+    if (!path) {
+        LOG_ERR("Path cannot be NULL");
+        return false;
+    }
+
+    FILE *fp = fopen(path,"rb");
+    if (fp) {
+        fclose(fp);
+        LOG_ERR("Path: %s already exists. Please rename or delete the file!",
+                path);
+        return true;
+    }
+    return false;
+}
+
+bool files_get_file_size_path(const char *path, unsigned long *file_size) {
+
+    bool result = false;
+
+    if (!path) {
+        LOG_ERR("Must specify a path argument, cannot be NULL!");
+        return false;
+    }
+
+    if (!file_size) {
+        LOG_ERR("Must specify a file size argument, cannot be NULL!");
+        return false;
+    }
+
+    FILE *fp = fopen(path,"rb");
+    if(!fp) {
+        LOG_ERR("Could not open file: \"%s\" error: %s", path, strerror(errno));
+        return false;
+    }
+
+    result = files_get_file_size(fp, file_size, path);
+
+    fclose(fp);
+    return result;
+}
+
+/**
+ * This is the magic for the file header. The header is organized
+ * as a big endian U32 (BEU32) of MAGIC followed by a BEU32 of the
+ * version number. Tools can define their own, individual file
+ * formats as they make sense, but they should always have the header.
+ */
+static const UINT32 MAGIC = 0xBADCC0DE;
+
+/**
+ * Writes size bytes to a file, continuing on EINTR short writes.
+ * @param f
+ *  The file to write to.
+ * @param data
+ *  The data to write.
+ * @param size
+ *  The size, in bytes, of that data.
+ * @return
+ *  True on success, False otherwise.
+ */
+static bool writex(FILE *f, UINT8 *data, size_t size) {
+
+    size_t wrote = 0;
+    size_t index = 0;
+    do {
+        wrote = fwrite(&data[index], 1, size, f);
+        if (wrote != size) {
+            if (errno != EINTR) {
+                return false;
+            }
+            /* continue on EINTR */
+        }
+        size -= wrote;
+        index += wrote;
+    } while (size > 0);
+
+    return true;
+}
+
+/**
+ * Reads size bytes from a file, continuing on EINTR short reads.
+ * @param f
+ *  The file to read from.
+ * @param data
+ *  The data buffer to read into.
+ * @param size
+ *  The size of the buffer, which is also the amount of bytes to read.
+ * @return
+ *  True on success, False otherwise.
+ */
+static bool readx(FILE *f, UINT8 *data, size_t size) {
+
+    size_t bread = 0;
+    size_t index = 0;
+    do {
+        bread = fread(&data[index], 1, size, f);
+        if (bread != size) {
+            if (feof(f) || (errno != EINTR)) {
+                return false;
+            }
+            /* continue on EINTR */
+        }
+        size -= bread;
+        index += bread;
+    } while (size > 0);
+
+    return true;
+}
+
+#define BAIL_ON_NULL(param, x) \
+    do { \
+        if (!x) { \
+            LOG_ERR(param" must be specified"); \
+            return false; \
+        } \
+    } while(0)
+
+#define BE_CONVERT(value, size) \
+    do { \
+        if (!tpm2_util_is_big_endian()) { \
+            value = tpm2_util_endian_swap_##size(value); \
+        } \
+    } while (0)
+
+#define FILE_WRITE(size) \
+    bool files_write_##size(FILE *out, UINT##size data) { \
+        BAIL_ON_NULL("FILE", out); \
+        BE_CONVERT(data, size); \
+        return writex(out, (UINT8 *)&data, sizeof(data)); \
+    }
+
+#define FILE_READ(size) \
+    bool files_read_##size(FILE *out, UINT##size *data) { \
+	    BAIL_ON_NULL("FILE", out); \
+	    BAIL_ON_NULL("data", data); \
+        bool res = readx(out, (UINT8 *)data, sizeof(*data)); \
+        if (res) { \
+            BE_CONVERT(*data, size); \
+        } \
+        return res; \
+    }
+
+/*
+ * all the files_read|write_bytes_16|32|64 functions
+ */
+FILE_READ(16);
+FILE_WRITE(16)
+
+FILE_READ(32);
+FILE_WRITE(32)
+
+FILE_READ(64)
+FILE_WRITE(64)
+
+bool files_read_bytes(FILE *out, UINT8 bytes[], size_t len) {
+
+    BAIL_ON_NULL("FILE", out);
+    BAIL_ON_NULL("bytes", bytes);
+    return readx(out, bytes, len);
+}
+
+bool files_write_bytes(FILE *out, uint8_t bytes[], size_t len) {
+
+    BAIL_ON_NULL("FILE", out);
+    BAIL_ON_NULL("bytes", bytes);
+    return writex(out, bytes, len);
+}
+
+bool files_write_header(FILE *out, UINT32 version) {
+
+    BAIL_ON_NULL("FILE", out);
+
+    bool res = files_write_32(out, MAGIC);
+    if (!res) {
+        return false;
+    }
+    return files_write_32(out, version);
+}
+
+bool files_read_header(FILE *out, uint32_t *version) {
+
+    BAIL_ON_NULL("FILE", out);
+    BAIL_ON_NULL("version", version);
+
+    UINT32 magic;
+    bool res = files_read_32(out, &magic);
+    if (!res) {
+        return false;
+    }
+
+    if (magic != MAGIC) {
+        LOG_ERR("Found magic 0x%x did not match expected magic of 0x%x!",
+                magic, MAGIC);
+        return false;
+    }
+
+    return files_read_32(out, version);
+}
+
+bool files_load_bytes_from_file_or_stdin(const char *path, UINT16 *size, BYTE *buf) {
+
+    FILE *file =  path ? fopen(path, "rb") : stdin;
+    path = file != stdin ? path : "<stdin>";
+    if (!file) {
+        LOG_ERR("Could not open file: \"%s\", error: %s", path,
+                strerror(errno));
+        return false;
+    }
+
+    /*
+     * Attempt to accurately read the file based on the file size.
+     * This may fail on stdin when it's a pipe.
+     */
+    if (file == stdin) {
+        path = NULL;
+    }
+
+    UINT16 original_size = *size;
+    bool res = files_load_bytes_from_path(path, buf,
+            size);
+    if (!res) {
+        res = true;
+        *size = fread(buf, 1,
+                *size, file);
+        if (!feof(file)) {
+            LOG_ERR("Data to be sealed larger than expected. Got %u expected %u",
+                    original_size, res);
+            res = false;
+        }
+        else if (ferror(file)) {
+            LOG_ERR("Error reading sealed data from \"<stdin>\"");
+            res = false;
+        }
+    }
+
+    if (file != stdin) {
+        fclose(file);
+    }
+
+    return res;
+}
+
+#define SAVE_TYPE(type, name) \
+    bool files_save_##name(type *name, const char *path) { \
+    \
+        size_t offset = 0; \
+        UINT8 buffer[sizeof(*name)]; \
+        TSS2_RC rc = Tss2_MU_##type##_Marshal(name, buffer, sizeof(buffer), &offset); \
+        if (rc != TSS2_RC_SUCCESS) { \
+            LOG_ERR("Error serializing "str(name)" structure: 0x%x", rc); \
+            return false; \
+        } \
+    \
+        return files_save_bytes_to_file(path, buffer, offset); \
+    }
+
+#define LOAD_TYPE(type, name) \
+    bool files_load_##name(const char *path, type *name) { \
+    \
+        UINT8 buffer[sizeof(*name)]; \
+        UINT16 size = sizeof(buffer); \
+        bool res = files_load_bytes_from_path(path, buffer, &size); \
+        if (!res) { \
+            return false; \
+        } \
+        \
+        size_t offset = 0; \
+        TSS2_RC rc = Tss2_MU_##type##_Unmarshal(buffer, size, &offset, name); \
+        if (rc != TSS2_RC_SUCCESS) { \
+            LOG_ERR("Error serializing "str(name)" structure: 0x%x", rc); \
+            return false; \
+        } \
+        \
+        return rc == TPM2_RC_SUCCESS; \
+    }
+
+SAVE_TYPE(TPM2B_PUBLIC, public)
+LOAD_TYPE(TPM2B_PUBLIC, public)
+
+SAVE_TYPE(TPMT_SIGNATURE, signature)
+LOAD_TYPE(TPMT_SIGNATURE, signature)
+
+SAVE_TYPE(TPMT_TK_VERIFIED, ticket)
+LOAD_TYPE(TPMT_TK_VERIFIED, ticket)
+
+SAVE_TYPE(TPM2B_SENSITIVE, sensitive)
+LOAD_TYPE(TPM2B_SENSITIVE, sensitive)
+
+SAVE_TYPE(TPMT_TK_HASHCHECK, validation)
+LOAD_TYPE(TPMT_TK_HASHCHECK, validation)