~ubuntu-branches/ubuntu/hardy/trousers/hardy-proposed

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_pcrs.c

* trousers - An open source TCG Software Stack

* (C) Copyright International Business Machines Corp. 2005

* (C) Copyright International Business Machines Corp. 2005, 2007

#include <stdio.h>

#include <errno.h>

#include <string.h>

#include <pthread.h>

#include "trousers/tss.h"

#include "trousers/trousers.h"

#include "spi_internal_types.h"

#include "trousers_types.h"

#include "spi_utils.h"

#include "capabilities.h"

#include "tsplog.h"

#include "obj.h"

TSS_RESULT

obj_pcrs_add(TSS_HCONTEXT tspContext, TSS_HOBJECT *phObject)

obj_pcrs_add(TSS_HCONTEXT tspContext, UINT32 type, TSS_HOBJECT *phObject)

{

TSS_RESULT result;

struct tr_pcrs_obj *pcrs = calloc(1, sizeof(struct tr_pcrs_obj));

UINT32 ver;

struct tr_pcrs_obj *pcrs;

if (pcrs == NULL) {

LogError("malloc of %zd bytes failed.",

sizeof(struct tr_pcrs_obj));

if ((pcrs = calloc(1, sizeof(struct tr_pcrs_obj))) == NULL) {

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

return TSPERR(TSS_E_OUTOFMEMORY);

}

if (type == TSS_PCRS_STRUCT_DEFAULT) {

if ((result = obj_context_get_connection_version(tspContext, &ver))) {

free(pcrs);

return result;

}

switch (ver) {

case TSS_TSPATTRIB_CONTEXT_VERSION_V1_2:

pcrs->type = TSS_PCRS_STRUCT_INFO_LONG;

pcrs->info.infolong.localityAtRelease = TSS_LOCALITY_ALL;

break;

case TSS_TSPATTRIB_CONTEXT_VERSION_V1_1:

/* fall through */

default:

pcrs->type = TSS_PCRS_STRUCT_INFO;

break;

}

} else

pcrs->type = type;

if ((result = obj_list_add(&pcrs_list, tspContext, 0, pcrs, phObject))) {

free(pcrs);

return result;

}

void

free_pcrs(struct tr_pcrs_obj *pcrs)

pcrs_free(void *data)

{

free(pcrs->select.pcrSelect);

struct tr_pcrs_obj *pcrs = (struct tr_pcrs_obj *)data;

switch (pcrs->type) {

case TSS_PCRS_STRUCT_INFO:

free(pcrs->info.info11.pcrSelection.pcrSelect);

break;

case TSS_PCRS_STRUCT_INFO_SHORT:

free(pcrs->info.infoshort.pcrSelection.pcrSelect);

break;

case TSS_PCRS_STRUCT_INFO_LONG:

free(pcrs->info.infolong.creationPCRSelection.pcrSelect);

free(pcrs->info.infolong.releasePCRSelection.pcrSelect);

break;

default:

LogDebugFn("Undefined type of PCRs object");

break;

}

free(pcrs);

}

TSS_RESULT

obj_pcrs_remove(TSS_HOBJECT hObject, TSS_HCONTEXT tspContext)

{

struct tsp_object *obj, *prev = NULL;

struct obj_list *list = &pcrs_list;

TSS_RESULT result = TSPERR(TSS_E_INVALID_HANDLE);

pthread_mutex_lock(&pcrs_list.lock);

for (obj = list->head; obj; prev = obj, obj = obj->next) {

if (obj->handle == hObject) {

/* validate tspContext */

if (obj->tspContext != tspContext)

break;

free_pcrs(obj->data);

if (prev)

prev->next = obj->next;

else

list->head = obj->next;

free(obj);

result = TSS_SUCCESS;

break;

}

pthread_mutex_unlock(&pcrs_list.lock);

return result;

TSS_RESULT result;

if ((result = obj_list_remove(&pcrs_list, &pcrs_free, hObject, tspContext)))

return result;

return TSS_SUCCESS;

}

100

101

TSS_BOOL

112

}

113

114

TSS_RESULT

obj_pcrs_get_tsp_context(TSS_HTPM hPcrs, TSS_HCONTEXT *tspContext)

115

obj_pcrs_get_tsp_context(TSS_HPCRS hPcrs, TSS_HCONTEXT *tspContext)

100

116

{

101

117

struct tsp_object *obj;

102

118

111

127

}

112

128

113

129

TSS_RESULT

114

obj_pcrs_get_selection(TSS_HPCRS hPcrs, TCPA_PCR_SELECTION *pcrSelect)

130

obj_pcrs_get_type(TSS_HPCRS hPcrs, UINT32 *type)

131

{

132

struct tsp_object *obj;

133

struct tr_pcrs_obj *pcrs;

134

135

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

136

return TSPERR(TSS_E_INVALID_HANDLE);

137

138

pcrs = (struct tr_pcrs_obj *)obj->data;

139

140

*type = pcrs->type;

141

142

obj_list_put(&pcrs_list);

143

144

return TSS_SUCCESS;

145

}

146

147

TSS_RESULT

148

obj_pcrs_get_selection(TSS_HPCRS hPcrs, UINT32 *size, BYTE *out)

115

149

{

116

150

struct tsp_object *obj;

117

151

struct tr_pcrs_obj *pcrs;

118

152

TSS_RESULT result = TSS_SUCCESS;

153

TPM_PCR_SELECTION *tmp;

154

UINT64 offset = 0;

119

155

120

156

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

121

157

return TSPERR(TSS_E_INVALID_HANDLE);

122

158

123

159

pcrs = (struct tr_pcrs_obj *)obj->data;

124

160

125

if (pcrs->select.pcrSelect == NULL) {

126

memcpy(pcrSelect, &pcrs->select, sizeof(TCPA_PCR_SELECTION));

127

} else {

128

if ((pcrSelect->pcrSelect = calloc(1,

129

pcrs->select.sizeOfSelect)) == NULL) {

130

LogError("malloc of %d bytes failed.",

131

pcrs->select.sizeOfSelect);

132

result = TSPERR(TSS_E_OUTOFMEMORY);

161

switch (pcrs->type) {

162

case TSS_PCRS_STRUCT_INFO:

163

tmp = &pcrs->info.info11.pcrSelection;

164

break;

165

case TSS_PCRS_STRUCT_INFO_SHORT:

166

tmp = &pcrs->info.infoshort.pcrSelection;

167

break;

168

case TSS_PCRS_STRUCT_INFO_LONG:

169

tmp = &pcrs->info.infolong.creationPCRSelection;

170

break;

171

default:

172

LogDebugFn("Undefined type of PCRs object");

173

result = TSPERR(TSS_E_INTERNAL_ERROR);

133

174

goto done;

134

}

135

pcrSelect->sizeOfSelect = pcrs->select.sizeOfSelect;

136

memcpy(pcrSelect->pcrSelect, pcrs->select.pcrSelect,

137

pcrs->select.sizeOfSelect);

138

175

}

139

176

177

Trspi_LoadBlob_PCR_SELECTION(&offset, out, tmp);

178

*size = offset;

140

179

done:

141

180

obj_list_put(&pcrs_list);

142

181

144

183

}

145

184

146

185

TSS_RESULT

147

obj_pcrs_set_values(TSS_HPCRS hPcrs, TCPA_PCR_COMPOSITE *pcrComp)

186

obj_pcrs_set_values(TSS_HPCRS hPcrs, TPM_PCR_COMPOSITE *pcrComp)

148

187

{

149

188

TSS_RESULT result = TSS_SUCCESS;

150

TCPA_PCR_SELECTION *select = &(pcrComp->select);

189

TPM_PCR_SELECTION *select = &(pcrComp->select);

151

190

UINT16 i, val_idx = 0;

152

191

153

192

for (i = 0; i < select->sizeOfSelect * 8; i++) {

154

193

if (select->pcrSelect[i / 8] & (1 << (i % 8))) {

155

194

if ((result = obj_pcrs_set_value(hPcrs, i, TCPA_SHA1_160_HASH_LEN,

156

195

(BYTE *)&pcrComp->pcrValue[val_idx])))

157

break;

196

return result;

158

197

159

198

val_idx++;

160

199

}

169

208

struct tsp_object *obj;

170

209

struct tr_pcrs_obj *pcrs;

171

210

TSS_RESULT result = TSS_SUCCESS;

211

TPM_PCR_SELECTION *select;

212

TPM_COMPOSITE_HASH *compHash;

172

213

UINT16 bytes_to_hold = (idx / 8) + 1;

173

214

174

215

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

176

217

177

218

pcrs = (struct tr_pcrs_obj *)obj->data;

178

219

220

switch(pcrs->type) {

221

case TSS_PCRS_STRUCT_INFO:

222

bytes_to_hold = (bytes_to_hold < 2) ? 2 : bytes_to_hold;

223

select = &pcrs->info.info11.pcrSelection;

224

compHash = &pcrs->info.info11.digestAtRelease;

225

break;

226

case TSS_PCRS_STRUCT_INFO_SHORT:

227

bytes_to_hold = (bytes_to_hold < 3) ? 3 : bytes_to_hold;

228

select = &pcrs->info.infoshort.pcrSelection;

229

compHash = &pcrs->info.infoshort.digestAtRelease;

230

break;

231

case TSS_PCRS_STRUCT_INFO_LONG:

232

bytes_to_hold = (bytes_to_hold < 3) ? 3 : bytes_to_hold;

233

select = &pcrs->info.infolong.releasePCRSelection;

234

compHash = &pcrs->info.infolong.digestAtRelease;

235

break;

236

default:

237

LogDebugFn("Undefined type of PCRs object");

238

result = TSPERR(TSS_E_INTERNAL_ERROR);

239

goto done;

240

break;

241

}

242

179

243

/* allocate the selection structure */

180

if (pcrs->select.pcrSelect == NULL) {

181

if ((pcrs->select.pcrSelect = malloc(bytes_to_hold)) == NULL) {

244

if (select->pcrSelect == NULL) {

245

if ((select->pcrSelect = malloc(bytes_to_hold)) == NULL) {

182

246

LogError("malloc of %d bytes failed.", bytes_to_hold);

183

247

result = TSPERR(TSS_E_OUTOFMEMORY);

184

248

goto done;

185

249

}

186

pcrs->select.sizeOfSelect = bytes_to_hold;

187

memset(pcrs->select.pcrSelect, 0, bytes_to_hold);

250

select->sizeOfSelect = bytes_to_hold;

251

memset(select->pcrSelect, 0, bytes_to_hold);

188

252

189

253

/* allocate the pcr array */

190

254

if ((pcrs->pcrs = malloc(bytes_to_hold * 8 *

194

258

result = TSPERR(TSS_E_OUTOFMEMORY);

195

259

goto done;

196

260

}

197

} else if (pcrs->select.sizeOfSelect < bytes_to_hold) {

198

if ((pcrs->select.pcrSelect = realloc(pcrs->select.pcrSelect,

199

bytes_to_hold)) == NULL) {

261

} else if (select->sizeOfSelect < bytes_to_hold) {

262

if ((select->pcrSelect = realloc(select->pcrSelect, bytes_to_hold)) == NULL) {

200

263

LogError("malloc of %d bytes failed.", bytes_to_hold);

201

264

result = TSPERR(TSS_E_OUTOFMEMORY);

202

265

goto done;

203

266

}

204

267

/* set the newly allocated bytes to 0 */

205

memset(&pcrs->select.pcrSelect[pcrs->select.sizeOfSelect], 0,

206

bytes_to_hold - pcrs->select.sizeOfSelect);

207

pcrs->select.sizeOfSelect = bytes_to_hold;

268

memset(&select->pcrSelect[select->sizeOfSelect], 0,

269

bytes_to_hold - select->sizeOfSelect);

270

select->sizeOfSelect = bytes_to_hold;

208

271

209

272

/* realloc the pcrs array */

210

273

if ((pcrs->pcrs = realloc(pcrs->pcrs, bytes_to_hold * 8 *

211

sizeof(TCPA_PCRVALUE))) == NULL) {

274

sizeof(TPM_PCRVALUE))) == NULL) {

212

275

LogError("malloc of %d bytes failed.",

213

276

bytes_to_hold * 8 * TCPA_SHA1_160_HASH_LEN);

214

277

result = TSPERR(TSS_E_OUTOFMEMORY);

217

280

}

218

281

219

282

/* set the bit in the selection structure */

220

pcrs->select.pcrSelect[idx / 8] |= (1 << (idx % 8));

283

select->pcrSelect[idx / 8] |= (1 << (idx % 8));

221

284

222

285

/* set the value in the pcrs array */

223

286

memcpy(&(pcrs->pcrs[idx]), value, size);

287

288

result = pcrs_calc_composite(select, pcrs->pcrs, compHash);

289

224

290

done:

225

291

obj_list_put(&pcrs_list);

226

292

233

299

struct tsp_object *obj;

234

300

struct tr_pcrs_obj *pcrs;

235

301

TSS_RESULT result = TSS_SUCCESS;

302

TPM_PCR_SELECTION *select;

236

303

237

304

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

238

305

return TSPERR(TSS_E_INVALID_HANDLE);

239

306

240

307

pcrs = (struct tr_pcrs_obj *)obj->data;

241

308

242

if (pcrs->select.sizeOfSelect < (idx / 8) + 1) {

309

switch(pcrs->type) {

310

case TSS_PCRS_STRUCT_INFO:

311

select = &pcrs->info.info11.pcrSelection;

312

break;

313

case TSS_PCRS_STRUCT_INFO_SHORT:

314

select = &pcrs->info.infoshort.pcrSelection;

315

break;

316

case TSS_PCRS_STRUCT_INFO_LONG:

317

select = &pcrs->info.infolong.creationPCRSelection;

318

break;

319

default:

320

LogDebugFn("Undefined type of PCRs object");

321

result = TSPERR(TSS_E_INTERNAL_ERROR);

322

goto done;

323

break;

324

}

325

326

if (select->sizeOfSelect < (idx / 8) + 1) {

243

327

result = TSPERR(TSS_E_BAD_PARAMETER);

244

328

goto done;

245

329

}

246

330

247

if ((*value = calloc_tspi(obj->tspContext, TCPA_SHA1_160_HASH_LEN))

248

== NULL) {

331

if ((*value = calloc_tspi(obj->tspContext, TCPA_SHA1_160_HASH_LEN)) == NULL) {

249

332

LogError("malloc of %d bytes failed.", TCPA_SHA1_160_HASH_LEN);

250

333

result = TSPERR(TSS_E_OUTOFMEMORY);

251

334

goto done;

260

343

return result;

261

344

}

262

345

263

/* This should only be called through paths with a verified connected

264

* TCS context */

265

TSS_RESULT

266

obj_pcrs_get_composite(TSS_HPCRS hPcrs, TCPA_PCRVALUE *comp)

267

{

268

struct tsp_object *obj;

269

struct tr_pcrs_obj *pcrs;

270

TSS_RESULT result = TSS_SUCCESS;

271

UINT16 num_pcrs, bytes_to_hold;

272

273

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

274

return TSPERR(TSS_E_INVALID_HANDLE);

275

276

pcrs = (struct tr_pcrs_obj *)obj->data;

277

278

if ((num_pcrs = get_num_pcrs(obj->tspContext)) == 0) {

346

TSS_RESULT

347

obj_pcrs_get_digest_at_release(TSS_HPCRS hPcrs, UINT32 *size, BYTE **out)

348

{

349

struct tsp_object *obj;

350

struct tr_pcrs_obj *pcrs;

351

TSS_RESULT result = TSS_SUCCESS;

352

BYTE *digest;

353

354

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

355

return TSPERR(TSS_E_INVALID_HANDLE);

356

357

pcrs = (struct tr_pcrs_obj *)obj->data;

358

359

switch(pcrs->type) {

360

case TSS_PCRS_STRUCT_INFO:

361

result = TSPERR(TSS_E_INVALID_OBJ_ACCESS);

362

goto done;

363

case TSS_PCRS_STRUCT_INFO_SHORT:

364

digest = (BYTE *)&pcrs->info.infoshort.digestAtRelease;

365

break;

366

case TSS_PCRS_STRUCT_INFO_LONG:

367

digest = (BYTE *)&pcrs->info.infolong.digestAtRelease;

368

break;

369

default:

370

LogDebugFn("Undefined type of PCRs object");

371

result = TSPERR(TSS_E_INTERNAL_ERROR);

372

goto done;

373

break;

374

}

375

376

if ((*out = calloc_tspi(obj->tspContext, sizeof(TPM_COMPOSITE_HASH))) == NULL) {

377

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

378

result = TSPERR(TSS_E_OUTOFMEMORY);

379

goto done;

380

}

381

memcpy(*out, digest, sizeof(TPM_COMPOSITE_HASH));

382

*size = sizeof(TPM_COMPOSITE_HASH);

383

384

done:

385

obj_list_put(&pcrs_list);

386

387

return result;

388

}

389

390

TSS_RESULT

391

obj_pcrs_select_index(TSS_HPCRS hPcrs, UINT32 idx)

392

{

393

struct tsp_object *obj;

394

struct tr_pcrs_obj *pcrs;

395

TSS_RESULT result = TSS_SUCCESS;

396

TPM_PCR_SELECTION *select;

397

UINT16 bytes_to_hold = (idx / 8) + 1;

398

399

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

400

return TSPERR(TSS_E_INVALID_HANDLE);

401

402

pcrs = (struct tr_pcrs_obj *)obj->data;

403

404

switch(pcrs->type) {

405

case TSS_PCRS_STRUCT_INFO:

406

bytes_to_hold = (bytes_to_hold < 2) ? 2 : bytes_to_hold;

407

select = &pcrs->info.info11.pcrSelection;

408

break;

409

case TSS_PCRS_STRUCT_INFO_SHORT:

410

case TSS_PCRS_STRUCT_INFO_LONG:

411

result = TSPERR(TSS_E_INVALID_OBJ_ACCESS);

412

goto done;

413

default:

414

LogDebugFn("Undefined type of PCRs object");

415

result = TSPERR(TSS_E_INTERNAL_ERROR);

416

goto done;

417

break;

418

}

419

420

/* allocate the selection structure */

421

if (select->pcrSelect == NULL) {

422

if ((select->pcrSelect = malloc(bytes_to_hold)) == NULL) {

423

LogError("malloc of %d bytes failed.", bytes_to_hold);

424

result = TSPERR(TSS_E_OUTOFMEMORY);

425

goto done;

426

}

427

select->sizeOfSelect = bytes_to_hold;

428

memset(select->pcrSelect, 0, bytes_to_hold);

429

430

/* alloc the pcrs array */

431

if ((pcrs->pcrs = malloc(bytes_to_hold * 8 * TCPA_SHA1_160_HASH_LEN)) == NULL) {

432

LogError("malloc of %d bytes failed.", bytes_to_hold * 8 *

433

TCPA_SHA1_160_HASH_LEN);

434

result = TSPERR(TSS_E_OUTOFMEMORY);

435

goto done;

436

}

437

} else if (select->sizeOfSelect < bytes_to_hold) {

438

if ((select->pcrSelect = realloc(select->pcrSelect, bytes_to_hold)) == NULL) {

439

LogError("malloc of %d bytes failed.", bytes_to_hold);

440

result = TSPERR(TSS_E_OUTOFMEMORY);

441

goto done;

442

}

443

/* set the newly allocated bytes to 0 */

444

memset(&select->pcrSelect[select->sizeOfSelect], 0,

445

bytes_to_hold - select->sizeOfSelect);

446

select->sizeOfSelect = bytes_to_hold;

447

448

/* realloc the pcrs array */

449

if ((pcrs->pcrs = realloc(pcrs->pcrs,

450

bytes_to_hold * 8 * TCPA_SHA1_160_HASH_LEN)) == NULL) {

451

LogError("malloc of %d bytes failed.", bytes_to_hold * 8 *

452

TCPA_SHA1_160_HASH_LEN);

453

result = TSPERR(TSS_E_OUTOFMEMORY);

454

goto done;

455

}

456

}

457

458

/* set the bit in the selection structure */

459

select->pcrSelect[idx / 8] |= (1 << (idx % 8));

460

461

done:

462

obj_list_put(&pcrs_list);

463

464

return result;

465

}

466

467

TSS_RESULT

468

obj_pcrs_select_index_ex(TSS_HPCRS hPcrs, UINT32 dir, UINT32 idx)

469

{

470

struct tsp_object *obj;

471

struct tr_pcrs_obj *pcrs;

472

TSS_RESULT result = TSS_SUCCESS;

473

TPM_PCR_SELECTION *select;

474

UINT16 bytes_to_hold = (idx / 8) + 1;

475

476

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

477

return TSPERR(TSS_E_INVALID_HANDLE);

478

479

pcrs = (struct tr_pcrs_obj *)obj->data;

480

481

switch(pcrs->type) {

482

case TSS_PCRS_STRUCT_INFO:

483

result = TSPERR(TSS_E_INVALID_OBJ_ACCESS);

484

goto done;

485

case TSS_PCRS_STRUCT_INFO_SHORT:

486

if (dir == TSS_PCRS_DIRECTION_CREATION) {

487

result = TSPERR(TSS_E_INVALID_OBJ_ACCESS);

488

goto done;

489

}

490

bytes_to_hold = (bytes_to_hold < 3) ? 3 : bytes_to_hold;

491

select = &pcrs->info.infoshort.pcrSelection;

492

break;

493

case TSS_PCRS_STRUCT_INFO_LONG:

494

bytes_to_hold = (bytes_to_hold < 3) ? 3 : bytes_to_hold;

495

if (dir == TSS_PCRS_DIRECTION_CREATION)

496

select = &pcrs->info.infolong.creationPCRSelection;

497

else

498

select = &pcrs->info.infolong.releasePCRSelection;

499

break;

500

default:

501

LogDebugFn("Undefined type of PCRs object");

502

result = TSPERR(TSS_E_INTERNAL_ERROR);

503

goto done;

504

break;

505

}

506

507

/* allocate the selection structure */

508

if (select->pcrSelect == NULL) {

509

if ((select->pcrSelect = malloc(bytes_to_hold)) == NULL) {

510

LogError("malloc of %d bytes failed.", bytes_to_hold);

511

result = TSPERR(TSS_E_OUTOFMEMORY);

512

goto done;

513

}

514

select->sizeOfSelect = bytes_to_hold;

515

memset(select->pcrSelect, 0, bytes_to_hold);

516

517

/* alloc the pcrs array */

518

if ((pcrs->pcrs = malloc(bytes_to_hold * 8 * TCPA_SHA1_160_HASH_LEN)) == NULL) {

519

LogError("malloc of %d bytes failed.", bytes_to_hold * 8 *

520

TCPA_SHA1_160_HASH_LEN);

521

result = TSPERR(TSS_E_OUTOFMEMORY);

522

goto done;

523

}

524

} else if (select->sizeOfSelect < bytes_to_hold) {

525

if ((select->pcrSelect = realloc(select->pcrSelect, bytes_to_hold)) == NULL) {

526

LogError("malloc of %d bytes failed.", bytes_to_hold);

527

result = TSPERR(TSS_E_OUTOFMEMORY);

528

goto done;

529

}

530

/* set the newly allocated bytes to 0 */

531

memset(&select->pcrSelect[select->sizeOfSelect], 0,

532

bytes_to_hold - select->sizeOfSelect);

533

select->sizeOfSelect = bytes_to_hold;

534

535

/* realloc the pcrs array */

536

if ((pcrs->pcrs = realloc(pcrs->pcrs,

537

bytes_to_hold * 8 * TCPA_SHA1_160_HASH_LEN)) == NULL) {

538

LogError("malloc of %d bytes failed.", bytes_to_hold * 8 *

539

TCPA_SHA1_160_HASH_LEN);

540

result = TSPERR(TSS_E_OUTOFMEMORY);

541

goto done;

542

}

543

}

544

545

/* set the bit in the selection structure */

546

select->pcrSelect[idx / 8] |= (1 << (idx % 8));

547

548

done:

549

obj_list_put(&pcrs_list);

550

551

return result;

552

}

553

554

TSS_RESULT

555

obj_pcrs_create_info_type(TSS_HPCRS hPcrs, UINT32 *type, UINT32 *size, BYTE **info)

556

{

557

TSS_RESULT result;

558

559

/* If type equals 0, then we create the structure

560

based on how the object was created */

561

if (*type == 0) {

562

struct tsp_object *obj;

563

struct tr_pcrs_obj *pcrs;

564

565

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

566

return TSPERR(TSS_E_INVALID_HANDLE);

567

568

pcrs = (struct tr_pcrs_obj *)obj->data;

569

*type = pcrs->type;

570

571

obj_list_put(&pcrs_list);

572

}

573

574

switch (*type) {

575

case TSS_PCRS_STRUCT_INFO:

576

result = obj_pcrs_create_info(hPcrs, size, info);

577

break;

578

case TSS_PCRS_STRUCT_INFO_LONG:

579

result = obj_pcrs_create_info_long(hPcrs, size, info);

580

break;

581

case TSS_PCRS_STRUCT_INFO_SHORT:

582

result = obj_pcrs_create_info_short(hPcrs, size, info);

583

break;

584

default:

585

return TSPERR(TSS_E_INTERNAL_ERROR);

586

}

587

588

return result;

589

}

590

591

/* Create a PCR info struct based on the hPcrs object */

592

TSS_RESULT

593

obj_pcrs_create_info(TSS_HPCRS hPcrs, UINT32 *size, BYTE **info)

594

{

595

struct tsp_object *obj;

596

struct tr_pcrs_obj *pcrs;

597

TSS_RESULT result = TSS_SUCCESS;

598

TPM_PCR_INFO info11;

599

UINT64 offset;

600

UINT32 ret_size;

601

BYTE *ret;

602

603

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

604

return TSPERR(TSS_E_INVALID_HANDLE);

605

606

pcrs = (struct tr_pcrs_obj *)obj->data;

607

608

/* Set everything that is not assigned to be all zeroes */

609

memset(&info11, 0, sizeof(info11));

610

611

switch (pcrs->type) {

612

case TSS_PCRS_STRUCT_INFO:

613

info11 = pcrs->info.info11;

614

break;

615

case TSS_PCRS_STRUCT_INFO_LONG:

616

info11.pcrSelection = pcrs->info.infolong.releasePCRSelection;

617

info11.digestAtRelease = pcrs->info.infolong.digestAtRelease;

618

break;

619

case TSS_PCRS_STRUCT_INFO_SHORT:

620

info11.pcrSelection = pcrs->info.infoshort.pcrSelection;

621

info11.digestAtRelease = pcrs->info.infoshort.digestAtRelease;

622

break;

623

default:

624

result = TSPERR(TSS_E_INTERNAL_ERROR);

625

goto done;

626

}

627

628

offset = 0;

629

Trspi_LoadBlob_PCR_INFO(&offset, NULL, &info11);

630

ret_size = offset;

631

632

if ((ret = calloc(1, ret_size)) == NULL) {

633

result = TSPERR(TSS_E_OUTOFMEMORY);

634

LogDebug("malloc of %u bytes failed.", ret_size);

635

goto done;

636

}

637

638

offset = 0;

639

Trspi_LoadBlob_PCR_INFO(&offset, ret, &info11);

640

641

*info = ret;

642

*size = ret_size;

643

644

done:

645

obj_list_put(&pcrs_list);

646

647

return result;

648

}

649

650

TSS_RESULT

651

obj_pcrs_create_info_long(TSS_HPCRS hPcrs, UINT32 *size, BYTE **info)

652

{

653

struct tsp_object *obj;

654

struct tr_pcrs_obj *pcrs;

655

TSS_RESULT result = TSS_SUCCESS;

656

TPM_PCR_INFO_LONG infolong;

657

BYTE dummyBits[3] = { 0, 0, 0 };

658

TPM_PCR_SELECTION dummySelection = { 3, dummyBits };

659

UINT64 offset;

660

UINT32 ret_size;

661

BYTE *ret;

662

663

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

664

return TSPERR(TSS_E_INVALID_HANDLE);

665

666

pcrs = (struct tr_pcrs_obj *)obj->data;

667

668

/* Set everything that is not assigned to be all zeroes */

669

memset(&infolong, 0, sizeof(infolong));

670

671

infolong.tag = TPM_TAG_PCR_INFO_LONG;

672

/* localityAtCreation and creationPCRSelection certainly do not need to be set here, but

673

* some chips such as Winbond do not ignore them on input, so we must give them dummy

674

* "good" values */

675

infolong.localityAtCreation = TPM_LOC_ZERO;

676

infolong.creationPCRSelection = dummySelection;

677

switch (pcrs->type) {

678

case TSS_PCRS_STRUCT_INFO:

679

infolong.localityAtRelease = TSS_LOCALITY_ALL;

680

infolong.releasePCRSelection = pcrs->info.info11.pcrSelection;

681

infolong.digestAtRelease = pcrs->info.info11.digestAtRelease;

682

break;

683

case TSS_PCRS_STRUCT_INFO_LONG:

684

infolong.localityAtRelease = pcrs->info.infolong.localityAtRelease;

685

infolong.releasePCRSelection = pcrs->info.infolong.releasePCRSelection;

686

infolong.digestAtRelease = pcrs->info.infolong.digestAtRelease;

687

break;

688

case TSS_PCRS_STRUCT_INFO_SHORT:

689

infolong.localityAtRelease = pcrs->info.infoshort.localityAtRelease;

690

infolong.releasePCRSelection = pcrs->info.infoshort.pcrSelection;

691

infolong.digestAtRelease = pcrs->info.infoshort.digestAtRelease;

692

break;

693

default:

694

result = TSPERR(TSS_E_INTERNAL_ERROR);

695

goto done;

696

}

697

698

offset = 0;

699

Trspi_LoadBlob_PCR_INFO_LONG(&offset, NULL, &infolong);

700

ret_size = offset;

701

702

if ((ret = calloc(1, ret_size)) == NULL) {

703

result = TSPERR(TSS_E_OUTOFMEMORY);

704

LogDebug("malloc of %u bytes failed.", ret_size);

705

goto done;

706

}

707

708

offset = 0;

709

Trspi_LoadBlob_PCR_INFO_LONG(&offset, ret, &infolong);

710

711

*info = ret;

712

*size = ret_size;

713

714

done:

715

obj_list_put(&pcrs_list);

716

717

return result;

718

}

719

720

TSS_RESULT

721

obj_pcrs_create_info_short(TSS_HPCRS hPcrs, UINT32 *size, BYTE **info)

722

{

723

struct tsp_object *obj;

724

struct tr_pcrs_obj *pcrs;

725

TSS_RESULT result = TSS_SUCCESS;

726

TPM_PCR_INFO_SHORT infoshort;

727

BYTE select[] = { 0, 0, 0 };

728

UINT64 offset;

729

UINT32 ret_size;

730

BYTE *ret;

731

732

/* Set everything that is not assigned to be all zeroes */

733

memset(&infoshort, 0, sizeof(infoshort));

734

735

if (hPcrs != NULL_HPCRS) {

736

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

737

return TSPERR(TSS_E_INVALID_HANDLE);

738

739

pcrs = (struct tr_pcrs_obj *)obj->data;

740

741

switch (pcrs->type) {

742

case TSS_PCRS_STRUCT_INFO:

743

infoshort.pcrSelection = pcrs->info.info11.pcrSelection;

744

infoshort.localityAtRelease = TSS_LOCALITY_ALL;

745

infoshort.digestAtRelease = pcrs->info.info11.digestAtRelease;

746

break;

747

case TSS_PCRS_STRUCT_INFO_LONG:

748

infoshort.pcrSelection = pcrs->info.infolong.releasePCRSelection;

749

infoshort.localityAtRelease = pcrs->info.infolong.localityAtRelease;

750

infoshort.digestAtRelease = pcrs->info.infolong.digestAtRelease;

751

break;

752

case TSS_PCRS_STRUCT_INFO_SHORT:

753

infoshort = pcrs->info.infoshort;

754

break;

755

default:

756

result = TSPERR(TSS_E_INTERNAL_ERROR);

757

goto done;

758

}

759

} else {

760

infoshort.pcrSelection.sizeOfSelect = sizeof(select);

761

infoshort.pcrSelection.pcrSelect = select;

762

infoshort.localityAtRelease = TSS_LOCALITY_ALL;

763

}

764

765

offset = 0;

766

Trspi_LoadBlob_PCR_INFO_SHORT(&offset, NULL, &infoshort);

767

ret_size = offset;

768

769

if ((ret = calloc(1, ret_size)) == NULL) {

770

result = TSPERR(TSS_E_OUTOFMEMORY);

771

LogDebug("malloc of %u bytes failed.", ret_size);

772

goto done;

773

}

774

775

offset = 0;

776

Trspi_LoadBlob_PCR_INFO_SHORT(&offset, ret, &infoshort);

777

778

*info = ret;

779

*size = ret_size;

780

781

done:

782

if (hPcrs != NULL_HPCRS)

783

obj_list_put(&pcrs_list);

784

785

return result;

786

}

787

788

TSS_RESULT

789

obj_pcrs_get_locality(TSS_HPCRS hPcrs, UINT32 *out)

790

{

791

struct tsp_object *obj;

792

struct tr_pcrs_obj *pcrs;

793

TSS_RESULT result = TSS_SUCCESS;

794

BYTE *locality;

795

796

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

797

return TSPERR(TSS_E_INVALID_HANDLE);

798

799

pcrs = (struct tr_pcrs_obj *)obj->data;

800

801

switch(pcrs->type) {

802

case TSS_PCRS_STRUCT_INFO:

803

result = TSPERR(TSS_E_INVALID_OBJ_ACCESS);

804

goto done;

805

case TSS_PCRS_STRUCT_INFO_SHORT:

806

locality = &pcrs->info.infoshort.localityAtRelease;

807

break;

808

case TSS_PCRS_STRUCT_INFO_LONG:

809

locality = &pcrs->info.infolong.localityAtRelease;

810

break;

811

default:

812

LogDebugFn("Undefined type of PCRs object");

813

result = TSPERR(TSS_E_INTERNAL_ERROR);

814

goto done;

815

}

816

817

*out = (UINT32)*locality;

818

819

done:

820

obj_list_put(&pcrs_list);

821

822

return result;

823

}

824

825

TSS_RESULT

826

obj_pcrs_set_locality(TSS_HPCRS hPcrs, UINT32 locality)

827

{

828

struct tsp_object *obj;

829

struct tr_pcrs_obj *pcrs;

830

TSS_RESULT result = TSS_SUCCESS;

831

BYTE *loc;

832

833

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

834

return TSPERR(TSS_E_INVALID_HANDLE);

835

836

pcrs = (struct tr_pcrs_obj *)obj->data;

837

838

switch(pcrs->type) {

839

case TSS_PCRS_STRUCT_INFO:

840

result = TSPERR(TSS_E_INVALID_OBJ_ACCESS);

841

goto done;

842

case TSS_PCRS_STRUCT_INFO_SHORT:

843

loc = &pcrs->info.infoshort.localityAtRelease;

844

break;

845

case TSS_PCRS_STRUCT_INFO_LONG:

846

loc = &pcrs->info.infolong.localityAtRelease;

847

break;

848

default:

849

LogDebugFn("Undefined type of PCRs object");

850

result = TSPERR(TSS_E_INTERNAL_ERROR);

851

goto done;

852

}

853

854

*loc = locality;

855

done:

856

obj_list_put(&pcrs_list);

857

858

return result;

859

}

860

861

TSS_RESULT

862

obj_pcrs_set_digest_at_release(TSS_HPCRS hPcrs, TPM_COMPOSITE_HASH digest)

863

{

864

struct tsp_object *obj;

865

struct tr_pcrs_obj *pcrs;

866

TSS_RESULT result = TSS_SUCCESS;

867

TPM_COMPOSITE_HASH *dig;

868

869

LogDebugFn("######## Digest to be set on TSS object:");

870

LogDebugData(TCPA_SHA1_160_HASH_LEN, digest.digest);

871

872

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

873

return TSPERR(TSS_E_INVALID_HANDLE);

874

875

pcrs = (struct tr_pcrs_obj *)obj->data;

876

877

switch(pcrs->type) {

878

case TSS_PCRS_STRUCT_INFO:

879

result = TSPERR(TSS_E_INVALID_OBJ_ACCESS);

880

goto done;

881

case TSS_PCRS_STRUCT_INFO_SHORT:

882

dig = &pcrs->info.infoshort.digestAtRelease;

883

break;

884

case TSS_PCRS_STRUCT_INFO_LONG:

885

dig = &pcrs->info.infolong.digestAtRelease;

886

break;

887

default:

888

LogDebugFn("Undefined type of PCRs object");

279

889

result = TSPERR(TSS_E_INTERNAL_ERROR);

280

890

goto done;

281

891

}

282

bytes_to_hold = num_pcrs / 8;

283

284

/* Is the current select object going to be interpretable by the TPM?

285

* If the select object is of a size greater than the one the TPM

286

* wants, just calculate the composite hash and let the TPM return an

287

* error code to the user. If its less than the size of the one the

288

* TPM wants, add extra zero bytes until its the right size. */

289

if (bytes_to_hold > pcrs->select.sizeOfSelect) {

290

if ((pcrs->select.pcrSelect = realloc(pcrs->select.pcrSelect,

291

bytes_to_hold)) == NULL) {

292

LogError("malloc of %d bytes failed.", bytes_to_hold);

293

result = TSPERR(TSS_E_OUTOFMEMORY);

294

goto done;

295

}

296

/* set the newly allocated bytes to 0 */

297

memset(&pcrs->select.pcrSelect[pcrs->select.sizeOfSelect], 0,

298

bytes_to_hold - pcrs->select.sizeOfSelect);

299

pcrs->select.sizeOfSelect = bytes_to_hold;

300

301

/* realloc the pcr array as well */

302

if ((pcrs->pcrs = realloc(pcrs->pcrs,

303

(bytes_to_hold * 8) * TCPA_SHA1_160_HASH_LEN))

304

== NULL) {

305

LogError("malloc of %d bytes failed.",

306

(bytes_to_hold * 8) * TCPA_SHA1_160_HASH_LEN);

307

result = TSPERR(TSS_E_OUTOFMEMORY);

308

goto done;

309

}

310

}

311

312

#ifdef TSS_DEBUG

313

{

314

int i;

315

for (i = 0; i < pcrs->select.sizeOfSelect * 8; i++) {

316

if (pcrs->select.pcrSelect[i/8] & (1 << (i % 8))) {

317

LogDebug("PCR%d: Selected", i);

318

LogBlobData(APPID, TCPA_SHA1_160_HASH_LEN,

319

(unsigned char *)&pcrs->pcrs[i]);

320

} else {

321

LogDebug("PCR%d: Not Selected", i);

322

}

323

}

324

}

325

#endif

326

327

result = calc_composite_from_object(&pcrs->select, pcrs->pcrs, comp);

328

329

done:

330

obj_list_put(&pcrs_list);

331

332

return result;

333

}

334

335

TSS_RESULT

336

obj_pcrs_select_index(TSS_HPCRS hPcrs, UINT32 idx)

337

{

338

struct tsp_object *obj;

339

struct tr_pcrs_obj *pcrs;

340

TSS_RESULT result = TSS_SUCCESS;

341

UINT16 bytes_to_hold = (idx / 8) + 1;

342

343

if ((obj = obj_list_get_obj(&pcrs_list, hPcrs)) == NULL)

344

return TSPERR(TSS_E_INVALID_HANDLE);

345

346

pcrs = (struct tr_pcrs_obj *)obj->data;

347

348

/* allocate the selection structure */

349

if (pcrs->select.pcrSelect == NULL) {

350

if ((pcrs->select.pcrSelect = malloc(bytes_to_hold)) == NULL) {

351

LogError("malloc of %d bytes failed.", bytes_to_hold);

352

result = TSPERR(TSS_E_OUTOFMEMORY);

353

goto done;

354

}

355

pcrs->select.sizeOfSelect = bytes_to_hold;

356

memset(pcrs->select.pcrSelect, 0, bytes_to_hold);

357

358

/* alloc the pcrs array */

359

if ((pcrs->pcrs = malloc(bytes_to_hold * 8 *

360

TCPA_SHA1_160_HASH_LEN)) == NULL) {

361

LogError("malloc of %d bytes failed.", bytes_to_hold *

362

8 * TCPA_SHA1_160_HASH_LEN);

363

result = TSPERR(TSS_E_OUTOFMEMORY);

364

goto done;

365

}

366

} else if (pcrs->select.sizeOfSelect < bytes_to_hold) {

367

if ((pcrs->select.pcrSelect = realloc(pcrs->select.pcrSelect,

368

bytes_to_hold)) == NULL) {

369

LogError("malloc of %d bytes failed.", bytes_to_hold);

370

result = TSPERR(TSS_E_OUTOFMEMORY);

371

goto done;

372

}

373

/* set the newly allocated bytes to 0 */

374

memset(&pcrs->select.pcrSelect[pcrs->select.sizeOfSelect], 0,

375

bytes_to_hold - pcrs->select.sizeOfSelect);

376

pcrs->select.sizeOfSelect = bytes_to_hold;

377

378

/* realloc the pcrs array */

379

if ((pcrs->pcrs = realloc(pcrs->pcrs, bytes_to_hold * 8 *

380

TCPA_SHA1_160_HASH_LEN)) == NULL) {

381

LogError("malloc of %d bytes failed.", bytes_to_hold *

382

8 * TCPA_SHA1_160_HASH_LEN);

383

result = TSPERR(TSS_E_OUTOFMEMORY);

384

goto done;

385

}

386

}

387

388

/* set the bit in the selection structure */

389

pcrs->select.pcrSelect[idx / 8] |= (1 << (idx % 8));

390

391

done:

392

obj_list_put(&pcrs_list);

393

394

return result;

395

}

396

397

TSS_RESULT

398

calc_composite_from_object(TCPA_PCR_SELECTION *select, TCPA_PCRVALUE * arrayOfPcrs, TCPA_DIGEST * digestOut)

399

{

400

UINT32 size, index;

401

BYTE mask;

402

BYTE hashBlob[1024];

403

UINT32 numPCRs = 0;

404

UINT16 offset = 0;

405

UINT64 sizeOffset = 0;

406

407

if (select->sizeOfSelect > 0) {

408

sizeOffset = 0;

409

Trspi_LoadBlob_PCR_SELECTION(&sizeOffset, hashBlob, select);

410

offset = sizeOffset + 4;

411

412

for (size = 0; size < select->sizeOfSelect; size++) {

413

for (index = 0, mask = 1; index < 8; index++, mask = mask << 1) {

414

if (select->pcrSelect[size] & mask) {

415

memcpy(&hashBlob[(numPCRs * TCPA_SHA1_160_HASH_LEN) + offset],

416

arrayOfPcrs[index + (size << 3)].digest,

417

TCPA_SHA1_160_HASH_LEN);

418

numPCRs++;

419

}

420

}

421

}

422

423

if (numPCRs > 0) {

424

offset += (numPCRs * TCPA_SHA1_160_HASH_LEN);

425

UINT32ToArray(numPCRs * TCPA_SHA1_160_HASH_LEN, &hashBlob[sizeOffset]);

426

427

Trspi_Hash(TSS_HASH_SHA1, offset, hashBlob, digestOut->digest);

428

429

return TSS_SUCCESS;

430

}

431

}

432

433

return TSPERR(TSS_E_INTERNAL_ERROR);

434

}

435

892

893

/* Copy the digest information */

894

memcpy(dig->digest,&digest.digest,TPM_SHA1_160_HASH_LEN);

895

896

LogDebugFn("######## Digest SET on TSS object:");

897

LogDebugData(TCPA_SHA1_160_HASH_LEN,pcrs->info.infoshort.digestAtRelease.digest);

898

899

done:

900

obj_list_put(&pcrs_list);

901

902

return result;

903

}

436

904

Older »