1 /*
2 * The Initial Developer of the Original Code is Intel Corporation.
3 * Portions created by Intel Corporation are Copyright (C) 2007 Intel Corporation.
4 * All Rights Reserved.
5 * trousers - An open source TCG Software Stack
6 *
7 * Author: james.xu@intel.com Rossey.liu@intel.com
8 *
9 */
10
11 #include <stdlib.h>
12 #include <stdio.h>
13 #include <syslog.h>
14 #include <string.h>
15 #include <netdb.h>
16
17 #include "trousers/tss.h"
18 #include "trousers_types.h"
19 #include "tcs_tsp.h"
20 #include "tcs_utils.h"
21 #include "tcs_int_literals.h"
22 #include "capabilities.h"
23 #include "tcslog.h"
24 #include "tcsd_wrap.h"
25 #include "tcsd.h"
26 #include "tcs_utils.h"
27 #include "rpc_tcstp_tcs.h"
28
29
30 TSS_RESULT
tcs_wrap_NV_DefineOrReleaseSpace(struct tcsd_thread_data * data)31 tcs_wrap_NV_DefineOrReleaseSpace(struct tcsd_thread_data *data)
32 {
33 TCS_CONTEXT_HANDLE hContext;
34 UINT32 cPubInfoSize;
35 BYTE *pubInfo = NULL;
36 TSS_RESULT result;
37 TPM_ENCAUTH encAuth;
38 TPM_AUTH Auth, *pAuth;
39
40 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
41 return TCSERR(TSS_E_INTERNAL_ERROR);
42
43 if ((result = ctx_verify_context(hContext)))
44 goto done;
45
46 if (getData(TCSD_PACKET_TYPE_UINT32, 1, &cPubInfoSize, 0, &data->comm))
47 return TCSERR(TSS_E_INTERNAL_ERROR);
48
49 pubInfo = calloc(1, cPubInfoSize);
50 if (pubInfo == NULL) {
51 LogError("malloc of %u bytes failed.", cPubInfoSize);
52 return TCSERR(TSS_E_OUTOFMEMORY);
53 }
54
55 if (getData(TCSD_PACKET_TYPE_PBYTE, 2, pubInfo, cPubInfoSize, &data->comm)) {
56 free(pubInfo);
57 return TCSERR(TSS_E_INTERNAL_ERROR);
58 }
59
60 if (getData(TCSD_PACKET_TYPE_ENCAUTH, 3, &encAuth, 0, &data->comm)) {
61 free(pubInfo);
62 return TCSERR(TSS_E_INTERNAL_ERROR);
63 }
64
65 if (getData(TCSD_PACKET_TYPE_AUTH, 4, &Auth, 0, &data->comm))
66 pAuth = NULL;
67 else
68 pAuth = &Auth;
69
70 MUTEX_LOCK(tcsp_lock);
71
72 result = TCSP_NV_DefineOrReleaseSpace_Internal(hContext,
73 cPubInfoSize, pubInfo, encAuth, pAuth);
74
75 MUTEX_UNLOCK(tcsp_lock);
76
77 free(pubInfo);
78
79 if (result == TSS_SUCCESS) {
80 initData(&data->comm, 1);
81 if ( pAuth) {
82 if (setData(TCSD_PACKET_TYPE_AUTH, 0, pAuth, 0, &data->comm)) {
83 return TCSERR(TSS_E_INTERNAL_ERROR);
84 }
85 }
86 } else
87 done: initData(&data->comm, 0);
88
89 data->comm.hdr.u.result = result;
90 return TSS_SUCCESS;
91 }
92
93 TSS_RESULT
tcs_wrap_NV_WriteValue(struct tcsd_thread_data * data)94 tcs_wrap_NV_WriteValue(struct tcsd_thread_data *data)
95 {
96 TCS_CONTEXT_HANDLE hContext;
97 TSS_NV_INDEX hNVStore;
98 UINT32 offset,ulDataLength;
99 BYTE *rgbDataToWrite = NULL;
100 TSS_RESULT result;
101 TPM_AUTH Auth, *pAuth;
102
103 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
104 return TCSERR(TSS_E_INTERNAL_ERROR);
105
106 if ((result = ctx_verify_context(hContext)))
107 goto done;
108
109 if (getData(TCSD_PACKET_TYPE_UINT32, 1, &hNVStore, 0, &data->comm))
110 return TCSERR(TSS_E_INTERNAL_ERROR);
111
112 if (getData(TCSD_PACKET_TYPE_UINT32, 2, &offset, 0, &data->comm))
113 return TCSERR(TSS_E_INTERNAL_ERROR);
114
115 if (getData(TCSD_PACKET_TYPE_UINT32, 3, &ulDataLength, 0, &data->comm))
116 return TCSERR(TSS_E_INTERNAL_ERROR);
117
118 rgbDataToWrite = calloc(1, ulDataLength);
119 if (rgbDataToWrite == NULL) {
120 LogError("malloc of %u bytes failed.", ulDataLength);
121 return TCSERR(TSS_E_OUTOFMEMORY);
122 }
123
124 if (getData(TCSD_PACKET_TYPE_PBYTE, 4, rgbDataToWrite, ulDataLength, &data->comm)) {
125 free(rgbDataToWrite);
126 return TCSERR(TSS_E_INTERNAL_ERROR);
127 }
128
129 if (getData(TCSD_PACKET_TYPE_AUTH, 5, &Auth, 0, &data->comm))
130 pAuth = NULL;
131 else
132 pAuth = &Auth;
133
134 MUTEX_LOCK(tcsp_lock);
135
136 result = TCSP_NV_WriteValue_Internal(hContext, hNVStore,
137 offset, ulDataLength, rgbDataToWrite, pAuth);
138
139 MUTEX_UNLOCK(tcsp_lock);
140
141 free(rgbDataToWrite);
142
143 if (result == TSS_SUCCESS) {
144 initData(&data->comm, 1);
145 if (pAuth) {
146 if (setData(TCSD_PACKET_TYPE_AUTH, 0, pAuth, 0, &data->comm)) {
147 return TCSERR(TSS_E_INTERNAL_ERROR);
148 }
149 }
150 } else
151 done: initData(&data->comm, 0);
152
153 data->comm.hdr.u.result = result;
154 return TSS_SUCCESS;
155 }
156
157 TSS_RESULT
tcs_wrap_NV_WriteValueAuth(struct tcsd_thread_data * data)158 tcs_wrap_NV_WriteValueAuth(struct tcsd_thread_data *data)
159 {
160 TCS_CONTEXT_HANDLE hContext;
161 TSS_NV_INDEX hNVStore;
162 UINT32 offset,ulDataLength;
163 BYTE *rgbDataToWrite = NULL;
164 TSS_RESULT result;
165 TPM_AUTH Auth, *pAuth;
166
167 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
168 return TCSERR(TSS_E_INTERNAL_ERROR);
169
170 if ((result = ctx_verify_context(hContext)))
171 goto done;
172
173 if (getData(TCSD_PACKET_TYPE_UINT32, 1, &hNVStore, 0, &data->comm))
174 return TCSERR(TSS_E_INTERNAL_ERROR);
175
176 if (getData(TCSD_PACKET_TYPE_UINT32, 2, &offset, 0, &data->comm))
177 return TCSERR(TSS_E_INTERNAL_ERROR);
178
179 if (getData(TCSD_PACKET_TYPE_UINT32, 3, &ulDataLength, 0, &data->comm))
180 return TCSERR(TSS_E_INTERNAL_ERROR);
181
182 rgbDataToWrite = calloc(1, ulDataLength);
183 if (rgbDataToWrite == NULL) {
184 LogError("malloc of %u bytes failed.", ulDataLength);
185 return TCSERR(TSS_E_OUTOFMEMORY);
186 }
187
188 if (getData(TCSD_PACKET_TYPE_PBYTE, 4, rgbDataToWrite, ulDataLength, &data->comm)) {
189 free(rgbDataToWrite);
190 return TCSERR(TSS_E_INTERNAL_ERROR);
191 }
192 if (getData(TCSD_PACKET_TYPE_AUTH, 5, &Auth, 0, &data->comm)) {
193 free(rgbDataToWrite);
194 return TCSERR(TSS_E_INTERNAL_ERROR);
195 } else
196 pAuth = &Auth;
197
198 MUTEX_LOCK(tcsp_lock);
199
200 result = TCSP_NV_WriteValueAuth_Internal(hContext, hNVStore,
201 offset, ulDataLength, rgbDataToWrite, pAuth);
202
203 MUTEX_UNLOCK(tcsp_lock);
204
205 free(rgbDataToWrite);
206
207 if (result == TSS_SUCCESS) {
208 initData(&data->comm, 1);
209 if ( pAuth) {
210 if (setData(TCSD_PACKET_TYPE_AUTH, 0, pAuth, 0, &data->comm)) {
211 return TCSERR(TSS_E_INTERNAL_ERROR);
212 }
213 }
214 } else
215 done: initData(&data->comm, 0);
216
217 data->comm.hdr.u.result = result;
218 return TSS_SUCCESS;
219 }
220
221 TSS_RESULT
tcs_wrap_NV_ReadValue(struct tcsd_thread_data * data)222 tcs_wrap_NV_ReadValue(struct tcsd_thread_data *data)
223 {
224 TCS_CONTEXT_HANDLE hContext;
225 TSS_NV_INDEX hNVStore;
226 UINT32 offset,ulDataLength, i;
227 BYTE *rgbDataRead = NULL;
228 TSS_RESULT result;
229 TPM_AUTH Auth, *pAuth;
230
231 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
232 return TCSERR(TSS_E_INTERNAL_ERROR);
233
234 if ((result = ctx_verify_context(hContext)))
235 goto done;
236
237 if (getData(TCSD_PACKET_TYPE_UINT32, 1, &hNVStore, 0, &data->comm))
238 return TCSERR(TSS_E_INTERNAL_ERROR);
239
240 if (getData(TCSD_PACKET_TYPE_UINT32, 2, &offset, 0, &data->comm))
241 return TCSERR(TSS_E_INTERNAL_ERROR);
242
243 if (getData(TCSD_PACKET_TYPE_UINT32, 3, &ulDataLength, 0, &data->comm))
244 return TCSERR(TSS_E_INTERNAL_ERROR);
245
246 if (getData(TCSD_PACKET_TYPE_AUTH, 4, &Auth, 0, &data->comm))
247 pAuth = NULL;
248 else
249 pAuth = &Auth;
250
251 MUTEX_LOCK(tcsp_lock);
252
253 result = TCSP_NV_ReadValue_Internal(hContext, hNVStore,
254 offset, &ulDataLength, pAuth, &rgbDataRead);
255
256 MUTEX_UNLOCK(tcsp_lock);
257
258 if (result == TSS_SUCCESS) {
259 i = 0;
260 initData(&data->comm, 3);
261 if ( pAuth) {
262 if (setData(TCSD_PACKET_TYPE_AUTH, i++, pAuth, 0, &data->comm)) {
263 free(rgbDataRead);
264 return TCSERR(TSS_E_INTERNAL_ERROR);
265 }
266 }
267 if (setData(TCSD_PACKET_TYPE_UINT32, i++, &ulDataLength, 0, &data->comm)) {
268 free(rgbDataRead);
269 return TCSERR(TSS_E_INTERNAL_ERROR);
270 }
271 if (setData(TCSD_PACKET_TYPE_PBYTE, i++, rgbDataRead, ulDataLength, &data->comm)) {
272 free(rgbDataRead);
273 return TCSERR(TSS_E_INTERNAL_ERROR);
274 }
275 free(rgbDataRead);
276 } else
277 done: initData(&data->comm, 0);
278
279 data->comm.hdr.u.result = result;
280 return TSS_SUCCESS;
281 }
282
283 TSS_RESULT
tcs_wrap_NV_ReadValueAuth(struct tcsd_thread_data * data)284 tcs_wrap_NV_ReadValueAuth(struct tcsd_thread_data *data)
285 {
286 TCS_CONTEXT_HANDLE hContext;
287 TSS_NV_INDEX hNVStore;
288 UINT32 offset,ulDataLength, i;
289 BYTE *rgbDataRead = NULL;
290 TSS_RESULT result;
291 TPM_AUTH NVAuth, *pNVAuth;
292
293 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
294 return TCSERR(TSS_E_INTERNAL_ERROR);
295
296 if ((result = ctx_verify_context(hContext)))
297 goto done;
298
299 if (getData(TCSD_PACKET_TYPE_UINT32, 1, &hNVStore, 0, &data->comm))
300 return TCSERR(TSS_E_INTERNAL_ERROR);
301
302 if (getData(TCSD_PACKET_TYPE_UINT32, 2, &offset, 0, &data->comm))
303 return TCSERR(TSS_E_INTERNAL_ERROR);
304
305 if (getData(TCSD_PACKET_TYPE_UINT32, 3, &ulDataLength, 0, &data->comm))
306 return TCSERR(TSS_E_INTERNAL_ERROR);
307
308 if (getData(TCSD_PACKET_TYPE_AUTH, 4, &NVAuth, 0, &data->comm)) {
309 pNVAuth = NULL;
310 } else {
311 pNVAuth = &NVAuth;
312 }
313
314 MUTEX_LOCK(tcsp_lock);
315
316 result = TCSP_NV_ReadValueAuth_Internal(hContext, hNVStore,
317 offset, &ulDataLength, pNVAuth, &rgbDataRead);
318
319 MUTEX_UNLOCK(tcsp_lock);
320
321 if (result == TSS_SUCCESS) {
322 i = 0;
323 initData(&data->comm, 3);
324 if ( pNVAuth) {
325 if (setData(TCSD_PACKET_TYPE_AUTH, i++, pNVAuth, 0, &data->comm)) {
326 free(rgbDataRead);
327 return TCSERR(TSS_E_INTERNAL_ERROR);
328 }
329 }
330 if (setData(TCSD_PACKET_TYPE_UINT32, i++, &ulDataLength, 0, &data->comm)) {
331 free(rgbDataRead);
332 return TCSERR(TSS_E_INTERNAL_ERROR);
333 }
334 if (setData(TCSD_PACKET_TYPE_PBYTE, i++, rgbDataRead, ulDataLength, &data->comm)) {
335 free(rgbDataRead);
336 return TCSERR(TSS_E_INTERNAL_ERROR);
337 }
338 free(rgbDataRead);
339 } else
340 done: initData(&data->comm, 0);
341
342 data->comm.hdr.u.result = result;
343 return TSS_SUCCESS;
344 }
345
346