Imported Upstream version 0.3.9upstream/0.3.9upstream

7 files changed, 4248 insertions, 0 deletions

diff --git a/src/trspi/Makefile.am b/src/trspi/Makefile.am
new file mode 100644
index 0000000..300e492
--- /dev/null
+++ b/src/trspi/Makefile.am
@@ -0,0 +1,11 @@
+noinst_LTLIBRARIES=libtrousers.la
+
+libtrousers_la_SOURCES=trousers.c crypto/@CRYPTO_PACKAGE@/hash.c
+libtrousers_la_CFLAGS=-DAPPID=\"TSPI\" -I${top_srcdir}/src/include
+
+if TSS_BUILD_ASYM_CRYPTO
+libtrousers_la_SOURCES+=crypto/@CRYPTO_PACKAGE@/rsa.c
+endif
+if TSS_BUILD_SYM_CRYPTO
+libtrousers_la_SOURCES+=crypto/@CRYPTO_PACKAGE@/symmetric.c
+endif
diff --git a/src/trspi/Makefile.in b/src/trspi/Makefile.in
new file mode 100644
index 0000000..5681451
--- /dev/null
+++ b/src/trspi/Makefile.in
@@ -0,0 +1,524 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+target_triplet = @target@
+@TSS_BUILD_ASYM_CRYPTO_TRUE@am__append_1 = crypto/@CRYPTO_PACKAGE@/rsa.c
+@TSS_BUILD_SYM_CRYPTO_TRUE@am__append_2 = crypto/@CRYPTO_PACKAGE@/symmetric.c
+subdir = src/trspi
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.in
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+LTLIBRARIES = $(noinst_LTLIBRARIES)
+libtrousers_la_LIBADD =
+am__libtrousers_la_SOURCES_DIST = trousers.c \
+	crypto/@CRYPTO_PACKAGE@/hash.c crypto/@CRYPTO_PACKAGE@/rsa.c \
+	crypto/@CRYPTO_PACKAGE@/symmetric.c
+@TSS_BUILD_ASYM_CRYPTO_TRUE@am__objects_1 = libtrousers_la-rsa.lo
+@TSS_BUILD_SYM_CRYPTO_TRUE@am__objects_2 =  \
+@TSS_BUILD_SYM_CRYPTO_TRUE@	libtrousers_la-symmetric.lo
+am_libtrousers_la_OBJECTS = libtrousers_la-trousers.lo \
+	libtrousers_la-hash.lo $(am__objects_1) $(am__objects_2)
+libtrousers_la_OBJECTS = $(am_libtrousers_la_OBJECTS)
+libtrousers_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(libtrousers_la_CFLAGS) \
+	$(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+DEFAULT_INCLUDES = -I.@am__isrc@
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
+	$(LDFLAGS) -o $@
+SOURCES = $(libtrousers_la_SOURCES)
+DIST_SOURCES = $(am__libtrousers_la_SOURCES_DIST)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CRYPTOLIB = @CRYPTOLIB@
+CRYPTO_PACKAGE = @CRYPTO_PACKAGE@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+GTK_CFLAGS = @GTK_CFLAGS@
+GTK_LIBS = @GTK_LIBS@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OPENSSL_LIB_DIR = @OPENSSL_LIB_DIR@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+RANLIB = @RANLIB@
+RPC = @RPC@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+TCSD_DEFAULT_PORT = @TCSD_DEFAULT_PORT@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target = @target@
+target_alias = @target_alias@
+target_cpu = @target_cpu@
+target_os = @target_os@
+target_vendor = @target_vendor@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+noinst_LTLIBRARIES = libtrousers.la
+libtrousers_la_SOURCES = trousers.c crypto/@CRYPTO_PACKAGE@/hash.c \
+	$(am__append_1) $(am__append_2)
+libtrousers_la_CFLAGS = -DAPPID=\"TSPI\" -I${top_srcdir}/src/include
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/trspi/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign src/trspi/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+clean-noinstLTLIBRARIES:
+	-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
+	@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
+	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+	  test "$$dir" != "$$p" || dir=.; \
+	  echo "rm -f \"$${dir}/so_locations\""; \
+	  rm -f "$${dir}/so_locations"; \
+	done
+libtrousers.la: $(libtrousers_la_OBJECTS) $(libtrousers_la_DEPENDENCIES) 
+	$(libtrousers_la_LINK)  $(libtrousers_la_OBJECTS) $(libtrousers_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libtrousers_la-hash.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libtrousers_la-rsa.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libtrousers_la-symmetric.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libtrousers_la-trousers.Plo@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ $<
+
+libtrousers_la-trousers.lo: trousers.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libtrousers_la_CFLAGS) $(CFLAGS) -MT libtrousers_la-trousers.lo -MD -MP -MF $(DEPDIR)/libtrousers_la-trousers.Tpo -c -o libtrousers_la-trousers.lo `test -f 'trousers.c' || echo '$(srcdir)/'`trousers.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/libtrousers_la-trousers.Tpo $(DEPDIR)/libtrousers_la-trousers.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='trousers.c' object='libtrousers_la-trousers.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libtrousers_la_CFLAGS) $(CFLAGS) -c -o libtrousers_la-trousers.lo `test -f 'trousers.c' || echo '$(srcdir)/'`trousers.c
+
+libtrousers_la-hash.lo: crypto/@CRYPTO_PACKAGE@/hash.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libtrousers_la_CFLAGS) $(CFLAGS) -MT libtrousers_la-hash.lo -MD -MP -MF $(DEPDIR)/libtrousers_la-hash.Tpo -c -o libtrousers_la-hash.lo `test -f 'crypto/@CRYPTO_PACKAGE@/hash.c' || echo '$(srcdir)/'`crypto/@CRYPTO_PACKAGE@/hash.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/libtrousers_la-hash.Tpo $(DEPDIR)/libtrousers_la-hash.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='crypto/@CRYPTO_PACKAGE@/hash.c' object='libtrousers_la-hash.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libtrousers_la_CFLAGS) $(CFLAGS) -c -o libtrousers_la-hash.lo `test -f 'crypto/@CRYPTO_PACKAGE@/hash.c' || echo '$(srcdir)/'`crypto/@CRYPTO_PACKAGE@/hash.c
+
+libtrousers_la-rsa.lo: crypto/@CRYPTO_PACKAGE@/rsa.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libtrousers_la_CFLAGS) $(CFLAGS) -MT libtrousers_la-rsa.lo -MD -MP -MF $(DEPDIR)/libtrousers_la-rsa.Tpo -c -o libtrousers_la-rsa.lo `test -f 'crypto/@CRYPTO_PACKAGE@/rsa.c' || echo '$(srcdir)/'`crypto/@CRYPTO_PACKAGE@/rsa.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/libtrousers_la-rsa.Tpo $(DEPDIR)/libtrousers_la-rsa.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='crypto/@CRYPTO_PACKAGE@/rsa.c' object='libtrousers_la-rsa.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libtrousers_la_CFLAGS) $(CFLAGS) -c -o libtrousers_la-rsa.lo `test -f 'crypto/@CRYPTO_PACKAGE@/rsa.c' || echo '$(srcdir)/'`crypto/@CRYPTO_PACKAGE@/rsa.c
+
+libtrousers_la-symmetric.lo: crypto/@CRYPTO_PACKAGE@/symmetric.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libtrousers_la_CFLAGS) $(CFLAGS) -MT libtrousers_la-symmetric.lo -MD -MP -MF $(DEPDIR)/libtrousers_la-symmetric.Tpo -c -o libtrousers_la-symmetric.lo `test -f 'crypto/@CRYPTO_PACKAGE@/symmetric.c' || echo '$(srcdir)/'`crypto/@CRYPTO_PACKAGE@/symmetric.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/libtrousers_la-symmetric.Tpo $(DEPDIR)/libtrousers_la-symmetric.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='crypto/@CRYPTO_PACKAGE@/symmetric.c' object='libtrousers_la-symmetric.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libtrousers_la_CFLAGS) $(CFLAGS) -c -o libtrousers_la-symmetric.lo `test -f 'crypto/@CRYPTO_PACKAGE@/symmetric.c' || echo '$(srcdir)/'`crypto/@CRYPTO_PACKAGE@/symmetric.c
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-noinstLTLIBRARIES \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool clean-noinstLTLIBRARIES ctags distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am install-man \
+	install-pdf install-pdf-am install-ps install-ps-am \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
+	pdf pdf-am ps ps-am tags uninstall uninstall-am
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/src/trspi/crypto/Makefile.am b/src/trspi/crypto/Makefile.am
new file mode 100644
index 0000000..bc3bf86
--- /dev/null
+++ b/src/trspi/crypto/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS = openssl
diff --git a/src/trspi/crypto/openssl/hash.c b/src/trspi/crypto/openssl/hash.c
new file mode 100644
index 0000000..f6cf3dc
--- /dev/null
+++ b/src/trspi/crypto/openssl/hash.c
@@ -0,0 +1,218 @@
+
+/*
+ * Licensed Materials - Property of IBM
+ *
+ * trousers - An open source TCG Software Stack
+ *
+ * (C) Copyright International Business Machines Corp. 2004-2006
+ *
+ */
+
+/*
+ * hash.c - openssl TSS crypto routines
+ *
+ * Kent Yoder <shpedoikal@gmail.com>
+ *
+ */
+
+#include <string.h>
+
+#include <openssl/opensslv.h>
+#include <openssl/rsa.h>  // for some reason the MGF1 prototype is in here
+#include <openssl/evp.h>
+#include <openssl/hmac.h>
+#include <openssl/err.h>
+#include <openssl/sha.h>
+
+#include "trousers/tss.h"
+#include "trousers/trousers.h"
+#include "trousers_types.h"
+#include "spi_utils.h"
+#include "tsplog.h"
+
+#ifdef TSS_DEBUG
+#define DEBUG_print_openssl_errors() \
+	do { \
+		ERR_load_crypto_strings(); \
+		ERR_print_errors_fp(stderr); \
+	} while (0)
+#else
+#define DEBUG_print_openssl_errors()
+#endif
+
+#if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
+#define OpenSSL_MGF1(m,mlen,s,slen,md)	PKCS1_MGF1(m,mlen,s,slen,md)
+#else
+int MGF1(unsigned char *, long, const unsigned char *, long);
+#define OpenSSL_MGF1(m,mlen,s,slen,md)	MGF1(m,mlen,s,slen)
+#endif
+
+/*
+ * Hopefully this will make the code clearer since
+ * OpenSSL returns 1 on success
+ */
+#define EVP_SUCCESS 1
+
+TSS_RESULT
+Trspi_Hash(UINT32 HashType, UINT32 BufSize, BYTE* Buf, BYTE* Digest)
+{
+	EVP_MD_CTX md_ctx;
+	unsigned int result_size;
+	int rv;
+
+	switch (HashType) {
+		case TSS_HASH_SHA1:
+			rv = EVP_DigestInit(&md_ctx, EVP_sha1());
+			break;
+		default:
+			rv = TSPERR(TSS_E_BAD_PARAMETER);
+			goto out;
+			break;
+	}
+
+	if (rv != EVP_SUCCESS) {
+		rv = TSPERR(TSS_E_INTERNAL_ERROR);
+		goto err;
+	}
+
+	rv = EVP_DigestUpdate(&md_ctx, Buf, BufSize);
+	if (rv != EVP_SUCCESS) {
+		rv = TSPERR(TSS_E_INTERNAL_ERROR);
+		goto err;
+	}
+
+	result_size = EVP_MD_CTX_size(&md_ctx);
+	rv = EVP_DigestFinal(&md_ctx, Digest, &result_size);
+	if (rv != EVP_SUCCESS) {
+		rv = TSPERR(TSS_E_INTERNAL_ERROR);
+		goto err;
+	} else
+		rv = TSS_SUCCESS;
+
+	goto out;
+
+err:
+	DEBUG_print_openssl_errors();
+out:
+        return rv;
+}
+
+TSS_RESULT
+Trspi_HashInit(Trspi_HashCtx *ctx, UINT32 HashType)
+{
+	int rv;
+	EVP_MD *md;
+
+	switch (HashType) {
+		case TSS_HASH_SHA1:
+			md = (EVP_MD *)EVP_sha1();
+			break;
+		default:
+			return TSPERR(TSS_E_BAD_PARAMETER);
+			break;
+	}
+
+	if ((ctx->ctx = malloc(sizeof(EVP_MD_CTX))) == NULL)
+		return TSPERR(TSS_E_OUTOFMEMORY);
+
+	rv = EVP_DigestInit((EVP_MD_CTX *)ctx->ctx, (const EVP_MD *)md);
+
+	if (rv != EVP_SUCCESS) {
+		DEBUG_print_openssl_errors();
+		return TSPERR(TSS_E_INTERNAL_ERROR);
+	}
+
+	return TSS_SUCCESS;
+}
+
+TSS_RESULT
+Trspi_HashUpdate(Trspi_HashCtx *ctx, UINT32 size, BYTE *data)
+{
+	int rv;
+
+	if (ctx == NULL || ctx->ctx == NULL)
+		return TSPERR(TSS_E_INTERNAL_ERROR);
+
+	if (data == NULL && size)
+		return TSPERR(TSS_E_BAD_PARAMETER);
+
+	if (!size)
+		return TSS_SUCCESS;
+
+	rv = EVP_DigestUpdate(ctx->ctx, data, size);
+	if (rv != EVP_SUCCESS) {
+		DEBUG_print_openssl_errors();
+		free(ctx->ctx);
+		ctx->ctx = NULL;
+		return TSPERR(TSS_E_INTERNAL_ERROR);
+	}
+
+	return TSS_SUCCESS;
+}
+
+TSS_RESULT
+Trspi_HashFinal(Trspi_HashCtx *ctx, BYTE *digest)
+{
+	int rv;
+	UINT32 result_size;
+
+	if (ctx == NULL || ctx->ctx == NULL)
+		return TSPERR(TSS_E_INTERNAL_ERROR);
+
+	result_size = EVP_MD_CTX_size((EVP_MD_CTX *)ctx->ctx);
+	rv = EVP_DigestFinal(ctx->ctx, digest, &result_size);
+	if (rv != EVP_SUCCESS)
+		return TSPERR(TSS_E_INTERNAL_ERROR);
+
+	free(ctx->ctx);
+	ctx->ctx = NULL;
+
+	return TSS_SUCCESS;
+}
+
+UINT32
+Trspi_HMAC(UINT32 HashType, UINT32 SecretSize, BYTE* Secret, UINT32 BufSize, BYTE* Buf, BYTE* hmacOut)
+{
+	/*HMAC_CTX hmac_ctx;*/
+	const EVP_MD *md;
+	unsigned int len;
+	int rv = TSS_SUCCESS;
+
+	switch (HashType) {
+		case TSS_HASH_SHA1:
+			md = EVP_sha1();
+			break;
+		default:
+			rv = TSPERR(TSS_E_BAD_PARAMETER);
+			goto out;
+			break;
+	}
+
+	len = EVP_MD_size(md);
+
+	HMAC(md, Secret, SecretSize, Buf, BufSize, hmacOut, &len);
+out:
+	return rv;
+}
+
+TSS_RESULT
+Trspi_MGF1(UINT32 alg, UINT32 seedLen, BYTE *seed, UINT32 outLen, BYTE *out)
+{
+	const EVP_MD *md;
+	long olen = outLen, slen = seedLen;
+	int rv = TSS_SUCCESS;
+
+	switch (alg) {
+		case TSS_HASH_SHA1:
+			md = EVP_sha1();
+			break;
+		default:
+			rv = TSPERR(TSS_E_BAD_PARAMETER);
+			goto out;
+			break;
+	}
+
+	rv = OpenSSL_MGF1(out, olen, seed, slen, md);
+out:
+	return rv;
+}
diff --git a/src/trspi/crypto/openssl/rsa.c b/src/trspi/crypto/openssl/rsa.c
new file mode 100644
index 0000000..0bd1e89
--- /dev/null
+++ b/src/trspi/crypto/openssl/rsa.c
@@ -0,0 +1,266 @@
+
+/*
+ * Licensed Materials - Property of IBM
+ *
+ * trousers - An open source TCG Software Stack
+ *
+ * (C) Copyright International Business Machines Corp. 2004-2006
+ *
+ */
+
+/*
+ * rsa.c - openssl TSS crypto routines
+ *
+ * Kent Yoder <shpedoikal@gmail.com>
+ *
+ */
+
+#include <string.h>
+
+#include <openssl/evp.h>
+#include <openssl/err.h>
+#include <openssl/sha.h>
+#include <openssl/rsa.h>
+
+#include "trousers/tss.h"
+#include "trousers/trousers.h"
+#include "trousers_types.h"
+#include "spi_utils.h"
+#include "tsplog.h"
+
+#ifdef TSS_DEBUG
+#define DEBUG_print_openssl_errors() \
+	do { \
+		ERR_load_crypto_strings(); \
+		ERR_print_errors_fp(stderr); \
+	} while (0)
+#else
+#define DEBUG_print_openssl_errors()
+#endif
+
+
+/*
+ * Hopefully this will make the code clearer since
+ * OpenSSL returns 1 on success
+ */
+#define EVP_SUCCESS 1
+
+/* XXX int set to unsigned int values */
+int
+Trspi_RSA_Encrypt(unsigned char *dataToEncrypt, /* in */
+		unsigned int dataToEncryptLen,  /* in */
+		unsigned char *encryptedData,   /* out */
+		unsigned int *encryptedDataLen, /* out */
+		unsigned char *publicKey,
+		unsigned int keysize)
+{
+	int rv;
+	unsigned char exp[] = { 0x01, 0x00, 0x01 }; /* 65537 hex */
+	unsigned char oaepPad[] = "TCPA";
+	int oaepPadLen = 4;
+	RSA *rsa = RSA_new();
+	BYTE encodedData[256];
+	int encodedDataLen;
+
+	if (rsa == NULL) {
+		rv = TSPERR(TSS_E_OUTOFMEMORY);
+		goto err;
+	}
+
+	/* set the public key value in the OpenSSL object */
+	rsa->n = BN_bin2bn(publicKey, keysize, rsa->n);
+	/* set the public exponent */
+	rsa->e = BN_bin2bn(exp, sizeof(exp), rsa->e);
+
+	if (rsa->n == NULL || rsa->e == NULL) {
+		rv = TSPERR(TSS_E_OUTOFMEMORY);
+		goto err;
+	}
+
+	/* padding constraint for PKCS#1 OAEP padding */
+	if ((int)dataToEncryptLen >= (RSA_size(rsa) - ((2 * SHA_DIGEST_LENGTH) + 1))) {
+		rv = TSPERR(TSS_E_INTERNAL_ERROR);
+		goto err;
+	}
+
+	encodedDataLen = MIN(RSA_size(rsa), 256);
+
+	/* perform our OAEP padding here with custom padding parameter */
+	rv = RSA_padding_add_PKCS1_OAEP(encodedData, encodedDataLen, dataToEncrypt,
+			dataToEncryptLen, oaepPad, oaepPadLen);
+	if (rv != EVP_SUCCESS) {
+		rv = TSPERR(TSS_E_INTERNAL_ERROR);
+		goto err;
+	}
+
+	/* call OpenSSL with no additional padding */
+	rv = RSA_public_encrypt(encodedDataLen, encodedData,
+				encryptedData, rsa, RSA_NO_PADDING);
+	if (rv == -1) {
+		rv = TSPERR(TSS_E_INTERNAL_ERROR);
+		goto err;
+	}
+
+	/* RSA_public_encrypt returns the size of the encrypted data */
+	*encryptedDataLen = rv;
+	rv = TSS_SUCCESS;
+	goto out;
+
+err:
+	DEBUG_print_openssl_errors();
+out:
+	if (rsa)
+		RSA_free(rsa);
+        return rv;
+}
+
+TSS_RESULT
+Trspi_Verify(UINT32 HashType, BYTE *pHash, UINT32 iHashLength,
+	     unsigned char *pModulus, int iKeyLength,
+	     BYTE *pSignature, UINT32 sig_len)
+{
+	int rv, nid;
+	unsigned char exp[] = { 0x01, 0x00, 0x01 }; /* The default public exponent for the TPM */
+	unsigned char buf[256];
+	RSA *rsa = RSA_new();
+
+	if (rsa == NULL) {
+		rv = TSPERR(TSS_E_OUTOFMEMORY);
+		goto err;
+	}
+
+	/* We assume we're verifying data from a TPM, so there are only
+	 * two options, SHA1 data and PKCSv1.5 encoded signature data.
+	 */
+	switch (HashType) {
+		case TSS_HASH_SHA1:
+			nid = NID_sha1;
+			break;
+		case TSS_HASH_OTHER:
+			nid = NID_undef;
+			break;
+		default:
+			rv = TSPERR(TSS_E_BAD_PARAMETER);
+			goto out;
+			break;
+	}
+
+	/* set the public key value in the OpenSSL object */
+	rsa->n = BN_bin2bn(pModulus, iKeyLength, rsa->n);
+	/* set the public exponent */
+	rsa->e = BN_bin2bn(exp, sizeof(exp), rsa->e);
+
+	if (rsa->n == NULL || rsa->e == NULL) {
+		rv = TSPERR(TSS_E_OUTOFMEMORY);
+		goto err;
+	}
+
+	/* if we don't know the structure of the data we're verifying, do a public decrypt
+	 * and compare manually. If we know we're looking for a SHA1 hash, allow OpenSSL
+	 * to do the work for us.
+	 */
+	if (nid == NID_undef) {
+		rv = RSA_public_decrypt(sig_len, pSignature, buf, rsa, RSA_PKCS1_PADDING);
+		if ((UINT32)rv != iHashLength) {
+			rv = TSPERR(TSS_E_FAIL);
+			goto out;
+		} else if (memcmp(pHash, buf, iHashLength)) {
+			rv = TSPERR(TSS_E_FAIL);
+			goto out;
+		}
+	} else {
+		if ((rv = RSA_verify(nid, pHash, iHashLength, pSignature, sig_len, rsa)) == 0) {
+			rv = TSPERR(TSS_E_FAIL);
+			goto out;
+		}
+	}
+
+	rv = TSS_SUCCESS;
+	goto out;
+
+err:
+	DEBUG_print_openssl_errors();
+out:
+	if (rsa)
+		RSA_free(rsa);
+        return rv;
+}
+
+int
+Trspi_RSA_Public_Encrypt(unsigned char *in, unsigned int inlen,
+			 unsigned char *out, unsigned int *outlen,
+			 unsigned char *pubkey, unsigned int pubsize,
+			 unsigned int e, int padding)
+{
+	int rv, e_size = 3;
+	unsigned char exp[] = { 0x01, 0x00, 0x01 };
+	RSA *rsa = RSA_new();
+
+	if (rsa == NULL) {
+		rv = TSPERR(TSS_E_OUTOFMEMORY);
+		goto err;
+	}
+
+	switch (e) {
+		case 0:
+			/* fall through */
+		case 65537:
+			break;
+		case 17:
+			exp[0] = 17;
+			e_size = 1;
+			break;
+		case 3:
+			exp[0] = 3;
+			e_size = 1;
+			break;
+		default:
+			rv = TSPERR(TSS_E_INTERNAL_ERROR);
+			goto out;
+			break;
+	}
+
+	switch (padding) {
+		case TR_RSA_PKCS1_OAEP_PADDING:
+			padding = RSA_PKCS1_OAEP_PADDING;
+			break;
+		case TR_RSA_PKCS1_PADDING:
+			padding = RSA_PKCS1_PADDING;
+			break;
+		case TR_RSA_NO_PADDING:
+			padding = RSA_NO_PADDING;
+			break;
+		default:
+			rv = TSPERR(TSS_E_INTERNAL_ERROR);
+			goto out;
+			break;
+	}
+
+	/* set the public key value in the OpenSSL object */
+	rsa->n = BN_bin2bn(pubkey, pubsize, rsa->n);
+	/* set the public exponent */
+	rsa->e = BN_bin2bn(exp, e_size, rsa->e);
+
+	if (rsa->n == NULL || rsa->e == NULL) {
+		rv = TSPERR(TSS_E_OUTOFMEMORY);
+		goto err;
+	}
+
+	rv = RSA_public_encrypt(inlen, in, out, rsa, padding);
+	if (rv == -1) {
+		rv = TSPERR(TSS_E_INTERNAL_ERROR);
+		goto err;
+	}
+
+	/* RSA_public_encrypt returns the size of the encrypted data */
+	*outlen = rv;
+	rv = TSS_SUCCESS;
+	goto out;
+
+err:
+	DEBUG_print_openssl_errors();
+out:
+	if (rsa)
+		RSA_free(rsa);
+        return rv;
+}
diff --git a/src/trspi/crypto/openssl/symmetric.c b/src/trspi/crypto/openssl/symmetric.c
new file mode 100644
index 0000000..f5c3836
--- /dev/null
+++ b/src/trspi/crypto/openssl/symmetric.c
@@ -0,0 +1,388 @@
+
+/*
+ * Licensed Materials - Property of IBM
+ *
+ * trousers - An open source TCG Software Stack
+ *
+ * (C) Copyright International Business Machines Corp. 2004-2006
+ *
+ */
+
+/*
+ * symmetric.c - openssl TSS crypto routines
+ *
+ * Kent Yoder <shpedoikal@gmail.com>
+ *
+ */
+
+#include <limits.h>
+#include <string.h>
+
+#include <openssl/evp.h>
+#include <openssl/err.h>
+#include <openssl/rand.h>
+#include <limits.h>
+
+#include "trousers/tss.h"
+#include "trousers/trousers.h"
+#include "trousers_types.h"
+#include "spi_utils.h"
+#include "tsplog.h"
+
+
+#ifdef TSS_DEBUG
+#define DEBUG_print_openssl_errors() \
+	do { \
+		ERR_load_crypto_strings(); \
+		ERR_print_errors_fp(stderr); \
+	} while (0)
+#else
+#define DEBUG_print_openssl_errors()
+#endif
+
+
+/*
+ * Hopefully this will make the code clearer since
+ * OpenSSL returns 1 on success
+ */
+#define EVP_SUCCESS 1
+
+TSS_RESULT
+Trspi_Encrypt_ECB(UINT16 alg, BYTE *key, BYTE *in, UINT32 in_len, BYTE *out,
+		  UINT32 *out_len)
+{
+	TSS_RESULT result = TSS_SUCCESS;
+	EVP_CIPHER_CTX ctx;
+	UINT32 tmp;
+
+	switch (alg) {
+		case TSS_ALG_AES:
+			break;
+		default:
+			result = TSPERR(TSS_E_INTERNAL_ERROR);
+			goto done;
+			break;
+	}
+
+	EVP_CIPHER_CTX_init(&ctx);
+
+	if (!EVP_EncryptInit(&ctx, EVP_aes_256_ecb(), key, NULL)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+
+	if (*out_len < in_len + EVP_CIPHER_CTX_block_size(&ctx) - 1) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		goto done;
+	}
+
+	if (!EVP_EncryptUpdate(&ctx, out, (int *)out_len, in, in_len)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+
+	if (!EVP_EncryptFinal(&ctx, out + *out_len, (int *)&tmp)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+	*out_len += tmp;
+done:
+	EVP_CIPHER_CTX_cleanup(&ctx);
+	return result;
+}
+
+TSS_RESULT
+Trspi_Decrypt_ECB(UINT16 alg, BYTE *key, BYTE *in, UINT32 in_len, BYTE *out,
+		  UINT32 *out_len)
+{
+	TSS_RESULT result = TSS_SUCCESS;
+	EVP_CIPHER_CTX ctx;
+	UINT32 tmp;
+
+	switch (alg) {
+		case TSS_ALG_AES:
+			break;
+		default:
+			result = TSPERR(TSS_E_INTERNAL_ERROR);
+			goto done;
+			break;
+	}
+
+	EVP_CIPHER_CTX_init(&ctx);
+
+	if (!EVP_DecryptInit(&ctx, EVP_aes_256_ecb(), key, NULL)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+
+	if (!EVP_DecryptUpdate(&ctx, out, (int *)out_len, in, in_len)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+
+	if (!EVP_DecryptFinal(&ctx, out + *out_len, (int *)&tmp)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+	*out_len += tmp;
+done:
+	EVP_CIPHER_CTX_cleanup(&ctx);
+	return result;
+}
+
+EVP_CIPHER *
+get_openssl_cipher(UINT16 alg, UINT16 mode)
+{
+	EVP_CIPHER *cipher = NULL;
+
+	switch (alg) {
+		case TSS_ALG_AES:
+		case TCPA_ALG_AES:
+			switch (mode) {
+				case TPM_ES_NONE:
+				case TSS_ES_NONE:
+				case TPM_ES_SYM_CBC_PKCS5PAD:
+					LogDebug("XXX Make sure this is really PKCS5 padded");
+				case TR_SYM_MODE_CBC:
+					cipher = (EVP_CIPHER *)EVP_aes_128_cbc();
+					break;
+				case TPM_ES_SYM_OFB:
+					cipher = (EVP_CIPHER *)EVP_aes_128_ofb();
+					break;
+				case TPM_ES_SYM_CNT:
+					LogDebug("XXX AES128 in CTR mode unsupp by openssl EVP");
+				default:
+					LogDebug("Invalid mode in doing symmetric encryption");
+					break;
+			}
+			break;
+		case TSS_ALG_DES:
+		case TCPA_ALG_DES:
+			switch (mode) {
+				case TPM_ES_NONE:
+				case TSS_ES_NONE:
+				case TPM_ES_SYM_CBC_PKCS5PAD:
+					LogDebug("XXX Make sure this is really PKCS5 padded");
+				case TR_SYM_MODE_CBC:
+					cipher = (EVP_CIPHER *)EVP_des_cbc();
+					break;
+				case TPM_ES_SYM_OFB:
+					cipher = (EVP_CIPHER *)EVP_des_ofb();
+					break;
+				case TPM_ES_SYM_CNT:
+					LogDebug("XXX DES in CTR mode unsupp by openssl EVP");
+				default:
+					LogDebug("Invalid mode in doing symmetric encryption");
+					break;
+			}
+			break;
+		case TSS_ALG_3DES:
+		case TCPA_ALG_3DES:
+			switch (mode) {
+				case TPM_ES_NONE:
+				case TSS_ES_NONE:
+				case TPM_ES_SYM_CBC_PKCS5PAD:
+					LogDebug("XXX Make sure this is really PKCS5 padded");
+				case TR_SYM_MODE_CBC:
+					cipher = (EVP_CIPHER *)EVP_des_ede3_cbc();
+					break;
+				case TPM_ES_SYM_OFB:
+					cipher = (EVP_CIPHER *)EVP_des_ede3_ofb();
+					break;
+				case TPM_ES_SYM_CNT:
+					LogDebug("XXX 3DES in CTR mode unsupp by openssl EVP");
+				default:
+					LogDebug("Invalid mode in doing symmetric encryption");
+					break;
+			}
+			break;
+		case TPM_ALG_AES192:
+		case TSS_ALG_AES192:
+			switch (mode) {
+				case TPM_ES_NONE:
+				case TSS_ES_NONE:
+				case TPM_ES_SYM_CBC_PKCS5PAD:
+					LogDebug("XXX Make sure this is really PKCS5 padded");
+				case TR_SYM_MODE_CBC:
+					cipher = (EVP_CIPHER *)EVP_aes_192_cbc();
+					break;
+				case TPM_ES_SYM_OFB:
+					cipher = (EVP_CIPHER *)EVP_aes_192_ofb();
+					break;
+				case TPM_ES_SYM_CNT:
+					LogDebug("XXX AES192 in CTR mode unsupp by openssl EVP");
+				default:
+					LogDebug("Invalid mode in doing symmetric encryption");
+					break;
+			}
+			break;
+		case TPM_ALG_AES256:
+		case TSS_ALG_AES256:
+			switch (mode) {
+				case TPM_ES_NONE:
+				case TSS_ES_NONE:
+				case TPM_ES_SYM_CBC_PKCS5PAD:
+					LogDebug("XXX Make sure this is really PKCS5 padded");
+				case TR_SYM_MODE_CBC:
+					cipher = (EVP_CIPHER *)EVP_aes_256_cbc();
+					break;
+				case TPM_ES_SYM_OFB:
+					cipher = (EVP_CIPHER *)EVP_aes_256_ofb();
+					break;
+				case TPM_ES_SYM_CNT:
+					LogDebug("XXX AES256 in CTR mode unsupp by openssl EVP");
+				default:
+					LogDebug("Invalid mode in doing symmetric encryption");
+					break;
+			}
+			break;
+		default:
+			LogDebug("Invalid algorithm in doing symmetric encryption");
+			break;
+	}
+
+	return cipher;
+}
+
+TSS_RESULT
+Trspi_SymEncrypt(UINT16 alg, UINT16 mode, BYTE *key, BYTE *iv, BYTE *in, UINT32 in_len, BYTE *out,
+		 UINT32 *out_len)
+{
+	TSS_RESULT result = TSS_SUCCESS;
+	EVP_CIPHER_CTX ctx;
+	EVP_CIPHER *cipher;
+	BYTE *def_iv = NULL, *outiv_ptr;
+	UINT32 tmp;
+	int iv_len, outiv_len;
+
+	if (*out_len > INT_MAX)
+		outiv_len = INT_MAX;
+	else
+		outiv_len = *(int *)out_len;
+
+	if ((cipher = get_openssl_cipher(alg, mode)) == NULL)
+		return TSPERR(TSS_E_INTERNAL_ERROR);
+
+	EVP_CIPHER_CTX_init(&ctx);
+
+	/* If the iv passed in is NULL, create a new random iv and prepend it to the ciphertext */
+	iv_len = EVP_CIPHER_iv_length(cipher);
+	if (iv == NULL) {
+		def_iv = malloc(iv_len);
+		if (def_iv == NULL) {
+			LogError("malloc of %d bytes failed.", iv_len);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		RAND_bytes(def_iv, iv_len);
+
+		memcpy(out, def_iv, iv_len);
+		outiv_ptr = &out[iv_len];
+		outiv_len -= iv_len;
+	} else {
+		def_iv = iv;
+		outiv_ptr = out;
+	}
+
+	if (!EVP_EncryptInit(&ctx, (const EVP_CIPHER *)cipher, key, def_iv)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+
+	if ((UINT32)outiv_len < in_len + (EVP_CIPHER_CTX_block_size(&ctx) * 2) - 1) {
+		LogDebug("Not enough space to do symmetric encryption");
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		goto done;
+	}
+
+	if (!EVP_EncryptUpdate(&ctx, outiv_ptr, &outiv_len, in, in_len)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+
+	if (!EVP_EncryptFinal(&ctx, outiv_ptr + outiv_len, (int *)&tmp)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+
+	outiv_len += tmp;
+	*out_len = outiv_len;
+done:
+	if (def_iv != iv) {
+		*out_len += iv_len;
+		free(def_iv);
+	}
+	EVP_CIPHER_CTX_cleanup(&ctx);
+	return result;
+}
+
+TSS_RESULT
+Trspi_SymDecrypt(UINT16 alg, UINT16 mode, BYTE *key, BYTE *iv, BYTE *in, UINT32 in_len, BYTE *out,
+		 UINT32 *out_len)
+{
+	TSS_RESULT result = TSS_SUCCESS;
+	EVP_CIPHER_CTX ctx;
+	EVP_CIPHER *cipher;
+	BYTE *def_iv = NULL, *iniv_ptr;
+	UINT32 tmp;
+	int iv_len, iniv_len;
+
+	if (in_len > INT_MAX)
+		return TSS_E_BAD_PARAMETER;
+
+	if ((cipher = get_openssl_cipher(alg, mode)) == NULL)
+		return TSPERR(TSS_E_INTERNAL_ERROR);
+
+	EVP_CIPHER_CTX_init(&ctx);
+
+	/* If the iv is NULL, assume that its prepended to the ciphertext */
+	if (iv == NULL) {
+		iv_len = EVP_CIPHER_iv_length(cipher);
+		def_iv = malloc(iv_len);
+		if (def_iv == NULL) {
+			LogError("malloc of %d bytes failed.", iv_len);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+
+		memcpy(def_iv, in, iv_len);
+		iniv_ptr = &in[iv_len];
+		iniv_len = in_len - iv_len;
+	} else {
+		def_iv = iv;
+		iniv_ptr = in;
+		iniv_len = in_len;
+	}
+
+	if (!EVP_DecryptInit(&ctx, cipher, key, def_iv)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+
+	if (!EVP_DecryptUpdate(&ctx, out, (int *)out_len, iniv_ptr, iniv_len)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+
+	if (!EVP_DecryptFinal(&ctx, out + *out_len, (int *)&tmp)) {
+		result = TSPERR(TSS_E_INTERNAL_ERROR);
+		DEBUG_print_openssl_errors();
+		goto done;
+	}
+
+	*out_len += tmp;
+done:
+	if (def_iv != iv)
+		free(def_iv);
+	EVP_CIPHER_CTX_cleanup(&ctx);
+	return result;
+}
diff --git a/src/trspi/trousers.c b/src/trspi/trousers.c
new file mode 100644
index 0000000..04156a5
--- /dev/null
+++ b/src/trspi/trousers.c
@@ -0,0 +1,2840 @@
+
+/*
+ * Licensed Materials - Property of IBM
+ *
+ * trousers - An open source TCG Software Stack
+ *
+ * (C) Copyright International Business Machines Corp. 2004-2007
+ *
+ */
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <langinfo.h>
+#include <iconv.h>
+#include <wchar.h>
+#include <errno.h>
+
+#include "trousers/tss.h"
+#include "trousers_types.h"
+#include "trousers/trousers.h"
+#include "trousers_types.h"
+#include "spi_utils.h"
+#include "capabilities.h"
+#include "tsplog.h"
+#include "obj.h"
+#include "tcs_tsp.h"
+
+void
+Trspi_UnloadBlob_NONCE(UINT64 *offset, BYTE *blob, TPM_NONCE *n)
+{
+	if (!n) {
+		(*offset) += TPM_SHA1_160_HASH_LEN;
+		return;
+	}
+
+	Trspi_UnloadBlob(offset, TPM_SHA1_160_HASH_LEN, blob, n->nonce);
+}
+
+void
+Trspi_LoadBlob_NONCE(UINT64 *offset, BYTE *blob, TPM_NONCE *n)
+{
+	Trspi_LoadBlob(offset, TPM_SHA1_160_HASH_LEN, blob, n->nonce);
+}
+
+void
+Trspi_LoadBlob_DIGEST(UINT64 *offset, BYTE *blob, TPM_DIGEST *digest)
+{
+	Trspi_LoadBlob(offset, TPM_SHA1_160_HASH_LEN, blob, digest->digest);
+}
+
+void
+Trspi_UnloadBlob_DIGEST(UINT64 *offset, BYTE *blob, TPM_DIGEST *digest)
+{
+	if (!digest) {
+		(*offset) += TPM_SHA1_160_HASH_LEN;
+		return;
+	}
+
+	Trspi_UnloadBlob(offset, TPM_SHA1_160_HASH_LEN, blob, digest->digest);
+}
+
+void
+Trspi_LoadBlob_PUBKEY(UINT64 *offset, BYTE *blob, TCPA_PUBKEY *pubKey)
+{
+	Trspi_LoadBlob_KEY_PARMS(offset, blob, &pubKey->algorithmParms);
+	Trspi_LoadBlob_STORE_PUBKEY(offset, blob, &pubKey->pubKey);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_PUBKEY(UINT64 *offset, BYTE *blob, TCPA_PUBKEY *pubKey)
+{
+	TSS_RESULT result;
+
+	if (!pubKey) {
+		(void)Trspi_UnloadBlob_KEY_PARMS(offset, blob, NULL);
+		(void)Trspi_UnloadBlob_STORE_PUBKEY(offset, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	if ((result = Trspi_UnloadBlob_KEY_PARMS(offset, blob, &pubKey->algorithmParms)))
+		return result;
+	if ((result = Trspi_UnloadBlob_STORE_PUBKEY(offset, blob, &pubKey->pubKey))) {
+		free(pubKey->pubKey.key);
+		free(pubKey->algorithmParms.parms);
+		pubKey->pubKey.key = NULL;
+		pubKey->pubKey.keyLength = 0;
+		pubKey->algorithmParms.parms = NULL;
+		pubKey->algorithmParms.parmSize = 0;
+		return result;
+	}
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob(UINT64 *offset, size_t size, BYTE *to, BYTE *from)
+{
+	if (size == 0)
+		return;
+
+	if ((*offset + size) > TSS_TPM_TXBLOB_SIZE)
+		return;
+
+	if (to)
+		memcpy(&to[(*offset)], from, size);
+	(*offset) += size;
+}
+
+void
+Trspi_UnloadBlob(UINT64 *offset, size_t size, BYTE *from, BYTE *to)
+{
+	if (size <= 0)
+		return;
+
+	if ((*offset + size) > TSS_TPM_TXBLOB_SIZE)
+		return;
+
+	if (to)
+		memcpy(to, &from[*offset], size);
+	(*offset) += size;
+}
+
+void
+Trspi_LoadBlob_BYTE(UINT64 *offset, BYTE data, BYTE *blob)
+{
+	if ((*offset + sizeof(BYTE)) > TSS_TPM_TXBLOB_SIZE)
+		return;
+
+	if (blob)
+		blob[*offset] = data;
+	(*offset)++;
+}
+
+void
+Trspi_UnloadBlob_BYTE(UINT64 *offset, BYTE *dataOut, BYTE *blob)
+{
+	if ((*offset + sizeof(BYTE)) > TSS_TPM_TXBLOB_SIZE)
+		return;
+
+	if (dataOut)
+		*dataOut = blob[*offset];
+	(*offset)++;
+}
+
+void
+Trspi_LoadBlob_BOOL(UINT64 *offset, TSS_BOOL data, BYTE *blob)
+{
+	if (blob)
+		blob[*offset] = (BYTE) data;
+	(*offset)++;
+}
+
+void
+Trspi_UnloadBlob_BOOL(UINT64 *offset, TSS_BOOL *dataOut, BYTE *blob)
+{
+	if (dataOut)
+		*dataOut = blob[*offset];
+	(*offset)++;
+}
+
+void
+Trspi_LoadBlob_UINT64(UINT64 *offset, UINT64 in, BYTE *blob)
+{
+	if ((*offset + sizeof(UINT64)) > TSS_TPM_TXBLOB_SIZE)
+		return;
+
+	if (blob)
+		UINT64ToArray(in, &blob[*offset]);
+	(*offset) += sizeof(UINT64);
+}
+
+void
+Trspi_LoadBlob_UINT32(UINT64 *offset, UINT32 in, BYTE *blob)
+{
+	if ((*offset + sizeof(UINT32)) > TSS_TPM_TXBLOB_SIZE)
+		return;
+
+	if (blob)
+		UINT32ToArray(in, &blob[*offset]);
+	(*offset) += sizeof(UINT32);
+}
+
+void
+Trspi_LoadBlob_UINT16(UINT64 *offset, UINT16 in, BYTE *blob)
+{
+	if ((*offset + sizeof(UINT16)) > TSS_TPM_TXBLOB_SIZE)
+		return;
+
+	if (blob)
+		UINT16ToArray(in, &blob[*offset]);
+	(*offset) += sizeof(UINT16);
+}
+
+void
+Trspi_UnloadBlob_UINT64(UINT64 *offset, UINT64 *out, BYTE *blob)
+{
+	if ((*offset + sizeof(UINT64)) > TSS_TPM_TXBLOB_SIZE)
+		return;
+
+	if (out)
+		*out = Decode_UINT64(&blob[*offset]);
+	(*offset) += sizeof(UINT64);
+}
+
+void
+Trspi_UnloadBlob_UINT32(UINT64 *offset, UINT32 *out, BYTE *blob)
+{
+	if ((*offset + sizeof(UINT32)) > TSS_TPM_TXBLOB_SIZE)
+		return;
+
+	if (out)
+		*out = Decode_UINT32(&blob[*offset]);
+	(*offset) += sizeof(UINT32);
+}
+
+void
+Trspi_UnloadBlob_UINT16(UINT64 *offset, UINT16 *out, BYTE *blob)
+{
+	if ((*offset + sizeof(UINT16)) > TSS_TPM_TXBLOB_SIZE)
+		return;
+
+	if (out)
+		*out = Decode_UINT16(&blob[*offset]);
+	(*offset) += sizeof(UINT16);
+}
+
+void
+Trspi_LoadBlob_RSA_KEY_PARMS(UINT64 *offset, BYTE *blob, TCPA_RSA_KEY_PARMS *parms)
+{
+	Trspi_LoadBlob_UINT32(offset, parms->keyLength, blob);
+	Trspi_LoadBlob_UINT32(offset, parms->numPrimes, blob);
+	Trspi_LoadBlob_UINT32(offset, parms->exponentSize, blob);
+
+	if (parms->exponentSize > 0)
+		Trspi_LoadBlob(offset, parms->exponentSize, blob, parms->exponent);
+}
+
+void
+Trspi_UnloadBlob_TSS_VERSION(UINT64 *offset, BYTE *blob, TSS_VERSION *out)
+{
+	if (!out) {
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+
+		return;
+	}
+
+	Trspi_UnloadBlob_BYTE(offset, &out->bMajor, blob);
+	Trspi_UnloadBlob_BYTE(offset, &out->bMinor, blob);
+	Trspi_UnloadBlob_BYTE(offset, &out->bRevMajor, blob);
+	Trspi_UnloadBlob_BYTE(offset, &out->bRevMinor, blob);
+}
+
+void
+Trspi_LoadBlob_TSS_VERSION(UINT64 *offset, BYTE *blob, TSS_VERSION version)
+{
+	Trspi_LoadBlob_BYTE(offset, version.bMajor, blob);
+	Trspi_LoadBlob_BYTE(offset, version.bMinor, blob);
+	Trspi_LoadBlob_BYTE(offset, version.bRevMajor, blob);
+	Trspi_LoadBlob_BYTE(offset, version.bRevMinor, blob);
+}
+
+void
+Trspi_UnloadBlob_TCPA_VERSION(UINT64 *offset, BYTE *blob, TCPA_VERSION *out)
+{
+	if (!out) {
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+
+		return;
+	}
+
+	Trspi_UnloadBlob_BYTE(offset, &out->major, blob);
+	Trspi_UnloadBlob_BYTE(offset, &out->minor, blob);
+	Trspi_UnloadBlob_BYTE(offset, &out->revMajor, blob);
+	Trspi_UnloadBlob_BYTE(offset, &out->revMinor, blob);
+}
+
+void
+Trspi_LoadBlob_TCPA_VERSION(UINT64 *offset, BYTE *blob, TCPA_VERSION version)
+{
+	Trspi_LoadBlob_BYTE(offset, version.major, blob);
+	Trspi_LoadBlob_BYTE(offset, version.minor, blob);
+	Trspi_LoadBlob_BYTE(offset, version.revMajor, blob);
+	Trspi_LoadBlob_BYTE(offset, version.revMinor, blob);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_PCR_INFO(UINT64 *offset, BYTE *blob, TCPA_PCR_INFO *pcr)
+{
+	TSS_RESULT result;
+
+	if (!pcr) {
+		(void)Trspi_UnloadBlob_PCR_SELECTION(offset, blob, NULL);
+		Trspi_UnloadBlob_DIGEST(offset, blob, NULL);
+		Trspi_UnloadBlob_DIGEST(offset, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	if ((result = Trspi_UnloadBlob_PCR_SELECTION(offset, blob, &pcr->pcrSelection)))
+		return result;
+	Trspi_UnloadBlob_DIGEST(offset, blob, &pcr->digestAtRelease);
+	Trspi_UnloadBlob_DIGEST(offset, blob, &pcr->digestAtCreation);
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_PCR_INFO(UINT64 *offset, BYTE *blob, TCPA_PCR_INFO *pcr)
+{
+	Trspi_LoadBlob_PCR_SELECTION(offset, blob, &pcr->pcrSelection);
+	Trspi_LoadBlob_DIGEST(offset, blob, &pcr->digestAtRelease);
+	Trspi_LoadBlob_DIGEST(offset, blob, &pcr->digestAtCreation);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_PCR_INFO_LONG(UINT64 *offset, BYTE *blob, TPM_PCR_INFO_LONG *pcr)
+{
+	TSS_RESULT result;
+
+	if (!pcr) {
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_PCR_SELECTION(offset, blob, NULL);
+		Trspi_UnloadBlob_PCR_SELECTION(offset, blob, NULL);
+		Trspi_UnloadBlob_DIGEST(offset, blob, NULL);
+		Trspi_UnloadBlob_DIGEST(offset, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &pcr->tag, blob);
+	Trspi_UnloadBlob_BYTE(offset, &pcr->localityAtCreation, blob);
+	Trspi_UnloadBlob_BYTE(offset, &pcr->localityAtRelease, blob);
+	if ((result = Trspi_UnloadBlob_PCR_SELECTION(offset, blob, &pcr->creationPCRSelection)))
+		return result;
+	if ((result = Trspi_UnloadBlob_PCR_SELECTION(offset, blob, &pcr->releasePCRSelection)))
+		return result;
+	Trspi_UnloadBlob_DIGEST(offset, blob, &pcr->digestAtCreation);
+	Trspi_UnloadBlob_DIGEST(offset, blob, &pcr->digestAtRelease);
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_PCR_INFO_LONG(UINT64 *offset, BYTE *blob, TPM_PCR_INFO_LONG *pcr)
+{
+	Trspi_LoadBlob_UINT16(offset, pcr->tag, blob);
+	Trspi_LoadBlob_BYTE(offset, pcr->localityAtCreation, blob);
+	Trspi_LoadBlob_BYTE(offset, pcr->localityAtRelease, blob);
+	Trspi_LoadBlob_PCR_SELECTION(offset, blob, &pcr->creationPCRSelection);
+	Trspi_LoadBlob_PCR_SELECTION(offset, blob, &pcr->releasePCRSelection);
+	Trspi_LoadBlob_DIGEST(offset, blob, &pcr->digestAtCreation);
+	Trspi_LoadBlob_DIGEST(offset, blob, &pcr->digestAtRelease);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_PCR_INFO_SHORT(UINT64 *offset, BYTE *blob, TPM_PCR_INFO_SHORT *pcr)
+{
+	TSS_RESULT result;
+
+	if (!pcr) {
+		Trspi_UnloadBlob_PCR_SELECTION(offset, blob, NULL);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_DIGEST(offset, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	if ((result = Trspi_UnloadBlob_PCR_SELECTION(offset, blob, &pcr->pcrSelection)))
+		return result;
+	Trspi_UnloadBlob_BYTE(offset, &pcr->localityAtRelease, blob);
+	Trspi_UnloadBlob_DIGEST(offset, blob, &pcr->digestAtRelease);
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_PCR_INFO_SHORT(UINT64 *offset, BYTE *blob, TPM_PCR_INFO_SHORT *pcr)
+{
+	Trspi_LoadBlob_PCR_SELECTION(offset, blob, &pcr->pcrSelection);
+	Trspi_LoadBlob_BYTE(offset, pcr->localityAtRelease, blob);
+	Trspi_LoadBlob_DIGEST(offset, blob, &pcr->digestAtRelease);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_PCR_SELECTION(UINT64 *offset, BYTE *blob, TCPA_PCR_SELECTION *pcr)
+{
+	if (!pcr) {
+		UINT16 sizeOfSelect;
+
+		Trspi_UnloadBlob_UINT16(offset, &sizeOfSelect, blob);
+		Trspi_UnloadBlob(offset, sizeOfSelect, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &pcr->sizeOfSelect, blob);
+
+	if (pcr->sizeOfSelect > 0) {
+		pcr->pcrSelect = calloc(1, pcr->sizeOfSelect);
+		if (pcr->pcrSelect == NULL) {
+			LogError("malloc of %u bytes failed.", pcr->sizeOfSelect);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+
+		Trspi_UnloadBlob(offset, pcr->sizeOfSelect, blob, pcr->pcrSelect);
+	} else {
+		pcr->pcrSelect = NULL;
+	}
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_PCR_SELECTION(UINT64 *offset, BYTE *blob, TCPA_PCR_SELECTION *pcr)
+{
+	UINT16 i;
+
+	Trspi_LoadBlob_UINT16(offset, pcr->sizeOfSelect, blob);
+	for (i = 0; i < pcr->sizeOfSelect; i++)
+		Trspi_LoadBlob_BYTE(offset, pcr->pcrSelect[i], blob);
+}
+
+void
+Trspi_LoadBlob_KEY12(UINT64 *offset, BYTE *blob, TPM_KEY12 *key)
+{
+	Trspi_LoadBlob_UINT16(offset, key->tag, blob);
+	Trspi_LoadBlob_UINT16(offset, key->fill, blob);
+	Trspi_LoadBlob_UINT16(offset, key->keyUsage, blob);
+	Trspi_LoadBlob_KEY_FLAGS(offset, blob, &key->keyFlags);
+	Trspi_LoadBlob_BYTE(offset, key->authDataUsage, blob);
+	Trspi_LoadBlob_KEY_PARMS(offset, blob, &key->algorithmParms);
+	Trspi_LoadBlob_UINT32(offset, key->PCRInfoSize, blob);
+	Trspi_LoadBlob(offset, key->PCRInfoSize, blob, key->PCRInfo);
+	Trspi_LoadBlob_STORE_PUBKEY(offset, blob, &key->pubKey);
+	Trspi_LoadBlob_UINT32(offset, key->encSize, blob);
+	Trspi_LoadBlob(offset, key->encSize, blob, key->encData);
+}
+
+void
+Trspi_LoadBlob_KEY(UINT64 *offset, BYTE *blob, TCPA_KEY *key)
+{
+	Trspi_LoadBlob_TCPA_VERSION(offset, blob, key->ver);
+	Trspi_LoadBlob_UINT16(offset, key->keyUsage, blob);
+	Trspi_LoadBlob_KEY_FLAGS(offset, blob, &key->keyFlags);
+	Trspi_LoadBlob_BYTE(offset, key->authDataUsage, blob);
+	Trspi_LoadBlob_KEY_PARMS(offset, blob, &key->algorithmParms);
+	Trspi_LoadBlob_UINT32(offset, key->PCRInfoSize, blob);
+	Trspi_LoadBlob(offset, key->PCRInfoSize, blob, key->PCRInfo);
+	Trspi_LoadBlob_STORE_PUBKEY(offset, blob, &key->pubKey);
+	Trspi_LoadBlob_UINT32(offset, key->encSize, blob);
+	Trspi_LoadBlob(offset, key->encSize, blob, key->encData);
+}
+
+void
+Trspi_LoadBlob_KEY_FLAGS(UINT64 *offset, BYTE *blob, TCPA_KEY_FLAGS *flags)
+{
+	Trspi_LoadBlob_UINT32(offset, *flags, blob);
+}
+
+void
+Trspi_UnloadBlob_KEY_FLAGS(UINT64 *offset, BYTE *blob, TCPA_KEY_FLAGS *flags)
+{
+	Trspi_UnloadBlob_UINT32(offset, flags, blob);
+}
+
+void
+Trspi_LoadBlob_KEY_PARMS(UINT64 *offset, BYTE *blob, TCPA_KEY_PARMS *keyInfo)
+{
+	Trspi_LoadBlob_UINT32(offset, keyInfo->algorithmID, blob);
+	Trspi_LoadBlob_UINT16(offset, keyInfo->encScheme, blob);
+	Trspi_LoadBlob_UINT16(offset, keyInfo->sigScheme, blob);
+	Trspi_LoadBlob_UINT32(offset, keyInfo->parmSize, blob);
+
+	if (keyInfo->parmSize > 0)
+		Trspi_LoadBlob(offset, keyInfo->parmSize, blob, keyInfo->parms);
+}
+
+void
+Trspi_LoadBlob_STORE_PUBKEY(UINT64 *offset, BYTE *blob, TCPA_STORE_PUBKEY *store)
+{
+	Trspi_LoadBlob_UINT32(offset, store->keyLength, blob);
+	Trspi_LoadBlob(offset, store->keyLength, blob, store->key);
+}
+
+void
+Trspi_LoadBlob_UUID(UINT64 *offset, BYTE *blob, TSS_UUID uuid)
+{
+	Trspi_LoadBlob_UINT32(offset, uuid.ulTimeLow, blob);
+	Trspi_LoadBlob_UINT16(offset, uuid.usTimeMid, blob);
+	Trspi_LoadBlob_UINT16(offset, uuid.usTimeHigh, blob);
+	Trspi_LoadBlob_BYTE(offset, uuid.bClockSeqHigh, blob);
+	Trspi_LoadBlob_BYTE(offset, uuid.bClockSeqLow, blob);
+	Trspi_LoadBlob(offset, 6, blob, uuid.rgbNode);
+}
+
+void
+Trspi_UnloadBlob_UUID(UINT64 *offset, BYTE *blob, TSS_UUID *uuid)
+{
+	if (!uuid) {
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob(offset, 6, blob, NULL);
+
+		return;
+	}
+
+	memset(uuid, 0, sizeof(TSS_UUID));
+	Trspi_UnloadBlob_UINT32(offset, &uuid->ulTimeLow, blob);
+	Trspi_UnloadBlob_UINT16(offset, &uuid->usTimeMid, blob);
+	Trspi_UnloadBlob_UINT16(offset, &uuid->usTimeHigh, blob);
+	Trspi_UnloadBlob_BYTE(offset, &uuid->bClockSeqHigh, blob);
+	Trspi_UnloadBlob_BYTE(offset, &uuid->bClockSeqLow, blob);
+	Trspi_UnloadBlob(offset, 6, blob, uuid->rgbNode);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_KEY_PARMS(UINT64 *offset, BYTE *blob, TCPA_KEY_PARMS *keyParms)
+{
+	if (!keyParms) {
+		UINT32 parmSize;
+
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, &parmSize, blob);
+
+		(*offset) += parmSize;
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT32(offset, &keyParms->algorithmID, blob);
+	Trspi_UnloadBlob_UINT16(offset, &keyParms->encScheme, blob);
+	Trspi_UnloadBlob_UINT16(offset, &keyParms->sigScheme, blob);
+	Trspi_UnloadBlob_UINT32(offset, &keyParms->parmSize, blob);
+
+	if (keyParms->parmSize > 0) {
+		keyParms->parms = malloc(keyParms->parmSize);
+		if (keyParms->parms == NULL) {
+			LogError("malloc of %u bytes failed.", keyParms->parmSize);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, keyParms->parmSize, blob, keyParms->parms);
+	} else {
+		keyParms->parms = NULL;
+	}
+
+	return TSS_SUCCESS;
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_KEY12(UINT64 *offset, BYTE *blob, TPM_KEY12 *key)
+{
+	TSS_RESULT result;
+
+	if (!key) {
+		UINT32 PCRInfoSize, encSize;
+
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_KEY_FLAGS(offset, blob, NULL);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_KEY_PARMS(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, &PCRInfoSize, blob);
+		Trspi_UnloadBlob(offset, PCRInfoSize, blob, NULL);
+		Trspi_UnloadBlob_STORE_PUBKEY(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, &encSize, blob);
+		Trspi_UnloadBlob(offset, encSize, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &key->tag, blob);
+	Trspi_UnloadBlob_UINT16(offset, &key->fill, blob);
+	Trspi_UnloadBlob_UINT16(offset, &key->keyUsage, blob);
+	Trspi_UnloadBlob_KEY_FLAGS(offset, blob, &key->keyFlags);
+	Trspi_UnloadBlob_BYTE(offset, &key->authDataUsage, blob);
+	if ((result = Trspi_UnloadBlob_KEY_PARMS(offset, (BYTE *) blob, &key->algorithmParms)))
+		return result;
+	Trspi_UnloadBlob_UINT32(offset, &key->PCRInfoSize, blob);
+
+	if (key->PCRInfoSize > 0) {
+		key->PCRInfo = malloc(key->PCRInfoSize);
+		if (key->PCRInfo == NULL) {
+			LogError("malloc of %d bytes failed.", key->PCRInfoSize);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, key->PCRInfoSize, blob, key->PCRInfo);
+	} else {
+		key->PCRInfo = NULL;
+	}
+
+	if ((result = Trspi_UnloadBlob_STORE_PUBKEY(offset, blob, &key->pubKey)))
+		return result;
+	Trspi_UnloadBlob_UINT32(offset, &key->encSize, blob);
+
+	if (key->encSize > 0) {
+		key->encData = malloc(key->encSize);
+		if (key->encData == NULL) {
+			LogError("malloc of %d bytes failed.", key->encSize);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, key->encSize, blob, key->encData);
+	} else {
+		key->encData = NULL;
+	}
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_KEY(UINT64 *offset, BYTE *blob, TCPA_KEY *key)
+{
+	TSS_RESULT result;
+
+	if (!key) {
+		UINT32 PCRInfoSize, encSize;
+
+		Trspi_UnloadBlob_TCPA_VERSION(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_KEY_FLAGS(offset, blob, NULL);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_KEY_PARMS(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, &PCRInfoSize, blob);
+		Trspi_UnloadBlob(offset, PCRInfoSize, blob, NULL);
+		Trspi_UnloadBlob_STORE_PUBKEY(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, &encSize, blob);
+		Trspi_UnloadBlob(offset, encSize, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_TCPA_VERSION(offset, blob, &key->ver);
+	Trspi_UnloadBlob_UINT16(offset, &key->keyUsage, blob);
+	Trspi_UnloadBlob_KEY_FLAGS(offset, blob, &key->keyFlags);
+	Trspi_UnloadBlob_BYTE(offset, &key->authDataUsage, blob);
+	if ((result = Trspi_UnloadBlob_KEY_PARMS(offset, (BYTE *) blob, &key->algorithmParms)))
+		return result;
+	Trspi_UnloadBlob_UINT32(offset, &key->PCRInfoSize, blob);
+
+	if (key->PCRInfoSize > 0) {
+		key->PCRInfo = malloc(key->PCRInfoSize);
+		if (key->PCRInfo == NULL) {
+			LogError("malloc of %d bytes failed.", key->PCRInfoSize);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, key->PCRInfoSize, blob, key->PCRInfo);
+	} else {
+		key->PCRInfo = NULL;
+	}
+
+	if ((result = Trspi_UnloadBlob_STORE_PUBKEY(offset, blob, &key->pubKey)))
+		return result;
+	Trspi_UnloadBlob_UINT32(offset, &key->encSize, blob);
+
+	if (key->encSize > 0) {
+		key->encData = malloc(key->encSize);
+		if (key->encData == NULL) {
+			LogError("malloc of %d bytes failed.", key->encSize);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, key->encSize, blob, key->encData);
+	} else {
+		key->encData = NULL;
+	}
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_STORE_PUBKEY(UINT64 *offset, BYTE *blob, TCPA_STORE_PUBKEY *store)
+{
+	if (!store) {
+		UINT32 keyLength;
+
+		Trspi_UnloadBlob_UINT32(offset, &keyLength, blob);
+		Trspi_UnloadBlob(offset, keyLength, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT32(offset, &store->keyLength, blob);
+
+	if (store->keyLength > 0) {
+		store->key = malloc(store->keyLength);
+		if (store->key == NULL) {
+			LogError("malloc of %d bytes failed.", store->keyLength);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, store->keyLength, blob, store->key);
+	} else {
+		store->key = NULL;
+	}
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_UnloadBlob_VERSION(UINT64 *offset, BYTE *blob, TCPA_VERSION *out)
+{
+	if (!out) {
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+
+		return;
+	}
+
+	Trspi_UnloadBlob_BYTE(offset, &out->major, blob);
+	Trspi_UnloadBlob_BYTE(offset, &out->minor, blob);
+	Trspi_UnloadBlob_BYTE(offset, &out->revMajor, blob);
+	Trspi_UnloadBlob_BYTE(offset, &out->revMinor, blob);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_KM_KEYINFO(UINT64 *offset, BYTE *blob, TSS_KM_KEYINFO *info)
+{
+	if (!info) {
+		UINT32 ulVendorDataLength;
+
+		Trspi_UnloadBlob_TSS_VERSION(offset, blob, NULL);
+		Trspi_UnloadBlob_UUID(offset, blob, NULL);
+		Trspi_UnloadBlob_UUID(offset, blob, NULL);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BOOL(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, &ulVendorDataLength, blob);
+
+		(*offset) += ulVendorDataLength;
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_TSS_VERSION(offset, blob, &info->versionInfo);
+	Trspi_UnloadBlob_UUID(offset, blob, &info->keyUUID);
+	Trspi_UnloadBlob_UUID(offset, blob, &info->parentKeyUUID);
+	Trspi_UnloadBlob_BYTE(offset, &info->bAuthDataUsage, blob);
+	Trspi_UnloadBlob_BOOL(offset, &info->fIsLoaded, blob);
+	Trspi_UnloadBlob_UINT32(offset, &info->ulVendorDataLength, blob);
+	if (info->ulVendorDataLength > 0){
+		/* allocate space for vendor data */
+		info->rgbVendorData = malloc(info->ulVendorDataLength);
+		if (info->rgbVendorData == NULL) {
+			LogError("malloc of %u bytes failed.", info->ulVendorDataLength);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+
+		Trspi_UnloadBlob(offset, info->ulVendorDataLength, blob, info->rgbVendorData);
+	} else
+		info->rgbVendorData = NULL;
+
+	return TSS_SUCCESS;
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_KM_KEYINFO2(UINT64 *offset, BYTE *blob, TSS_KM_KEYINFO2 *info)
+{
+	if (!info) {
+		UINT32 ulVendorDataLength;
+
+		Trspi_UnloadBlob_TSS_VERSION(offset, blob, NULL);
+		Trspi_UnloadBlob_UUID(offset, blob, NULL);
+		Trspi_UnloadBlob_UUID(offset, blob, NULL);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_BOOL(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, &ulVendorDataLength, blob);
+
+		(*offset) += ulVendorDataLength;
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_TSS_VERSION(offset, blob, &info->versionInfo);
+	Trspi_UnloadBlob_UUID(offset, blob, &info->keyUUID);
+	Trspi_UnloadBlob_UUID(offset, blob, &info->parentKeyUUID);
+	Trspi_UnloadBlob_BYTE(offset, &info->bAuthDataUsage, blob);
+	/* Takes data regarding the new 2 fields of TSS_KM_KEYINFO2 */
+	Trspi_UnloadBlob_UINT32(offset, &info->persistentStorageType, blob);
+	Trspi_UnloadBlob_UINT32(offset, &info->persistentStorageTypeParent, blob);
+	Trspi_UnloadBlob_BOOL(offset, &info->fIsLoaded, blob);
+	Trspi_UnloadBlob_UINT32(offset, &info->ulVendorDataLength, blob);
+	if (info->ulVendorDataLength > 0) {
+		/* allocate space for vendor data */
+		info->rgbVendorData = malloc(info->ulVendorDataLength);
+		if (info->rgbVendorData == NULL) {
+			LogError("malloc of %u bytes failed.", info->ulVendorDataLength);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+
+		Trspi_UnloadBlob(offset, info->ulVendorDataLength, blob, info->rgbVendorData);
+	} else
+		info->rgbVendorData = NULL;
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_PCR_EVENT(UINT64 *offset, BYTE *blob, TSS_PCR_EVENT *event)
+{
+	Trspi_LoadBlob_TCPA_VERSION(offset, blob, *(TCPA_VERSION *)(&event->versionInfo));
+	Trspi_LoadBlob_UINT32(offset, event->ulPcrIndex, blob);
+	Trspi_LoadBlob_UINT32(offset, event->eventType, blob);
+
+	Trspi_LoadBlob_UINT32(offset, event->ulPcrValueLength, blob);
+	if (event->ulPcrValueLength > 0)
+		Trspi_LoadBlob(offset, event->ulPcrValueLength, blob, event->rgbPcrValue);
+
+	Trspi_LoadBlob_UINT32(offset, event->ulEventLength, blob);
+	if (event->ulEventLength > 0)
+		Trspi_LoadBlob(offset, event->ulEventLength, blob, event->rgbEvent);
+
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_PCR_EVENT(UINT64 *offset, BYTE *blob, TSS_PCR_EVENT *event)
+{
+	if (!event) {
+		UINT32 ulPcrValueLength, ulEventLength;
+
+		Trspi_UnloadBlob_VERSION(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+
+		Trspi_UnloadBlob_UINT32(offset, &ulPcrValueLength, blob);
+		(*offset) += ulPcrValueLength;
+
+		Trspi_UnloadBlob_UINT32(offset, &ulEventLength, blob);
+		(*offset) += ulEventLength;
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_VERSION(offset, blob, (TCPA_VERSION *)&(event->versionInfo));
+	Trspi_UnloadBlob_UINT32(offset, &event->ulPcrIndex, blob);
+	Trspi_UnloadBlob_UINT32(offset, &event->eventType, blob);
+
+	Trspi_UnloadBlob_UINT32(offset, &event->ulPcrValueLength, blob);
+	if (event->ulPcrValueLength > 0) {
+		event->rgbPcrValue = malloc(event->ulPcrValueLength);
+		if (event->rgbPcrValue == NULL) {
+			LogError("malloc of %u bytes failed.", event->ulPcrValueLength);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+
+		Trspi_UnloadBlob(offset, event->ulPcrValueLength, blob, event->rgbPcrValue);
+	} else {
+		event->rgbPcrValue = NULL;
+	}
+
+	Trspi_UnloadBlob_UINT32(offset, &event->ulEventLength, blob);
+	if (event->ulEventLength > 0) {
+		event->rgbEvent = malloc(event->ulEventLength);
+		if (event->rgbEvent == NULL) {
+			LogError("malloc of %d bytes failed.", event->ulEventLength);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+
+		Trspi_UnloadBlob(offset, event->ulEventLength, blob, event->rgbEvent);
+	} else {
+		event->rgbEvent = NULL;
+	}
+
+	return TSS_SUCCESS;
+}
+
+/* loads a blob with the info needed to hash when creating the private key area
+ * of a TPM_KEY(12) from an external source
+ */
+void
+Trspi_LoadBlob_PRIVKEY_DIGEST12(UINT64 *offset, BYTE *blob, TPM_KEY12 *key)
+{
+	Trspi_LoadBlob_UINT16(offset, key->tag, blob);
+	Trspi_LoadBlob_UINT16(offset, key->fill, blob);
+	Trspi_LoadBlob_UINT16(offset, key->keyUsage, blob);
+	Trspi_LoadBlob_KEY_FLAGS(offset, blob, &key->keyFlags);
+	Trspi_LoadBlob_BYTE(offset, key->authDataUsage, blob);
+	Trspi_LoadBlob_KEY_PARMS(offset, blob, &key->algorithmParms);
+
+	Trspi_LoadBlob_UINT32(offset, key->PCRInfoSize, blob);
+	/* exclude pcrInfo when PCRInfoSize is 0 as spec'd in TPM 1.1b spec p.71 */
+	if (key->PCRInfoSize != 0)
+		Trspi_LoadBlob(offset, key->PCRInfoSize, blob, key->PCRInfo);
+
+	Trspi_LoadBlob_STORE_PUBKEY(offset, blob, &key->pubKey);
+	/* exclude encSize, encData as spec'd in TPM 1.1b spec p.71 */
+}
+
+void
+Trspi_LoadBlob_PRIVKEY_DIGEST(UINT64 *offset, BYTE *blob, TCPA_KEY *key)
+{
+	Trspi_LoadBlob_TCPA_VERSION(offset, blob, key->ver);
+	Trspi_LoadBlob_UINT16(offset, key->keyUsage, blob);
+	Trspi_LoadBlob_KEY_FLAGS(offset, blob, &key->keyFlags);
+	Trspi_LoadBlob_BYTE(offset, key->authDataUsage, blob);
+	Trspi_LoadBlob_KEY_PARMS(offset, blob, &key->algorithmParms);
+
+	Trspi_LoadBlob_UINT32(offset, key->PCRInfoSize, blob);
+	/* exclude pcrInfo when PCRInfoSize is 0 as spec'd in TPM 1.1b spec p.71 */
+	if (key->PCRInfoSize != 0)
+		Trspi_LoadBlob(offset, key->PCRInfoSize, blob, key->PCRInfo);
+
+	Trspi_LoadBlob_STORE_PUBKEY(offset, blob, &key->pubKey);
+	/* exclude encSize, encData as spec'd in TPM 1.1b spec p.71 */
+}
+
+void
+Trspi_LoadBlob_SYMMETRIC_KEY(UINT64 *offset, BYTE *blob, TCPA_SYMMETRIC_KEY *key)
+{
+	Trspi_LoadBlob_UINT32(offset, key->algId, blob);
+	Trspi_LoadBlob_UINT16(offset, key->encScheme, blob);
+	Trspi_LoadBlob_UINT16(offset, key->size, blob);
+
+	if (key->size > 0)
+		Trspi_LoadBlob(offset, key->size, blob, key->data);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_SYMMETRIC_KEY(UINT64 *offset, BYTE *blob, TCPA_SYMMETRIC_KEY *key)
+{
+	if (!key) {
+		UINT16 size;
+
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT16(offset, &size, blob);
+		(*offset) += size;
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT32(offset, &key->algId, blob);
+	Trspi_UnloadBlob_UINT16(offset, &key->encScheme, blob);
+	Trspi_UnloadBlob_UINT16(offset, &key->size, blob);
+
+	if (key->size > 0) {
+		key->data = malloc(key->size);
+		if (key->data == NULL) {
+			key->size = 0;
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, key->size, blob, key->data);
+	} else {
+		key->data = NULL;
+	}
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_IDENTITY_REQ(UINT64 *offset, BYTE *blob, TCPA_IDENTITY_REQ *req)
+{
+	Trspi_LoadBlob_UINT32(offset, req->asymSize, blob);
+	Trspi_LoadBlob_UINT32(offset, req->symSize, blob);
+	Trspi_LoadBlob_KEY_PARMS(offset, blob, &req->asymAlgorithm);
+	Trspi_LoadBlob_KEY_PARMS(offset, blob, &req->symAlgorithm);
+	Trspi_LoadBlob(offset, req->asymSize, blob, req->asymBlob);
+	Trspi_LoadBlob(offset, req->symSize, blob, req->symBlob);
+}
+
+void
+Trspi_LoadBlob_CHANGEAUTH_VALIDATE(UINT64 *offset, BYTE *blob, TPM_CHANGEAUTH_VALIDATE *caValidate)
+{
+	Trspi_LoadBlob(offset, TCPA_SHA1_160_HASH_LEN, blob, caValidate->newAuthSecret.authdata);
+	Trspi_LoadBlob(offset, TCPA_SHA1_160_HASH_LEN, blob, caValidate->n1.nonce);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_IDENTITY_REQ(UINT64 *offset, BYTE *blob, TCPA_IDENTITY_REQ *req)
+{
+	TSS_RESULT result;
+
+	if (!req) {
+		UINT32 asymSize, symSize;
+
+		Trspi_UnloadBlob_UINT32(offset, &asymSize, blob);
+		Trspi_UnloadBlob_UINT32(offset, &symSize, blob);
+		(void)Trspi_UnloadBlob_KEY_PARMS(offset, blob, NULL);
+		(void)Trspi_UnloadBlob_KEY_PARMS(offset, blob, NULL);
+
+		(*offset) += asymSize;
+		(*offset) += symSize;
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT32(offset, &req->asymSize, blob);
+	Trspi_UnloadBlob_UINT32(offset, &req->symSize, blob);
+	if ((result = Trspi_UnloadBlob_KEY_PARMS(offset, blob, &req->asymAlgorithm)))
+		return result;
+	if ((Trspi_UnloadBlob_KEY_PARMS(offset, blob, &req->symAlgorithm))) {
+		free(req->asymAlgorithm.parms);
+		req->asymAlgorithm.parmSize = 0;
+		return result;
+	}
+
+	if (req->asymSize > 0) {
+		req->asymBlob = malloc(req->asymSize);
+		if (req->asymBlob == NULL) {
+			req->asymSize = 0;
+			req->asymAlgorithm.parmSize = 0;
+			free(req->asymAlgorithm.parms);
+			req->symAlgorithm.parmSize = 0;
+			free(req->symAlgorithm.parms);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, req->asymSize, blob, req->asymBlob);
+	} else {
+		req->asymBlob = NULL;
+	}
+
+	if (req->symSize > 0) {
+		req->symBlob = malloc(req->symSize);
+		if (req->symBlob == NULL) {
+			req->symSize = 0;
+			req->asymSize = 0;
+			free(req->asymBlob);
+			req->asymBlob = NULL;
+			req->asymAlgorithm.parmSize = 0;
+			free(req->asymAlgorithm.parms);
+			req->symAlgorithm.parmSize = 0;
+			free(req->symAlgorithm.parms);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, req->symSize, blob, req->symBlob);
+	} else {
+		req->symBlob = NULL;
+	}
+
+	return TSS_SUCCESS;
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_IDENTITY_PROOF(UINT64 *offset, BYTE *blob, TCPA_IDENTITY_PROOF *proof)
+{
+	TSS_RESULT result;
+
+	if (!proof) {
+		UINT32 labelSize, identityBindingSize, endorsementSize, platformSize;
+		UINT32 conformanceSize;
+
+		Trspi_UnloadBlob_VERSION(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, &labelSize, blob);
+		Trspi_UnloadBlob_UINT32(offset, &identityBindingSize, blob);
+		Trspi_UnloadBlob_UINT32(offset, &endorsementSize, blob);
+		Trspi_UnloadBlob_UINT32(offset, &platformSize, blob);
+		Trspi_UnloadBlob_UINT32(offset, &conformanceSize, blob);
+
+		(void)Trspi_UnloadBlob_PUBKEY(offset, blob, NULL);
+
+		(*offset) += labelSize;
+		(*offset) += identityBindingSize;
+		(*offset) += endorsementSize;
+		(*offset) += platformSize;
+		(*offset) += conformanceSize;
+
+		return TSS_SUCCESS;
+	}
+
+	/* helps when an error occurs */
+	memset(proof, 0, sizeof(TCPA_IDENTITY_PROOF));
+
+	Trspi_UnloadBlob_VERSION(offset, blob, (TCPA_VERSION *)&proof->ver);
+	Trspi_UnloadBlob_UINT32(offset, &proof->labelSize, blob);
+	Trspi_UnloadBlob_UINT32(offset, &proof->identityBindingSize, blob);
+	Trspi_UnloadBlob_UINT32(offset, &proof->endorsementSize, blob);
+	Trspi_UnloadBlob_UINT32(offset, &proof->platformSize, blob);
+	Trspi_UnloadBlob_UINT32(offset, &proof->conformanceSize, blob);
+
+	if ((result = Trspi_UnloadBlob_PUBKEY(offset, blob,
+					      &proof->identityKey))) {
+		proof->labelSize = 0;
+		proof->identityBindingSize = 0;
+		proof->endorsementSize = 0;
+		proof->platformSize = 0;
+		proof->conformanceSize = 0;
+		return result;
+	}
+
+	if (proof->labelSize > 0) {
+		proof->labelArea = malloc(proof->labelSize);
+		if (proof->labelArea == NULL) {
+			result = TSPERR(TSS_E_OUTOFMEMORY);
+			goto error;
+		}
+		Trspi_UnloadBlob(offset, proof->labelSize, blob, proof->labelArea);
+	} else {
+		proof->labelArea = NULL;
+	}
+
+	if (proof->identityBindingSize > 0) {
+		proof->identityBinding = malloc(proof->identityBindingSize);
+		if (proof->identityBinding == NULL) {
+			result = TSPERR(TSS_E_OUTOFMEMORY);
+			goto error;
+		}
+		Trspi_UnloadBlob(offset, proof->identityBindingSize, blob,
+				 proof->identityBinding);
+	} else {
+		proof->identityBinding = NULL;
+	}
+
+	if (proof->endorsementSize > 0) {
+		proof->endorsementCredential = malloc(proof->endorsementSize);
+		if (proof->endorsementCredential == NULL) {
+			result = TSPERR(TSS_E_OUTOFMEMORY);
+			goto error;
+		}
+		Trspi_UnloadBlob(offset, proof->endorsementSize, blob,
+				 proof->endorsementCredential);
+	} else {
+		proof->endorsementCredential = NULL;
+	}
+
+	if (proof->platformSize > 0) {
+		proof->platformCredential = malloc(proof->platformSize);
+		if (proof->platformCredential == NULL) {
+			result = TSPERR(TSS_E_OUTOFMEMORY);
+			goto error;
+		}
+		Trspi_UnloadBlob(offset, proof->platformSize, blob,
+				 proof->platformCredential);
+	} else {
+		proof->platformCredential = NULL;
+	}
+
+	if (proof->conformanceSize > 0) {
+		proof->conformanceCredential = malloc(proof->conformanceSize);
+		if (proof->conformanceCredential == NULL) {
+			result = TSPERR(TSS_E_OUTOFMEMORY);
+			goto error;
+		}
+		Trspi_UnloadBlob(offset, proof->conformanceSize, blob,
+				 proof->conformanceCredential);
+	} else {
+		proof->conformanceCredential = NULL;
+	}
+
+	return TSS_SUCCESS;
+error:
+	proof->labelSize = 0;
+	proof->identityBindingSize = 0;
+	proof->endorsementSize = 0;
+	proof->platformSize = 0;
+	proof->conformanceSize = 0;
+	free(proof->labelArea);
+	proof->labelArea = NULL;
+	free(proof->identityBinding);
+	proof->identityBinding = NULL;
+	free(proof->endorsementCredential);
+	proof->endorsementCredential = NULL;
+	free(proof->conformanceCredential);
+	proof->conformanceCredential = NULL;
+	/* free identityKey */
+	free(proof->identityKey.pubKey.key);
+	free(proof->identityKey.algorithmParms.parms);
+	proof->identityKey.pubKey.key = NULL;
+	proof->identityKey.pubKey.keyLength = 0;
+	proof->identityKey.algorithmParms.parms = NULL;
+	proof->identityKey.algorithmParms.parmSize = 0;
+
+	return result;
+}
+
+void
+Trspi_LoadBlob_SYM_CA_ATTESTATION(UINT64 *offset, BYTE *blob, TCPA_SYM_CA_ATTESTATION *sym)
+{
+	Trspi_LoadBlob_UINT32(offset, sym->credSize, blob);
+	Trspi_LoadBlob_KEY_PARMS(offset, blob, &sym->algorithm);
+	Trspi_LoadBlob(offset, sym->credSize, blob, sym->credential);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_SYM_CA_ATTESTATION(UINT64 *offset, BYTE *blob, TCPA_SYM_CA_ATTESTATION *sym)
+{
+	TSS_RESULT result;
+
+	if (!sym) {
+		UINT32 credSize;
+
+		Trspi_UnloadBlob_UINT32(offset, &credSize, blob);
+		(void)Trspi_UnloadBlob_KEY_PARMS(offset, blob, NULL);
+
+		(*offset) += credSize;
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT32(offset, &sym->credSize, blob);
+	if ((result = Trspi_UnloadBlob_KEY_PARMS(offset, blob, &sym->algorithm))) {
+		sym->credSize = 0;
+		return result;
+	}
+
+	if (sym->credSize > 0) {
+		if ((sym->credential = malloc(sym->credSize)) == NULL) {
+			free(sym->algorithm.parms);
+			sym->algorithm.parmSize = 0;
+			sym->credSize = 0;
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, sym->credSize, blob, sym->credential);
+	} else {
+		sym->credential = NULL;
+	}
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_ASYM_CA_CONTENTS(UINT64 *offset, BYTE *blob, TCPA_ASYM_CA_CONTENTS *asym)
+{
+	Trspi_LoadBlob_SYMMETRIC_KEY(offset, blob, &asym->sessionKey);
+	Trspi_LoadBlob(offset, TCPA_SHA1_160_HASH_LEN, blob,
+		       (BYTE *)&asym->idDigest);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_ASYM_CA_CONTENTS(UINT64 *offset, BYTE *blob, TCPA_ASYM_CA_CONTENTS *asym)
+{
+	TSS_RESULT result;
+
+	if (!asym) {
+		(void)Trspi_UnloadBlob_SYMMETRIC_KEY(offset, blob, NULL);
+		Trspi_UnloadBlob(offset, TCPA_SHA1_160_HASH_LEN, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	if ((result = Trspi_UnloadBlob_SYMMETRIC_KEY(offset, blob, &asym->sessionKey)))
+		return result;
+
+	Trspi_UnloadBlob(offset, TCPA_SHA1_160_HASH_LEN, blob, (BYTE *)&asym->idDigest);
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_BOUND_DATA(UINT64 *offset, TCPA_BOUND_DATA bd, UINT32 payloadLength, BYTE *blob)
+{
+	Trspi_LoadBlob_TCPA_VERSION(offset, blob, bd.ver);
+	Trspi_LoadBlob(offset, 1, blob, &bd.payload);
+	Trspi_LoadBlob(offset, payloadLength, blob, bd.payloadData);
+}
+
+/* function to mimic strerror with TSS error codes */
+char *
+Trspi_Error_String(TSS_RESULT r)
+{
+	/* Check the return code to see if it is common to all layers.
+	 * If so, return it.
+	 */
+	switch (TSS_ERROR_CODE(r)) {
+		case TSS_SUCCESS:			return "Success";
+		default:
+			break;
+	}
+
+	/* The return code is either unknown, or specific to a layer */
+	if (TSS_ERROR_LAYER(r) == TSS_LAYER_TPM) {
+		switch (TSS_ERROR_CODE(r)) {
+			case TPM_E_AUTHFAIL:			return "Authentication failed";
+			case TPM_E_BAD_PARAMETER:		return "Bad Parameter";
+			case TPM_E_BADINDEX:			return "Bad memory index";
+			case TPM_E_AUDITFAILURE:		return "Audit failure";
+			case TPM_E_CLEAR_DISABLED:		return "Clear has been disabled";
+			case TPM_E_DEACTIVATED:			return "TPM is deactivated";
+			case TPM_E_DISABLED:			return "TPM is disabled";
+			case TPM_E_FAIL:			return "Operation failed";
+			case TPM_E_BAD_ORDINAL:			return "Ordinal was unknown or inconsistent";
+			case TPM_E_INSTALL_DISABLED:		return "Owner install disabled";
+			case TPM_E_INVALID_KEYHANDLE:		return "Invalid keyhandle";
+			case TPM_E_KEYNOTFOUND:			return "Key not found";
+			case TPM_E_INAPPROPRIATE_ENC:		return "Bad encryption scheme";
+			case TPM_E_MIGRATEFAIL:			return "Migration authorization failed";
+			case TPM_E_INVALID_PCR_INFO:		return "PCR information uninterpretable";
+			case TPM_E_NOSPACE:			return "No space to load key";
+			case TPM_E_NOSRK:			return "No SRK";
+			case TPM_E_NOTSEALED_BLOB:		return "Encrypted blob invalid";
+			case TPM_E_OWNER_SET:			return "Owner already set";
+			case TPM_E_RESOURCES:			return "Insufficient TPM resources";
+			case TPM_E_SHORTRANDOM:			return "Random string too short";
+			case TPM_E_SIZE:			return "TPM out of space";
+			case TPM_E_WRONGPCRVAL:			return "Wrong PCR value";
+			case TPM_E_BAD_PARAM_SIZE:		return "Bad input size";
+			case TPM_E_SHA_THREAD:			return "No existing SHA-1 thread";
+			case TPM_E_SHA_ERROR:			return "SHA-1 error";
+			case TPM_E_FAILEDSELFTEST:		return "Self-test failed, TPM shutdown";
+			case TPM_E_AUTH2FAIL:			return "Second authorization session failed";
+			case TPM_E_BADTAG:			return "Invalid tag";
+			case TPM_E_IOERROR:			return "I/O error";
+			case TPM_E_ENCRYPT_ERROR:		return "Encryption error";
+			case TPM_E_DECRYPT_ERROR:		return "Decryption error";
+			case TPM_E_INVALID_AUTHHANDLE:		return "Invalid authorization handle";
+			case TPM_E_NO_ENDORSEMENT:		return "No EK";
+			case TPM_E_INVALID_KEYUSAGE:		return "Invalid key usage";
+			case TPM_E_WRONG_ENTITYTYPE:		return "Invalid entity type";
+			case TPM_E_INVALID_POSTINIT:		return "Invalid POST init sequence";
+			case TPM_E_INAPPROPRIATE_SIG:		return "Invalid signature format";
+			case TPM_E_BAD_KEY_PROPERTY:		return "Unsupported key parameters";
+			case TPM_E_BAD_MIGRATION:		return "Invalid migration properties";
+			case TPM_E_BAD_SCHEME:			return "Invalid signature or encryption scheme";
+			case TPM_E_BAD_DATASIZE:		return "Invalid data size";
+			case TPM_E_BAD_MODE:			return "Bad mode parameter";
+			case TPM_E_BAD_PRESENCE:		return "Bad physical presence value";
+			case TPM_E_BAD_VERSION:			return "Invalid version";
+			case TPM_E_NO_WRAP_TRANSPORT:		return "TPM does not allow for wrapped transport sessions";
+			case TPM_E_AUDITFAIL_UNSUCCESSFUL:	return "TPM audit construction failed and the underlying command was returning a failure code also";
+			case TPM_E_AUDITFAIL_SUCCESSFUL:	return "TPM audit construction failed and the underlying command was returning success";
+			case TPM_E_NOTRESETABLE:		return "Attempt to reset a PCR register that does not have the resettable attribute";
+			case TPM_E_NOTLOCAL:			return "Attempt to reset a PCR register that requires locality and locality modifier not part of command transport";
+			case TPM_E_BAD_TYPE:			return "Make identity blob not properly typed";
+			case TPM_E_INVALID_RESOURCE:		return "When saving context identified resource type does not match actual resource";
+			case TPM_E_NOTFIPS:			return "TPM is attempting to execute a command only available when in FIPS mode";
+			case TPM_E_INVALID_FAMILY:		return "Command is attempting to use an invalid family ID";
+			case TPM_E_NO_NV_PERMISSION:		return "Permission to manipulate the NV storage is not available";
+			case TPM_E_REQUIRES_SIGN:		return "Operation requires a signed command";
+			case TPM_E_KEY_NOTSUPPORTED:		return "Wrong operation to load an NV key";
+			case TPM_E_AUTH_CONFLICT:		return "NV_LoadKey blob requires both owner and blob authorization";
+			case TPM_E_AREA_LOCKED:			return "NV area is locked and not writable";
+			case TPM_E_BAD_LOCALITY:		return "Locality is incorrect for attempted operation";
+			case TPM_E_READ_ONLY:			return "NV area is read only and can't be written to";
+			case TPM_E_PER_NOWRITE:			return "There is no protection on write to NV area";
+			case TPM_E_FAMILYCOUNT:			return "Family count value does not match";
+			case TPM_E_WRITE_LOCKED:		return "NV area has already been written to";
+			case TPM_E_BAD_ATTRIBUTES:		return "NV area attributes conflict";
+			case TPM_E_INVALID_STRUCTURE:		return "Structure tag and version are invalid or inconsistent";
+			case TPM_E_KEY_OWNER_CONTROL:		return "Key is under control of TPM Owner and can only be evicted by TPM Owner";
+			case TPM_E_BAD_COUNTER:			return "Counter handle is incorrect";
+			case TPM_E_NOT_FULLWRITE:		return "Write is not a complete write of area";
+			case TPM_E_CONTEXT_GAP:			return "Gap between saved context counts is too large";
+			case TPM_E_MAXNVWRITES:			return "Maximum number of NV writes without an owner has been exceeded";
+			case TPM_E_NOOPERATOR:			return "No operator AuthData value is set";
+			case TPM_E_RESOURCEMISSING:		return "Resource pointed to by context is not loaded";
+			case TPM_E_DELEGATE_LOCK:		return "Delegate administration is locked";
+			case TPM_E_DELEGATE_FAMILY:		return "Attempt to manage a family other then delegated family";
+			case TPM_E_DELEGATE_ADMIN:		return "Delegation table management not enabled";
+			case TPM_E_TRANSPORT_NOTEXCLUSIVE:	return "A command was executed outside of an exclusive transport session";
+			case TPM_E_OWNER_CONTROL:		return "Attempt to context save an owner evict-controlled key";
+			case TPM_E_DAA_RESOURCES:		return "DAA command has no resources available to execute command";
+			case TPM_E_DAA_INPUT_DATA0:		return "Consistency check on DAA parameter inputData0 has failed";
+			case TPM_E_DAA_INPUT_DATA1:		return "Consistency check on DAA parameter inputData1 has failed";
+			case TPM_E_DAA_ISSUER_SETTINGS:		return "Consistency check on DAA_issuerSettings has failed";
+			case TPM_E_DAA_TPM_SETTINGS:		return "Consistency check on DAA_tpmSpecific has failed";
+			case TPM_E_DAA_STAGE:			return "Atomic process indicated by submitted DAA command is not expected process";
+			case TPM_E_DAA_ISSUER_VALIDITY:		return "Issuer's validity check has detected an inconsistency";
+			case TPM_E_DAA_WRONG_W:			return "Consistency check on w has failed";
+			case TPM_E_BAD_HANDLE:			return "Handle is incorrect";
+			case TPM_E_BAD_DELEGATE:		return "Delegation is not correct";
+			case TPM_E_BADCONTEXT:			return "Context blob is invalid";
+			case TPM_E_TOOMANYCONTEXTS:		return "Too many contexts held by TPM";
+			case TPM_E_MA_TICKET_SIGNATURE:		return "Migration authority signature validation failure";
+			case TPM_E_MA_DESTINATION:		return "Migration destination not authenticated";
+			case TPM_E_MA_SOURCE:			return "Migration source incorrect";
+			case TPM_E_MA_AUTHORITY:		return "Incorrect migration authority";
+			case TPM_E_PERMANENTEK:			return "Attempt to revoke EK but EK is not revocable";
+			case TPM_E_BAD_SIGNATURE:		return "Bad signature of CMK ticket";
+			case TPM_E_NOCONTEXTSPACE:		return "No room in context list for additional contexts";
+			case TPM_E_RETRY:			return "TPM busy: Retry command at a later time";
+			case TPM_E_NEEDS_SELFTEST:		return "SelfTestFull has not been run";
+			case TPM_E_DOING_SELFTEST:		return "TPM is currently executing a full selftest";
+			case TPM_E_DEFEND_LOCK_RUNNING:		return "TPM is defending against dictionary attacks and is in some time-out period";
+			case TPM_E_DISABLED_CMD:		return "The TPM target command has been disabled";
+			default:				return "Unknown error";
+		}
+	} else if (TSS_ERROR_LAYER(r) == TSS_LAYER_TDDL) {
+		switch (TSS_ERROR_CODE(r)) {
+			case TSS_E_FAIL:			return "General failure";
+			case TSS_E_BAD_PARAMETER:		return "Bad parameter";
+			case TSS_E_INTERNAL_ERROR:		return "Internal software error";
+			case TSS_E_NOTIMPL:			return "Not implemented";
+			case TSS_E_PS_KEY_NOTFOUND:		return "Key not found in persistent storage";
+			case TSS_E_KEY_ALREADY_REGISTERED:	return "UUID already registered";
+			case TSS_E_CANCELED:			return "The action was cancelled by request";
+			case TSS_E_TIMEOUT:			return "The operation has timed out";
+			case TSS_E_OUTOFMEMORY:			return "Out of memory";
+			case TSS_E_TPM_UNEXPECTED:		return "Unexpected TPM output";
+			case TSS_E_COMM_FAILURE:		return "Communication failure";
+			case TSS_E_TPM_UNSUPPORTED_FEATURE:	return "Unsupported feature";
+			case TDDL_E_COMPONENT_NOT_FOUND:	return "Connection to TPM device failed";
+			case TDDL_E_ALREADY_OPENED:		return "Device already opened";
+			case TDDL_E_BADTAG:			return "Invalid or unsupported capability";
+			case TDDL_E_INSUFFICIENT_BUFFER:	return "Receive buffer too small";
+			case TDDL_E_COMMAND_COMPLETED:		return "Command has already completed";
+			case TDDL_E_COMMAND_ABORTED:		return "TPM aborted processing of command";
+			case TDDL_E_ALREADY_CLOSED:		return "Device driver already closed";
+			case TDDL_E_IOERROR:			return "I/O error";
+			default:				return "Unknown";
+		}
+	} else if (TSS_ERROR_LAYER(r) == TSS_LAYER_TCS) {
+		switch (TSS_ERROR_CODE(r)) {
+			case TSS_E_FAIL:			return "General failure";
+			case TSS_E_BAD_PARAMETER:		return "Bad parameter";
+			case TSS_E_INTERNAL_ERROR:		return "Internal software error";
+			case TSS_E_NOTIMPL:			return "Not implemented";
+			case TSS_E_PS_KEY_NOTFOUND:		return "Key not found in persistent storage";
+			case TSS_E_KEY_ALREADY_REGISTERED:	return "UUID already registered";
+			case TSS_E_CANCELED:			return "The action was cancelled by request";
+			case TSS_E_TIMEOUT:			return "The operation has timed out";
+			case TSS_E_OUTOFMEMORY:			return "Out of memory";
+			case TSS_E_TPM_UNEXPECTED:		return "Unexpected TPM output";
+			case TSS_E_COMM_FAILURE:		return "Communication failure";
+			case TSS_E_TPM_UNSUPPORTED_FEATURE:	return "Unsupported feature";
+			case TCS_E_KEY_MISMATCH:		return "UUID does not match key handle";
+			case TCS_E_KM_LOADFAILED:		return "Key load failed: parent key requires authorization";
+			case TCS_E_KEY_CONTEXT_RELOAD:		return "Reload of key context failed";
+			case TCS_E_BAD_INDEX:			return "Bad memory index";
+			case TCS_E_INVALID_CONTEXTHANDLE:	return "Invalid context handle";
+			case TCS_E_INVALID_KEYHANDLE:		return "Invalid key handle";
+			case TCS_E_INVALID_AUTHHANDLE:		return "Invalid authorization session handle";
+			case TCS_E_INVALID_AUTHSESSION:		return "Authorization session has been closed by TPM";
+			case TCS_E_INVALID_KEY:			return "Invalid key";
+			default:				return "Unknown";
+		}
+	} else {
+		switch (TSS_ERROR_CODE(r)) {
+			case TSS_E_FAIL:			return "General failure";
+			case TSS_E_BAD_PARAMETER:		return "Bad parameter";
+			case TSS_E_INTERNAL_ERROR:		return "Internal software error";
+			case TSS_E_NOTIMPL:			return "Not implemented";
+			case TSS_E_PS_KEY_NOTFOUND:		return "Key not found in persistent storage";
+			case TSS_E_KEY_ALREADY_REGISTERED:	return "UUID already registered";
+			case TSS_E_CANCELED:			return "The action was cancelled by request";
+			case TSS_E_TIMEOUT:			return "The operation has timed out";
+			case TSS_E_OUTOFMEMORY:			return "Out of memory";
+			case TSS_E_TPM_UNEXPECTED:		return "Unexpected TPM output";
+			case TSS_E_COMM_FAILURE:		return "Communication failure";
+			case TSS_E_TPM_UNSUPPORTED_FEATURE:	return "Unsupported feature";
+			case TSS_E_INVALID_OBJECT_TYPE:		return "Object type not valid for this operation";
+			case TSS_E_INVALID_OBJECT_INITFLAG:	return "Wrong flag information for object creation";
+			case TSS_E_INVALID_HANDLE:		return "Invalid handle";
+			case TSS_E_NO_CONNECTION:		return "Core service connection doesn't exist";
+			case TSS_E_CONNECTION_FAILED:		return "Core service connection failed";
+			case TSS_E_CONNECTION_BROKEN:		return "Communication with core services failed";
+			case TSS_E_HASH_INVALID_ALG:		return "Invalid hash algorithm";
+			case TSS_E_HASH_INVALID_LENGTH:		return "Hash length is inconsistent with algorithm";
+			case TSS_E_HASH_NO_DATA:		return "Hash object has no internal hash value";
+			case TSS_E_SILENT_CONTEXT:		return "A silent context requires user input";
+			case TSS_E_INVALID_ATTRIB_FLAG:		return "Flag value for attrib-functions inconsistent";
+			case TSS_E_INVALID_ATTRIB_SUBFLAG:	return "Sub-flag value for attrib-functions inconsistent";
+			case TSS_E_INVALID_ATTRIB_DATA:		return "Data for attrib-functions invalid";
+			case TSS_E_NO_PCRS_SET:			return "No PCR registers are selected or set";
+			case TSS_E_KEY_NOT_LOADED:		return "The addressed key is not currently loaded";
+			case TSS_E_KEY_NOT_SET:			return "No key informatio is currently available";
+			case TSS_E_VALIDATION_FAILED:		return "Internal validation of data failed";
+			case TSS_E_TSP_AUTHREQUIRED:		return "Authorization is required";
+			case TSS_E_TSP_AUTH2REQUIRED:		return "Multiple authorizations are required";
+			case TSS_E_TSP_AUTHFAIL:		return "Authorization failed";
+			case TSS_E_TSP_AUTH2FAIL:		return "Multiple authorization failed";
+			case TSS_E_KEY_NO_MIGRATION_POLICY:	return "Addressed key has no migration policy";
+			case TSS_E_POLICY_NO_SECRET:		return "No secret information available for the address policy";
+			case TSS_E_INVALID_OBJ_ACCESS:		return "Accessed object is in an inconsistent state";
+			case TSS_E_INVALID_ENCSCHEME:		return "Invalid encryption scheme";
+			case TSS_E_INVALID_SIGSCHEME:		return "Invalid signature scheme";
+			case TSS_E_ENC_INVALID_LENGTH:		return "Invalid length for encrypted data object";
+			case TSS_E_ENC_NO_DATA:			return "Encrypted data object contains no data";
+			case TSS_E_ENC_INVALID_TYPE:		return "Invalid type for encrypted data object";
+			case TSS_E_INVALID_KEYUSAGE:		return "Invalid usage of key";
+			case TSS_E_VERIFICATION_FAILED:		return "Internal validation of data failed";
+			case TSS_E_HASH_NO_IDENTIFIER:		return "Hash algorithm identifier not set";
+			case TSS_E_NV_AREA_EXIST:		return "NVRAM area already exists";
+			case TSS_E_NV_AREA_NOT_EXIST:		return "NVRAM area does not exist";
+			default:				return "Unknown";
+		}
+	}
+}
+
+char *
+Trspi_Error_Layer(TSS_RESULT r)
+{
+	switch (TSS_ERROR_LAYER(r)) {
+		case TSS_LAYER_TPM:	return "tpm";
+		case TSS_LAYER_TDDL:	return "tddl";
+		case TSS_LAYER_TCS:	return "tcs";
+		case TSS_LAYER_TSP:	return "tsp";
+		default:		return "unknown";
+	}
+}
+
+TSS_RESULT
+Trspi_Error_Code(TSS_RESULT r)
+{
+	return TSS_ERROR_CODE(r);
+}
+
+static int
+hacky_strlen(char *codeset, BYTE *string)
+{
+	BYTE *ptr = string;
+	int len = 0;
+
+	if (strcmp("UTF-16", codeset) == 0) {
+		while (!(ptr[0] == '\0' && ptr[1] == '\0')) {
+			len += 2;
+			ptr += 2;
+		}
+	} else if (strcmp("UTF-32", codeset) == 0) {
+		while (!(ptr[0] == '\0' && ptr[1] == '\0' &&
+			 ptr[2] == '\0' && ptr[3] == '\0')) {
+			len += 4;
+			ptr += 4;
+		}
+	} else {
+		/* default to 8bit chars */
+		while (*ptr++ != '\0') {
+			len++;
+		}
+	}
+
+	return len;
+}
+
+static inline int
+char_width(char *codeset)
+{
+	if (strcmp("UTF-16", codeset) == 0) {
+		return 2;
+	} else if (strcmp("UTF-32", codeset) == 0) {
+		return 4;
+	}
+
+	return 1;
+}
+
+#define MAX_BUF_SIZE	4096
+
+BYTE *
+Trspi_Native_To_UNICODE(BYTE *string, unsigned *size)
+{
+	char *ret, *outbuf, tmpbuf[MAX_BUF_SIZE] = { 0, };
+	BSD_CONST char *ptr;
+	unsigned len = 0, tmplen;
+	iconv_t cd = 0;
+	size_t rc, outbytesleft, inbytesleft;
+
+	if (string == NULL)
+		goto alloc_string;
+
+	if ((cd = iconv_open("UTF-16LE", nl_langinfo(CODESET))) == (iconv_t)-1) {
+		LogDebug("iconv_open: %s", strerror(errno));
+		return NULL;
+	}
+
+	if ((tmplen = hacky_strlen(nl_langinfo(CODESET), string)) == 0) {
+		LogDebug("hacky_strlen returned 0");
+		goto alloc_string;
+	}
+
+	do {
+		len++;
+		outbytesleft = len;
+		inbytesleft = tmplen;
+		outbuf = tmpbuf;
+		ptr = (char *)string;
+		errno = 0;
+
+		rc = iconv(cd, (BSD_CONST char **)&ptr, &inbytesleft, &outbuf, &outbytesleft);
+	} while (rc == (size_t)-1 && errno == E2BIG);
+
+	if (len > MAX_BUF_SIZE) {
+		LogDebug("string too long.");
+		iconv_close(cd);
+		return NULL;
+	}
+
+alloc_string:
+	/* add terminating bytes of the correct width */
+	len += char_width("UTF-16");
+	if ((ret = calloc(1, len)) == NULL) {
+		LogDebug("malloc of %u bytes failed.", len);
+		iconv_close(cd);
+		return NULL;
+	}
+
+	memcpy(ret, &tmpbuf, len);
+	if (size)
+		*size = len;
+
+	if (cd)
+		iconv_close(cd);
+
+	return (BYTE *)ret;
+
+}
+
+BYTE *
+Trspi_UNICODE_To_Native(BYTE *string, unsigned *size)
+{
+	char *ret, *outbuf, tmpbuf[MAX_BUF_SIZE] = { 0, };
+	BSD_CONST char *ptr;
+	unsigned len = 0, tmplen;
+	iconv_t cd;
+	size_t rc, outbytesleft, inbytesleft;
+
+	if (string == NULL) {
+		if (size)
+			*size = 0;
+		return NULL;
+	}
+
+	if ((cd = iconv_open(nl_langinfo(CODESET), "UTF-16LE")) == (iconv_t)-1) {
+		LogDebug("iconv_open: %s", strerror(errno));
+		return NULL;
+	}
+
+	if ((tmplen = hacky_strlen("UTF-16", string)) == 0) {
+		LogDebug("hacky_strlen returned 0");
+		return 0;
+	}
+
+	do {
+		len++;
+		outbytesleft = len;
+		inbytesleft = tmplen;
+		outbuf = tmpbuf;
+		ptr = (char *)string;
+		errno = 0;
+
+		rc = iconv(cd, (BSD_CONST char **)&ptr, &inbytesleft, &outbuf, &outbytesleft);
+	} while (rc == (size_t)-1 && errno == E2BIG);
+
+	/* add terminating bytes of the correct width */
+	len += char_width(nl_langinfo(CODESET));
+	if (len > MAX_BUF_SIZE) {
+		LogDebug("string too long.");
+		iconv_close(cd);
+		return NULL;
+	}
+
+	if ((ret = calloc(1, len)) == NULL) {
+		LogDebug("malloc of %d bytes failed.", len);
+		iconv_close(cd);
+		return NULL;
+	}
+
+	memcpy(ret, &tmpbuf, len);
+	if (size)
+		*size = len;
+	iconv_close(cd);
+
+	return (BYTE *)ret;
+}
+
+/* Functions to support incremental hashing */
+TSS_RESULT
+Trspi_Hash_UINT16(Trspi_HashCtx *c, UINT16 i)
+{
+	BYTE bytes[sizeof(UINT16)];
+
+	UINT16ToArray(i, bytes);
+	return Trspi_HashUpdate(c, sizeof(UINT16), bytes);
+}
+
+TSS_RESULT
+Trspi_Hash_UINT32(Trspi_HashCtx *c, UINT32 i)
+{
+	BYTE bytes[sizeof(UINT32)];
+
+	UINT32ToArray(i, bytes);
+	return Trspi_HashUpdate(c, sizeof(UINT32), bytes);
+}
+
+TSS_RESULT
+Trspi_Hash_UINT64(Trspi_HashCtx *c, UINT64 i)
+{
+	BYTE bytes[sizeof(UINT64)];
+
+	UINT64ToArray(i, bytes);
+	return Trspi_HashUpdate(c, sizeof(UINT64), bytes);
+}
+
+TSS_RESULT
+Trspi_Hash_BYTE(Trspi_HashCtx *c, BYTE data)
+{
+	return Trspi_HashUpdate(c, sizeof(BYTE), &data);
+}
+
+TSS_RESULT
+Trspi_Hash_BOOL(Trspi_HashCtx *c, TSS_BOOL data)
+{
+	return Trspi_HashUpdate(c, (UINT32)sizeof(TSS_BOOL), (BYTE *)&data);
+}
+
+TSS_RESULT
+Trspi_Hash_VERSION(Trspi_HashCtx *c, TSS_VERSION *version)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_BYTE(c, version->bMajor);
+	result |= Trspi_Hash_BYTE(c, version->bMinor);
+	result |= Trspi_Hash_BYTE(c, version->bRevMajor);
+	result |= Trspi_Hash_BYTE(c, version->bRevMinor);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_DAA_PK(Trspi_HashCtx *c, TSS_DAA_PK *pk)
+{
+	UINT32 i;
+	TSS_RESULT result;
+
+	result = Trspi_Hash_VERSION(c, &pk->versionInfo);
+
+	result |= Trspi_Hash_UINT32(c, pk->modulusLength);
+	result |= Trspi_HashUpdate(c, pk->modulusLength, pk->modulus);
+
+	result |= Trspi_Hash_UINT32(c, pk->capitalSLength);
+	result |= Trspi_HashUpdate(c, pk->capitalSLength, pk->capitalS);
+
+	result |= Trspi_Hash_UINT32(c, pk->capitalZLength);
+	result |= Trspi_HashUpdate(c, pk->capitalZLength, pk->capitalZ);
+
+	result |= Trspi_Hash_UINT32(c, pk->capitalR0Length);
+	result |= Trspi_HashUpdate(c, pk->capitalR0Length, pk->capitalR0);
+
+	result |= Trspi_Hash_UINT32(c, pk->capitalR1Length);
+	result |= Trspi_HashUpdate(c, pk->capitalR1Length, pk->capitalR1);
+
+	result |= Trspi_Hash_UINT32(c, pk->gammaLength);
+	result |= Trspi_HashUpdate(c, pk->gammaLength, pk->gamma);
+
+	result |= Trspi_Hash_UINT32(c, pk->capitalGammaLength);
+	result |= Trspi_HashUpdate(c, pk->capitalGammaLength, pk->capitalGamma);
+
+	result |= Trspi_Hash_UINT32(c, pk->rhoLength);
+	result |= Trspi_HashUpdate(c, pk->rhoLength, pk->rho);
+
+	for (i = 0; i < pk->capitalYLength; i++)
+		result |= Trspi_HashUpdate(c, pk->capitalYLength2, pk->capitalY[i]);
+
+	result |= Trspi_Hash_UINT32(c, pk->capitalYPlatformLength);
+
+	result |= Trspi_Hash_UINT32(c, pk->issuerBaseNameLength);
+	result |= Trspi_HashUpdate(c, pk->issuerBaseNameLength, pk->issuerBaseName);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_RSA_KEY_PARMS(Trspi_HashCtx *c, TCPA_RSA_KEY_PARMS *parms)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT32(c, parms->keyLength);
+	result |= Trspi_Hash_UINT32(c, parms->numPrimes);
+	result |= Trspi_Hash_UINT32(c, parms->exponentSize);
+
+	if (parms->exponentSize > 0)
+		result |= Trspi_HashUpdate(c, parms->exponentSize, parms->exponent);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_STORE_PUBKEY(Trspi_HashCtx *c, TCPA_STORE_PUBKEY *store)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT32(c, store->keyLength);
+	result |= Trspi_HashUpdate(c, store->keyLength, store->key);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_KEY_PARMS(Trspi_HashCtx *c, TCPA_KEY_PARMS *keyInfo)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT32(c, keyInfo->algorithmID);
+	result |= Trspi_Hash_UINT16(c, keyInfo->encScheme);
+	result |= Trspi_Hash_UINT16(c, keyInfo->sigScheme);
+	result |= Trspi_Hash_UINT32(c, keyInfo->parmSize);
+
+	if (keyInfo->parmSize > 0)
+		result |= Trspi_HashUpdate(c, keyInfo->parmSize, keyInfo->parms);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_PUBKEY(Trspi_HashCtx *c, TCPA_PUBKEY *pubKey)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_KEY_PARMS(c, &pubKey->algorithmParms);
+	result |= Trspi_Hash_STORE_PUBKEY(c, &pubKey->pubKey);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_STORED_DATA(Trspi_HashCtx *c, TCPA_STORED_DATA *data)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_VERSION(c, (TSS_VERSION *)&data->ver);
+	result |= Trspi_Hash_UINT32(c, data->sealInfoSize);
+	result |= Trspi_HashUpdate(c, data->sealInfoSize, data->sealInfo);
+	result |= Trspi_Hash_UINT32(c, data->encDataSize);
+	result |= Trspi_HashUpdate(c, data->encDataSize, data->encData);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_PCR_SELECTION(Trspi_HashCtx *c, TCPA_PCR_SELECTION *pcr)
+{
+	TSS_RESULT result;
+	UINT16 i;
+
+	result = Trspi_Hash_UINT16(c, pcr->sizeOfSelect);
+
+	for (i = 0; i < pcr->sizeOfSelect; i++)
+		result |= Trspi_Hash_BYTE(c, pcr->pcrSelect[i]);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_KEY_FLAGS(Trspi_HashCtx *c, TCPA_KEY_FLAGS *flags)
+{
+	return Trspi_Hash_UINT32(c, *flags);
+}
+
+TSS_RESULT
+Trspi_Hash_KEY12(Trspi_HashCtx *c, TPM_KEY12 *key)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT16(c, key->tag);
+	result |= Trspi_Hash_UINT16(c, key->fill);
+	result |= Trspi_Hash_UINT16(c, key->keyUsage);
+	result |= Trspi_Hash_KEY_FLAGS(c, &key->keyFlags);
+	result |= Trspi_Hash_BYTE(c, key->authDataUsage);
+	result |= Trspi_Hash_KEY_PARMS(c, &key->algorithmParms);
+	result |= Trspi_Hash_UINT32(c, key->PCRInfoSize);
+	result |= Trspi_HashUpdate(c, key->PCRInfoSize, key->PCRInfo);
+	result |= Trspi_Hash_STORE_PUBKEY(c, &key->pubKey);
+	result |= Trspi_Hash_UINT32(c, key->encSize);
+	result |= Trspi_HashUpdate(c, key->encSize, key->encData);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_KEY(Trspi_HashCtx *c, TCPA_KEY *key)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_VERSION(c, (TSS_VERSION *)&key->ver);
+	result |= Trspi_Hash_UINT16(c, key->keyUsage);
+	result |= Trspi_Hash_KEY_FLAGS(c, &key->keyFlags);
+	result |= Trspi_Hash_BYTE(c, key->authDataUsage);
+	result |= Trspi_Hash_KEY_PARMS(c, &key->algorithmParms);
+	result |= Trspi_Hash_UINT32(c, key->PCRInfoSize);
+	result |= Trspi_HashUpdate(c, key->PCRInfoSize, key->PCRInfo);
+	result |= Trspi_Hash_STORE_PUBKEY(c, &key->pubKey);
+	result |= Trspi_Hash_UINT32(c, key->encSize);
+	result |= Trspi_HashUpdate(c, key->encSize, key->encData);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_UUID(Trspi_HashCtx *c, TSS_UUID uuid)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT32(c, uuid.ulTimeLow);
+	result |= Trspi_Hash_UINT16(c, uuid.usTimeMid);
+	result |= Trspi_Hash_UINT16(c, uuid.usTimeHigh);
+	result |= Trspi_Hash_BYTE(c, uuid.bClockSeqHigh);
+	result |= Trspi_Hash_BYTE(c, uuid.bClockSeqLow);
+	result |= Trspi_HashUpdate(c, sizeof(uuid.rgbNode), uuid.rgbNode);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_PCR_EVENT(Trspi_HashCtx *c, TSS_PCR_EVENT *event)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_VERSION(c, &event->versionInfo);
+	result |= Trspi_Hash_UINT32(c, event->ulPcrIndex);
+	result |= Trspi_Hash_UINT32(c, event->eventType);
+
+	Trspi_Hash_UINT32(c, event->ulPcrValueLength);
+	if (event->ulPcrValueLength > 0)
+		result |= Trspi_HashUpdate(c, event->ulPcrValueLength, event->rgbPcrValue);
+
+	result |= Trspi_Hash_UINT32(c, event->ulEventLength);
+	if (event->ulEventLength > 0)
+		result |= Trspi_HashUpdate(c, event->ulEventLength, event->rgbEvent);
+
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_PRIVKEY_DIGEST12(Trspi_HashCtx *c, TPM_KEY12 *key)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT16(c, key->tag);
+	result |= Trspi_Hash_UINT16(c, key->fill);
+	result |= Trspi_Hash_UINT16(c, key->keyUsage);
+	result |= Trspi_Hash_KEY_FLAGS(c, &key->keyFlags);
+	result |= Trspi_Hash_BYTE(c, key->authDataUsage);
+	result |= Trspi_Hash_KEY_PARMS(c, &key->algorithmParms);
+
+	result |= Trspi_Hash_UINT32(c, key->PCRInfoSize);
+	/* exclude pcrInfo when PCRInfoSize is 0 as spec'd in TPM 1.1b spec p.71 */
+	if (key->PCRInfoSize != 0)
+		result |= Trspi_HashUpdate(c, key->PCRInfoSize, key->PCRInfo);
+
+	Trspi_Hash_STORE_PUBKEY(c, &key->pubKey);
+	/* exclude encSize, encData as spec'd in TPM 1.1b spec p.71 */
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_PRIVKEY_DIGEST(Trspi_HashCtx *c, TCPA_KEY *key)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_VERSION(c, (TSS_VERSION *)&key->ver);
+	result |= Trspi_Hash_UINT16(c, key->keyUsage);
+	result |= Trspi_Hash_KEY_FLAGS(c, &key->keyFlags);
+	result |= Trspi_Hash_BYTE(c, key->authDataUsage);
+	result |= Trspi_Hash_KEY_PARMS(c, &key->algorithmParms);
+
+	result |= Trspi_Hash_UINT32(c, key->PCRInfoSize);
+	/* exclude pcrInfo when PCRInfoSize is 0 as spec'd in TPM 1.1b spec p.71 */
+	if (key->PCRInfoSize != 0)
+		result |= Trspi_HashUpdate(c, key->PCRInfoSize, key->PCRInfo);
+
+	Trspi_Hash_STORE_PUBKEY(c, &key->pubKey);
+	/* exclude encSize, encData as spec'd in TPM 1.1b spec p.71 */
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_SYMMETRIC_KEY(Trspi_HashCtx *c, TCPA_SYMMETRIC_KEY *key)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT32(c, key->algId);
+	result |= Trspi_Hash_UINT16(c, key->encScheme);
+	result |= Trspi_Hash_UINT16(c, key->size);
+
+	if (key->size > 0)
+		result |= Trspi_HashUpdate(c, key->size, key->data);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_IDENTITY_REQ(Trspi_HashCtx *c, TCPA_IDENTITY_REQ *req)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT32(c, req->asymSize);
+	result |= Trspi_Hash_UINT32(c, req->symSize);
+	result |= Trspi_Hash_KEY_PARMS(c, &req->asymAlgorithm);
+	result |= Trspi_Hash_KEY_PARMS(c, &req->symAlgorithm);
+	result |= Trspi_HashUpdate(c, req->asymSize, req->asymBlob);
+	result |= Trspi_HashUpdate(c, req->symSize, req->symBlob);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_CHANGEAUTH_VALIDATE(Trspi_HashCtx *c, TPM_CHANGEAUTH_VALIDATE *caValidate)
+{
+	TSS_RESULT result;
+
+	result = Trspi_HashUpdate(c, TCPA_SHA1_160_HASH_LEN, caValidate->newAuthSecret.authdata);
+	result |= Trspi_HashUpdate(c, TCPA_SHA1_160_HASH_LEN, caValidate->n1.nonce);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_SYM_CA_ATTESTATION(Trspi_HashCtx *c, TCPA_SYM_CA_ATTESTATION *sym)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT32(c, sym->credSize);
+	result |= Trspi_Hash_KEY_PARMS(c, &sym->algorithm);
+	result |= Trspi_HashUpdate(c, sym->credSize, sym->credential);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_ASYM_CA_CONTENTS(Trspi_HashCtx *c, TCPA_ASYM_CA_CONTENTS *asym)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_SYMMETRIC_KEY(c, &asym->sessionKey);
+	result |= Trspi_HashUpdate(c, TCPA_SHA1_160_HASH_LEN, (BYTE *)&asym->idDigest);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_BOUND_DATA(Trspi_HashCtx *c, TCPA_BOUND_DATA *bd, UINT32 payloadLength)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_VERSION(c, (TSS_VERSION *)&bd->ver);
+	result |= Trspi_Hash_BYTE(c, bd->payload);
+	result |= Trspi_HashUpdate(c, payloadLength, bd->payloadData);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_TRANSPORT_AUTH(Trspi_HashCtx *c, TPM_TRANSPORT_AUTH *a)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT16(c, a->tag);
+	result |= Trspi_HashUpdate(c, TPM_SHA1_160_HASH_LEN, a->authData.authdata);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_TRANSPORT_LOG_IN(Trspi_HashCtx *c, TPM_TRANSPORT_LOG_IN *l)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT16(c, l->tag);
+	result |= Trspi_Hash_DIGEST(c, l->parameters.digest);
+	result |= Trspi_Hash_DIGEST(c, l->pubKeyHash.digest);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_TRANSPORT_LOG_OUT(Trspi_HashCtx *c, TPM_TRANSPORT_LOG_OUT *l)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT16(c, l->tag);
+	result |= Trspi_Hash_CURRENT_TICKS(c, &l->currentTicks);
+	result |= Trspi_Hash_DIGEST(c, l->parameters.digest);
+	result |= Trspi_Hash_UINT32(c, l->locality);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_CURRENT_TICKS(Trspi_HashCtx *c, TPM_CURRENT_TICKS *t)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT16(c, t->tag);
+	result |= Trspi_Hash_UINT64(c, t->currentTicks);
+	result |= Trspi_Hash_UINT16(c, t->tickRate);
+	result |= Trspi_Hash_NONCE(c, t->tickNonce.nonce);
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_Hash_SIGN_INFO(Trspi_HashCtx *c, TPM_SIGN_INFO *s)
+{
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT16(c, s->tag);
+	result |= Trspi_HashUpdate(c, 4, s->fixed);
+	result |= Trspi_Hash_NONCE(c, s->replay.nonce);
+	result |= Trspi_Hash_UINT32(c, s->dataLen);
+	result |= Trspi_HashUpdate(c, s->dataLen, s->data);
+
+	return result;
+}
+
+void
+Trspi_UnloadBlob_COUNTER_VALUE(UINT64 *offset, BYTE *blob, TPM_COUNTER_VALUE *ctr)
+{
+	if (!ctr) {
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		/* '4' is hard-coded in the spec */
+		Trspi_UnloadBlob(offset, 4, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+
+		return;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &ctr->tag, blob);
+	/* '4' is hard-coded in the spec */
+	Trspi_UnloadBlob(offset, 4, blob, (BYTE *)&ctr->label);
+	Trspi_UnloadBlob_UINT32(offset, &ctr->counter, blob);
+}
+
+void
+Trspi_LoadBlob_COUNTER_VALUE(UINT64 *offset, BYTE *blob, TPM_COUNTER_VALUE *ctr)
+{
+	Trspi_LoadBlob_UINT16(offset, ctr->tag, blob);
+	Trspi_LoadBlob(offset, 4, blob, (BYTE *)&ctr->label);
+	Trspi_LoadBlob_UINT32(offset, ctr->counter, blob);
+}
+
+void
+Trspi_UnloadBlob_CURRENT_TICKS(UINT64 *offset, BYTE *blob, TPM_CURRENT_TICKS *ticks)
+{
+	if (!ticks) {
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT64(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob(offset, sizeof(TPM_NONCE), blob, NULL);
+
+		return;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &ticks->tag, blob);
+	Trspi_UnloadBlob_UINT64(offset, &ticks->currentTicks, blob);
+	Trspi_UnloadBlob_UINT16(offset, &ticks->tickRate, blob);
+	Trspi_UnloadBlob(offset, sizeof(TPM_NONCE), blob, (BYTE *)&ticks->tickNonce);
+}
+
+void
+Trspi_UnloadBlob_TRANSPORT_PUBLIC(UINT64 *offset, BYTE *blob, TPM_TRANSPORT_PUBLIC *t)
+{
+	Trspi_UnloadBlob_UINT16(offset, &t->tag, blob);
+	Trspi_UnloadBlob_UINT32(offset, &t->transAttributes, blob);
+	Trspi_UnloadBlob_UINT32(offset, &t->algId, blob);
+	Trspi_UnloadBlob_UINT16(offset, &t->encScheme, blob);
+}
+
+void
+Trspi_LoadBlob_TRANSPORT_PUBLIC(UINT64 *offset, BYTE *blob, TPM_TRANSPORT_PUBLIC *t)
+{
+	Trspi_LoadBlob_UINT16(offset, t->tag, blob);
+	Trspi_LoadBlob_UINT32(offset, t->transAttributes, blob);
+	Trspi_LoadBlob_UINT32(offset, t->algId, blob);
+	Trspi_LoadBlob_UINT16(offset, t->encScheme, blob);
+}
+
+void
+Trspi_LoadBlob_TRANSPORT_AUTH(UINT64 *offset, BYTE *blob, TPM_TRANSPORT_AUTH *t)
+{
+	Trspi_LoadBlob_UINT16(offset, t->tag, blob);
+	Trspi_LoadBlob(offset, TPM_SHA1_160_HASH_LEN, blob, t->authData.authdata);
+}
+
+void
+Trspi_LoadBlob_SIGN_INFO(UINT64 *offset, BYTE *blob, TPM_SIGN_INFO *s)
+{
+	Trspi_LoadBlob_UINT16(offset, s->tag, blob);
+	Trspi_LoadBlob(offset, 4, blob, s->fixed);
+	Trspi_LoadBlob(offset, TPM_SHA1_160_HASH_LEN, blob, s->replay.nonce);
+	Trspi_LoadBlob_UINT32(offset, s->dataLen, blob);
+	Trspi_LoadBlob(offset, s->dataLen, blob, s->data);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_CERTIFY_INFO(UINT64 *offset, BYTE *blob, TPM_CERTIFY_INFO *c)
+{
+	TSS_RESULT result;
+
+	if (!c) {
+		UINT32 pcrInfoSize;
+
+		Trspi_UnloadBlob_VERSION(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_KEY_PARMS(offset, blob, NULL);
+		Trspi_UnloadBlob_DIGEST(offset, blob, NULL);
+		Trspi_UnloadBlob_NONCE(offset, blob, NULL);
+		Trspi_UnloadBlob_BOOL(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, &pcrInfoSize, blob);
+
+		(*offset) += pcrInfoSize;
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_VERSION(offset, blob, &c->version);
+	Trspi_UnloadBlob_UINT16(offset, &c->keyUsage, blob);
+	Trspi_UnloadBlob_UINT32(offset, &c->keyFlags, blob);
+	Trspi_UnloadBlob_BYTE(offset, &c->authDataUsage, blob);
+	if ((result = Trspi_UnloadBlob_KEY_PARMS(offset, blob, &c->algorithmParms)))
+		return result;
+	Trspi_UnloadBlob_DIGEST(offset, blob, &c->pubkeyDigest);
+	Trspi_UnloadBlob_NONCE(offset, blob, &c->data);
+	Trspi_UnloadBlob_BOOL(offset, (TSS_BOOL *)&c->parentPCRStatus, blob);
+	Trspi_UnloadBlob_UINT32(offset, &c->PCRInfoSize, blob);
+        if (c->PCRInfoSize != 0) {
+                c->PCRInfo = malloc(sizeof(TPM_PCR_INFO));
+                if (c->PCRInfo == NULL) {
+                        LogError("malloc of %lu bytes failed.", sizeof(TPM_PCR_INFO));
+                        return TSPERR(TSS_E_OUTOFMEMORY);
+                }
+        } else {
+                c->PCRInfo = NULL;
+        }
+        Trspi_UnloadBlob_PCR_INFO(offset, blob, (TPM_PCR_INFO *)c->PCRInfo);
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_UnloadBlob_TPM_FAMILY_LABEL(UINT64 *offset, BYTE *blob, TPM_FAMILY_LABEL *label)
+{
+	if (!label) {
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+
+		return;
+	}
+
+	Trspi_UnloadBlob_BYTE(offset, &label->label, blob);
+}
+
+void
+Trspi_LoadBlob_TPM_FAMILY_LABEL(UINT64 *offset, BYTE *blob, TPM_FAMILY_LABEL *label)
+{
+	Trspi_LoadBlob_BYTE(offset, label->label, blob);
+}
+
+void
+Trspi_UnloadBlob_TPM_FAMILY_TABLE_ENTRY(UINT64 *offset, BYTE *blob, TPM_FAMILY_TABLE_ENTRY *entry)
+{
+	if (!entry) {
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_TPM_FAMILY_LABEL(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+
+		return;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &entry->tag, blob);
+	Trspi_UnloadBlob_TPM_FAMILY_LABEL(offset, blob, &entry->label);
+	Trspi_UnloadBlob_UINT32(offset, &entry->familyID, blob);
+	Trspi_UnloadBlob_UINT32(offset, &entry->verificationCount, blob);
+	Trspi_UnloadBlob_UINT32(offset, &entry->flags, blob);
+}
+
+void
+Trspi_LoadBlob_TPM_FAMILY_TABLE_ENTRY(UINT64 *offset, BYTE *blob, TPM_FAMILY_TABLE_ENTRY *entry)
+{
+	Trspi_LoadBlob_UINT16(offset, entry->tag, blob);
+	Trspi_LoadBlob_TPM_FAMILY_LABEL(offset, blob, &entry->label);
+	Trspi_LoadBlob_UINT32(offset, entry->familyID, blob);
+	Trspi_LoadBlob_UINT32(offset, entry->verificationCount, blob);
+	Trspi_LoadBlob_UINT32(offset, entry->flags, blob);
+}
+
+void
+Trspi_UnloadBlob_TPM_DELEGATE_LABEL(UINT64 *offset, BYTE *blob, TPM_DELEGATE_LABEL *label)
+{
+	if (!label) {
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+
+		return;
+	}
+
+	Trspi_UnloadBlob_BYTE(offset, &label->label, blob);
+}
+
+void
+Trspi_LoadBlob_TPM_DELEGATE_LABEL(UINT64 *offset, BYTE *blob, TPM_DELEGATE_LABEL *label)
+{
+	Trspi_LoadBlob_BYTE(offset, label->label, blob);
+}
+
+void
+Trspi_UnloadBlob_TPM_DELEGATIONS(UINT64 *offset, BYTE *blob, TPM_DELEGATIONS *delegations)
+{
+	if (!delegations) {
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+
+		return;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &delegations->tag, blob);
+	Trspi_UnloadBlob_UINT32(offset, &delegations->delegateType, blob);
+	Trspi_UnloadBlob_UINT32(offset, &delegations->per1, blob);
+	Trspi_UnloadBlob_UINT32(offset, &delegations->per2, blob);
+}
+
+void
+Trspi_LoadBlob_TPM_DELEGATIONS(UINT64 *offset, BYTE *blob, TPM_DELEGATIONS *delegations)
+{
+	Trspi_LoadBlob_UINT16(offset, delegations->tag, blob);
+	Trspi_LoadBlob_UINT32(offset, delegations->delegateType, blob);
+	Trspi_LoadBlob_UINT32(offset, delegations->per1, blob);
+	Trspi_LoadBlob_UINT32(offset, delegations->per2, blob);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_TPM_DELEGATE_PUBLIC(UINT64 *offset, BYTE *blob, TPM_DELEGATE_PUBLIC *pub)
+{
+	TSS_RESULT result;
+
+	if (!pub) {
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_TPM_DELEGATE_LABEL(offset, blob, NULL);
+		(void)Trspi_UnloadBlob_PCR_INFO_SHORT(offset, blob, NULL);
+		Trspi_UnloadBlob_TPM_DELEGATIONS(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &pub->tag, blob);
+	Trspi_UnloadBlob_TPM_DELEGATE_LABEL(offset, blob, &pub->label);
+	if ((result = Trspi_UnloadBlob_PCR_INFO_SHORT(offset, blob, &pub->pcrInfo)))
+		return result;
+	Trspi_UnloadBlob_TPM_DELEGATIONS(offset, blob, &pub->permissions);
+	Trspi_UnloadBlob_UINT32(offset, &pub->familyID, blob);
+	Trspi_UnloadBlob_UINT32(offset, &pub->verificationCount, blob);
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_TPM_DELEGATE_PUBLIC(UINT64 *offset, BYTE *blob, TPM_DELEGATE_PUBLIC *pub)
+{
+	Trspi_LoadBlob_UINT16(offset, pub->tag, blob);
+	Trspi_LoadBlob_TPM_DELEGATE_LABEL(offset, blob, &pub->label);
+	Trspi_LoadBlob_PCR_INFO_SHORT(offset, blob, &pub->pcrInfo);
+	Trspi_LoadBlob_TPM_DELEGATIONS(offset, blob, &pub->permissions);
+	Trspi_LoadBlob_UINT32(offset, pub->familyID, blob);
+	Trspi_LoadBlob_UINT32(offset, pub->verificationCount, blob);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_TPM_DELEGATE_OWNER_BLOB(UINT64 *offset, BYTE *blob, TPM_DELEGATE_OWNER_BLOB *owner)
+{
+	TSS_RESULT result;
+
+	if (!owner) {
+		UINT32 additionalSize, sensitiveSize;
+
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		(void)Trspi_UnloadBlob_TPM_DELEGATE_PUBLIC(offset, blob, NULL);
+		Trspi_UnloadBlob_DIGEST(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, &additionalSize, blob);
+		(void)Trspi_UnloadBlob(offset, additionalSize, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, &sensitiveSize, blob);
+		(void)Trspi_UnloadBlob(offset, sensitiveSize, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &owner->tag, blob);
+	if ((result = Trspi_UnloadBlob_TPM_DELEGATE_PUBLIC(offset, blob, &owner->pub)))
+		return result;
+	Trspi_UnloadBlob_DIGEST(offset, blob, &owner->integrityDigest);
+	Trspi_UnloadBlob_UINT32(offset, &owner->additionalSize, blob);
+	if (owner->additionalSize > 0) {
+		owner->additionalArea = malloc(owner->additionalSize);
+		if (owner->additionalArea == NULL) {
+			LogError("malloc of %u bytes failed.", owner->additionalSize);
+			free(owner->pub.pcrInfo.pcrSelection.pcrSelect);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, owner->additionalSize, blob, owner->additionalArea);
+	}
+	Trspi_UnloadBlob_UINT32(offset, &owner->sensitiveSize, blob);
+	if (owner->sensitiveSize > 0) {
+		owner->sensitiveArea = malloc(owner->sensitiveSize);
+		if (owner->sensitiveArea == NULL) {
+			LogError("malloc of %u bytes failed.", owner->sensitiveSize);
+			free(owner->pub.pcrInfo.pcrSelection.pcrSelect);
+			free(owner->additionalArea);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, owner->sensitiveSize, blob, owner->sensitiveArea);
+	}
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_TPM_DELEGATE_OWNER_BLOB(UINT64 *offset, BYTE *blob, TPM_DELEGATE_OWNER_BLOB *owner)
+{
+	Trspi_LoadBlob_UINT16(offset, owner->tag, blob);
+	Trspi_LoadBlob_TPM_DELEGATE_PUBLIC(offset, blob, &owner->pub);
+	Trspi_LoadBlob_DIGEST(offset, blob, &owner->integrityDigest);
+	Trspi_LoadBlob_UINT32(offset, owner->additionalSize, blob);
+	Trspi_LoadBlob(offset, owner->additionalSize, blob, owner->additionalArea);
+	Trspi_LoadBlob_UINT32(offset, owner->sensitiveSize, blob);
+	Trspi_LoadBlob(offset, owner->sensitiveSize, blob, owner->sensitiveArea);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_TPM_DELEGATE_KEY_BLOB(UINT64 *offset, BYTE *blob, TPM_DELEGATE_KEY_BLOB *key)
+{
+	TSS_RESULT result;
+
+	if (!key) {
+		UINT32 additionalSize, sensitiveSize;
+
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		(void)Trspi_UnloadBlob_TPM_DELEGATE_PUBLIC(offset, blob, NULL);
+		Trspi_UnloadBlob_DIGEST(offset, blob, NULL);
+		Trspi_UnloadBlob_DIGEST(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, &additionalSize, blob);
+		(void)Trspi_UnloadBlob(offset, additionalSize, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, &sensitiveSize, blob);
+		(void)Trspi_UnloadBlob(offset, sensitiveSize, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &key->tag, blob);
+	if ((result = Trspi_UnloadBlob_TPM_DELEGATE_PUBLIC(offset, blob, &key->pub)))
+		return result;
+	Trspi_UnloadBlob_DIGEST(offset, blob, &key->integrityDigest);
+	Trspi_UnloadBlob_DIGEST(offset, blob, &key->pubKeyDigest);
+	Trspi_UnloadBlob_UINT32(offset, &key->additionalSize, blob);
+	if (key->additionalSize > 0) {
+		key->additionalArea = malloc(key->additionalSize);
+		if (key->additionalArea == NULL) {
+			LogError("malloc of %u bytes failed.", key->additionalSize);
+			free(key->pub.pcrInfo.pcrSelection.pcrSelect);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, key->additionalSize, blob, key->additionalArea);
+	}
+	Trspi_UnloadBlob_UINT32(offset, &key->sensitiveSize, blob);
+	if (key->sensitiveSize > 0) {
+		key->sensitiveArea = malloc(key->sensitiveSize);
+		if (key->sensitiveArea == NULL) {
+			LogError("malloc of %u bytes failed.", key->sensitiveSize);
+			free(key->pub.pcrInfo.pcrSelection.pcrSelect);
+			free(key->additionalArea);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, key->sensitiveSize, blob, key->sensitiveArea);
+	}
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_TPM_DELEGATE_KEY_BLOB(UINT64 *offset, BYTE *blob, TPM_DELEGATE_KEY_BLOB *key)
+{
+	Trspi_LoadBlob_UINT16(offset, key->tag, blob);
+	Trspi_LoadBlob_TPM_DELEGATE_PUBLIC(offset, blob, &key->pub);
+	Trspi_LoadBlob_DIGEST(offset, blob, &key->integrityDigest);
+	Trspi_LoadBlob_DIGEST(offset, blob, &key->pubKeyDigest);
+	Trspi_LoadBlob_UINT32(offset, key->additionalSize, blob);
+	Trspi_LoadBlob(offset, key->additionalSize, blob, key->additionalArea);
+	Trspi_LoadBlob_UINT32(offset, key->sensitiveSize, blob);
+	Trspi_LoadBlob(offset, key->sensitiveSize, blob, key->sensitiveArea);
+}
+
+void
+Trspi_UnloadBlob_TSS_FAMILY_TABLE_ENTRY(UINT64 *offset, BYTE *blob, TSS_FAMILY_TABLE_ENTRY *entry)
+{
+	if (!entry) {
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_BOOL(offset, NULL, blob);
+		Trspi_UnloadBlob_BOOL(offset, NULL, blob);
+
+		return;
+	}
+
+	Trspi_UnloadBlob_UINT32(offset, &entry->familyID, blob);
+	Trspi_UnloadBlob_BYTE(offset, &entry->label, blob);
+	Trspi_UnloadBlob_UINT32(offset, &entry->verificationCount, blob);
+	Trspi_UnloadBlob_BOOL(offset, &entry->enabled, blob);
+	Trspi_UnloadBlob_BOOL(offset, &entry->locked, blob);
+}
+
+void
+Trspi_LoadBlob_TSS_FAMILY_TABLE_ENTRY(UINT64 *offset, BYTE *blob, TSS_FAMILY_TABLE_ENTRY *entry)
+{
+	Trspi_LoadBlob_UINT32(offset, entry->familyID, blob);
+	Trspi_LoadBlob_BYTE(offset, entry->label, blob);
+	Trspi_LoadBlob_UINT32(offset, entry->verificationCount, blob);
+	Trspi_LoadBlob_BOOL(offset, entry->enabled, blob);
+	Trspi_LoadBlob_BOOL(offset, entry->locked, blob);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_TSS_PCR_INFO_SHORT(UINT64 *offset, BYTE *blob, TSS_PCR_INFO_SHORT *pcr)
+{
+	if (!pcr) {
+		UINT32 sizeOfSelect, sizeOfDigestAtRelease;
+
+		Trspi_UnloadBlob_UINT32(offset, &sizeOfSelect, blob);
+		(void)Trspi_UnloadBlob(offset, sizeOfSelect, blob, NULL);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, &sizeOfDigestAtRelease, blob);
+		(void)Trspi_UnloadBlob(offset, sizeOfDigestAtRelease, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT32(offset, &pcr->sizeOfSelect, blob);
+	if (pcr->sizeOfSelect > 0) {
+		pcr->selection = malloc(pcr->sizeOfSelect);
+		if (pcr->selection == NULL) {
+			LogError("malloc of %u bytes failed.", pcr->sizeOfSelect);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, pcr->sizeOfSelect, blob, pcr->selection);
+	} else {
+		pcr->selection = NULL;
+	}
+	Trspi_UnloadBlob_BYTE(offset, &pcr->localityAtRelease, blob);
+	Trspi_UnloadBlob_UINT32(offset, &pcr->sizeOfDigestAtRelease, blob);
+	if (pcr->sizeOfDigestAtRelease > 0) {
+		pcr->digestAtRelease = malloc(pcr->sizeOfDigestAtRelease);
+		if (pcr->digestAtRelease == NULL) {
+			LogError("malloc of %u bytes failed.", pcr->sizeOfDigestAtRelease);
+			free(pcr->selection);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+		Trspi_UnloadBlob(offset, pcr->sizeOfDigestAtRelease, blob, pcr->digestAtRelease);
+	} else {
+		pcr->digestAtRelease = NULL;
+	}
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_TSS_PCR_INFO_SHORT(UINT64 *offset, BYTE *blob, TSS_PCR_INFO_SHORT *pcr)
+{
+	Trspi_LoadBlob_UINT32(offset, pcr->sizeOfSelect, blob);
+	Trspi_LoadBlob(offset, pcr->sizeOfSelect, blob, pcr->selection);
+	Trspi_LoadBlob_BYTE(offset, pcr->localityAtRelease, blob);
+	Trspi_LoadBlob_UINT32(offset, pcr->sizeOfDigestAtRelease, blob);
+	Trspi_LoadBlob(offset, pcr->sizeOfDigestAtRelease, blob, pcr->digestAtRelease);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_TSS_DELEGATION_TABLE_ENTRY(UINT64 *offset, BYTE *blob,
+					    TSS_DELEGATION_TABLE_ENTRY *entry)
+{
+	TSS_RESULT result;
+
+	if (!entry) {
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		(void)Trspi_UnloadBlob_TSS_PCR_INFO_SHORT(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT32(offset, &entry->tableIndex, blob);
+	Trspi_UnloadBlob_BYTE(offset, &entry->label, blob);
+	if ((result = Trspi_UnloadBlob_TSS_PCR_INFO_SHORT(offset, blob, &entry->pcrInfo)))
+		return result;
+	Trspi_UnloadBlob_UINT32(offset, &entry->per1, blob);
+	Trspi_UnloadBlob_UINT32(offset, &entry->per2, blob);
+	Trspi_UnloadBlob_UINT32(offset, &entry->familyID, blob);
+	Trspi_UnloadBlob_UINT32(offset, &entry->verificationCount, blob);
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_TSS_DELEGATION_TABLE_ENTRY(UINT64 *offset, BYTE *blob,
+					  TSS_DELEGATION_TABLE_ENTRY *entry)
+{
+	Trspi_LoadBlob_UINT32(offset, entry->tableIndex, blob);
+	Trspi_LoadBlob_BYTE(offset, entry->label, blob);
+	Trspi_LoadBlob_TSS_PCR_INFO_SHORT(offset, blob, &entry->pcrInfo);
+	Trspi_LoadBlob_UINT32(offset, entry->per1, blob);
+	Trspi_LoadBlob_UINT32(offset, entry->per2, blob);
+	Trspi_LoadBlob_UINT32(offset, entry->familyID, blob);
+	Trspi_LoadBlob_UINT32(offset, entry->verificationCount, blob);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_PCR_COMPOSITE(UINT64 *offset, BYTE *blob, TCPA_PCR_COMPOSITE *out)
+{
+	TSS_RESULT result;
+
+	if (!out) {
+		UINT32 valueSize;
+
+		Trspi_UnloadBlob_PCR_SELECTION(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT32(offset, &valueSize, blob);
+		Trspi_UnloadBlob(offset, valueSize, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	if ((result = Trspi_UnloadBlob_PCR_SELECTION(offset, blob, &out->select)))
+		return result;
+
+	Trspi_UnloadBlob_UINT32(offset, &out->valueSize, blob);
+	out->pcrValue = malloc(out->valueSize);
+	if (out->pcrValue == NULL) {
+		LogError("malloc of %u bytes failed.", out->valueSize);
+		return TSPERR(TSS_E_OUTOFMEMORY);
+	}
+	Trspi_UnloadBlob(offset, out->valueSize, blob, (BYTE *)out->pcrValue);
+
+	return TSS_SUCCESS;
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_MIGRATIONKEYAUTH(UINT64 *offset, BYTE *blob, TPM_MIGRATIONKEYAUTH *migAuth)
+{
+	TSS_RESULT result;
+
+	if (!migAuth) {
+		(void)Trspi_UnloadBlob_PUBKEY(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_DIGEST(offset, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+
+	if ((result = Trspi_UnloadBlob_PUBKEY(offset, blob, &migAuth->migrationKey)))
+		return result;
+
+	Trspi_UnloadBlob_UINT16(offset, &migAuth->migrationScheme, blob);
+	Trspi_UnloadBlob_DIGEST(offset, blob, &migAuth->digest);
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_MIGRATIONKEYAUTH(UINT64 *offset, BYTE *blob, TPM_MIGRATIONKEYAUTH *migAuth)
+{
+	Trspi_LoadBlob_PUBKEY(offset, blob, &migAuth->migrationKey);
+	Trspi_LoadBlob_UINT16(offset, migAuth->migrationScheme, blob);
+	Trspi_LoadBlob_DIGEST(offset, blob, &migAuth->digest);
+}
+
+void
+Trspi_LoadBlob_MSA_COMPOSITE(UINT64 *offset, BYTE *blob, TPM_MSA_COMPOSITE *msaComp)
+{
+	UINT32 i;
+
+	Trspi_LoadBlob_UINT32(offset, msaComp->MSAlist, blob);
+	for (i = 0; i < msaComp->MSAlist; i++)
+		Trspi_LoadBlob_DIGEST(offset, blob, &msaComp->migAuthDigest[i]);
+}
+
+void
+Trspi_LoadBlob_CMK_AUTH(UINT64 *offset, BYTE *blob, TPM_CMK_AUTH *cmkAuth)
+{
+	Trspi_LoadBlob_DIGEST(offset, blob, &cmkAuth->migrationAuthorityDigest);
+	Trspi_LoadBlob_DIGEST(offset, blob, &cmkAuth->destinationKeyDigest);
+	Trspi_LoadBlob_DIGEST(offset, blob, &cmkAuth->sourceKeyDigest);
+}
+
+TSS_RESULT
+Trspi_Hash_MSA_COMPOSITE(Trspi_HashCtx *c, TPM_MSA_COMPOSITE *m)
+{
+	UINT32 i;
+	TPM_DIGEST *digest;
+	TSS_RESULT result;
+
+	result = Trspi_Hash_UINT32(c, m->MSAlist);
+	digest = m->migAuthDigest;
+	for (i = 0; i < m->MSAlist; i++) {
+		result |= Trspi_Hash_DIGEST(c, digest->digest);
+		digest++;
+	}
+
+	return result;
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_TSS_PLATFORM_CLASS(UINT64 *offset, BYTE *blob, TSS_PLATFORM_CLASS *platClass)
+{
+	if (!platClass){
+		UINT32 classURISize;
+
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, &classURISize, blob);
+		Trspi_UnloadBlob(offset, classURISize, blob, NULL);
+
+		return TSS_SUCCESS;
+	}
+	Trspi_UnloadBlob_UINT32(offset, &platClass->platformClassSimpleIdentifier, blob);
+	Trspi_UnloadBlob_UINT32(offset, &platClass->platformClassURISize, blob);
+
+	platClass->pPlatformClassURI = malloc(platClass->platformClassURISize);
+	if (platClass->pPlatformClassURI == NULL) {
+		LogError("malloc of %u bytes failed.", platClass->platformClassURISize);
+		return TSPERR(TSS_E_OUTOFMEMORY);
+	}
+	Trspi_UnloadBlob(offset, platClass->platformClassURISize, blob,
+			 (BYTE *)platClass->pPlatformClassURI);
+
+	return TSS_SUCCESS;
+}
+
+void
+Trspi_LoadBlob_CAP_VERSION_INFO(UINT64 *offset, BYTE *blob, TPM_CAP_VERSION_INFO *v)
+{
+	Trspi_LoadBlob_UINT16(offset, v->tag, blob);
+	Trspi_LoadBlob_TCPA_VERSION(offset, blob, *(TCPA_VERSION *)(&v->version));
+	Trspi_LoadBlob_UINT16(offset, v->specLevel, blob);
+	Trspi_LoadBlob_BYTE(offset, v->errataRev, blob);
+	Trspi_LoadBlob(offset, sizeof(v->tpmVendorID), blob, v->tpmVendorID);
+	Trspi_LoadBlob_UINT16(offset, v->vendorSpecificSize, blob);
+	Trspi_LoadBlob(offset, v->vendorSpecificSize, blob, v->vendorSpecific);
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_CAP_VERSION_INFO(UINT64 *offset, BYTE *blob, TPM_CAP_VERSION_INFO *v)
+{
+	if (!v) {
+		UINT16 vendorSpecificSize;
+
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_VERSION(offset, blob, NULL);
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob(offset, 4, blob, NULL);
+		Trspi_UnloadBlob_UINT16(offset, &vendorSpecificSize, blob);
+
+		(*offset) += vendorSpecificSize;
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &v->tag, blob);
+	Trspi_UnloadBlob_VERSION(offset, blob, (TCPA_VERSION *)&v->version);
+	Trspi_UnloadBlob_UINT16(offset, &v->specLevel, blob);
+	Trspi_UnloadBlob_BYTE(offset, &v->errataRev, blob);
+	Trspi_UnloadBlob(offset, sizeof(v->tpmVendorID), blob, v->tpmVendorID);
+	Trspi_UnloadBlob_UINT16(offset, &v->vendorSpecificSize, blob);
+
+	if (v->vendorSpecificSize > 0) {
+		if ((v->vendorSpecific = malloc(v->vendorSpecificSize)) == NULL) {
+			LogError("malloc of %u bytes failed.", v->vendorSpecificSize);
+			return TSPERR(TSS_E_OUTOFMEMORY);
+		}
+
+		Trspi_UnloadBlob(offset, v->vendorSpecificSize, blob, v->vendorSpecific);
+	} else {
+		v->vendorSpecific = NULL;
+	}
+
+	return TSS_SUCCESS;
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_NV_INDEX(UINT64 *offset, BYTE *blob, TPM_NV_INDEX *v)
+{
+	if (!v) {
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT32(offset, v, blob);
+
+	return TSS_SUCCESS;
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_NV_ATTRIBUTES(UINT64 *offset, BYTE *blob, TPM_NV_ATTRIBUTES *v)
+{
+	if (!v) {
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &v->tag, blob);
+	Trspi_UnloadBlob_UINT32(offset, &v->attributes, blob);
+
+	return TSS_SUCCESS;
+}
+
+TSS_RESULT
+Trspi_UnloadBlob_NV_DATA_PUBLIC(UINT64 *offset, BYTE *blob, TPM_NV_DATA_PUBLIC *v)
+{
+	if (!v) {
+		Trspi_UnloadBlob_UINT16(offset, NULL, blob);
+		Trspi_UnloadBlob_NV_INDEX(offset, blob, NULL);
+		Trspi_UnloadBlob_PCR_INFO_SHORT(offset, blob, NULL);
+		Trspi_UnloadBlob_PCR_INFO_SHORT(offset, blob, NULL);
+		Trspi_UnloadBlob_NV_ATTRIBUTES(offset, blob, NULL);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_BYTE(offset, NULL, blob);
+		Trspi_UnloadBlob_UINT32(offset, NULL, blob);
+
+		return TSS_SUCCESS;
+	}
+
+	Trspi_UnloadBlob_UINT16(offset, &v->tag, blob);
+	Trspi_UnloadBlob_NV_INDEX(offset, blob, &v->nvIndex);
+	Trspi_UnloadBlob_PCR_INFO_SHORT(offset, blob, &v->pcrInfoRead);
+	Trspi_UnloadBlob_PCR_INFO_SHORT(offset, blob, &v->pcrInfoWrite);
+	Trspi_UnloadBlob_NV_ATTRIBUTES(offset, blob, &v->permission);
+	Trspi_UnloadBlob_BYTE(offset, &v->bReadSTClear, blob);
+	Trspi_UnloadBlob_BYTE(offset, &v->bWriteSTClear, blob);
+	Trspi_UnloadBlob_BYTE(offset, &v->bWriteDefine, blob);
+	Trspi_UnloadBlob_UINT32(offset, &v->dataSize, blob);
+
+	return TSS_SUCCESS;
+}