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
28 TSS_RESULT
RPC_GetRegisteredKeyByPublicInfo_TP(struct host_table_entry * hte,TCPA_ALGORITHM_ID algID,UINT32 ulPublicInfoLength,BYTE * rgbPublicInfo,UINT32 * keySize,BYTE ** keyBlob)29 RPC_GetRegisteredKeyByPublicInfo_TP(struct host_table_entry *hte,
30 TCPA_ALGORITHM_ID algID, /* in */
31 UINT32 ulPublicInfoLength, /* in */
32 BYTE * rgbPublicInfo, /* in */
33 UINT32 * keySize, /* out */
34 BYTE ** keyBlob) /* out */
35 {
36 TSS_RESULT result;
37
38 initData(&hte->comm, 4);
39 hte->comm.hdr.u.ordinal = TCSD_ORD_GETREGISTEREDKEYBYPUBLICINFO;
40 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
41
42 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
43 return TSPERR(TSS_E_INTERNAL_ERROR);
44 if (setData(TCSD_PACKET_TYPE_UINT32, 1, &algID, 0, &hte->comm))
45 return TSPERR(TSS_E_INTERNAL_ERROR);
46 if (setData(TCSD_PACKET_TYPE_UINT32, 2, &ulPublicInfoLength, 0, &hte->comm))
47 return TSPERR(TSS_E_INTERNAL_ERROR);
48 if (setData(TCSD_PACKET_TYPE_PBYTE, 3, rgbPublicInfo, ulPublicInfoLength, &hte->comm))
49 return TSPERR(TSS_E_INTERNAL_ERROR);
50
51 result = sendTCSDPacket(hte);
52
53 if (result == TSS_SUCCESS)
54 result = hte->comm.hdr.u.result;
55
56 if (result == TSS_SUCCESS) {
57 if (getData(TCSD_PACKET_TYPE_UINT32, 0, keySize, 0, &hte->comm)) {
58 result = TSPERR(TSS_E_INTERNAL_ERROR);
59 goto done;
60 }
61 *keyBlob = (BYTE *) malloc(*keySize);
62 if (*keyBlob == NULL) {
63 LogError("malloc of %u bytes failed.", *keySize);
64 result = TSPERR(TSS_E_OUTOFMEMORY);
65 goto done;
66 }
67 if (getData(TCSD_PACKET_TYPE_PBYTE, 1, *keyBlob, *keySize, &hte->comm)) {
68 free(*keyBlob);
69 result = TSPERR(TSS_E_INTERNAL_ERROR);
70 goto done;
71 }
72 }
73
74 done:
75 return result;
76 }
77
78 TSS_RESULT
RPC_RegisterKey_TP(struct host_table_entry * hte,TSS_UUID WrappingKeyUUID,TSS_UUID KeyUUID,UINT32 cKeySize,BYTE * rgbKey,UINT32 cVendorData,BYTE * gbVendorData)79 RPC_RegisterKey_TP(struct host_table_entry *hte,
80 TSS_UUID WrappingKeyUUID, /* in */
81 TSS_UUID KeyUUID, /* in */
82 UINT32 cKeySize, /* in */
83 BYTE * rgbKey, /* in */
84 UINT32 cVendorData, /* in */
85 BYTE * gbVendorData /* in */
86 ) {
87 TSS_RESULT result;
88
89 initData(&hte->comm, 7);
90 hte->comm.hdr.u.ordinal = TCSD_ORD_REGISTERKEY;
91 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
92
93 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
94 return TSPERR(TSS_E_INTERNAL_ERROR);
95 if (setData(TCSD_PACKET_TYPE_UUID, 1, &WrappingKeyUUID, 0, &hte->comm))
96 return TSPERR(TSS_E_INTERNAL_ERROR);
97 if (setData(TCSD_PACKET_TYPE_UUID, 2, &KeyUUID, 0, &hte->comm))
98 return TSPERR(TSS_E_INTERNAL_ERROR);
99 if (setData(TCSD_PACKET_TYPE_UINT32, 3, &cKeySize, 0, &hte->comm))
100 return TSPERR(TSS_E_INTERNAL_ERROR);
101 if (setData(TCSD_PACKET_TYPE_PBYTE, 4, rgbKey, cKeySize, &hte->comm))
102 return TSPERR(TSS_E_INTERNAL_ERROR);
103 if (setData(TCSD_PACKET_TYPE_UINT32, 5, &cVendorData, 0, &hte->comm))
104 return TSPERR(TSS_E_INTERNAL_ERROR);
105 if (setData(TCSD_PACKET_TYPE_PBYTE, 6, gbVendorData, cVendorData, &hte->comm))
106 return TSPERR(TSS_E_INTERNAL_ERROR);
107
108 result = sendTCSDPacket(hte);
109
110 if (result == TSS_SUCCESS)
111 result = hte->comm.hdr.u.result;
112
113 return result;
114 }
115
116 TSS_RESULT
RPC_UnregisterKey_TP(struct host_table_entry * hte,TSS_UUID KeyUUID)117 RPC_UnregisterKey_TP(struct host_table_entry *hte,
118 TSS_UUID KeyUUID /* in */
119 ) {
120 TSS_RESULT result;
121
122 initData(&hte->comm, 2);
123 hte->comm.hdr.u.ordinal = TCSD_ORD_UNREGISTERKEY;
124 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
125
126 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
127 return TSPERR(TSS_E_INTERNAL_ERROR);
128 if (setData(TCSD_PACKET_TYPE_UUID, 1, &KeyUUID, 0, &hte->comm))
129 return TSPERR(TSS_E_INTERNAL_ERROR);
130
131 result = sendTCSDPacket(hte);
132
133 if (result == TSS_SUCCESS)
134 result = hte->comm.hdr.u.result;
135
136 return result;
137 }
138
139 TSS_RESULT
RPC_EnumRegisteredKeys_TP(struct host_table_entry * hte,TSS_UUID * pKeyUUID,UINT32 * pcKeyHierarchySize,TSS_KM_KEYINFO ** ppKeyHierarchy)140 RPC_EnumRegisteredKeys_TP(struct host_table_entry *hte,
141 TSS_UUID * pKeyUUID, /* in */
142 UINT32 * pcKeyHierarchySize, /* out */
143 TSS_KM_KEYINFO ** ppKeyHierarchy /* out */
144 ) {
145 TSS_RESULT result;
146 int i, j;
147
148 initData(&hte->comm, 2);
149 hte->comm.hdr.u.ordinal = TCSD_ORD_ENUMREGISTEREDKEYS;
150 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
151
152 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
153 return TSPERR(TSS_E_INTERNAL_ERROR);
154
155 if (pKeyUUID != NULL) {
156 if (setData(TCSD_PACKET_TYPE_UUID, 1, pKeyUUID, 0, &hte->comm))
157 return TSPERR(TSS_E_INTERNAL_ERROR);
158 }
159
160 result = sendTCSDPacket(hte);
161
162 if (result == TSS_SUCCESS)
163 result = hte->comm.hdr.u.result;
164
165 if (result == TSS_SUCCESS) {
166 i = 0;
167 if (getData(TCSD_PACKET_TYPE_UINT32, i++, pcKeyHierarchySize, 0, &hte->comm)) {
168 result = TSPERR(TSS_E_INTERNAL_ERROR);
169 goto done;
170 }
171
172 if (*pcKeyHierarchySize > 0) {
173 *ppKeyHierarchy = malloc((*pcKeyHierarchySize) * sizeof(TSS_KM_KEYINFO));
174 if (*ppKeyHierarchy == NULL) {
175 LogError("malloc of %zu bytes failed.", (*pcKeyHierarchySize) *
176 sizeof(TSS_KM_KEYINFO));
177 result = TSPERR(TSS_E_OUTOFMEMORY);
178 goto done;
179 }
180 for (j = 0; (UINT32)j < *pcKeyHierarchySize; j++) {
181 if (getData(TCSD_PACKET_TYPE_KM_KEYINFO, i++,
182 &((*ppKeyHierarchy)[j]), 0, &hte->comm)) {
183 free(*ppKeyHierarchy);
184 result = TSPERR(TSS_E_INTERNAL_ERROR);
185 goto done;
186 }
187 }
188 } else {
189 *ppKeyHierarchy = NULL;
190 }
191 }
192
193 done:
194 return result;
195 }
196
197 TSS_RESULT
RPC_EnumRegisteredKeys2_TP(struct host_table_entry * hte,TSS_UUID * pKeyUUID,UINT32 * pcKeyHierarchySize,TSS_KM_KEYINFO2 ** ppKeyHierarchy)198 RPC_EnumRegisteredKeys2_TP(struct host_table_entry *hte,
199 TSS_UUID * pKeyUUID, /* in */
200 UINT32 * pcKeyHierarchySize, /* out */
201 TSS_KM_KEYINFO2 ** ppKeyHierarchy /* out */
202 )
203 {
204 TSS_RESULT result;
205 int i, j;
206
207 initData(&hte->comm, 2);
208 hte->comm.hdr.u.ordinal = TCSD_ORD_ENUMREGISTEREDKEYS2;
209 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
210
211 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
212 return TSPERR(TSS_E_INTERNAL_ERROR);
213
214 if (pKeyUUID != NULL) {
215 if (setData(TCSD_PACKET_TYPE_UUID, 1, pKeyUUID, 0, &hte->comm))
216 return TSPERR(TSS_E_INTERNAL_ERROR);
217 }
218
219 result = sendTCSDPacket(hte);
220
221 if (result == TSS_SUCCESS)
222 result = hte->comm.hdr.u.result;
223
224 if (result == TSS_SUCCESS) {
225 i = 0;
226 if (getData(TCSD_PACKET_TYPE_UINT32, i++, pcKeyHierarchySize, 0, &hte->comm)) {
227 result = TSPERR(TSS_E_INTERNAL_ERROR);
228 goto done;
229 }
230
231 if (*pcKeyHierarchySize > 0) {
232 *ppKeyHierarchy = malloc((*pcKeyHierarchySize) * sizeof(TSS_KM_KEYINFO2));
233 if (*ppKeyHierarchy == NULL) {
234 LogError("malloc of %zu bytes failed.", (*pcKeyHierarchySize) *
235 sizeof(TSS_KM_KEYINFO2));
236 result = TSPERR(TSS_E_OUTOFMEMORY);
237 goto done;
238 }
239 for (j = 0; (UINT32)j < *pcKeyHierarchySize; j++) {
240 if (getData(TCSD_PACKET_TYPE_KM_KEYINFO2, i++,
241 &((*ppKeyHierarchy)[j]), 0, &hte->comm)) {
242 free(*ppKeyHierarchy);
243 result = TSPERR(TSS_E_INTERNAL_ERROR);
244 goto done;
245 }
246 }
247 } else {
248 *ppKeyHierarchy = NULL;
249 }
250 }
251
252 done:
253 return result;
254 }
255
256 TSS_RESULT
RPC_GetRegisteredKey_TP(struct host_table_entry * hte,TSS_UUID KeyUUID,TSS_KM_KEYINFO ** ppKeyInfo)257 RPC_GetRegisteredKey_TP(struct host_table_entry *hte,
258 TSS_UUID KeyUUID, /* in */
259 TSS_KM_KEYINFO ** ppKeyInfo /* out */
260 ) {
261 return TSPERR(TSS_E_NOTIMPL);
262 }
263
264 TSS_RESULT
RPC_GetRegisteredKeyBlob_TP(struct host_table_entry * hte,TSS_UUID KeyUUID,UINT32 * pcKeySize,BYTE ** prgbKey)265 RPC_GetRegisteredKeyBlob_TP(struct host_table_entry *hte,
266 TSS_UUID KeyUUID, /* in */
267 UINT32 * pcKeySize, /* out */
268 BYTE ** prgbKey /* out */
269 ) {
270 TSS_RESULT result;
271
272 initData(&hte->comm, 2);
273 hte->comm.hdr.u.ordinal = TCSD_ORD_GETREGISTEREDKEYBLOB;
274 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
275
276 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
277 return TSPERR(TSS_E_INTERNAL_ERROR);
278 if (setData(TCSD_PACKET_TYPE_UUID, 1, &KeyUUID, 0, &hte->comm))
279 return TSPERR(TSS_E_INTERNAL_ERROR);
280
281 result = sendTCSDPacket(hte);
282
283 if (result == TSS_SUCCESS)
284 result = hte->comm.hdr.u.result;
285
286 if (result == TSS_SUCCESS) {
287 if (getData(TCSD_PACKET_TYPE_UINT32, 0, pcKeySize, 0, &hte->comm)) {
288 result = TSPERR(TSS_E_INTERNAL_ERROR);
289 goto done;
290 }
291 *prgbKey = malloc(*pcKeySize);
292 if (*prgbKey == NULL) {
293 LogError("malloc of %u bytes failed.", *pcKeySize);
294 result = TSPERR(TSS_E_OUTOFMEMORY);
295 goto done;
296 }
297 if (getData(TCSD_PACKET_TYPE_PBYTE, 1, *prgbKey, *pcKeySize, &hte->comm)) {
298 free(*prgbKey);
299 result = TSPERR(TSS_E_INTERNAL_ERROR);
300 }
301 }
302
303 done:
304 return result;
305
306 }
307
308 TSS_RESULT
RPC_LoadKeyByUUID_TP(struct host_table_entry * hte,TSS_UUID KeyUUID,TCS_LOADKEY_INFO * pLoadKeyInfo,TCS_KEY_HANDLE * phKeyTCSI)309 RPC_LoadKeyByUUID_TP(struct host_table_entry *hte,
310 TSS_UUID KeyUUID, /* in */
311 TCS_LOADKEY_INFO * pLoadKeyInfo, /* in, out */
312 TCS_KEY_HANDLE * phKeyTCSI /* out */
313 ) {
314 TSS_RESULT result;
315
316 initData(&hte->comm, 3);
317 hte->comm.hdr.u.ordinal = TCSD_ORD_LOADKEYBYUUID;
318 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
319
320 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
321 return TSPERR(TSS_E_INTERNAL_ERROR);
322 if (setData(TCSD_PACKET_TYPE_UUID, 1, &KeyUUID, 0, &hte->comm))
323 return TSPERR(TSS_E_INTERNAL_ERROR);
324
325 if (pLoadKeyInfo != NULL) {
326 if (setData(TCSD_PACKET_TYPE_LOADKEY_INFO, 2, pLoadKeyInfo, 0, &hte->comm))
327 return TSPERR(TSS_E_INTERNAL_ERROR);
328 }
329
330 result = sendTCSDPacket(hte);
331
332 if (result == TSS_SUCCESS)
333 result = hte->comm.hdr.u.result;
334
335 if (result == TSS_SUCCESS) {
336 if (getData(TCSD_PACKET_TYPE_UINT32, 0, phKeyTCSI, 0, &hte->comm))
337 result = TSPERR(TSS_E_INTERNAL_ERROR);
338
339 LogDebugFn("TCS key handle: 0x%x", *phKeyTCSI);
340 } else if (pLoadKeyInfo && (result == (TCS_E_KM_LOADFAILED | TSS_LAYER_TCS))) {
341 if (getData(TCSD_PACKET_TYPE_LOADKEY_INFO, 0, pLoadKeyInfo, 0, &hte->comm))
342 result = TSPERR(TSS_E_INTERNAL_ERROR);
343 }
344
345 return result;
346 }
347
348 void
LoadBlob_LOADKEY_INFO(UINT64 * offset,BYTE * blob,TCS_LOADKEY_INFO * info)349 LoadBlob_LOADKEY_INFO(UINT64 *offset, BYTE *blob, TCS_LOADKEY_INFO *info)
350 {
351 Trspi_LoadBlob_UUID(offset, blob, info->keyUUID);
352 Trspi_LoadBlob_UUID(offset, blob, info->parentKeyUUID);
353 Trspi_LoadBlob(offset, TCPA_DIGEST_SIZE, blob, info->paramDigest.digest);
354 Trspi_LoadBlob_UINT32(offset, info->authData.AuthHandle, blob);
355 Trspi_LoadBlob(offset, TCPA_NONCE_SIZE, blob, (BYTE *)&info->authData.NonceOdd.nonce);
356 Trspi_LoadBlob(offset, TCPA_NONCE_SIZE, blob, (BYTE *)&info->authData.NonceEven.nonce);
357 Trspi_LoadBlob_BOOL(offset, info->authData.fContinueAuthSession, blob);
358 Trspi_LoadBlob(offset, TCPA_DIGEST_SIZE, blob, (BYTE *)&info->authData.HMAC);
359 }
360
361 void
UnloadBlob_LOADKEY_INFO(UINT64 * offset,BYTE * blob,TCS_LOADKEY_INFO * info)362 UnloadBlob_LOADKEY_INFO(UINT64 *offset, BYTE *blob, TCS_LOADKEY_INFO *info)
363 {
364 Trspi_UnloadBlob_UUID(offset, blob, &info->keyUUID);
365 Trspi_UnloadBlob_UUID(offset, blob, &info->parentKeyUUID);
366 Trspi_UnloadBlob(offset, TCPA_DIGEST_SIZE, blob, (BYTE *)&info->paramDigest.digest);
367 Trspi_UnloadBlob_UINT32(offset, &info->authData.AuthHandle, blob);
368 Trspi_UnloadBlob(offset, TCPA_NONCE_SIZE, blob, (BYTE *)&info->authData.NonceOdd.nonce);
369 Trspi_UnloadBlob(offset, TCPA_NONCE_SIZE, blob, (BYTE *)&info->authData.NonceEven.nonce);
370 Trspi_UnloadBlob_BOOL(offset, &info->authData.fContinueAuthSession, blob);
371 Trspi_UnloadBlob(offset, TCPA_DIGEST_SIZE, blob, (BYTE *)&info->authData.HMAC);
372 }
373
374