1
2/*
3 * Licensed Materials - Property of IBM
4 *
5 * trousers - An open source TCG Software Stack
6 *
7 * (C) Copyright International Business Machines Corp. 2007
8 *
9 */
10
11
12#include <stdlib.h>
13#include <stdio.h>
14#include <errno.h>
15#include <string.h>
16
17#include "trousers/tss.h"
18#include "trousers/trousers.h"
19#include "trousers_types.h"
20#include "spi_utils.h"
21#include "capabilities.h"
22#include "tsplog.h"
23#include "obj.h"
24
25
26void
27migdata_free(void *data)
28{
29	struct tr_migdata_obj *migdata = (struct tr_migdata_obj *)data;
30
31	free(migdata);
32}
33
34TSS_BOOL
35obj_is_migdata(TSS_HOBJECT hObject)
36{
37	TSS_BOOL answer = FALSE;
38
39	if ((obj_list_get_obj(&migdata_list, hObject))) {
40		answer = TRUE;
41		obj_list_put(&migdata_list);
42	}
43
44	return answer;
45}
46
47TSS_RESULT
48obj_migdata_add(TSS_HCONTEXT hContext, TSS_HOBJECT *phObject)
49{
50	TSS_RESULT result;
51	struct tr_migdata_obj *migdata = calloc(1, sizeof(struct tr_migdata_obj));
52
53	if (migdata == NULL) {
54		LogError("malloc of %zd bytes failed.",	sizeof(struct tr_migdata_obj));
55		return TSPERR(TSS_E_OUTOFMEMORY);
56	}
57
58	if ((result = obj_list_add(&migdata_list, hContext, 0, migdata, phObject))) {
59		free(migdata);
60		return result;
61	}
62
63	return TSS_SUCCESS;
64}
65
66TSS_RESULT
67obj_migdata_remove(TSS_HMIGDATA hMigData, TSS_HCONTEXT hContext)
68{
69	TSS_RESULT result;
70
71	if ((result = obj_list_remove(&migdata_list, &migdata_free, hMigData, hContext)))
72		return result;
73
74	return TSS_SUCCESS;
75}
76
77TSS_RESULT
78obj_migdata_get_tsp_context(TSS_HMIGDATA hMigData, TSS_HCONTEXT *hContext)
79{
80	struct tsp_object *obj;
81
82	if ((obj = obj_list_get_obj(&migdata_list, hMigData)) == NULL)
83		return TSPERR(TSS_E_INVALID_HANDLE);
84
85	*hContext = obj->tspContext;
86
87	obj_list_put(&migdata_list);
88
89	return TSS_SUCCESS;
90}
91
92TSS_RESULT
93obj_migdata_set_migrationblob(TSS_HMIGDATA hMigData, UINT32 whichOne, UINT32 blobSize, BYTE *blob)
94{
95	TSS_RESULT result;
96
97	switch (whichOne) {
98	case TSS_MIGATTRIB_MIG_MSALIST_PUBKEY_BLOB:
99		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
117TSS_RESULT
118obj_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
133TSS_RESULT
134obj_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
155TSS_RESULT
156obj_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
177TSS_RESULT
178obj_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
199TSS_RESULT
200obj_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
221TSS_RESULT
222obj_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
246TSS_RESULT
247obj_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
262TSS_RESULT
263obj_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
284done:
285	obj_list_put(&migdata_list);
286
287	return result;
288}
289
290TSS_RESULT
291obj_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
310done:
311	obj_list_put(&migdata_list);
312
313	return result;
314}
315
316TSS_RESULT
317obj_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
350done:
351	obj_list_put(&migdata_list);
352
353	return result;
354}
355
356TSS_RESULT
357obj_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
385done:
386	obj_list_put(&migdata_list);
387
388	return result;
389}
390
391TSS_RESULT
392obj_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
421done:
422	obj_list_put(&migdata_list);
423
424	return result;
425}
426
427TSS_RESULT
428obj_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
445done:
446	obj_list_put(&migdata_list);
447
448	return result;
449}
450
451TSS_RESULT
452obj_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
471done:
472	obj_list_put(&migdata_list);
473
474	return result;
475}
476
477TSS_RESULT
478obj_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
502done:
503	obj_list_put(&migdata_list);
504
505	return result;
506}
507
508TSS_RESULT
509obj_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
526done:
527	obj_list_put(&migdata_list);
528
529	return result;
530}
531
532TSS_RESULT
533obj_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
552done:
553	obj_list_put(&migdata_list);
554
555	return result;
556}
557
558TSS_RESULT
559obj_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
578done:
579	obj_list_put(&migdata_list);
580
581	return TSS_SUCCESS;
582}
583
584TSS_RESULT
585obj_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
604done:
605	obj_list_put(&migdata_list);
606
607	return result;
608}
609
610TSS_RESULT
611obj_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
630done:
631	obj_list_put(&migdata_list);
632
633	return result;
634}
635
636TSS_RESULT
637obj_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
656done:
657	obj_list_put(&migdata_list);
658
659	return TSS_SUCCESS;
660}
661
662TSS_RESULT
663obj_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
682done:
683	obj_list_put(&migdata_list);
684
685	return result;
686}
687
688TSS_RESULT
689obj_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
708done:
709	obj_list_put(&migdata_list);
710
711	return result;
712}
713
714TSS_RESULT
715obj_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
734done:
735	obj_list_put(&migdata_list);
736
737	return TSS_SUCCESS;
738}
739
740TSS_RESULT
741obj_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
760done:
761	obj_list_put(&migdata_list);
762
763	return result;
764}
765
766TSS_RESULT
767obj_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
786done:
787	obj_list_put(&migdata_list);
788
789	return result;
790}
791
792TSS_RESULT
793obj_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
818done:
819	obj_list_put(&migdata_list);
820
821	return result;
822}
823
824TSS_RESULT
825obj_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
844TSS_RESULT
845obj_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
870done:
871	obj_list_put(&migdata_list);
872
873	return result;
874}
875
876TSS_RESULT
877obj_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
894done:
895	obj_list_put(&migdata_list);
896
897	return result;
898}
899
900TSS_RESULT
901obj_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
920done:
921	obj_list_put(&migdata_list);
922
923	return result;
924}
925
926TSS_RESULT
927obj_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
948done:
949	obj_list_put(&migdata_list);
950
951	return result;
952}
953
954TSS_RESULT
955obj_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
974done:
975	obj_list_put(&migdata_list);
976
977	return result;
978}
979
980TSS_RESULT
981obj_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
998done:
999	obj_list_put(&migdata_list);
1000
1001	return result;
1002}
1003
1004TSS_RESULT
1005obj_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
1024done:
1025	obj_list_put(&migdata_list);
1026
1027	return result;
1028}
1029
1030TSS_RESULT
1031obj_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
1052done:
1053	obj_list_put(&migdata_list);
1054
1055	return result;
1056}
1057
1058TSS_RESULT
1059obj_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
1078done:
1079	obj_list_put(&migdata_list);
1080
1081	return result;
1082}
1083
1084
1085TSS_RESULT
1086obj_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
1098TSS_RESULT
1099obj_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
1111TSS_RESULT
1112obj_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}
1125