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-2007
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_MakeIdentity_TP(struct host_table_entry *hte,
30		    TCPA_ENCAUTH identityAuth,	/* in */
31		    TCPA_CHOSENID_HASH IDLabel_PrivCAHash,	/* in */
32		    UINT32 idKeyInfoSize,	/* in */
33		    BYTE * idKeyInfo,	/* in */
34		    TPM_AUTH * pSrkAuth,	/* in, out */
35		    TPM_AUTH * pOwnerAuth,	/* in, out */
36		    UINT32 * idKeySize,	/* out */
37		    BYTE ** idKey,	/* out */
38		    UINT32 * pcIdentityBindingSize,	/* out */
39		    BYTE ** prgbIdentityBinding,	/* out */
40		    UINT32 * pcEndorsementCredentialSize,	/* out */
41		    BYTE ** prgbEndorsementCredential,	/* out */
42		    UINT32 * pcPlatformCredentialSize,	/* out */
43		    BYTE ** prgbPlatformCredential,	/* out */
44		    UINT32 * pcConformanceCredentialSize,	/* out */
45		    BYTE ** prgbConformanceCredential)	/* out */
46{
47	TSS_RESULT result;
48	int i;
49
50	initData(&hte->comm, 7);
51	hte->comm.hdr.u.ordinal = TCSD_ORD_MAKEIDENTITY;
52	LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
53
54	if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
55		return TSPERR(TSS_E_INTERNAL_ERROR);
56	if (setData(TCSD_PACKET_TYPE_ENCAUTH, 1, &identityAuth, 0, &hte->comm))
57		return TSPERR(TSS_E_INTERNAL_ERROR);
58	if (setData(TCSD_PACKET_TYPE_DIGEST, 2, &IDLabel_PrivCAHash, 0, &hte->comm))
59		return TSPERR(TSS_E_INTERNAL_ERROR);
60	if (setData(TCSD_PACKET_TYPE_UINT32, 3, &idKeyInfoSize, 0, &hte->comm))
61		return TSPERR(TSS_E_INTERNAL_ERROR);
62	if (setData(TCSD_PACKET_TYPE_PBYTE, 4, idKeyInfo, idKeyInfoSize, &hte->comm))
63		return TSPERR(TSS_E_INTERNAL_ERROR);
64	i = 5;
65	if (pSrkAuth) {
66		if (setData(TCSD_PACKET_TYPE_AUTH, i++, pSrkAuth, 0, &hte->comm))
67			return TSPERR(TSS_E_INTERNAL_ERROR);
68	}
69	if (setData(TCSD_PACKET_TYPE_AUTH, i++, pOwnerAuth, 0, &hte->comm))
70		return TSPERR(TSS_E_INTERNAL_ERROR);
71
72	result = sendTCSDPacket(hte);
73
74	if (result == TSS_SUCCESS)
75		result = hte->comm.hdr.u.result;
76
77	i = 0;
78	if (result == TSS_SUCCESS) {
79		i = 0;
80		if (pSrkAuth) {
81			if (getData(TCSD_PACKET_TYPE_AUTH, i++, pSrkAuth, 0, &hte->comm)) {
82				result = TSPERR(TSS_E_INTERNAL_ERROR);
83				goto done;
84			}
85		}
86		if (getData(TCSD_PACKET_TYPE_AUTH, i++, pOwnerAuth, 0, &hte->comm)) {
87			result = TSPERR(TSS_E_INTERNAL_ERROR);
88			goto done;
89		}
90		if (getData(TCSD_PACKET_TYPE_UINT32, i++, idKeySize, 0, &hte->comm)) {
91			result = TSPERR(TSS_E_INTERNAL_ERROR);
92			goto done;
93		}
94
95		*idKey = (BYTE *) malloc(*idKeySize);
96		if (*idKey == NULL) {
97			LogError("malloc of %u bytes failed.", *idKeySize);
98			result = TSPERR(TSS_E_OUTOFMEMORY);
99			goto done;
100		}
101		if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *idKey, *idKeySize, &hte->comm)) {
102			free(*idKey);
103			result = TSPERR(TSS_E_INTERNAL_ERROR);
104			goto done;
105		}
106		if (getData(TCSD_PACKET_TYPE_UINT32, i++, pcIdentityBindingSize, 0, &hte->comm)) {
107			free(*idKey);
108			result = TSPERR(TSS_E_INTERNAL_ERROR);
109			goto done;
110		}
111
112		*prgbIdentityBinding = (BYTE *) malloc(*pcIdentityBindingSize);
113		if (*prgbIdentityBinding == NULL) {
114			LogError("malloc of %u bytes failed.", *pcIdentityBindingSize);
115			free(*idKey);
116			result = TSPERR(TSS_E_OUTOFMEMORY);
117			goto done;
118		}
119		if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *prgbIdentityBinding, *pcIdentityBindingSize, &hte->comm)) {
120			free(*idKey);
121			free(*prgbIdentityBinding);
122			result = TSPERR(TSS_E_INTERNAL_ERROR);
123			goto done;
124		}
125		if (getData(TCSD_PACKET_TYPE_UINT32, i++, pcEndorsementCredentialSize, 0, &hte->comm)) {
126			free(*idKey);
127			free(*prgbIdentityBinding);
128			result = TSPERR(TSS_E_INTERNAL_ERROR);
129			goto done;
130		}
131
132		*prgbEndorsementCredential = (BYTE *) malloc(*pcEndorsementCredentialSize);
133		if (*prgbEndorsementCredential == NULL) {
134			LogError("malloc of %u bytes failed.", *pcEndorsementCredentialSize);
135			free(*idKey);
136			free(*prgbIdentityBinding);
137			*prgbIdentityBinding = NULL;
138			result = TSPERR(TSS_E_OUTOFMEMORY);
139			goto done;
140		}
141		if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *prgbEndorsementCredential, *pcEndorsementCredentialSize, &hte->comm)) {
142			free(*idKey);
143			free(*prgbIdentityBinding);
144			*prgbIdentityBinding = NULL;
145			free(*prgbEndorsementCredential);
146			*prgbEndorsementCredential = NULL;
147			result = TSPERR(TSS_E_INTERNAL_ERROR);
148			goto done;
149		}
150		if (getData(TCSD_PACKET_TYPE_UINT32, i++, pcPlatformCredentialSize, 0, &hte->comm)) {
151			free(*idKey);
152			free(*prgbIdentityBinding);
153			*prgbIdentityBinding = NULL;
154			free(*prgbEndorsementCredential);
155			*prgbEndorsementCredential = NULL;
156			result = TSPERR(TSS_E_INTERNAL_ERROR);
157			goto done;
158		}
159
160		*prgbPlatformCredential = (BYTE *) malloc(*pcPlatformCredentialSize);
161		if (*prgbPlatformCredential == NULL) {
162			LogError("malloc of %u bytes failed.", *pcPlatformCredentialSize);
163			free(*idKey);
164			free(*prgbIdentityBinding);
165			*prgbIdentityBinding = NULL;
166			free(*prgbEndorsementCredential);
167			*prgbEndorsementCredential = NULL;
168			result = TSPERR(TSS_E_OUTOFMEMORY);
169			goto done;
170		}
171		if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *prgbPlatformCredential, *pcPlatformCredentialSize, &hte->comm)) {
172			free(*idKey);
173			free(*prgbIdentityBinding);
174			*prgbIdentityBinding = NULL;
175			free(*prgbEndorsementCredential);
176			*prgbEndorsementCredential = NULL;
177			free(*prgbPlatformCredential);
178			*prgbPlatformCredential = NULL;
179			result = TSPERR(TSS_E_INTERNAL_ERROR);
180			goto done;
181		}
182		if (getData(TCSD_PACKET_TYPE_UINT32, i++, pcConformanceCredentialSize, 0, &hte->comm)) {
183			free(*idKey);
184			free(*prgbIdentityBinding);
185			*prgbIdentityBinding = NULL;
186			free(*prgbEndorsementCredential);
187			*prgbEndorsementCredential = NULL;
188			free(*prgbPlatformCredential);
189			*prgbPlatformCredential = NULL;
190			result = TSPERR(TSS_E_INTERNAL_ERROR);
191			goto done;
192		}
193
194		*prgbConformanceCredential = (BYTE *) malloc(*pcConformanceCredentialSize);
195		if (*prgbConformanceCredential == NULL) {
196			LogError("malloc of %u bytes failed.", *pcConformanceCredentialSize);
197			free(*idKey);
198			free(*prgbIdentityBinding);
199			*prgbIdentityBinding = NULL;
200			free(*prgbEndorsementCredential);
201			*prgbEndorsementCredential = NULL;
202			free(*prgbPlatformCredential);
203			*prgbPlatformCredential = NULL;
204			result = TSPERR(TSS_E_OUTOFMEMORY);
205			goto done;
206		}
207		if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *prgbConformanceCredential, *pcConformanceCredentialSize, &hte->comm)) {
208			free(*idKey);
209			free(*prgbIdentityBinding);
210			*prgbIdentityBinding = NULL;
211			free(*prgbEndorsementCredential);
212			*prgbEndorsementCredential = NULL;
213			free(*prgbPlatformCredential);
214			*prgbPlatformCredential = NULL;
215			free(*prgbConformanceCredential);
216			*prgbConformanceCredential = NULL;
217			result = TSPERR(TSS_E_INTERNAL_ERROR);
218		}
219	}
220
221done:
222	return result;
223}
224
225TSS_RESULT
226RPC_GetCredential_TP(struct host_table_entry *hte,
227		     UINT32 ulCredentialType,          /* in */
228		     UINT32 ulCredentialAccessMode,    /* in */
229		     UINT32 * pulCredentialSize,       /* out */
230		     BYTE ** prgbCredentialData)       /* out */
231{
232	TSS_RESULT result;
233
234	initData(&hte->comm, 3);
235	hte->comm.hdr.u.ordinal = TCSD_ORD_GETCREDENTIAL;
236	LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
237
238	if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
239		return TSPERR(TSS_E_INTERNAL_ERROR);
240	if (setData(TCSD_PACKET_TYPE_UINT32, 1, &ulCredentialType, 0, &hte->comm))
241		return TSPERR(TSS_E_INTERNAL_ERROR);
242	if (setData(TCSD_PACKET_TYPE_UINT32, 2, &ulCredentialAccessMode, 0, &hte->comm))
243		return TSPERR(TSS_E_INTERNAL_ERROR);
244
245	result = sendTCSDPacket(hte);
246
247	if (result == TSS_SUCCESS)
248		result = hte->comm.hdr.u.result;
249
250	if (result == TSS_SUCCESS) {
251		if (getData(TCSD_PACKET_TYPE_UINT32, 0, pulCredentialSize, 0, &hte->comm)) {
252			return TSPERR(TSS_E_INTERNAL_ERROR);
253		}
254
255		*prgbCredentialData = (BYTE *) malloc(*pulCredentialSize);
256		if (*prgbCredentialData == NULL) {
257			LogError("malloc of %u bytes failed.", *pulCredentialSize);
258			return TSPERR(TSS_E_OUTOFMEMORY);
259		}
260
261		if (getData(TCSD_PACKET_TYPE_PBYTE, 1, *prgbCredentialData,
262			    *pulCredentialSize, &hte->comm)) {
263			free(*prgbCredentialData);
264			result = TSPERR(TSS_E_INTERNAL_ERROR);
265                }
266	}
267	return result;
268}
269
270TSS_RESULT
271RPC_ActivateTPMIdentity_TP(struct host_table_entry *hte,
272			   TCS_KEY_HANDLE idKey,	/* in */
273			   UINT32 blobSize,	/* in */
274			   BYTE * blob,	/* in */
275			   TPM_AUTH * idKeyAuth,	/* in, out */
276			   TPM_AUTH * ownerAuth,	/* in, out */
277			   UINT32 * SymmetricKeySize,	/* out */
278			   BYTE ** SymmetricKey)	/* out */
279{
280	TSS_RESULT result;
281	int i = 0;
282
283	initData(&hte->comm, 6);
284	hte->comm.hdr.u.ordinal = TCSD_ORD_ACTIVATETPMIDENTITY;
285	LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
286
287	if (setData(TCSD_PACKET_TYPE_UINT32, i++, &hte->tcsContext, 0, &hte->comm))
288		return TSPERR(TSS_E_INTERNAL_ERROR);
289	if (setData(TCSD_PACKET_TYPE_UINT32, i++, &idKey, 0, &hte->comm))
290		return TSPERR(TSS_E_INTERNAL_ERROR);
291	if (setData(TCSD_PACKET_TYPE_UINT32, i++, &blobSize, 0, &hte->comm))
292		return TSPERR(TSS_E_INTERNAL_ERROR);
293	if (setData(TCSD_PACKET_TYPE_PBYTE, i++, blob, blobSize, &hte->comm))
294		return TSPERR(TSS_E_INTERNAL_ERROR);
295
296	if (idKeyAuth) {
297		if (setData(TCSD_PACKET_TYPE_AUTH, i++, idKeyAuth, 0, &hte->comm))
298			return TSPERR(TSS_E_INTERNAL_ERROR);
299	}
300	if (setData(TCSD_PACKET_TYPE_AUTH, i++, ownerAuth, 0, &hte->comm))
301		return TSPERR(TSS_E_INTERNAL_ERROR);
302
303	result = sendTCSDPacket(hte);
304
305	if (result == TSS_SUCCESS)
306		result = hte->comm.hdr.u.result;
307
308	if (result == TSS_SUCCESS) {
309		i = 0;
310		if (idKeyAuth) {
311			if (getData(TCSD_PACKET_TYPE_AUTH, i++, idKeyAuth, 0, &hte->comm))
312				result = TSPERR(TSS_E_INTERNAL_ERROR);
313		}
314		if (getData(TCSD_PACKET_TYPE_AUTH, i++, ownerAuth, 0, &hte->comm)) {
315			result = TSPERR(TSS_E_INTERNAL_ERROR);
316			goto done;
317		}
318		if (getData(TCSD_PACKET_TYPE_UINT32, i++, SymmetricKeySize, 0, &hte->comm)) {
319			result = TSPERR(TSS_E_INTERNAL_ERROR);
320			goto done;
321		}
322
323		*SymmetricKey = malloc(*SymmetricKeySize);
324		if (*SymmetricKey == NULL) {
325			LogError("malloc of %u bytes failed.", *SymmetricKeySize);
326			result = TSPERR(TSS_E_OUTOFMEMORY);
327			goto done;
328		}
329		if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *SymmetricKey, *SymmetricKeySize, &hte->comm)) {
330			free(*SymmetricKey);
331			result = TSPERR(TSS_E_INTERNAL_ERROR);
332		}
333	}
334done:
335	return result;
336}
337