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. 2004-2006
8 *
9 */
10
11#include <stdlib.h>
12#include <stdio.h>
13#include <string.h>
14#include <assert.h>
15
16#include "trousers/tss.h"
17#include "trousers/trousers.h"
18#include "trousers_types.h"
19#include "spi_utils.h"
20#include "capabilities.h"
21#include "tsplog.h"
22#include "hosttable.h"
23#include "tcsd_wrap.h"
24#include "obj.h"
25#include "rpc_tcstp_tsp.h"
26
27
28TSS_RESULT
29RPC_CreateMigrationBlob_TP(struct host_table_entry *hte,
30					TCS_KEY_HANDLE parentHandle,	/* in */
31					TSS_MIGRATE_SCHEME migrationType,	/* in */
32					UINT32 MigrationKeyAuthSize,	/* in */
33					BYTE * MigrationKeyAuth,	/* in */
34					UINT32 encDataSize,	/* in */
35					BYTE * encData,	/* in */
36					TPM_AUTH * parentAuth,	/* in, out */
37					TPM_AUTH * entityAuth,	/* in, out */
38					UINT32 * randomSize,	/* out */
39					BYTE ** random,	/* out */
40					UINT32 * outDataSize,	/* out */
41					BYTE ** outData	/* out */
42    ) {
43	TSS_RESULT result;
44	TPM_AUTH null_auth;
45	UINT32 i;
46
47	initData(&hte->comm, 9);
48	memset(&null_auth, 0, sizeof(TPM_AUTH));
49
50	hte->comm.hdr.u.ordinal = TCSD_ORD_CREATEMIGRATIONBLOB;
51	LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
52
53	i = 0;
54	if (setData(TCSD_PACKET_TYPE_UINT32, i++, &hte->tcsContext, 0, &hte->comm))
55		return TSPERR(TSS_E_INTERNAL_ERROR);
56	if (setData(TCSD_PACKET_TYPE_UINT32, i++, &parentHandle, 0, &hte->comm))
57		return TSPERR(TSS_E_INTERNAL_ERROR);
58	if (setData(TCSD_PACKET_TYPE_UINT16, i++, &migrationType, 0, &hte->comm))
59		return TSPERR(TSS_E_INTERNAL_ERROR);
60	if (setData(TCSD_PACKET_TYPE_UINT32, i++, &MigrationKeyAuthSize, 0, &hte->comm))
61		return TSPERR(TSS_E_INTERNAL_ERROR);
62	if (setData(TCSD_PACKET_TYPE_PBYTE, i++, MigrationKeyAuth, MigrationKeyAuthSize, &hte->comm))
63		return TSPERR(TSS_E_INTERNAL_ERROR);
64	if (setData(TCSD_PACKET_TYPE_UINT32, i++, &encDataSize, 0, &hte->comm))
65		return TSPERR(TSS_E_INTERNAL_ERROR);
66	if (setData(TCSD_PACKET_TYPE_PBYTE, i++, encData, encDataSize, &hte->comm))
67		return TSPERR(TSS_E_INTERNAL_ERROR);
68
69	if (parentAuth) {
70		if (setData(TCSD_PACKET_TYPE_AUTH, i++, parentAuth, 0, &hte->comm))
71			return TSPERR(TSS_E_INTERNAL_ERROR);
72	}
73
74	if (setData(TCSD_PACKET_TYPE_AUTH, i++, entityAuth, 0, &hte->comm))
75		return TSPERR(TSS_E_INTERNAL_ERROR);
76
77	result = sendTCSDPacket(hte);
78
79	if (result == TSS_SUCCESS)
80		result = hte->comm.hdr.u.result;
81
82	if (result == TSS_SUCCESS) {
83		i = 0;
84		if (parentAuth) {
85			if (getData(TCSD_PACKET_TYPE_AUTH, i++, parentAuth, 0, &hte->comm)) {
86				result = TSPERR(TSS_E_INTERNAL_ERROR);
87				goto done;
88			}
89		}
90		if (getData(TCSD_PACKET_TYPE_AUTH, i++, entityAuth, 0, &hte->comm)) {
91			result = TSPERR(TSS_E_INTERNAL_ERROR);
92			goto done;
93		}
94
95		if (getData(TCSD_PACKET_TYPE_UINT32, i++, randomSize, 0, &hte->comm)) {
96			result = TSPERR(TSS_E_INTERNAL_ERROR);
97			goto done;
98		}
99
100		if (*randomSize > 0) {
101			*random = (BYTE *)malloc(*randomSize);
102			if (*random == NULL) {
103				LogError("malloc of %u bytes failed.", *randomSize);
104				result = TSPERR(TSS_E_OUTOFMEMORY);
105				goto done;
106			}
107			if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *random, *randomSize, &hte->comm)) {
108				free(*random);
109				result = TSPERR(TSS_E_INTERNAL_ERROR);
110				goto done;
111			}
112		}
113
114		if (getData(TCSD_PACKET_TYPE_UINT32, i++, outDataSize, 0, &hte->comm)) {
115			if (*randomSize > 0)
116				free(*random);
117			result = TSPERR(TSS_E_INTERNAL_ERROR);
118			goto done;
119		}
120
121		*outData = (BYTE *)malloc(*outDataSize);
122		if (*outData == NULL) {
123			if (*randomSize > 0)
124				free(*random);
125			LogError("malloc of %u bytes failed.", *outDataSize);
126			result = TSPERR(TSS_E_OUTOFMEMORY);
127			goto done;
128		}
129		if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *outData, *outDataSize, &hte->comm)) {
130			if (*randomSize > 0)
131				free(*random);
132			free(*outData);
133			result = TSPERR(TSS_E_INTERNAL_ERROR);
134			goto done;
135		}
136	}
137
138done:
139	return result;
140}
141
142TSS_RESULT
143RPC_ConvertMigrationBlob_TP(struct host_table_entry *hte,
144					 TCS_KEY_HANDLE parentHandle,	/* in */
145					 UINT32 inDataSize,	/* in */
146					 BYTE * inData,	/* in */
147					 UINT32 randomSize,	/* in */
148					 BYTE * random,	/* in */
149					 TPM_AUTH * parentAuth,	/* in, out */
150					 UINT32 * outDataSize,	/* out */
151					 BYTE ** outData	/* out */
152    ) {
153	TSS_RESULT result;
154	UINT32 i;
155
156	initData(&hte->comm, 7);
157	hte->comm.hdr.u.ordinal = TCSD_ORD_CONVERTMIGRATIONBLOB;
158	LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
159
160	if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
161		return TSPERR(TSS_E_INTERNAL_ERROR);
162	if (setData(TCSD_PACKET_TYPE_UINT32, 1, &parentHandle, 0, &hte->comm))
163		return TSPERR(TSS_E_INTERNAL_ERROR);
164	if (setData(TCSD_PACKET_TYPE_UINT32, 2, &inDataSize, 0, &hte->comm))
165		return TSPERR(TSS_E_INTERNAL_ERROR);
166	if (setData(TCSD_PACKET_TYPE_PBYTE, 3, inData, inDataSize, &hte->comm))
167		return TSPERR(TSS_E_INTERNAL_ERROR);
168	if (setData(TCSD_PACKET_TYPE_UINT32, 4, &randomSize, 0, &hte->comm))
169		return TSPERR(TSS_E_INTERNAL_ERROR);
170	if (setData(TCSD_PACKET_TYPE_PBYTE, 5, random, randomSize, &hte->comm))
171		return TSPERR(TSS_E_INTERNAL_ERROR);
172
173	if (parentAuth) {
174		if (setData(TCSD_PACKET_TYPE_AUTH, 6, parentAuth, 0, &hte->comm))
175			return TSPERR(TSS_E_INTERNAL_ERROR);
176	}
177
178	result = sendTCSDPacket(hte);
179
180	if (result == TSS_SUCCESS)
181		result = hte->comm.hdr.u.result;
182
183	if (result == TSS_SUCCESS) {
184		i = 0;
185		if (parentAuth) {
186			if (getData(TCSD_PACKET_TYPE_AUTH, i++, parentAuth, 0, &hte->comm)) {
187				result = TSPERR(TSS_E_INTERNAL_ERROR);
188				goto done;
189			}
190		}
191
192		if (getData(TCSD_PACKET_TYPE_UINT32, i++, outDataSize, 0, &hte->comm)) {
193			result = TSPERR(TSS_E_INTERNAL_ERROR);
194			goto done;
195		}
196
197		*outData = (BYTE *)malloc(*outDataSize);
198		if (*outData == NULL) {
199			LogError("malloc of %u bytes failed.", *outDataSize);
200			result = TSPERR(TSS_E_OUTOFMEMORY);
201			goto done;
202		}
203		if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *outData, *outDataSize, &hte->comm)) {
204			result = TSPERR(TSS_E_INTERNAL_ERROR);
205			goto done;
206		}
207	}
208
209done:
210	return result;
211}
212
213TSS_RESULT
214RPC_AuthorizeMigrationKey_TP(struct host_table_entry *hte,
215					  TSS_MIGRATE_SCHEME migrateScheme,	/* in */
216					  UINT32 MigrationKeySize,	/* in */
217					  BYTE * MigrationKey,	/* in */
218					  TPM_AUTH * ownerAuth,	/* in, out */
219					  UINT32 * MigrationKeyAuthSize,	/* out */
220					  BYTE ** MigrationKeyAuth	/* out */
221    ) {
222	TSS_RESULT result;
223
224	initData(&hte->comm, 5);
225	hte->comm.hdr.u.ordinal = TCSD_ORD_AUTHORIZEMIGRATIONKEY;
226	LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
227
228	if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
229		return TSPERR(TSS_E_INTERNAL_ERROR);
230	if (setData(TCSD_PACKET_TYPE_UINT16, 1, &migrateScheme, 0, &hte->comm))
231		return TSPERR(TSS_E_INTERNAL_ERROR);
232	if (setData(TCSD_PACKET_TYPE_UINT32, 2, &MigrationKeySize, 0, &hte->comm))
233		return TSPERR(TSS_E_INTERNAL_ERROR);
234	if (setData(TCSD_PACKET_TYPE_PBYTE, 3, MigrationKey, MigrationKeySize, &hte->comm))
235		return TSPERR(TSS_E_INTERNAL_ERROR);
236	if (setData(TCSD_PACKET_TYPE_AUTH, 4, ownerAuth, 0, &hte->comm))
237		return TSPERR(TSS_E_INTERNAL_ERROR);
238
239	result = sendTCSDPacket(hte);
240
241	if (result == TSS_SUCCESS)
242		result = hte->comm.hdr.u.result;
243
244	if (result == TSS_SUCCESS) {
245		if (getData(TCSD_PACKET_TYPE_AUTH, 0, ownerAuth, 0, &hte->comm)) {
246			result = TSPERR(TSS_E_INTERNAL_ERROR);
247			goto done;
248		}
249		if (getData(TCSD_PACKET_TYPE_UINT32, 1, MigrationKeyAuthSize, 0, &hte->comm)) {
250			result = TSPERR(TSS_E_INTERNAL_ERROR);
251			goto done;
252		}
253
254		*MigrationKeyAuth = (BYTE *)malloc(*MigrationKeyAuthSize);
255		if (*MigrationKeyAuth == NULL) {
256			LogError("malloc of %u bytes failed.", *MigrationKeyAuthSize);
257			result = TSPERR(TSS_E_OUTOFMEMORY);
258			goto done;
259		}
260		if (getData(TCSD_PACKET_TYPE_PBYTE, 2, *MigrationKeyAuth, *MigrationKeyAuthSize,
261			    &hte->comm)) {
262			free(*MigrationKeyAuth);
263			result = TSPERR(TSS_E_INTERNAL_ERROR);
264			goto done;
265		}
266	}
267
268done:
269	return result;
270}
271