« back to all changes in this revision
Viewing changes to .pc/04-gcc46.patch/src/tspi/obj_nv.c
- browse files at revision 23
- compare with another revision
- download diff
- download tarball
- view history from revision 23
- Committer: Package Import Robot
- Author(s): Pierre Chifflier
- Date: 2012-06-18 22:22:21 UTC
- mfrom: (0.1.22 sid)
- Revision ID: package-import@ubuntu.com-20120618222221-kumdab5nrfx4kvyh
Tags: 0.3.9-1
* Imported Upstream version 0.3.9
* Refreshed Debian patches
* Removed patch 04-gcc46.patch, not required anymore
* Refreshed Debian patches
* Removed patch 04-gcc46.patch, not required anymore
- files added:
- .gitignore
- autom4te.cache
- src/include/daa
- src/tspi/daa/big_integer/test
- src/tspi/daa/daa_verifier/test
- files removed:
- .pc/04-gcc46.patch
- .pc/04-gcc46.patch/src
- .pc/04-gcc46.patch/src/tcs
- .pc/04-gcc46.patch/src/tcs/rpc
- .pc/04-gcc46.patch/src/tcs/rpc/tcstp
- .pc/04-gcc46.patch/src/tspi
- files modified:
- .pc/applied-patches
added
removed
.pc/04-gcc46.patch/src/tspi/obj_nv.c
1
/*
2
* The Initial Developer of the Original Code is Intel Corporation.
3
* Portions created by Intel Corporation are Copyright (C) 2007 Intel Corporation.
4
* All Rights Reserved.
5
*
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the Common Public License as published by
8
* IBM Corporation; either version 1 of the License, or (at your option)
9
* any later version.
10
*
11
* This program is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* Common Public License for more details.
15
*
16
* You should have received a copy of the Common Public License
17
* along with this program; if not, a copy can be viewed at
18
* http://www.opensource.org/licenses/cpl1.0.php.
19
*
20
* trousers - An open source TCG Software Stack
21
*
22
* Author: james.xu@intel.com Rossey.liu@intel.com
23
*
24
*/
25
26
#include <stdlib.h>
27
#include <stdio.h>
28
#include <errno.h>
29
#include <string.h>
30
31
#include "trousers/tss.h"
32
#include "trousers/trousers.h"
33
#include "trousers_types.h"
34
#include "spi_utils.h"
35
#include "capabilities.h"
36
#include "tsplog.h"
37
#include "obj.h"
38
39
TSS_RESULT
40
obj_nvstore_add(TSS_HCONTEXT tspContext, TSS_HOBJECT *phObject)
41
{
42
TSS_RESULT result;
43
struct tr_nvstore_obj *nvstore = calloc(1, sizeof(struct tr_nvstore_obj));
44
45
if (nvstore == NULL) {
46
LogError("malloc of %zd bytes failed.",
47
sizeof(struct tr_nvstore_obj));
48
return TSPERR(TSS_E_OUTOFMEMORY);
49
}
50
51
if ((result = obj_list_add(&nvstore_list, tspContext, 0, nvstore, phObject))) {
52
free(nvstore);
53
return result;
54
}
55
56
return TSS_SUCCESS;
57
}
58
59
TSS_BOOL
60
obj_is_nvstore(TSS_HOBJECT hObject)
61
{
62
TSS_BOOL answer = FALSE;
63
64
if ((obj_list_get_obj(&nvstore_list, hObject))) {
65
answer = TRUE;
66
obj_list_put(&nvstore_list);
67
}
68
69
return answer;
70
}
71
72
void
73
nvstore_free(void *data)
74
{
75
struct tr_nvstore_obj *nvstore = (struct tr_nvstore_obj *)data;
76
77
free(nvstore);
78
}
79
80
TSS_RESULT
81
obj_nvstore_remove(TSS_HOBJECT hObject, TSS_HCONTEXT tspContext)
82
{
83
TSS_RESULT result;
84
85
if ((result = obj_list_remove(&nvstore_list, &nvstore_free, hObject, tspContext)))
86
return result;
87
88
return TSS_SUCCESS;
89
}
90
91
TSS_RESULT
92
obj_nvstore_get_tsp_context(TSS_HNVSTORE hNvstore, TSS_HCONTEXT * tspContext)
93
{
94
struct tsp_object *obj;
95
96
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
97
return TSPERR(TSS_E_INVALID_HANDLE);
98
99
*tspContext = obj->tspContext;
100
101
obj_list_put(&nvstore_list);
102
103
return TSS_SUCCESS;
104
}
105
106
TSS_RESULT
107
obj_nvstore_set_index(TSS_HNVSTORE hNvstore, UINT32 index)
108
{
109
struct tsp_object *obj;
110
struct tr_nvstore_obj *nvstore;
111
TSS_RESULT result=TSS_SUCCESS;
112
113
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
114
return TSPERR(TSS_E_INVALID_HANDLE);
115
116
nvstore = (struct tr_nvstore_obj *)obj->data;
117
118
nvstore->nvIndex = index;
119
120
obj_list_put(&nvstore_list);
121
122
return result;
123
}
124
125
TSS_RESULT
126
obj_nvstore_get_index(TSS_HNVSTORE hNvstore, UINT32 * index)
127
{
128
struct tsp_object *obj;
129
struct tr_nvstore_obj *nvstore;
130
TSS_RESULT result=TSS_SUCCESS;
131
132
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
133
return TSPERR(TSS_E_INVALID_HANDLE);
134
135
nvstore = (struct tr_nvstore_obj *)obj->data;
136
137
*index = nvstore->nvIndex;
138
139
obj_list_put(&nvstore_list);
140
141
return result;
142
}
143
144
TSS_RESULT
145
obj_nvstore_set_datasize(TSS_HNVSTORE hNvstore, UINT32 datasize)
146
{
147
struct tsp_object *obj;
148
struct tr_nvstore_obj *nvstore;
149
TSS_RESULT result=TSS_SUCCESS;
150
151
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
152
return TSPERR(TSS_E_INVALID_HANDLE);
153
154
nvstore = (struct tr_nvstore_obj *)obj->data;
155
156
nvstore->dataSize= datasize;
157
158
obj_list_put(&nvstore_list);
159
160
return result;
161
}
162
163
TSS_RESULT
164
obj_nvstore_get_datasize(TSS_HNVSTORE hNvstore, UINT32 * datasize)
165
{
166
struct tsp_object *obj;
167
struct tr_nvstore_obj *nvstore;
168
TSS_RESULT result=TSS_SUCCESS;
169
170
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
171
return TSPERR(TSS_E_INVALID_HANDLE);
172
173
nvstore = (struct tr_nvstore_obj *)obj->data;
174
175
*datasize = nvstore->dataSize;
176
177
obj_list_put(&nvstore_list);
178
179
return result;
180
}
181
182
TSS_RESULT
183
obj_nvstore_set_permission(TSS_HNVSTORE hNvstore, UINT32 permission)
184
{
185
struct tsp_object *obj;
186
struct tr_nvstore_obj *nvstore;
187
TSS_RESULT result=TSS_SUCCESS;
188
189
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
190
return TSPERR(TSS_E_INVALID_HANDLE);
191
192
nvstore = (struct tr_nvstore_obj *)obj->data;
193
194
nvstore->permission.attributes= permission;
195
196
obj_list_put(&nvstore_list);
197
198
return result;
199
}
200
201
TSS_RESULT
202
obj_nvstore_get_permission_from_tpm(TSS_HNVSTORE hNvstore, UINT32 * permission)
203
{
204
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE] = {0};
205
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
206
UINT32 offset;
207
UINT16 pcrread_sizeOfSelect;
208
UINT16 pcrwrite_sizeOfSelect;
209
TPM_NV_ATTRIBUTES nv_attributes_value;
210
TSS_HCONTEXT tspContext;
211
TSS_RESULT result;
212
213
if((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
214
return result;
215
216
if ((result = obj_nvstore_get_tsp_context(hNvstore, &tspContext)))
217
return result;
218
219
offset = 0;
220
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
221
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
222
223
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
224
+ sizeof(TPM_LOCALITY_SELECTION)
225
+ sizeof(TPM_COMPOSITE_HASH);
226
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
227
228
offset = offset + sizeof(UINT16) + pcrwrite_sizeOfSelect
229
+ sizeof(TPM_LOCALITY_SELECTION)
230
+ sizeof(TPM_COMPOSITE_HASH);
231
232
nv_attributes_value.attributes = Decode_UINT32(nv_data_public
233
+ offset + sizeof(TPM_STRUCTURE_TAG));
234
*permission = nv_attributes_value.attributes;
235
236
return result;
237
}
238
239
TSS_RESULT
240
obj_nvstore_get_permission(TSS_HNVSTORE hNvstore, UINT32 * permission)
241
{
242
struct tsp_object *obj;
243
struct tr_nvstore_obj *nvstore;
244
TSS_RESULT result=TSS_SUCCESS;
245
246
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
247
return TSPERR(TSS_E_INVALID_HANDLE);
248
249
nvstore = (struct tr_nvstore_obj *)obj->data;
250
251
*permission = nvstore->permission.attributes;
252
253
obj_list_put(&nvstore_list);
254
255
return result;
256
}
257
258
TSS_RESULT
259
obj_nvstore_set_policy(TSS_HNVSTORE hNvstore, TSS_HPOLICY hPolicy)
260
{
261
struct tsp_object *obj;
262
struct tr_nvstore_obj *nvstore;
263
UINT32 policyType;
264
TSS_RESULT result = TSS_SUCCESS;
265
266
if ((result = obj_policy_get_type(hPolicy, &policyType)))
267
return result;
268
269
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
270
return TSPERR(TSS_E_INVALID_HANDLE);
271
272
nvstore = (struct tr_nvstore_obj *)obj->data;
273
274
switch (policyType) {
275
case TSS_POLICY_USAGE:
276
nvstore->policy = hPolicy;
277
break;
278
default:
279
result = TSPERR(TSS_E_BAD_PARAMETER);
280
}
281
282
obj_list_put(&nvstore_list);
283
284
return result;
285
}
286
287
TSS_RESULT
288
obj_nvstore_get_policy(TSS_HNVSTORE hNvstore, UINT32 policyType, TSS_HPOLICY *phPolicy)
289
{
290
struct tsp_object *obj;
291
struct tr_nvstore_obj *nvstore;
292
TSS_RESULT result=TSS_SUCCESS;
293
294
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
295
return TSPERR(TSS_E_INVALID_HANDLE);
296
297
nvstore = (struct tr_nvstore_obj *)obj->data;
298
299
switch (policyType) {
300
case TSS_POLICY_USAGE:
301
*phPolicy = nvstore->policy;
302
break;
303
default:
304
result = TSPERR(TSS_E_BAD_PARAMETER);
305
}
306
307
obj_list_put(&nvstore_list);
308
309
return result;
310
}
311
312
TSS_RESULT
313
obj_nvstore_get_datapublic(TSS_HNVSTORE hNvstore, UINT32 *size, BYTE *nv_data_public)
314
{
315
struct tsp_object *obj;
316
TSS_HCONTEXT hContext;
317
TSS_HTPM hTpm;
318
TSS_RESULT result;
319
struct tr_nvstore_obj *nvstore;
320
UINT32 uiResultLen;
321
BYTE *pResult;
322
UINT32 i;
323
TPM_BOOL defined_index = FALSE;
324
325
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
326
return TSPERR(TSS_E_INVALID_HANDLE);
327
328
hContext = obj->tspContext;
329
nvstore = (struct tr_nvstore_obj *)obj->data;
330
331
if ((result = obj_tpm_get(hContext, &hTpm)))
332
goto out;
333
334
if ((result = Tspi_TPM_GetCapability(hTpm, TSS_TPMCAP_NV_LIST, 0,
335
NULL, &uiResultLen, &pResult))) {
336
goto out;
337
}
338
339
for (i = 0; i < uiResultLen/sizeof(UINT32); i++) {
340
if (nvstore->nvIndex == Decode_UINT32(pResult + i * sizeof(UINT32))) {
341
defined_index = TRUE;
342
break;
343
}
344
}
345
346
free_tspi(hContext, pResult);
347
348
if (!defined_index) {
349
result = TSPERR(TPM_E_BADINDEX);
350
goto out;
351
}
352
353
if ((result = Tspi_TPM_GetCapability(hTpm, TSS_TPMCAP_NV_INDEX,
354
sizeof(UINT32), (BYTE *)(&(nvstore->nvIndex)),
355
&uiResultLen, &pResult))) {
356
LogDebug("get the index capability error");
357
goto out;
358
}
359
360
if (uiResultLen > *size) {
361
free_tspi(hContext, pResult);
362
result = TSPERR(TSS_E_INTERNAL_ERROR);
363
goto out;
364
}
365
*size = uiResultLen;
366
memcpy(nv_data_public, pResult, uiResultLen);
367
free_tspi(hContext, pResult);
368
369
out:
370
obj_list_put(&nvstore_list);
371
return result;
372
}
373
374
TSS_RESULT
375
obj_nvstore_get_readdigestatrelease(TSS_HNVSTORE hNvstore, UINT32 *size, BYTE **data)
376
{
377
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
378
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
379
UINT32 offset;
380
UINT16 pcrread_sizeOfSelect;
381
TSS_HCONTEXT tspContext;
382
TSS_RESULT result;
383
384
if((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
385
return result;
386
387
if ((result = obj_nvstore_get_tsp_context(hNvstore, &tspContext)))
388
return result;
389
390
*size = sizeof(TPM_COMPOSITE_HASH);
391
*data = calloc_tspi(tspContext, *size);
392
if (*data == NULL) {
393
LogError("malloc of %u bytes failed.", *size);
394
result = TSPERR(TSS_E_OUTOFMEMORY);
395
return result;
396
}
397
398
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
399
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
400
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect + sizeof(TPM_LOCALITY_SELECTION);
401
memcpy(*data, nv_data_public + offset, sizeof(TPM_COMPOSITE_HASH));
402
403
return result;
404
}
405
406
TSS_RESULT
407
obj_nvstore_get_readpcrselection(TSS_HNVSTORE hNvstore, UINT32 *size, BYTE **data)
408
{
409
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
410
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
411
UINT32 offset;
412
UINT16 pcrread_sizeOfSelect;
413
TSS_HCONTEXT tspContext;
414
TSS_RESULT result;
415
416
if((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
417
return result;
418
419
if ((result = obj_nvstore_get_tsp_context(hNvstore, &tspContext)))
420
return result;
421
422
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
423
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
424
425
*size = sizeof(UINT16) + pcrread_sizeOfSelect;
426
*data = calloc_tspi(tspContext, *size);
427
if (*data == NULL) {
428
LogError("malloc of %u bytes failed.", *size);
429
result = TSPERR(TSS_E_OUTOFMEMORY);
430
return result;
431
}
432
433
memcpy(*data, nv_data_public + offset, *size);
434
435
return result;
436
}
437
438
TSS_RESULT
439
obj_nvstore_get_writedigestatrelease(TSS_HNVSTORE hNvstore, UINT32 *size, BYTE **data)
440
{
441
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
442
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
443
UINT32 offset;
444
UINT16 pcrread_sizeOfSelect;
445
UINT16 pcrwrite_sizeOfSelect;
446
TSS_HCONTEXT tspContext;
447
TSS_RESULT result;
448
449
if ((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
450
return result;
451
452
if ((result = obj_nvstore_get_tsp_context(hNvstore, &tspContext)))
453
return result;
454
455
*size = sizeof(TPM_COMPOSITE_HASH);
456
*data = calloc_tspi(tspContext, *size);
457
if (*data == NULL) {
458
LogError("malloc of %u bytes failed.", *size);
459
result = TSPERR(TSS_E_OUTOFMEMORY);
460
return result;
461
}
462
463
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
464
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
465
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
466
+ sizeof(TPM_LOCALITY_SELECTION)
467
+ sizeof(TPM_COMPOSITE_HASH);
468
469
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
470
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect + sizeof(TPM_LOCALITY_SELECTION);
471
memcpy(*data, nv_data_public + offset, sizeof(TPM_COMPOSITE_HASH));
472
473
return result;
474
}
475
476
TSS_RESULT
477
obj_nvstore_get_writepcrselection(TSS_HNVSTORE hNvstore, UINT32 *size, BYTE **data)
478
{
479
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
480
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
481
UINT32 offset;
482
UINT16 pcrread_sizeOfSelect;
483
UINT16 pcrwrite_sizeOfSelect;
484
TSS_HCONTEXT tspContext;
485
TSS_RESULT result;
486
487
if((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
488
return result;
489
490
if ((result = obj_nvstore_get_tsp_context(hNvstore, &tspContext)))
491
return result;
492
493
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
494
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
495
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
496
+ sizeof(TPM_LOCALITY_SELECTION)
497
+ sizeof(TPM_COMPOSITE_HASH);
498
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
499
500
*size = sizeof(UINT16) + pcrwrite_sizeOfSelect;
501
*data = calloc_tspi(tspContext, *size);
502
if (*data == NULL) {
503
LogError("malloc of %u bytes failed.", *size);
504
result = TSPERR(TSS_E_OUTOFMEMORY);
505
return result;
506
}
507
508
memcpy(*data, nv_data_public + offset, *size);
509
return result;
510
}
511
512
TSS_RESULT
513
obj_nvstore_get_state_readstclear(TSS_HNVSTORE hNvstore, UINT32 * readstclear)
514
{
515
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
516
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
517
UINT32 offset;
518
UINT16 pcrread_sizeOfSelect;
519
UINT16 pcrwrite_sizeOfSelect;
520
TPM_BOOL value;
521
TSS_RESULT result;
522
523
if ((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
524
return result;
525
526
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
527
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
528
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
529
+ sizeof(TPM_LOCALITY_SELECTION)
530
+ sizeof(TPM_COMPOSITE_HASH);
531
532
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
533
offset = offset + sizeof(UINT16) + pcrwrite_sizeOfSelect
534
+ sizeof(TPM_LOCALITY_SELECTION)
535
+ sizeof(TPM_COMPOSITE_HASH)
536
+ sizeof(TPM_NV_ATTRIBUTES);
537
538
value = *((TPM_BOOL *)(nv_data_public + offset));
539
540
*readstclear = value;
541
542
return result;
543
}
544
545
TSS_RESULT
546
obj_nvstore_get_state_writedefine(TSS_HNVSTORE hNvstore, UINT32 * writedefine)
547
{
548
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
549
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
550
UINT32 offset;
551
UINT16 pcrread_sizeOfSelect;
552
UINT16 pcrwrite_sizeOfSelect;
553
TPM_BOOL value;
554
TSS_RESULT result;
555
556
if ((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
557
return result;
558
559
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
560
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
561
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
562
+ sizeof(TPM_LOCALITY_SELECTION)
563
+ sizeof(TPM_COMPOSITE_HASH);
564
565
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
566
offset = offset + sizeof(UINT16) + pcrwrite_sizeOfSelect
567
+ sizeof(TPM_LOCALITY_SELECTION)
568
+ sizeof(TPM_COMPOSITE_HASH)
569
+ sizeof(TPM_NV_ATTRIBUTES)
570
+ sizeof(TPM_BOOL)
571
+ sizeof(TPM_BOOL);
572
573
value = *((TPM_BOOL *)(nv_data_public + offset));
574
575
*writedefine = value;
576
577
return result;
578
}
579
580
TSS_RESULT
581
obj_nvstore_get_state_writestclear(TSS_HNVSTORE hNvstore, UINT32 * writestclear)
582
{
583
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
584
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
585
UINT32 offset;
586
UINT16 pcrread_sizeOfSelect;
587
UINT16 pcrwrite_sizeOfSelect;
588
TPM_BOOL value;
589
TSS_RESULT result;
590
591
if ((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
592
return result;
593
594
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
595
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
596
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
597
+ sizeof(TPM_LOCALITY_SELECTION)
598
+ sizeof(TPM_COMPOSITE_HASH);
599
600
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
601
offset = offset + sizeof(UINT16) + pcrwrite_sizeOfSelect
602
+ sizeof(TPM_LOCALITY_SELECTION)
603
+ sizeof(TPM_COMPOSITE_HASH)
604
+ sizeof(TPM_NV_ATTRIBUTES)
605
+ sizeof(TPM_BOOL);
606
607
value = *((TPM_BOOL *)(nv_data_public + offset));
608
*writestclear = value;
609
610
return result;
611
}
612
613
TSS_RESULT
614
obj_nvstore_get_readlocalityatrelease(TSS_HNVSTORE hNvstore, UINT32 * readlocalityatrelease)
615
{
616
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
617
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
618
UINT32 offset;
619
UINT16 pcrread_sizeOfSelect;
620
TPM_LOCALITY_SELECTION locality_value;
621
TSS_RESULT result;
622
623
if ((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
624
return result;
625
626
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
627
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
628
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect;
629
locality_value = *((TPM_LOCALITY_SELECTION *)(nv_data_public + offset));
630
*readlocalityatrelease = locality_value;
631
632
return result;
633
}
634
635
TSS_RESULT
636
obj_nvstore_get_writelocalityatrelease(TSS_HNVSTORE hNvstore, UINT32 * writelocalityatrelease)
637
{
638
BYTE nv_data_public[MAX_PUBLIC_DATA_SIZE];
639
UINT32 data_public_size = MAX_PUBLIC_DATA_SIZE;
640
UINT32 offset;
641
UINT16 pcrread_sizeOfSelect;
642
UINT16 pcrwrite_sizeOfSelect;
643
TPM_LOCALITY_SELECTION locality_value;
644
TSS_RESULT result;
645
646
if ((result = obj_nvstore_get_datapublic(hNvstore, &data_public_size, nv_data_public)))
647
return result;
648
649
offset = sizeof(TPM_STRUCTURE_TAG)+ sizeof(TPM_NV_INDEX);
650
pcrread_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
651
offset = offset + sizeof(UINT16) + pcrread_sizeOfSelect
652
+ sizeof(TPM_LOCALITY_SELECTION)
653
+ sizeof(TPM_COMPOSITE_HASH);
654
pcrwrite_sizeOfSelect = Decode_UINT16(nv_data_public + offset);
655
offset = offset + sizeof(UINT16) + pcrwrite_sizeOfSelect;
656
657
locality_value = *((TPM_LOCALITY_SELECTION *)(nv_data_public + offset));
658
*writelocalityatrelease = locality_value;
659
660
return result;
661
}
662
663
TSS_RESULT
664
obj_nvstore_create_pcrshortinfo(TSS_HNVSTORE hNvstore,
665
TSS_HPCRS hPcrComposite,
666
UINT32 *size,
667
BYTE **data)
668
{
669
struct tsp_object *obj;
670
BYTE pdata[MAX_PUBLIC_DATA_SIZE];
671
UINT32 dataLen;
672
UINT64 offset;
673
TSS_HCONTEXT tspContext;
674
TSS_RESULT result = TSS_SUCCESS;
675
BYTE* ppbHashData;
676
UINT32 i;
677
BYTE digAtRelease[TPM_SHA1_160_HASH_LEN] = { 0, };
678
UINT32 tmp_locAtRelease;
679
TPM_LOCALITY_SELECTION locAtRelease = TPM_LOC_ZERO | TPM_LOC_ONE
680
| TPM_LOC_TWO | TPM_LOC_THREE| TPM_LOC_FOUR;
681
BYTE tmp_pcr_select[3] = {0, 0, 0};
682
TCPA_PCR_SELECTION pcrSelect = { 3, tmp_pcr_select};
683
684
if ((obj = obj_list_get_obj(&nvstore_list, hNvstore)) == NULL)
685
return TSPERR(TSS_E_INVALID_HANDLE);
686
687
tspContext = obj->tspContext;
688
689
if (hPcrComposite) {
690
if ((result = obj_pcrs_get_selection(hPcrComposite, &dataLen, pdata))) {
691
LogDebug("get_selection error from hReadPcrComposite");
692
goto out;
693
}
694
695
/* the index should not >= 24, so the sizeofselect should not be >3*/
696
if (dataLen - sizeof(UINT16) > 3) {
697
result = TSPERR(TSS_E_BAD_PARAMETER);
698
goto out;
699
}
700
offset = 0;
701
Trspi_UnloadBlob_PCR_SELECTION(&offset, pdata, &pcrSelect);
702
703
if (pcrSelect.sizeOfSelect != 0) {
704
if ((result = obj_pcrs_get_digest_at_release(hPcrComposite,
705
&dataLen, &ppbHashData))) {
706
LogDebug("get_composite error from hReadPcrComposite");
707
goto out;
708
}
709
memcpy(digAtRelease, ppbHashData, dataLen);
710
free_tspi(tspContext, ppbHashData);
711
} else {
712
pcrSelect.sizeOfSelect = 3;
713
pcrSelect.pcrSelect = tmp_pcr_select;
714
}
715
716
if (pcrSelect.sizeOfSelect < 3) {
717
for (i = 0; i < pcrSelect.sizeOfSelect; i++) {
718
tmp_pcr_select[i] = pcrSelect.pcrSelect[i];
719
}
720
pcrSelect.sizeOfSelect = 3;
721
pcrSelect.pcrSelect = tmp_pcr_select;
722
}
723
724
if ((result = obj_pcrs_get_locality(hPcrComposite, &tmp_locAtRelease)))
725
goto out;
726
locAtRelease = (TPM_LOCALITY_SELECTION)(tmp_locAtRelease & TSS_LOCALITY_MASK);
727
}
728
729
*size = sizeof(UINT16) + 3 + sizeof(TPM_LOCALITY_SELECTION) + TPM_SHA1_160_HASH_LEN;
730
*data = calloc_tspi(tspContext, *size);
731
if (*data == NULL) {
732
LogError("malloc of %u bytes failed.", *size);
733
result = TSPERR(TSS_E_OUTOFMEMORY);
734
goto out;
735
}
736
737
offset = 0;
738
Trspi_LoadBlob_PCR_SELECTION(&offset, *data, &pcrSelect);
739
Trspi_LoadBlob_BYTE(&offset, locAtRelease, *data);
740
Trspi_LoadBlob(&offset, TPM_SHA1_160_HASH_LEN, *data, digAtRelease);
741
742
out:
743
obj_list_put(&nvstore_list);
744
return result;
745
}
746
747
Loggerhead is a web-based interface for Breezy
Version: 2.0.1