← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/trousers/jaunty

« back to all changes in this revision

Viewing changes to src/tspi/rpc/tcstp/rpc_key.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2008-01-23 22:03:00 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080123220300-fhtqja3c0oq0gp6z
Tags: 0.3.1-4
http://bugs.debian.org/457400
http://bugs.debian.org/459682
* Added patch from Aaron M. Ucko <ucko@debian.org> to allow trousers to
  build successfully on amd64, and presumably also other 64-bit
  architectures (Closes: #457400).
* Including udev rule for /dev/tpm from William Lima
  <wlima.amadeus@gmail.com> as suggested by David Smith <dds@google.com>
  (Closes: #459682).
* Added lintian overrides.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tspi/rpc/tcstp/rpc_key.c
 
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
 
 
28
TSS_RESULT
 
29
RPC_LoadKeyByBlob_TP(struct host_table_entry *hte,
 
30
                      TCS_KEY_HANDLE hUnwrappingKey,    /* in */
 
31
                      UINT32 cWrappedKeyBlobSize,       /* in */
 
32
                      BYTE * rgbWrappedKeyBlob, /* in */
 
33
                      TPM_AUTH * pAuth, /* in, out */
 
34
                      TCS_KEY_HANDLE * phKeyTCSI,       /* out */
 
35
                      TCS_KEY_HANDLE * phKeyHMAC)       /* out */
 
36
{
 
37
        TSS_RESULT result;
 
38
        int i;
 
39
 
 
40
        initData(&hte->comm, 5);
 
41
        hte->comm.hdr.u.ordinal = TCSD_ORD_LOADKEYBYBLOB;
 
42
        LogDebugFn("IN: TCS Context: 0x%x", hte->tcsContext);
 
43
 
 
44
        if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
 
45
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
46
        if (setData(TCSD_PACKET_TYPE_UINT32, 1, &hUnwrappingKey, 0, &hte->comm))
 
47
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
48
        if (setData(TCSD_PACKET_TYPE_UINT32, 2, &cWrappedKeyBlobSize, 0, &hte->comm))
 
49
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
50
        if (setData(TCSD_PACKET_TYPE_PBYTE, 3, rgbWrappedKeyBlob, cWrappedKeyBlobSize, &hte->comm))
 
51
                        return TSPERR(TSS_E_INTERNAL_ERROR);
 
52
 
 
53
        if (pAuth != NULL) {
 
54
                if (setData(TCSD_PACKET_TYPE_AUTH, 4, pAuth, 0, &hte->comm))
 
55
                        return TSPERR(TSS_E_INTERNAL_ERROR);
 
56
        }
 
57
 
 
58
        result = sendTCSDPacket(hte);
 
59
 
 
60
        if (result == TSS_SUCCESS)
 
61
                result = hte->comm.hdr.u.result;
 
62
 
 
63
        if (result == TSS_SUCCESS) {
 
64
                i = 0;
 
65
                if (pAuth != NULL) {
 
66
                        if (getData(TCSD_PACKET_TYPE_AUTH, i++, pAuth, 0, &hte->comm))
 
67
                                result = TSPERR(TSS_E_INTERNAL_ERROR);
 
68
                }
 
69
                if (getData(TCSD_PACKET_TYPE_UINT32, i++, phKeyTCSI, 0, &hte->comm))
 
70
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
71
                if (getData(TCSD_PACKET_TYPE_UINT32, i++, phKeyHMAC, 0, &hte->comm))
 
72
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
73
 
 
74
                LogDebugFn("OUT: TCS key handle: 0x%x, TPM key slot: 0x%x", *phKeyTCSI,
 
75
                           *phKeyHMAC);
 
76
        }
 
77
 
 
78
        return result;
 
79
}
 
80
 
 
81
TSS_RESULT
 
82
RPC_EvictKey_TP(struct host_table_entry *hte,
 
83
                 TCS_KEY_HANDLE hKey)   /* in */
 
84
{
 
85
        TSS_RESULT result;
 
86
 
 
87
        initData(&hte->comm, 2);
 
88
        hte->comm.hdr.u.ordinal = TCSD_ORD_EVICTKEY;
 
89
        LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
 
90
 
 
91
        if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
 
92
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
93
        if (setData(TCSD_PACKET_TYPE_UINT32, 1, &hKey, 0, &hte->comm))
 
94
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
95
 
 
96
        result = sendTCSDPacket(hte);
 
97
 
 
98
        if (result == TSS_SUCCESS)
 
99
                result = hte->comm.hdr.u.result;
 
100
 
 
101
        return result;
 
102
}
 
103
 
 
104
TSS_RESULT
 
105
RPC_CreateWrapKey_TP(struct host_table_entry *hte,
 
106
                      TCS_KEY_HANDLE hWrappingKey,      /* in */
 
107
                      TCPA_ENCAUTH *KeyUsageAuth,       /* in */
 
108
                      TCPA_ENCAUTH *KeyMigrationAuth,   /* in */
 
109
                      UINT32 keyInfoSize,       /* in */
 
110
                      BYTE * keyInfo,   /* in */
 
111
                      UINT32 * keyDataSize,     /* out */
 
112
                      BYTE ** keyData,  /* out */
 
113
                      TPM_AUTH * pAuth) /* in, out */
 
114
{
 
115
        TSS_RESULT result;
 
116
 
 
117
        initData(&hte->comm, 7);
 
118
        hte->comm.hdr.u.ordinal = TCSD_ORD_CREATEWRAPKEY;
 
119
        LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
 
120
 
 
121
        if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
 
122
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
123
        if (setData(TCSD_PACKET_TYPE_UINT32, 1, &hWrappingKey, 0, &hte->comm))
 
124
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
125
        if (setData(TCSD_PACKET_TYPE_ENCAUTH, 2, KeyUsageAuth, 0, &hte->comm))
 
126
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
127
        if (setData(TCSD_PACKET_TYPE_ENCAUTH, 3, KeyMigrationAuth, 0, &hte->comm))
 
128
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
129
        if (setData(TCSD_PACKET_TYPE_UINT32, 4, &keyInfoSize, 0, &hte->comm))
 
130
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
131
        if (setData(TCSD_PACKET_TYPE_PBYTE, 5, keyInfo, keyInfoSize, &hte->comm))
 
132
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
133
        if (pAuth) {
 
134
                if (setData(TCSD_PACKET_TYPE_AUTH, 6, pAuth, 0, &hte->comm))
 
135
                        return TSPERR(TSS_E_INTERNAL_ERROR);
 
136
        }
 
137
 
 
138
        result = sendTCSDPacket(hte);
 
139
 
 
140
        if (result == TSS_SUCCESS)
 
141
                result = hte->comm.hdr.u.result;
 
142
 
 
143
        if (result == TSS_SUCCESS) {
 
144
                if (getData(TCSD_PACKET_TYPE_UINT32, 0, keyDataSize, 0, &hte->comm)) {
 
145
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
146
                        goto done;
 
147
                }
 
148
                *keyData = (BYTE *) malloc(*keyDataSize);
 
149
                if (*keyData == NULL) {
 
150
                        LogError("malloc of %u bytes failed.", *keyDataSize);
 
151
                        result = TSPERR(TSS_E_OUTOFMEMORY);
 
152
                        goto done;
 
153
                }
 
154
                if (getData(TCSD_PACKET_TYPE_PBYTE, 1, *keyData, *keyDataSize, &hte->comm)) {
 
155
                        free(*keyData);
 
156
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
157
                        goto done;
 
158
                }
 
159
                if (pAuth) {
 
160
                        if (getData(TCSD_PACKET_TYPE_AUTH, 2, pAuth, 0, &hte->comm)) {
 
161
                                free(*keyData);
 
162
                                result = TSPERR(TSS_E_INTERNAL_ERROR);
 
163
                                goto done;
 
164
                        }
 
165
                }
 
166
        }
 
167
 
 
168
done:
 
169
        return result;
 
170
}
 
171
 
 
172
TSS_RESULT
 
173
RPC_GetPubKey_TP(struct host_table_entry *hte,
 
174
                  TCS_KEY_HANDLE hKey,  /* in */
 
175
                  TPM_AUTH * pAuth,     /* in, out */
 
176
                  UINT32 * pcPubKeySize,        /* out */
 
177
                  BYTE ** prgbPubKey)   /* out */
 
178
{
 
179
        TSS_RESULT result;
 
180
        int i;
 
181
 
 
182
        initData(&hte->comm, 3);
 
183
        hte->comm.hdr.u.ordinal = TCSD_ORD_GETPUBKEY;
 
184
        LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
 
185
 
 
186
        if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
 
187
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
188
        if (setData(TCSD_PACKET_TYPE_UINT32, 1, &hKey, 0, &hte->comm))
 
189
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
190
        if (pAuth != NULL) {
 
191
                if (setData(TCSD_PACKET_TYPE_AUTH, 2, pAuth, 0, &hte->comm))
 
192
                        return TSPERR(TSS_E_INTERNAL_ERROR);
 
193
        }
 
194
 
 
195
        result = sendTCSDPacket(hte);
 
196
 
 
197
        if (result == TSS_SUCCESS)
 
198
                result = hte->comm.hdr.u.result;
 
199
 
 
200
        i = 0;
 
201
        if (result == TSS_SUCCESS) {
 
202
                if (pAuth != NULL) {
 
203
                        if (getData(TCSD_PACKET_TYPE_AUTH, i++, pAuth, 0, &hte->comm)) {
 
204
                                result = TSPERR(TSS_E_INTERNAL_ERROR);
 
205
                                goto done;
 
206
                        }
 
207
                }
 
208
                if (getData(TCSD_PACKET_TYPE_UINT32, i++, pcPubKeySize, 0, &hte->comm)) {
 
209
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
210
                        goto done;
 
211
                }
 
212
 
 
213
                *prgbPubKey = (BYTE *) malloc(*pcPubKeySize);
 
214
                if (*prgbPubKey == NULL) {
 
215
                        LogError("malloc of %u bytes failed.", *pcPubKeySize);
 
216
                        result = TSPERR(TSS_E_OUTOFMEMORY);
 
217
                        goto done;
 
218
                }
 
219
                if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *prgbPubKey, *pcPubKeySize, &hte->comm)) {
 
220
                        free(*prgbPubKey);
 
221
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
222
                }
 
223
        }
 
224
 
 
225
done:
 
226
        return result;
 
227
}
 
228
 
 
229
TSS_RESULT
 
230
RPC_TerminateHandle_TP(struct host_table_entry *hte,
 
231
                        TCS_AUTHHANDLE handle)  /* in */
 
232
{
 
233
        TSS_RESULT result;
 
234
 
 
235
        initData(&hte->comm, 2);
 
236
        hte->comm.hdr.u.ordinal = TCSD_ORD_TERMINATEHANDLE;
 
237
        LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
 
238
 
 
239
        if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
 
240
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
241
        if (setData(TCSD_PACKET_TYPE_UINT32, 1, &handle, 0, &hte->comm))
 
242
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
243
 
 
244
        result = sendTCSDPacket(hte);
 
245
 
 
246
        if (result == TSS_SUCCESS)
 
247
                result = hte->comm.hdr.u.result;
 
248
 
 
249
        return result;
 
250
}
 
251
 
 
252
TSS_RESULT
 
253
RPC_OwnerReadInternalPub_TP(struct host_table_entry *hte,
 
254
                             TCS_KEY_HANDLE hKey,       /* in */
 
255
                             TPM_AUTH * pOwnerAuth,     /* in, out */
 
256
                             UINT32 * punPubKeySize,    /* out */
 
257
                             BYTE ** ppbPubKeyData)     /* out */
 
258
{
 
259
        TSS_RESULT result;
 
260
 
 
261
        initData(&hte->comm, 3);
 
262
        hte->comm.hdr.u.ordinal = TCSD_ORD_OWNERREADINTERNALPUB;
 
263
        LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
 
264
 
 
265
        if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
 
266
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
267
        if (setData(TCSD_PACKET_TYPE_UINT32, 1, &hKey, 0, &hte->comm))
 
268
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
269
        if (pOwnerAuth != NULL) {
 
270
                if (setData(TCSD_PACKET_TYPE_AUTH, 2, pOwnerAuth, 0, &hte->comm))
 
271
                        return TSPERR(TSS_E_INTERNAL_ERROR);
 
272
        }
 
273
 
 
274
        result = sendTCSDPacket(hte);
 
275
 
 
276
        if (result == TSS_SUCCESS)
 
277
                result = hte->comm.hdr.u.result;
 
278
 
 
279
        if (result == TSS_SUCCESS) {
 
280
                if (getData(TCSD_PACKET_TYPE_AUTH, 0, pOwnerAuth, 0, &hte->comm))
 
281
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
282
                if (getData(TCSD_PACKET_TYPE_UINT32, 1, punPubKeySize, 0, &hte->comm))
 
283
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
284
 
 
285
                *ppbPubKeyData = (BYTE *) malloc(*punPubKeySize);
 
286
                if (*ppbPubKeyData == NULL) {
 
287
                        LogError("malloc of %u bytes failed.", *punPubKeySize);
 
288
                        return TSPERR(TSS_E_OUTOFMEMORY);
 
289
                }
 
290
                if (getData(TCSD_PACKET_TYPE_PBYTE, 2, *ppbPubKeyData, *punPubKeySize, 
 
291
                            &hte->comm)) {
 
292
                        free(*ppbPubKeyData);
 
293
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
294
                }
 
295
        }
 
296
 
 
297
        return result;
 
298
}
 
299
 
 
300
/* TSS 1.2-only interfaces */
 
301
#ifdef TSS_BUILD_TSS12
 
302
TSS_RESULT
 
303
RPC_KeyControlOwner_TP(struct host_table_entry *hte,            // in
 
304
                        TCS_KEY_HANDLE     hKey,                // in
 
305
                        UINT32             ulPublicInfoLength,  // in
 
306
                        BYTE*              rgbPublicInfo,       // in
 
307
                        UINT32             attribName,          // in
 
308
                        TSS_BOOL           attribValue,         // in
 
309
                        TPM_AUTH*          pOwnerAuth,          // in, out
 
310
                        TSS_UUID*          pUuidData)           // out
 
311
 
 
312
{
 
313
        TSS_RESULT result;
 
314
 
 
315
        initData(&hte->comm, 7);
 
316
        hte->comm.hdr.u.ordinal = TCSD_ORD_KEYCONTROLOWNER;
 
317
        LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
 
318
 
 
319
        if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
 
320
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
321
        if (setData(TCSD_PACKET_TYPE_UINT32, 1, &hKey, 0, &hte->comm))
 
322
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
323
        if (setData(TCSD_PACKET_TYPE_UINT32, 2, &ulPublicInfoLength, 0, &hte->comm))
 
324
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
325
        if (setData(TCSD_PACKET_TYPE_PBYTE, 3, rgbPublicInfo, ulPublicInfoLength, &hte->comm))
 
326
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
327
        if (setData(TCSD_PACKET_TYPE_UINT32, 4, &attribName, 0, &hte->comm))
 
328
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
329
        if (setData(TCSD_PACKET_TYPE_BOOL, 5, &attribValue, 0, &hte->comm))
 
330
                return TSPERR(TSS_E_INTERNAL_ERROR);
 
331
        if (pOwnerAuth != NULL) {
 
332
                if (setData(TCSD_PACKET_TYPE_AUTH, 6, pOwnerAuth, 0, &hte->comm))
 
333
                        return TSPERR(TSS_E_INTERNAL_ERROR);
 
334
        }
 
335
 
 
336
        result = sendTCSDPacket(hte);
 
337
 
 
338
        if (result == TSS_SUCCESS)
 
339
                result = hte->comm.hdr.u.result;
 
340
 
 
341
        if (result == TSS_SUCCESS) {
 
342
                if (getData(TCSD_PACKET_TYPE_AUTH, 0, pOwnerAuth, 0, &hte->comm))
 
343
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
344
                if (getData(TCSD_PACKET_TYPE_UUID, 1, pUuidData, 0, &hte->comm))
 
345
                        result = TSPERR(TSS_E_INTERNAL_ERROR);
 
346
        }
 
347
 
 
348
        return result;
 
349
}
 
350
#endif