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 <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_GetCapability(struct tcsd_thread_data * data)31 tcs_wrap_GetCapability(struct tcsd_thread_data *data)
32 {
33           TCS_CONTEXT_HANDLE hContext;
34           TCPA_CAPABILITY_AREA capArea;
35           UINT32 subCapSize;
36           BYTE *subCap;
37           UINT32 respSize;
38           BYTE *resp;
39           TSS_RESULT result;
40 
41           if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
42                     return TCSERR(TSS_E_INTERNAL_ERROR);
43 
44           if ((result = ctx_verify_context(hContext)))
45                     goto done;
46 
47           LogDebugFn("thread %ldd context %x", THREAD_ID, hContext);
48 
49           if (getData(TCSD_PACKET_TYPE_UINT32, 1, &capArea, 0, &data->comm))
50                     return TCSERR(TSS_E_INTERNAL_ERROR);
51           if (getData(TCSD_PACKET_TYPE_UINT32, 2, &subCapSize, 0, &data->comm))
52                     return TCSERR(TSS_E_INTERNAL_ERROR);
53 
54           if (subCapSize == 0)
55                     subCap = NULL;
56           else {
57                     subCap = calloc(1, subCapSize);
58                     if (subCap == NULL) {
59                               LogError("malloc of %u bytes failed.", subCapSize);
60                               return TCSERR(TSS_E_OUTOFMEMORY);
61                     }
62                     if (getData(TCSD_PACKET_TYPE_PBYTE, 3, subCap, subCapSize, &data->comm)) {
63                               free(subCap);
64                               return TCSERR(TSS_E_INTERNAL_ERROR);
65                     }
66           }
67 
68           MUTEX_LOCK(tcsp_lock);
69 
70           result = TCSP_GetCapability_Internal(hContext, capArea, subCapSize, subCap, &respSize,
71                                                        &resp);
72 
73           MUTEX_UNLOCK(tcsp_lock);
74           free(subCap);
75 
76           if (result == TSS_SUCCESS) {
77                     initData(&data->comm, 2);
78                     if (setData(TCSD_PACKET_TYPE_UINT32, 0, &respSize, 0, &data->comm)) {
79                               free(resp);
80                               return TCSERR(TSS_E_INTERNAL_ERROR);
81                     }
82                     if (setData(TCSD_PACKET_TYPE_PBYTE, 1, resp, respSize, &data->comm)) {
83                               free(resp);
84                               return TCSERR(TSS_E_INTERNAL_ERROR);
85                     }
86                     free(resp);
87           } else
88 done:               initData(&data->comm, 0);
89 
90           data->comm.hdr.u.result = result;
91           return TSS_SUCCESS;
92 }
93 
94 TSS_RESULT
tcs_wrap_GetCapabilityOwner(struct tcsd_thread_data * data)95 tcs_wrap_GetCapabilityOwner(struct tcsd_thread_data *data)
96 {
97           TCS_CONTEXT_HANDLE hContext;
98           TPM_AUTH ownerAuth;
99           TCPA_VERSION version;
100           UINT32 nonVol;
101           UINT32 vol;
102           TSS_RESULT result;
103 
104           if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
105                     return TCSERR(TSS_E_INTERNAL_ERROR);
106 
107           if ((result = ctx_verify_context(hContext)))
108                     goto done;
109 
110           LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
111 
112           if (getData(TCSD_PACKET_TYPE_AUTH, 1, &ownerAuth, 0, &data->comm))
113                     return TCSERR(TSS_E_INTERNAL_ERROR);
114 
115           MUTEX_LOCK(tcsp_lock);
116 
117           result = TCSP_GetCapabilityOwner_Internal(hContext, &ownerAuth, &version, &nonVol, &vol);
118 
119           MUTEX_UNLOCK(tcsp_lock);
120 
121           if (result == TSS_SUCCESS) {
122                     initData(&data->comm, 4);
123                     if (setData(TCSD_PACKET_TYPE_VERSION, 0, &version, 0, &data->comm)) {
124                               return TCSERR(TSS_E_INTERNAL_ERROR);
125                     }
126                     if (setData(TCSD_PACKET_TYPE_UINT32, 1, &nonVol, 0, &data->comm)) {
127                               return TCSERR(TSS_E_INTERNAL_ERROR);
128                     }
129                     if (setData(TCSD_PACKET_TYPE_UINT32, 2, &vol, 0, &data->comm)) {
130                               return TCSERR(TSS_E_INTERNAL_ERROR);
131                     }
132                     if (setData(TCSD_PACKET_TYPE_AUTH, 3, &ownerAuth, 0, &data->comm)) {
133                               return TCSERR(TSS_E_INTERNAL_ERROR);
134                     }
135           } else
136 done:               initData(&data->comm, 0);
137 
138           data->comm.hdr.u.result = result;
139           return TSS_SUCCESS;
140 }
141 
142 TSS_RESULT
tcs_wrap_SetCapability(struct tcsd_thread_data * data)143 tcs_wrap_SetCapability(struct tcsd_thread_data *data)
144 {
145           TCS_CONTEXT_HANDLE hContext;
146           TCPA_CAPABILITY_AREA capArea;
147           UINT32 subCapSize;
148           BYTE *subCap;
149           UINT32 valueSize;
150           BYTE *value;
151           TSS_RESULT result;
152           TPM_AUTH ownerAuth, *pOwnerAuth;
153 
154           if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
155                     return TCSERR(TSS_E_INTERNAL_ERROR);
156 
157           if ((result = ctx_verify_context(hContext)))
158                     goto done;
159 
160           LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
161 
162           if (getData(TCSD_PACKET_TYPE_UINT32, 1, &capArea, 0, &data->comm))
163                     return TCSERR(TSS_E_INTERNAL_ERROR);
164           if (getData(TCSD_PACKET_TYPE_UINT32, 2, &subCapSize, 0, &data->comm))
165                     return TCSERR(TSS_E_INTERNAL_ERROR);
166 
167           if (subCapSize == 0)
168                     subCap = NULL;
169           else {
170                     subCap = calloc(1, subCapSize);
171                     if (subCap == NULL) {
172                               LogError("malloc of %u bytes failed.", subCapSize);
173                               return TCSERR(TSS_E_OUTOFMEMORY);
174                     }
175                     if (getData(TCSD_PACKET_TYPE_PBYTE, 3, subCap, subCapSize, &data->comm)) {
176                               free(subCap);
177                               return TCSERR(TSS_E_INTERNAL_ERROR);
178                     }
179           }
180 
181           if (getData(TCSD_PACKET_TYPE_UINT32, 4, &valueSize, 0, &data->comm)) {
182                     free(subCap);
183                     return TCSERR(TSS_E_INTERNAL_ERROR);
184           }
185 
186           if (valueSize == 0)
187                     value = NULL;
188           else {
189                     value = calloc(1, valueSize);
190                     if (value == NULL) {
191                               free(subCap);
192                               LogError("malloc of %u bytes failed.", valueSize);
193                               return TCSERR(TSS_E_OUTOFMEMORY);
194                     }
195                     if (getData(TCSD_PACKET_TYPE_PBYTE, 5, value, valueSize, &data->comm)) {
196                               free(subCap);
197                               free(value);
198                               return TCSERR(TSS_E_INTERNAL_ERROR);
199                     }
200           }
201 
202           if (getData(TCSD_PACKET_TYPE_AUTH, 6, &ownerAuth, 0, &data->comm))
203                     pOwnerAuth = NULL;
204           else
205                     pOwnerAuth = &ownerAuth;
206 
207 
208           MUTEX_LOCK(tcsp_lock);
209 
210           result = TCSP_SetCapability_Internal(hContext, capArea, subCapSize, subCap, valueSize,
211                                                        value, pOwnerAuth);
212 
213           MUTEX_UNLOCK(tcsp_lock);
214           free(subCap);
215           free(value);
216 
217           if (result == TSS_SUCCESS) {
218                     initData(&data->comm, 1);
219                     if (pOwnerAuth) {
220                               if (setData(TCSD_PACKET_TYPE_AUTH, 0, pOwnerAuth, 0, &data->comm)) {
221                                         return TCSERR(TSS_E_INTERNAL_ERROR);
222                               }
223                     }
224           } else
225 done:               initData(&data->comm, 0);
226 
227           data->comm.hdr.u.result = result;
228           return TSS_SUCCESS;
229 }
230