~ubuntu-branches/ubuntu/karmic/trousers/karmic

Viewing changes to src/tspi/obj_migdata.c

Committer: Bazaar Package Importer
Author(s): Daniel Baumann
Date: 2008-01-23 22:03:00 UTC
mfrom: (1.1.1 upstream)
Revision ID: james.westby@ubuntu.com-20080123220300-fhtqja3c0oq0gp6z

Tags: 0.3.1-4

http://bugs.debian.org/457400

http://bugs.debian.org/459682

* Added patch from Aaron M. Ucko <ucko@debian.org> to allow trousers to
  build successfully on amd64, and presumably also other 64-bit
  architectures (Closes: #457400).
* Including udev rule for /dev/tpm from William Lima
  <wlima.amadeus@gmail.com> as suggested by David Smith <dds@google.com>
  (Closes: #459682).
* Added lintian overrides.

files added:
debian/TODO

debian/config

debian/config/45-trousers.rules

debian/libtspi-dev.docs

debian/lintian

debian/lintian/libtspi1

debian/lintian/trousers

debian/patches/01-tss-user.dpatch

debian/patches/02-manapge.dpatch

debian/patches/03-readme.dpatch

debian/patches/04-64bit-cleanliness.dpatch

debian/trousers.examples

man/man3/Tspi_Context_GetRegisteredKeysByUUID2.3

man/man3/Tspi_DAA_IssueCredential.3

man/man3/Tspi_DAA_IssueInit.3

man/man3/Tspi_DAA_IssueSetup.3

man/man3/Tspi_DAA_IssuerKeyVerification.3

man/man3/Tspi_DAA_VerifyInit.3

man/man3/Tspi_DAA_VerifySignature.3

man/man3/Tspi_DecodeBER_TssBlob.3

man/man3/Tspi_EncodeDER_TssBlob.3

man/man3/Tspi_TPM_DAA_JoinCreateDaaPubKey.3

man/man3/Tspi_TPM_DAA_JoinInit.3

man/man3/Tspi_TPM_DAA_JoinStoreCredential.3

man/man3/Tspi_TPM_DAA_Sign.3

man/man3/Tspi_TPM_GetAuditDigest.3

man/man3/Tspi_TPM_OwnerGetSRKPubKey.3

man/man3/Tspi_TPM_Quote2.3

src/include/authsess.h

src/include/obj_context.h

src/include/obj_daa.h

src/include/obj_delfamily.h

src/include/obj_encdata.h

src/include/obj_hash.h

src/include/obj_migdata.h

src/include/obj_nv.h

src/include/obj_pcrs.h

src/include/obj_policy.h

src/include/obj_rsakey.h

src/include/obj_tpm.h

src/include/rpc_tcstp.h

src/include/rpc_tcstp_tcs.h

src/include/rpc_tcstp_tsp.h

src/include/tcs_aik.h

src/include/tcs_context.h

src/include/tcs_key_ps.h

src/include/threads.h

src/include/tsp_audit.h

src/include/tsp_delegate.h

src/include/tsp_seal.h

src/include/tss/TSP.idl

src/include/tss/compat11b.h

src/include/tss/tcs.h

src/include/tss/tcs_defines.h

src/include/tss/tpm.h

src/include/tss/tpm_error.h

src/include/tss/tpm_ordinal.h

src/tcs/crypto

src/tcs/crypto/openssl

src/tcs/crypto/openssl/crypto.c

src/tcs/rpc

src/tcs/rpc/tcstp

src/tcs/rpc/tcstp/rpc.c

src/tcs/rpc/tcstp/rpc_admin.c

src/tcs/rpc/tcstp/rpc_aik.c

src/tcs/rpc/tcstp/rpc_audit.c

src/tcs/rpc/tcstp/rpc_auth.c

src/tcs/rpc/tcstp/rpc_bind.c

src/tcs/rpc/tcstp/rpc_caps.c

src/tcs/rpc/tcstp/rpc_caps_tpm.c

src/tcs/rpc/tcstp/rpc_certify.c

src/tcs/rpc/tcstp/rpc_changeauth.c

src/tcs/rpc/tcstp/rpc_cmk.c

src/tcs/rpc/tcstp/rpc_context.c

src/tcs/rpc/tcstp/rpc_counter.c

src/tcs/rpc/tcstp/rpc_daa.c

src/tcs/rpc/tcstp/rpc_delegate.c

src/tcs/rpc/tcstp/rpc_dir.c

src/tcs/rpc/tcstp/rpc_ek.c

src/tcs/rpc/tcstp/rpc_evlog.c

src/tcs/rpc/tcstp/rpc_key.c

src/tcs/rpc/tcstp/rpc_maint.c

src/tcs/rpc/tcstp/rpc_migration.c

src/tcs/rpc/tcstp/rpc_nv.c

src/tcs/rpc/tcstp/rpc_oper.c

src/tcs/rpc/tcstp/rpc_own.c

src/tcs/rpc/tcstp/rpc_pcr_extend.c

src/tcs/rpc/tcstp/rpc_ps.c

src/tcs/rpc/tcstp/rpc_quote.c

src/tcs/rpc/tcstp/rpc_quote2.c

src/tcs/rpc/tcstp/rpc_random.c

src/tcs/rpc/tcstp/rpc_seal.c

src/tcs/rpc/tcstp/rpc_selftest.c

src/tcs/rpc/tcstp/rpc_sign.c

src/tcs/rpc/tcstp/rpc_tick.c

src/tcs/rpc/tcstp/rpc_transport.c

src/tcs/tcs_aik.c

src/tcs/tcs_auth_mgr.c

src/tcs/tcs_caps.c

src/tcs/tcs_context.c

src/tcs/tcs_context_key.c

src/tcs/tcs_counter.c

src/tcs/tcs_evlog.c

src/tcs/tcs_evlog_biosem.c

src/tcs/tcs_evlog_imaem.c

src/tcs/tcs_key.c

src/tcs/tcs_key_mem_cache.c

src/tcs/tcs_key_ps.c

src/tcs/tcs_migration.c

src/tcs/tcs_pbg.c

src/tcs/tcs_ps.c

src/tcs/tcs_quote.c

src/tcs/tcs_quote2.c

src/tcs/tcs_req_mgr.c

src/tcs/tcs_seal.c

src/tcs/tcsi_admin.c

src/tcs/tcsi_aik.c

src/tcs/tcsi_audit.c

src/tcs/tcsi_auth.c

src/tcs/tcsi_bind.c

src/tcs/tcsi_caps.c

src/tcs/tcsi_caps_tpm.c

src/tcs/tcsi_certify.c

src/tcs/tcsi_changeauth.c

src/tcs/tcsi_cmk.c

src/tcs/tcsi_context.c

src/tcs/tcsi_counter.c

src/tcs/tcsi_daa.c

src/tcs/tcsi_delegate.c

src/tcs/tcsi_dir.c

src/tcs/tcsi_ek.c

src/tcs/tcsi_evlog.c

src/tcs/tcsi_key.c

src/tcs/tcsi_maint.c

src/tcs/tcsi_migration.c

src/tcs/tcsi_nv.c

src/tcs/tcsi_oper.c

src/tcs/tcsi_own.c

src/tcs/tcsi_pcr.c

src/tcs/tcsi_ps.c

src/tcs/tcsi_quote.c

src/tcs/tcsi_quote2.c

src/tcs/tcsi_random.c

src/tcs/tcsi_seal.c

src/tcs/tcsi_selftest.c

src/tcs/tcsi_sign.c

src/tcs/tcsi_tick.c

src/tcs/tcsi_transport.c

src/trspi/crypto/openssl/hash.c

src/trspi/crypto/openssl/rsa.c

src/trspi/crypto/openssl/symmetric.c

src/tspi/obj_daa.c

src/tspi/obj_delfamily.c

src/tspi/obj_migdata.c

src/tspi/obj_nv.c

src/tspi/rpc

src/tspi/rpc/hosttable.c

src/tspi/rpc/tcs_api.c

src/tspi/rpc/tcstp

src/tspi/rpc/tcstp/rpc.c

src/tspi/rpc/tcstp/rpc_admin.c

src/tspi/rpc/tcstp/rpc_aik.c

src/tspi/rpc/tcstp/rpc_audit.c

src/tspi/rpc/tcstp/rpc_auth.c

src/tspi/rpc/tcstp/rpc_bind.c

src/tspi/rpc/tcstp/rpc_caps.c

src/tspi/rpc/tcstp/rpc_caps_tpm.c

src/tspi/rpc/tcstp/rpc_certify.c

src/tspi/rpc/tcstp/rpc_changeauth.c

src/tspi/rpc/tcstp/rpc_cmk.c

src/tspi/rpc/tcstp/rpc_context.c

src/tspi/rpc/tcstp/rpc_counter.c

src/tspi/rpc/tcstp/rpc_daa.c

src/tspi/rpc/tcstp/rpc_delegate.c

src/tspi/rpc/tcstp/rpc_dir.c

src/tspi/rpc/tcstp/rpc_ek.c

src/tspi/rpc/tcstp/rpc_evlog.c

src/tspi/rpc/tcstp/rpc_key.c

src/tspi/rpc/tcstp/rpc_maint.c

src/tspi/rpc/tcstp/rpc_migration.c

src/tspi/rpc/tcstp/rpc_nv.c

src/tspi/rpc/tcstp/rpc_oper.c

src/tspi/rpc/tcstp/rpc_own.c

src/tspi/rpc/tcstp/rpc_pcr_extend.c

src/tspi/rpc/tcstp/rpc_ps.c

src/tspi/rpc/tcstp/rpc_quote.c

src/tspi/rpc/tcstp/rpc_quote2.c

src/tspi/rpc/tcstp/rpc_random.c

src/tspi/rpc/tcstp/rpc_seal.c

src/tspi/rpc/tcstp/rpc_selftest.c

src/tspi/rpc/tcstp/rpc_sign.c

src/tspi/rpc/tcstp/rpc_tick.c

src/tspi/rpc/tcstp/rpc_transport.c

src/tspi/tsp_admin.c

src/tspi/tsp_aik.c

src/tspi/tsp_asym.c

src/tspi/tsp_audit.c

src/tspi/tsp_auth.c

src/tspi/tsp_bind.c

src/tspi/tsp_caps.c

src/tspi/tsp_caps_tpm.c

src/tspi/tsp_certify.c

src/tspi/tsp_changeauth.c

src/tspi/tsp_context_mem.c

src/tspi/tsp_counter.c

src/tspi/tsp_daa.c

src/tspi/tsp_delegate.c

src/tspi/tsp_dir.c

src/tspi/tsp_ek.c

src/tspi/tsp_get_flags.c

src/tspi/tsp_key.c

src/tspi/tsp_maint.c

src/tspi/tsp_migration.c

src/tspi/tsp_nv.c

src/tspi/tsp_oper.c

src/tspi/tsp_own.c

src/tspi/tsp_pcr.c

src/tspi/tsp_pcr_extend.c

src/tspi/tsp_policy.c

src/tspi/tsp_ps.c

src/tspi/tsp_quote.c

src/tspi/tsp_quote2.c

src/tspi/tsp_random.c

src/tspi/tsp_seal.c

src/tspi/tsp_selftest.c

src/tspi/tsp_sign.c

src/tspi/tsp_tick.c

src/tspi/tsp_transport.c

src/tspi/tspi_admin.c

src/tspi/tspi_aik.c

src/tspi/tspi_asn1.c

src/tspi/tspi_audit.c

src/tspi/tspi_bind.c

src/tspi/tspi_caps.c

src/tspi/tspi_caps_tpm.c

src/tspi/tspi_certify.c

src/tspi/tspi_changeauth.c

src/tspi/tspi_cmk.c

src/tspi/tspi_context.c

src/tspi/tspi_counter.c

src/tspi/tspi_daa.c

src/tspi/tspi_delegate.c

src/tspi/tspi_dir.c

src/tspi/tspi_ek.c

src/tspi/tspi_getset.c

src/tspi/tspi_hash.c

src/tspi/tspi_key.c

src/tspi/tspi_maint.c

src/tspi/tspi_migration.c

src/tspi/tspi_nv.c

src/tspi/tspi_oper.c

src/tspi/tspi_own.c

src/tspi/tspi_pcr_comp.c

src/tspi/tspi_pcr_comp12.c

src/tspi/tspi_pcr_events.c

src/tspi/tspi_pcr_extend.c

src/tspi/tspi_policy.c

src/tspi/tspi_ps.c

src/tspi/tspi_quote.c

src/tspi/tspi_quote2.c

src/tspi/tspi_random.c

src/tspi/tspi_seal.c

src/tspi/tspi_selftest.c

src/tspi/tspi_sign.c

src/tspi/tspi_tick.c

src/tspi/tspi_transport.c

files removed:
autom4te.cache

autom4te.cache/output.0

autom4te.cache/output.1

autom4te.cache/requests

autom4te.cache/traces.0

autom4te.cache/traces.1

debian/45-trousers.rules

debian/patches/01_makefiles.diff

debian/patches/01_makefiles.dpatch

debian/patches/02_defaultgroup__tcsd.dpatch

debian/trousers.README.Debian

debian/trousers.default

debian/trousers.dirs

debian/watch

src/include/spi_internal_types.h

src/include/tcs_internal_types.h

src/include/trpctp.h

src/tcs/auth_mgr.c

src/tcs/biosem.c

src/tcs/cache.c

src/tcs/cxt.c

src/tcs/imaem.c

src/tcs/req_mgr.c

src/tcs/tcscm.c

src/tcs/tcsem.c

src/tcs/tcskcm.c

src/tcs/tcspbg.c

src/tcsd/tcsd_wrap.c

src/tcsd_api

src/tcsd_api/calltcsapi.c

src/tcsd_api/clntside.c

src/tcsd_api/hosttable.c

src/tcsd_api/tcstp.c

src/trspi/crypto/openssl/crypto.c

src/tspi/keyreg.c

src/tspi/memmgr.c

src/tspi/secrets.c

src/tspi/spi_context.c

src/tspi/spi_data.c

src/tspi/spi_getset.c

src/tspi/spi_hash.c

src/tspi/spi_key.c

src/tspi/spi_pcr.c

src/tspi/spi_policy.c

src/tspi/spi_tpm.c

files modified:
AUTHORS

ChangeLog

Makefile.in

README

config.guess

config.sub

configure

configure.in

debian/changelog

debian/control

debian/copyright

debian/libtspi-dev.install

debian/libtspi1.install

debian/patches/00list

debian/rules

debian/trousers.docs

debian/trousers.init

debian/trousers.install

debian/trousers.postinst

debian/trousers.postrm

dist/Makefile.in

dist/tcsd.conf.in

man/Makefile.in

man/man3/Makefile.am

man/man3/Makefile.in

man/man3/Tspi_Context_LoadKeyByUUID.3

man/man3/Tspi_TPM_GetPubEndorsementKey.3

man/man5/Makefile.in

man/man5/tcsd.conf.5.in

man/man8/Makefile.in

src/Makefile.in

src/include/Makefile.am

src/include/Makefile.in

src/include/auth_mgr.h

src/include/capabilities.h

src/include/hosttable.h

src/include/memmgr.h

src/include/obj.h

src/include/req_mgr.h

src/include/spi_utils.h

src/include/tcs_tsp.h

src/include/tcs_utils.h

src/include/tcsd.h

src/include/tcsd_ops.h

src/include/tcsd_wrap.h

src/include/tcsem.h

src/include/tcslog.h

src/include/tcsps.h

src/include/trousers/trousers.h

src/include/trousers/tss.h

src/include/trousers_types.h

src/include/tspps.h

src/include/tss/platform.h

src/include/tss/tcpa_defines.h

src/include/tss/tcpa_error.h

src/include/tss/tcpa_struct.h

src/include/tss/tcpa_typedef.h

src/include/tss/tcs_error.h

src/include/tss/tcs_structs.h

src/include/tss/tcs_typedef.h

src/include/tss/tddl_error.h

src/include/tss/tddlapi_error.h

src/include/tss/tddli.h

src/include/tss/tspi.h

src/include/tss/tss_defines.h

src/include/tss/tss_error.h

src/include/tss/tss_error_basics.h

src/include/tss/tss_structs.h

src/include/tss/tss_typedef.h

src/tcs/Makefile.am

src/tcs/Makefile.in

src/tcs/ps/ps_utils.c

src/tcs/ps/tcsps.c

src/tcs/tcs_utils.c

src/tcsd/Makefile.am

src/tcsd/Makefile.in

src/tcsd/platform.c

src/tcsd/svrside.c

src/tcsd/tcsd_conf.c

src/tcsd/tcsd_threads.c

src/tddl/Makefile.am

src/tddl/Makefile.in

src/trspi/Makefile.am

src/trspi/Makefile.in

src/trspi/trousers.c

src/tspi/Makefile.am

src/tspi/Makefile.in

src/tspi/obj.c

src/tspi/obj_context.c

src/tspi/obj_encdata.c

src/tspi/obj_hash.c

src/tspi/obj_pcrs.c

src/tspi/obj_policy.c

src/tspi/obj_rsakey.c

src/tspi/obj_tpm.c

src/tspi/ps/tspps.c

src/tspi/spi_utils.c

tools/Makefile.in

tools/ps_inspect.c

Show diffs side-by-side

added added

removed removed

src/tspi/obj_migdata.c

* Licensed Materials - Property of IBM

* trousers - An open source TCG Software Stack

* (C) Copyright International Business Machines Corp. 2007

#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

#include <string.h>

#include "trousers/tss.h"

#include "trousers/trousers.h"

#include "trousers_types.h"

#include "spi_utils.h"

#include "capabilities.h"

#include "tsplog.h"

#include "obj.h"

void

migdata_free(void *data)

{

struct tr_migdata_obj *migdata = (struct tr_migdata_obj *)data;

free(migdata);

}

TSS_BOOL

obj_is_migdata(TSS_HOBJECT hObject)

{

TSS_BOOL answer = FALSE;

if ((obj_list_get_obj(&migdata_list, hObject))) {

answer = TRUE;

obj_list_put(&migdata_list);

}

return answer;

}

TSS_RESULT

obj_migdata_add(TSS_HCONTEXT hContext, TSS_HOBJECT *phObject)

{

TSS_RESULT result;

struct tr_migdata_obj *migdata = calloc(1, sizeof(struct tr_migdata_obj));

if (migdata == NULL) {

LogError("malloc of %zd bytes failed.", sizeof(struct tr_migdata_obj));

return TSPERR(TSS_E_OUTOFMEMORY);

}

if ((result = obj_list_add(&migdata_list, hContext, 0, migdata, phObject))) {

free(migdata);

return result;

}

return TSS_SUCCESS;

}

TSS_RESULT

obj_migdata_remove(TSS_HMIGDATA hMigData, TSS_HCONTEXT hContext)

{

TSS_RESULT result;

if ((result = obj_list_remove(&migdata_list, &migdata_free, hMigData, hContext)))

return result;

return TSS_SUCCESS;

}

TSS_RESULT

obj_migdata_get_tsp_context(TSS_HMIGDATA hMigData, TSS_HCONTEXT *hContext)

{

struct tsp_object *obj;

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

return TSPERR(TSS_E_INVALID_HANDLE);

*hContext = obj->tspContext;

obj_list_put(&migdata_list);

return TSS_SUCCESS;

}

TSS_RESULT

obj_migdata_set_migrationblob(TSS_HMIGDATA hMigData, UINT32 whichOne, UINT32 blobSize, BYTE *blob)

{

TSS_RESULT result;

switch (whichOne) {

case TSS_MIGATTRIB_MIG_MSALIST_PUBKEY_BLOB:

result = obj_migdata_set_msa_pubkey(hMigData, blobSize, blob);

100

break;

101

case TSS_MIGATTRIB_MIG_AUTHORITY_PUBKEY_BLOB:

102

result = obj_migdata_set_ma_pubkey(hMigData, blobSize, blob);

103

break;

104

case TSS_MIGATTRIB_MIG_DESTINATION_PUBKEY_BLOB:

105

result = obj_migdata_set_dest_pubkey(hMigData, blobSize, blob);

106

break;

107

case TSS_MIGATTRIB_MIG_SOURCE_PUBKEY_BLOB:

108

result = obj_migdata_set_src_pubkey(hMigData, blobSize, blob);

109

break;

110

default:

111

result = TSPERR(TSS_E_BAD_PARAMETER);

112

}

113

114

return result;

115

}

116

117

TSS_RESULT

118

obj_migdata_get_migrationblob(TSS_HMIGDATA hMigData, UINT32 whichOne, UINT32 *blobSize, BYTE **blob)

119

{

120

TSS_RESULT result;

121

122

switch (whichOne) {

123

case TSS_MIGATTRIB_MIG_XOR_BLOB:

124

result = obj_migdata_get_blob(hMigData, blobSize, blob);

125

break;

126

default:

127

result = TSPERR(TSS_E_BAD_PARAMETER);

128

}

129

130

return result;

131

}

132

133

TSS_RESULT

134

obj_migdata_set_authoritydata(TSS_HMIGDATA hMigData, UINT32 whichOne, UINT32 blobSize, BYTE *blob)

135

{

136

TSS_RESULT result;

137

138

switch (whichOne) {

139

case TSS_MIGATTRIB_AUTHORITY_DIGEST:

140

result = obj_migdata_set_msa_digest(hMigData, blobSize, blob);

141

break;

142

case TSS_MIGATTRIB_AUTHORITY_APPROVAL_HMAC:

143

result = obj_migdata_set_msa_hmac(hMigData, blobSize, blob);

144

break;

145

case TSS_MIGATTRIB_AUTHORITY_MSALIST:

146

result = obj_migdata_set_msa_list(hMigData, blobSize, blob);

147

break;

148

default:

149

result = TSPERR(TSS_E_BAD_PARAMETER);

150

}

151

152

return result;

153

}

154

155

TSS_RESULT

156

obj_migdata_get_authoritydata(TSS_HMIGDATA hMigData, UINT32 whichOne, UINT32 *blobSize, BYTE **blob)

157

{

158

TSS_RESULT result;

159

160

switch (whichOne) {

161

case TSS_MIGATTRIB_AUTHORITY_DIGEST:

162

result = obj_migdata_get_msa_digest(hMigData, blobSize, blob);

163

break;

164

case TSS_MIGATTRIB_AUTHORITY_APPROVAL_HMAC:

165

result = obj_migdata_get_msa_hmac(hMigData, blobSize, blob);

166

break;

167

case TSS_MIGATTRIB_AUTHORITY_MSALIST:

168

result = obj_migdata_get_msa_list(hMigData, blobSize, blob);

169

break;

170

default:

171

result = TSPERR(TSS_E_BAD_PARAMETER);

172

}

173

174

return result;

175

}

176

177

TSS_RESULT

178

obj_migdata_set_migauthdata(TSS_HMIGDATA hMigData, UINT32 whichOne, UINT32 blobSize, BYTE *blob)

179

{

180

TSS_RESULT result;

181

182

switch (whichOne) {

183

case TSS_MIGATTRIB_MIG_AUTH_AUTHORITY_DIGEST:

184

result = obj_migdata_set_ma_digest(hMigData, blobSize, blob);

185

break;

186

case TSS_MIGATTRIB_MIG_AUTH_DESTINATION_DIGEST:

187

result = obj_migdata_set_dest_digest(hMigData, blobSize, blob);

188

break;

189

case TSS_MIGATTRIB_MIG_AUTH_SOURCE_DIGEST:

190

result = obj_migdata_set_src_digest(hMigData, blobSize, blob);

191

break;

192

default:

193

result = TSPERR(TSS_E_BAD_PARAMETER);

194

}

195

196

return result;

197

}

198

199

TSS_RESULT

200

obj_migdata_get_migauthdata(TSS_HMIGDATA hMigData, UINT32 whichOne, UINT32 *blobSize, BYTE **blob)

201

{

202

TSS_RESULT result;

203

204

switch (whichOne) {

205

case TSS_MIGATTRIB_MIG_AUTH_AUTHORITY_DIGEST:

206

result = obj_migdata_get_ma_digest(hMigData, blobSize, blob);

207

break;

208

case TSS_MIGATTRIB_MIG_AUTH_DESTINATION_DIGEST:

209

result = obj_migdata_get_dest_digest(hMigData, blobSize, blob);

210

break;

211

case TSS_MIGATTRIB_MIG_AUTH_SOURCE_DIGEST:

212

result = obj_migdata_get_src_digest(hMigData, blobSize, blob);

213

break;

214

default:

215

result = TSPERR(TSS_E_BAD_PARAMETER);

216

}

217

218

return result;

219

}

220

221

TSS_RESULT

222

obj_migdata_set_ticketdata(TSS_HMIGDATA hMigData, UINT32 whichOne, UINT32 blobSize, BYTE *blob)

223

{

224

TSS_RESULT result;

225

226

switch (whichOne) {

227

case TSS_MIGATTRIB_TICKET_SIG_DIGEST:

228

result = obj_migdata_set_sig_data(hMigData, blobSize, blob);

229

break;

230

case TSS_MIGATTRIB_TICKET_SIG_VALUE:

231

result = obj_migdata_set_sig_value(hMigData, blobSize, blob);

232

break;

233

case TSS_MIGATTRIB_TICKET_SIG_TICKET:

234

result = obj_migdata_set_sig_ticket(hMigData, blobSize, blob);

235

break;

236

case TSS_MIGATTRIB_TICKET_RESTRICT_TICKET:

237

result = obj_migdata_set_cmk_auth(hMigData, blobSize, blob);

238

break;

239

default:

240

result = TSPERR(TSS_E_BAD_PARAMETER);

241

}

242

243

return result;

244

}

245

246

TSS_RESULT

247

obj_migdata_get_ticketdata(TSS_HMIGDATA hMigData, UINT32 whichOne, UINT32 *blobSize, BYTE **blob)

248

{

249

TSS_RESULT result;

250

251

switch (whichOne) {

252

case TSS_MIGATTRIB_TICKET_SIG_TICKET:

253

result = obj_migdata_get_sig_ticket(hMigData, blobSize, blob);

254

break;

255

default:

256

result = TSPERR(TSS_E_BAD_PARAMETER);

257

}

258

259

return result;

260

}

261

262

TSS_RESULT

263

obj_migdata_set_ticket_blob(TSS_HMIGDATA hMigData, UINT32 migTicketSize, BYTE *migTicket)

264

{

265

struct tsp_object *obj;

266

struct tr_migdata_obj *migdata;

267

TSS_RESULT result = TSS_SUCCESS;

268

269

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

270

return TSPERR(TSS_E_INVALID_HANDLE);

271

272

migdata = (struct tr_migdata_obj *)obj->data;

273

274

migdata->migTicketSize = 0;

275

free(migdata->migTicket);

276

if ((migdata->migTicket = malloc(migTicketSize)) == NULL) {

277

LogError("malloc of %u bytes failed.", migTicketSize);

278

result = TSPERR(TSS_E_OUTOFMEMORY);

279

goto done;

280

}

281

memcpy(migdata->migTicket, migTicket, migTicketSize);

282

migdata->migTicketSize = migTicketSize;

283

284

done:

285

obj_list_put(&migdata_list);

286

287

return result;

288

}

289

290

TSS_RESULT

291

obj_migdata_get_ticket_blob(TSS_HMIGDATA hMigData, UINT32 *migTicketSize, BYTE **migTicket)

292

{

293

struct tsp_object *obj;

294

struct tr_migdata_obj *migdata;

295

TSS_RESULT result = TSS_SUCCESS;

296

297

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

298

return TSPERR(TSS_E_INVALID_HANDLE);

299

300

migdata = (struct tr_migdata_obj *)obj->data;

301

302

if ((*migTicket = calloc_tspi(obj->tspContext, migdata->migTicketSize)) == NULL) {

303

LogError("malloc of %u bytes failed.", migdata->migTicketSize);

304

result = TSPERR(TSS_E_OUTOFMEMORY);

305

goto done;

306

}

307

memcpy(*migTicket, migdata->migTicket, migdata->migTicketSize);

308

*migTicketSize = migdata->migTicketSize;

309

310

done:

311

obj_list_put(&migdata_list);

312

313

return result;

314

}

315

316

TSS_RESULT

317

obj_migdata_set_msa_list(TSS_HMIGDATA hMigData, UINT32 msaListSize, BYTE *msaList)

318

{

319

struct tsp_object *obj;

320

struct tr_migdata_obj *migdata;

321

UINT32 i, count, size;

322

TPM_DIGEST *digest;

323

TSS_RESULT result = TSS_SUCCESS;

324

325

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

326

return TSPERR(TSS_E_INVALID_HANDLE);

327

328

migdata = (struct tr_migdata_obj *)obj->data;

329

330

count = msaListSize / sizeof(digest->digest);

331

size = count * sizeof(*digest);

332

333

migdata->msaList.MSAlist = 0;

334

free(migdata->msaList.migAuthDigest);

335

if ((migdata->msaList.migAuthDigest = malloc(size)) == NULL) {

336

LogError("malloc of %u bytes failed.", size);

337

result = TSPERR(TSS_E_OUTOFMEMORY);

338

goto done;

339

}

340

digest = migdata->msaList.migAuthDigest;

341

for (i = 0; i < count; i++) {

342

memcpy(digest->digest, msaList, sizeof(digest->digest));

343

msaList += sizeof(digest->digest);

344

digest++;

345

}

346

migdata->msaList.MSAlist = count;

347

348

result = obj_migdata_calc_msa_digest(migdata);

349

350

done:

351

obj_list_put(&migdata_list);

352

353

return result;

354

}

355

356

TSS_RESULT

357

obj_migdata_get_msa_list(TSS_HMIGDATA hMigData, UINT32 *size, BYTE **msaList)

358

{

359

struct tsp_object *obj;

360

struct tr_migdata_obj *migdata;

361

UINT32 i;

362

TPM_DIGEST *digest;

363

BYTE *tmpMsaList;

364

TSS_RESULT result = TSS_SUCCESS;

365

366

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

367

return TSPERR(TSS_E_INVALID_HANDLE);

368

369

migdata = (struct tr_migdata_obj *)obj->data;

370

371

*size = migdata->msaList.MSAlist * sizeof(migdata->msaList.migAuthDigest->digest);

372

if ((*msaList = calloc_tspi(obj->tspContext, *size)) == NULL) {

373

LogError("malloc of %u bytes failed.", *size);

374

result = TSPERR(TSS_E_OUTOFMEMORY);

375

goto done;

376

}

377

tmpMsaList = *msaList;

378

digest = migdata->msaList.migAuthDigest;

379

for (i = 0; i < migdata->msaList.MSAlist; i++) {

380

memcpy(tmpMsaList, digest->digest, sizeof(digest->digest));

381

tmpMsaList += sizeof(digest->digest);

382

digest++;

383

}

384

385

done:

386

obj_list_put(&migdata_list);

387

388

return TSS_SUCCESS;

389

}

390

391

TSS_RESULT

392

obj_migdata_set_msa_pubkey(TSS_HMIGDATA hMigData, UINT32 blobSize, BYTE *pubKeyBlob)

393

{

394

struct tsp_object *obj;

395

struct tr_migdata_obj *migdata;

396

UINT32 size;

397

TPM_DIGEST msaDigest;

398

TPM_DIGEST *digest;

399

TSS_RESULT result = TSS_SUCCESS;

400

401

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

402

return TSPERR(TSS_E_INVALID_HANDLE);

403

404

migdata = (struct tr_migdata_obj *)obj->data;

405

406

if ((result = obj_migdata_calc_pubkey_digest(blobSize, pubKeyBlob, &msaDigest)))

407

goto done;

408

409

size = (migdata->msaList.MSAlist + 1) * sizeof(*digest);

410

if ((migdata->msaList.migAuthDigest = realloc(migdata->msaList.migAuthDigest, size)) == NULL) {

411

LogError("malloc of %u bytes failed.", size);

412

result = TSPERR(TSS_E_OUTOFMEMORY);

413

goto done;

414

}

415

digest = migdata->msaList.migAuthDigest + migdata->msaList.MSAlist;

416

*digest = msaDigest;

417

migdata->msaList.MSAlist++;

418

419

result = obj_migdata_calc_msa_digest(migdata);

420

421

done:

422

obj_list_put(&migdata_list);

423

424

return result;

425

}

426

427

TSS_RESULT

428

obj_migdata_set_msa_digest(TSS_HMIGDATA hMigData, UINT32 digestSize, BYTE *digest)

429

{

430

struct tsp_object *obj;

431

struct tr_migdata_obj *migdata;

432

TSS_RESULT result = TSS_SUCCESS;

433

434

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

435

return TSPERR(TSS_E_INVALID_HANDLE);

436

437

migdata = (struct tr_migdata_obj *)obj->data;

438

439

if (digestSize != sizeof(migdata->msaDigest.digest)) {

440

result = TSPERR(TSS_E_BAD_PARAMETER);

441

goto done;

442

}

443

memcpy(migdata->msaDigest.digest, digest, sizeof(migdata->msaDigest.digest));

444

445

done:

446

obj_list_put(&migdata_list);

447

448

return result;

449

}

450

451

TSS_RESULT

452

obj_migdata_get_msa_digest(TSS_HMIGDATA hMigData, UINT32 *digestSize, BYTE **digest)

453

{

454

struct tsp_object *obj;

455

struct tr_migdata_obj *migdata;

456

TSS_RESULT result = TSS_SUCCESS;

457

458

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

459

return TSPERR(TSS_E_INVALID_HANDLE);

460

461

migdata = (struct tr_migdata_obj *)obj->data;

462

463

if ((*digest = calloc_tspi(obj->tspContext, sizeof(migdata->msaDigest.digest))) == NULL) {

464

LogError("malloc of %zd bytes failed.", sizeof(migdata->msaDigest.digest));

465

result = TSPERR(TSS_E_OUTOFMEMORY);

466

goto done;

467

}

468

memcpy(*digest, migdata->msaDigest.digest, sizeof(migdata->msaDigest.digest));

469

*digestSize = sizeof(migdata->msaDigest.digest);

470

471

done:

472

obj_list_put(&migdata_list);

473

474

return result;

475

}

476

477

TSS_RESULT

478

obj_migdata_get_msa_list_blob(TSS_HMIGDATA hMigData, UINT32 *blobSize, BYTE **msaListBlob)

479

{

480

struct tsp_object *obj;

481

struct tr_migdata_obj *migdata;

482

UINT64 offset;

483

TSS_RESULT result = TSS_SUCCESS;

484

485

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

486

return TSPERR(TSS_E_INVALID_HANDLE);

487

488

migdata = (struct tr_migdata_obj *)obj->data;

489

490

offset = 0;

491

Trspi_LoadBlob_MSA_COMPOSITE(&offset, NULL, &migdata->msaList);

492

493

*blobSize = offset;

494

if ((*msaListBlob = calloc_tspi(obj->tspContext, *blobSize)) == NULL) {

495

LogError("malloc of %u bytes failed.", *blobSize);

496

result = TSPERR(TSS_E_OUTOFMEMORY);

497

goto done;

498

}

499

offset = 0;

500

Trspi_LoadBlob_MSA_COMPOSITE(&offset, *msaListBlob, &migdata->msaList);

501

502

done:

503

obj_list_put(&migdata_list);

504

505

return TSS_SUCCESS;

506

}

507

508

TSS_RESULT

509

obj_migdata_set_msa_hmac(TSS_HMIGDATA hMigData, UINT32 hmacSize, BYTE *hmac)

510

{

511

struct tsp_object *obj;

512

struct tr_migdata_obj *migdata;

513

TSS_RESULT result = TSS_SUCCESS;

514

515

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

516

return TSPERR(TSS_E_INVALID_HANDLE);

517

518

migdata = (struct tr_migdata_obj *)obj->data;

519

520

if (hmacSize != sizeof(migdata->msaHmac.digest)) {

521

result = TSPERR(TSS_E_BAD_PARAMETER);

522

goto done;

523

}

524

memcpy(migdata->msaHmac.digest, hmac, sizeof(migdata->msaHmac.digest));

525

526

done:

527

obj_list_put(&migdata_list);

528

529

return result;

530

}

531

532

TSS_RESULT

533

obj_migdata_get_msa_hmac(TSS_HMIGDATA hMigData, UINT32 *hmacSize, BYTE **hmac)

534

{

535

struct tsp_object *obj;

536

struct tr_migdata_obj *migdata;

537

TSS_RESULT result = TSS_SUCCESS;

538

539

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

540

return TSPERR(TSS_E_INVALID_HANDLE);

541

542

migdata = (struct tr_migdata_obj *)obj->data;

543

544

if ((*hmac = calloc_tspi(obj->tspContext, sizeof(migdata->msaHmac.digest))) == NULL) {

545

LogError("malloc of %zd bytes failed.", sizeof(migdata->msaHmac.digest));

546

result = TSPERR(TSS_E_OUTOFMEMORY);

547

goto done;

548

}

549

memcpy(*hmac, migdata->msaHmac.digest, sizeof(migdata->msaHmac.digest));

550

*hmacSize = sizeof(migdata->msaHmac.digest);

551

552

done:

553

obj_list_put(&migdata_list);

554

555

return result;

556

}

557

558

TSS_RESULT

559

obj_migdata_set_ma_pubkey(TSS_HMIGDATA hMigData, UINT32 blobSize, BYTE *pubKeyBlob)

560

{

561

struct tsp_object *obj;

562

struct tr_migdata_obj *migdata;

563

TPM_DIGEST pubKeyDigest;

564

TSS_RESULT result = TSS_SUCCESS;

565

566

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

567

return TSPERR(TSS_E_INVALID_HANDLE);

568

569

migdata = (struct tr_migdata_obj *)obj->data;

570

571

if ((result = obj_migdata_calc_pubkey_digest(blobSize, pubKeyBlob, &pubKeyDigest)))

572

goto done;

573

574

migdata->maDigest = pubKeyDigest;

575

576

obj_migdata_calc_sig_data_digest(migdata);

577

578

done:

579

obj_list_put(&migdata_list);

580

581

return TSS_SUCCESS;

582

}

583

584

TSS_RESULT

585

obj_migdata_set_ma_digest(TSS_HMIGDATA hMigData, UINT32 digestSize, BYTE *digest)

586

{

587

struct tsp_object *obj;

588

struct tr_migdata_obj *migdata;

589

TSS_RESULT result = TSS_SUCCESS;

590

591

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

592

return TSPERR(TSS_E_INVALID_HANDLE);

593

594

migdata = (struct tr_migdata_obj *)obj->data;

595

596

if (digestSize != sizeof(migdata->maDigest.digest)) {

597

result = TSPERR(TSS_E_BAD_PARAMETER);

598

goto done;

599

}

600

memcpy(migdata->maDigest.digest, digest, sizeof(migdata->maDigest.digest));

601

602

obj_migdata_calc_sig_data_digest(migdata);

603

604

done:

605

obj_list_put(&migdata_list);

606

607

return result;

608

}

609

610

TSS_RESULT

611

obj_migdata_get_ma_digest(TSS_HMIGDATA hMigData, UINT32 *digestSize, BYTE **digest)

612

{

613

struct tsp_object *obj;

614

struct tr_migdata_obj *migdata;

615

TSS_RESULT result = TSS_SUCCESS;

616

617

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

618

return TSPERR(TSS_E_INVALID_HANDLE);

619

620

migdata = (struct tr_migdata_obj *)obj->data;

621

622

if ((*digest = calloc_tspi(obj->tspContext, sizeof(migdata->maDigest.digest))) == NULL) {

623

LogError("malloc of %zd bytes failed.", sizeof(migdata->maDigest.digest));

624

result = TSPERR(TSS_E_OUTOFMEMORY);

625

goto done;

626

}

627

memcpy(*digest, migdata->maDigest.digest, sizeof(migdata->maDigest.digest));

628

*digestSize = sizeof(migdata->maDigest.digest);

629

630

done:

631

obj_list_put(&migdata_list);

632

633

return result;

634

}

635

636

TSS_RESULT

637

obj_migdata_set_dest_pubkey(TSS_HMIGDATA hMigData, UINT32 blobSize, BYTE *pubKeyBlob)

638

{

639

struct tsp_object *obj;

640

struct tr_migdata_obj *migdata;

641

TPM_DIGEST pubKeyDigest;

642

TSS_RESULT result = TSS_SUCCESS;

643

644

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

645

return TSPERR(TSS_E_INVALID_HANDLE);

646

647

migdata = (struct tr_migdata_obj *)obj->data;

648

649

if ((result = obj_migdata_calc_pubkey_digest(blobSize, pubKeyBlob, &pubKeyDigest)))

650

goto done;

651

652

migdata->destDigest = pubKeyDigest;

653

654

obj_migdata_calc_sig_data_digest(migdata);

655

656

done:

657

obj_list_put(&migdata_list);

658

659

return TSS_SUCCESS;

660

}

661

662

TSS_RESULT

663

obj_migdata_set_dest_digest(TSS_HMIGDATA hMigData, UINT32 digestSize, BYTE *digest)

664

{

665

struct tsp_object *obj;

666

struct tr_migdata_obj *migdata;

667

TSS_RESULT result = TSS_SUCCESS;

668

669

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

670

return TSPERR(TSS_E_INVALID_HANDLE);

671

672

migdata = (struct tr_migdata_obj *)obj->data;

673

674

if (digestSize != sizeof(migdata->destDigest.digest)) {

675

result = TSPERR(TSS_E_BAD_PARAMETER);

676

goto done;

677

}

678

memcpy(migdata->destDigest.digest, digest, sizeof(migdata->destDigest.digest));

679

680

obj_migdata_calc_sig_data_digest(migdata);

681

682

done:

683

obj_list_put(&migdata_list);

684

685

return result;

686

}

687

688

TSS_RESULT

689

obj_migdata_get_dest_digest(TSS_HMIGDATA hMigData, UINT32 *digestSize, BYTE **digest)

690

{

691

struct tsp_object *obj;

692

struct tr_migdata_obj *migdata;

693

TSS_RESULT result = TSS_SUCCESS;

694

695

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

696

return TSPERR(TSS_E_INVALID_HANDLE);

697

698

migdata = (struct tr_migdata_obj *)obj->data;

699

700

if ((*digest = calloc_tspi(obj->tspContext, sizeof(migdata->destDigest.digest))) == NULL) {

701

LogError("malloc of %zd bytes failed.", sizeof(migdata->destDigest.digest));

702

result = TSPERR(TSS_E_OUTOFMEMORY);

703

goto done;

704

}

705

memcpy(*digest, migdata->destDigest.digest, sizeof(migdata->destDigest.digest));

706

*digestSize = sizeof(migdata->destDigest.digest);

707

708

done:

709

obj_list_put(&migdata_list);

710

711

return result;

712

}

713

714

TSS_RESULT

715

obj_migdata_set_src_pubkey(TSS_HMIGDATA hMigData, UINT32 blobSize, BYTE *pubKeyBlob)

716

{

717

struct tsp_object *obj;

718

struct tr_migdata_obj *migdata;

719

TPM_DIGEST pubKeyDigest;

720

TSS_RESULT result = TSS_SUCCESS;

721

722

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

723

return TSPERR(TSS_E_INVALID_HANDLE);

724

725

migdata = (struct tr_migdata_obj *)obj->data;

726

727

if ((result = obj_migdata_calc_pubkey_digest(blobSize, pubKeyBlob, &pubKeyDigest)))

728

goto done;

729

730

migdata->srcDigest = pubKeyDigest;

731

732

obj_migdata_calc_sig_data_digest(migdata);

733

734

done:

735

obj_list_put(&migdata_list);

736

737

return TSS_SUCCESS;

738

}

739

740

TSS_RESULT

741

obj_migdata_set_src_digest(TSS_HMIGDATA hMigData, UINT32 digestSize, BYTE *digest)

742

{

743

struct tsp_object *obj;

744

struct tr_migdata_obj *migdata;

745

TSS_RESULT result = TSS_SUCCESS;

746

747

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

748

return TSPERR(TSS_E_INVALID_HANDLE);

749

750

migdata = (struct tr_migdata_obj *)obj->data;

751

752

if (digestSize != sizeof(migdata->srcDigest.digest)) {

753

result = TSPERR(TSS_E_BAD_PARAMETER);

754

goto done;

755

}

756

memcpy(migdata->srcDigest.digest, digest, sizeof(migdata->srcDigest.digest));

757

758

obj_migdata_calc_sig_data_digest(migdata);

759

760

done:

761

obj_list_put(&migdata_list);

762

763

return result;

764

}

765

766

TSS_RESULT

767

obj_migdata_get_src_digest(TSS_HMIGDATA hMigData, UINT32 *digestSize, BYTE **digest)

768

{

769

struct tsp_object *obj;

770

struct tr_migdata_obj *migdata;

771

TSS_RESULT result = TSS_SUCCESS;

772

773

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

774

return TSPERR(TSS_E_INVALID_HANDLE);

775

776

migdata = (struct tr_migdata_obj *)obj->data;

777

778

if ((*digest = calloc_tspi(obj->tspContext, sizeof(migdata->srcDigest.digest))) == NULL) {

779

LogError("malloc of %zd bytes failed.", sizeof(migdata->srcDigest.digest));

780

result = TSPERR(TSS_E_OUTOFMEMORY);

781

goto done;

782

}

783

memcpy(*digest, migdata->srcDigest.digest, sizeof(migdata->srcDigest.digest));

784

*digestSize = sizeof(migdata->srcDigest.digest);

785

786

done:

787

obj_list_put(&migdata_list);

788

789

return result;

790

}

791

792

TSS_RESULT

793

obj_migdata_set_cmk_auth(TSS_HMIGDATA hMigData, UINT32 digestsSize, BYTE *digests)

794

{

795

struct tsp_object *obj;

796

struct tr_migdata_obj *migdata;

797

TSS_RESULT result = TSS_SUCCESS;

798

799

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

800

return TSPERR(TSS_E_INVALID_HANDLE);

801

802

migdata = (struct tr_migdata_obj *)obj->data;

803

804

if (digestsSize != (sizeof(migdata->maDigest.digest) +

805

sizeof(migdata->destDigest.digest) +

806

sizeof(migdata->srcDigest.digest))) {

807

result = TSPERR(TSS_E_BAD_PARAMETER);

808

goto done;

809

}

810

memcpy(migdata->maDigest.digest, digests, sizeof(migdata->maDigest.digest));

811

digests += sizeof(migdata->maDigest.digest);

812

memcpy(migdata->destDigest.digest, digests, sizeof(migdata->destDigest.digest));

813

digests += sizeof(migdata->destDigest.digest);

814

memcpy(migdata->srcDigest.digest, digests, sizeof(migdata->srcDigest.digest));

815

816

obj_migdata_calc_sig_data_digest(migdata);

817

818

done:

819

obj_list_put(&migdata_list);

820

821

return result;

822

}

823

824

TSS_RESULT

825

obj_migdata_get_cmk_auth(TSS_HMIGDATA hMigData, TPM_CMK_AUTH *cmkAuth)

826

{

827

struct tsp_object *obj;

828

struct tr_migdata_obj *migdata;

829

830

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

831

return TSPERR(TSS_E_INVALID_HANDLE);

832

833

migdata = (struct tr_migdata_obj *)obj->data;

834

835

cmkAuth->migrationAuthorityDigest = migdata->maDigest;

836

cmkAuth->destinationKeyDigest = migdata->destDigest;

837

cmkAuth->sourceKeyDigest = migdata->srcDigest;

838

839

obj_list_put(&migdata_list);

840

841

return TSS_SUCCESS;

842

}

843

844

TSS_RESULT

845

obj_migdata_get_cmk_auth_blob(TSS_HMIGDATA hMigData, UINT32 *blobSize, BYTE **cmkAuthBlob)

846

{

847

struct tsp_object *obj;

848

TPM_CMK_AUTH cmkAuth;

849

UINT64 offset;

850

TSS_RESULT result;

851

852

if ((result = obj_migdata_get_cmk_auth(hMigData, &cmkAuth)))

853

return result;

854

855

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

856

return TSPERR(TSS_E_INVALID_HANDLE);

857

858

offset = 0;

859

Trspi_LoadBlob_CMK_AUTH(&offset, NULL, &cmkAuth);

860

861

*blobSize = offset;

862

if ((*cmkAuthBlob = calloc_tspi(obj->tspContext, *blobSize)) == NULL) {

863

LogError("malloc of %u bytes failed.", *blobSize);

864

result = TSPERR(TSS_E_OUTOFMEMORY);

865

goto done;

866

}

867

offset = 0;

868

Trspi_LoadBlob_CMK_AUTH(&offset, *cmkAuthBlob, &cmkAuth);

869

870

done:

871

obj_list_put(&migdata_list);

872

873

return result;

874

}

875

876

TSS_RESULT

877

obj_migdata_set_sig_data(TSS_HMIGDATA hMigData, UINT32 sigDataSize, BYTE *sigData)

878

{

879

struct tsp_object *obj;

880

struct tr_migdata_obj *migdata;

881

TSS_RESULT result = TSS_SUCCESS;

882

883

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

884

return TSPERR(TSS_E_INVALID_HANDLE);

885

886

migdata = (struct tr_migdata_obj *)obj->data;

887

888

if (sigDataSize != sizeof(migdata->sigData.digest)) {

889

result = TSPERR(TSS_E_BAD_PARAMETER);

890

goto done;

891

}

892

memcpy(migdata->sigData.digest, sigData, sizeof(migdata->sigData.digest));

893

894

done:

895

obj_list_put(&migdata_list);

896

897

return result;

898

}

899

900

TSS_RESULT

901

obj_migdata_get_sig_data(TSS_HMIGDATA hMigData, UINT32 *sigDataSize, BYTE **sigData)

902

{

903

struct tsp_object *obj;

904

struct tr_migdata_obj *migdata;

905

TSS_RESULT result = TSS_SUCCESS;

906

907

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

908

return TSPERR(TSS_E_INVALID_HANDLE);

909

910

migdata = (struct tr_migdata_obj *)obj->data;

911

912

if ((*sigData = calloc_tspi(obj->tspContext, sizeof(migdata->sigData.digest))) == NULL) {

913

LogError("malloc of %zd bytes failed.", sizeof(migdata->sigData.digest));

914

result = TSPERR(TSS_E_OUTOFMEMORY);

915

goto done;

916

}

917

memcpy(*sigData, migdata->sigData.digest, sizeof(migdata->sigData.digest));

918

*sigDataSize = sizeof(migdata->sigData.digest);

919

920

done:

921

obj_list_put(&migdata_list);

922

923

return result;

924

}

925

926

TSS_RESULT

927

obj_migdata_set_sig_value(TSS_HMIGDATA hMigData, UINT32 sigValueSize, BYTE *sigValue)

928

{

929

struct tsp_object *obj;

930

struct tr_migdata_obj *migdata;

931

TSS_RESULT result = TSS_SUCCESS;

932

933

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

934

return TSPERR(TSS_E_INVALID_HANDLE);

935

936

migdata = (struct tr_migdata_obj *)obj->data;

937

938

migdata->sigValueSize = 0;

939

free(migdata->sigValue);

940

if ((migdata->sigValue = malloc(sigValueSize)) == NULL) {

941

LogError("malloc of %u bytes failed.", sigValueSize);

942

result = TSPERR(TSS_E_OUTOFMEMORY);

943

goto done;

944

}

945

memcpy(migdata->sigValue, sigValue, sigValueSize);

946

migdata->sigValueSize = sigValueSize;

947

948

done:

949

obj_list_put(&migdata_list);

950

951

return result;

952

}

953

954

TSS_RESULT

955

obj_migdata_get_sig_value(TSS_HMIGDATA hMigData, UINT32 *sigValueSize, BYTE **sigValue)

956

{

957

struct tsp_object *obj;

958

struct tr_migdata_obj *migdata;

959

TSS_RESULT result = TSS_SUCCESS;

960

961

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

962

return TSPERR(TSS_E_INVALID_HANDLE);

963

964

migdata = (struct tr_migdata_obj *)obj->data;

965

966

if ((*sigValue = calloc_tspi(obj->tspContext, migdata->sigValueSize)) == NULL) {

967

LogError("malloc of %u bytes failed.", migdata->sigValueSize);

968

result = TSPERR(TSS_E_OUTOFMEMORY);

969

goto done;

970

}

971

memcpy(*sigValue, migdata->sigValue, migdata->sigValueSize);

972

*sigValueSize = migdata->sigValueSize;

973

974

done:

975

obj_list_put(&migdata_list);

976

977

return result;

978

}

979

980

TSS_RESULT

981

obj_migdata_set_sig_ticket(TSS_HMIGDATA hMigData, UINT32 sigTicketSize, BYTE *sigTicket)

982

{

983

struct tsp_object *obj;

984

struct tr_migdata_obj *migdata;

985

TSS_RESULT result = TSS_SUCCESS;

986

987

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

988

return TSPERR(TSS_E_INVALID_HANDLE);

989

990

migdata = (struct tr_migdata_obj *)obj->data;

991

992

if (sigTicketSize != sizeof(migdata->sigTicket.digest)) {

993

result = TSPERR(TSS_E_BAD_PARAMETER);

994

goto done;

995

}

996

memcpy(migdata->sigTicket.digest, sigTicket, sizeof(migdata->sigTicket.digest));

997

998

done:

999

obj_list_put(&migdata_list);

1000

1001

return result;

1002

}

1003

1004

TSS_RESULT

1005

obj_migdata_get_sig_ticket(TSS_HMIGDATA hMigData, UINT32 *sigTicketSize, BYTE **sigTicket)

1006

{

1007

struct tsp_object *obj;

1008

struct tr_migdata_obj *migdata;

1009

TSS_RESULT result = TSS_SUCCESS;

1010

1011

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

1012

return TSPERR(TSS_E_INVALID_HANDLE);

1013

1014

migdata = (struct tr_migdata_obj *)obj->data;

1015

1016

if ((*sigTicket = calloc_tspi(obj->tspContext, sizeof(migdata->sigTicket.digest))) == NULL) {

1017

LogError("malloc of %zd bytes failed.", sizeof(migdata->sigTicket.digest));

1018

result = TSPERR(TSS_E_OUTOFMEMORY);

1019

goto done;

1020

}

1021

memcpy(*sigTicket, migdata->sigTicket.digest, sizeof(migdata->sigTicket.digest));

1022

*sigTicketSize = sizeof(migdata->sigTicket.digest);

1023

1024

done:

1025

obj_list_put(&migdata_list);

1026

1027

return result;

1028

}

1029

1030

TSS_RESULT

1031

obj_migdata_set_blob(TSS_HMIGDATA hMigData, UINT32 blobSize, BYTE *blob)

1032

{

1033

struct tsp_object *obj;

1034

struct tr_migdata_obj *migdata;

1035

TSS_RESULT result = TSS_SUCCESS;

1036

1037

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

1038

return TSPERR(TSS_E_INVALID_HANDLE);

1039

1040

migdata = (struct tr_migdata_obj *)obj->data;

1041

1042

migdata->blobSize = 0;

1043

free(migdata->blob);

1044

if ((migdata->blob = malloc(blobSize)) == NULL) {

1045

LogError("malloc of %u bytes failed.", blobSize);

1046

result = TSPERR(TSS_E_OUTOFMEMORY);

1047

goto done;

1048

}

1049

memcpy(migdata->blob, blob, blobSize);

1050

migdata->blobSize = blobSize;

1051

1052

done:

1053

obj_list_put(&migdata_list);

1054

1055

return result;

1056

}

1057

1058

TSS_RESULT

1059

obj_migdata_get_blob(TSS_HMIGDATA hMigData, UINT32 *blobSize, BYTE **blob)

1060

{

1061

struct tsp_object *obj;

1062

struct tr_migdata_obj *migdata;

1063

TSS_RESULT result = TSS_SUCCESS;

1064

1065

if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)

1066

return TSPERR(TSS_E_INVALID_HANDLE);

1067

1068

migdata = (struct tr_migdata_obj *)obj->data;

1069

1070

if ((*blob = calloc_tspi(obj->tspContext, migdata->blobSize)) == NULL) {

1071

LogError("malloc of %u bytes failed.", migdata->blobSize);

1072

result = TSPERR(TSS_E_OUTOFMEMORY);

1073

goto done;

1074

}

1075

memcpy(*blob, migdata->blob, migdata->blobSize);

1076

*blobSize = migdata->blobSize;

1077

1078

done:

1079

obj_list_put(&migdata_list);

1080

1081

return result;

1082

}

1083

1084

1085

TSS_RESULT

1086

obj_migdata_calc_pubkey_digest(UINT32 blobSize, BYTE *blob, TPM_DIGEST *digest)

1087

{

1088

Trspi_HashCtx hashCtx;

1089

TSS_RESULT result;

1090

1091

result = Trspi_HashInit(&hashCtx, TSS_HASH_SHA1);

1092

result |= Trspi_HashUpdate(&hashCtx, blobSize, blob);

1093

result |= Trspi_HashFinal(&hashCtx, digest->digest);

1094

1095

return result;

1096

}

1097

1098

TSS_RESULT

1099

obj_migdata_calc_msa_digest(struct tr_migdata_obj *migdata)

1100

{

1101

Trspi_HashCtx hashCtx;

1102

TSS_RESULT result;

1103

1104

result = Trspi_HashInit(&hashCtx, TSS_HASH_SHA1);

1105

result |= Trspi_Hash_MSA_COMPOSITE(&hashCtx, &migdata->msaList);

1106

result |= Trspi_HashFinal(&hashCtx, migdata->msaDigest.digest);

1107

1108

return result;

1109

}

1110

1111

TSS_RESULT

1112

obj_migdata_calc_sig_data_digest(struct tr_migdata_obj *migdata)

1113

{

1114

Trspi_HashCtx hashCtx;

1115

TSS_RESULT result;

1116

1117

result = Trspi_HashInit(&hashCtx, TSS_HASH_SHA1);

1118

result |= Trspi_Hash_DIGEST(&hashCtx, migdata->maDigest.digest);

1119

result |= Trspi_Hash_DIGEST(&hashCtx, migdata->destDigest.digest);

1120

result |= Trspi_Hash_DIGEST(&hashCtx, migdata->srcDigest.digest);

1121

result |= Trspi_HashFinal(&hashCtx, migdata->sigData.digest);

1122

1123

return result;

1124

}

Older »