rpm  5.4.15
rpmtpm.c
Go to the documentation of this file.
1 
5 #include "system.h"
6 
7 #include <rpmiotypes.h>
8 #include <rpmio.h> /* for *Pool methods */
9 
10 #if defined(WITH_LIBTPM)
11 
12 #define TPM_POSIX 1
13 #define TPM_V12 1
14 #define TPM_NV_DISK 1
15 #define TPM_MAXIMUM_KEY_SIZE 4096
16 #define TPM_AES 1
17 #define TPM_USE_TAG_IN_STRUCTURE 1
18 
19 #include <tpmfunc.h>
20 #include <tpm_error.h>
21 
22 #endif /* WITH_LIBTPM */
23 
24 #define _RPMTPM_INTERNAL
25 #include <rpmtpm.h>
26 
27 #include "debug.h"
28 
29 /*@unchecked@*/
30 int _rpmtpm_debug = 0;
31 #define TPMDBG(_l) if (_rpmtpm_debug) fprintf _l
32 
33 struct rpmtpm_s __tpm = {
34 };
36 
37 int rpmtpmErr(rpmtpm tpm, const char * msg, uint32_t mask, uint32_t rc)
38 {
39  uint32_t err = rc & (mask ? mask : 0xffffffff);
40  (void)tpm;
41  (void)err;
42 #if defined(WITH_LIBTPM)
43  if (err || _rpmtpm_debug) {
44  if (!strncmp(msg, "TSS_", sizeof("TSS_")-1)
45  || !strncmp(msg, "TPM_", sizeof("TPMC_")-1)
46  || !strncmp(msg, "TPM_", sizeof("TPM_")-1))
47  fprintf (stderr, "*** %s rc %u: %s\n", msg, rc,
48  (err ? TPM_GetErrMsg(rc) : "Success"));
49  else
50  fprintf (stderr, "*** TPM_%s rc %u: %s\n", msg, rc,
51  (err ? TPM_GetErrMsg(rc) : "Success"));
52  }
53 #endif /* WITH_LIBTPM */
54  return rc;
55 }
56 
57 void rpmtpmDump(rpmtpm tpm, const char * msg, unsigned char * b, size_t nb)
58 {
59  FILE * fp = stdout;
60  size_t i;
61  tpm = tpm;
62  if (msg)
63  fprintf(fp, "%s: ", msg);
64  if (b)
65  for (i = 0; i < nb; i++)
66  fprintf(fp, "%02x", b[i]);
67  fprintf(fp, "\n");
68 }
69 
70 /*==============================================================*/
71 
73 {
74  int xx = -1;
75 
76 #if defined(WITH_LIBTPM)
77  STACK_TPM_BUFFER( subcap );
78  STACK_TPM_BUFFER( resp );
79  STACK_TPM_BUFFER( tb );
80  TPM_PERMANENT_FLAGS permanentFlags;
81 
82  STORE32(subcap.buffer, 0, TPM_CAP_FLAG_PERMANENT);
83 
84  subcap.used = 4;
85  xx = rpmtpmErr(tpm, "GetCapability", 0,
86  TPM_GetCapability(TPM_CAP_FLAG, &subcap, &resp));
87  if (xx)
88  goto exit;
89 
90  TSS_SetTPMBuffer(&tb, resp.buffer, resp.used);
91 
92  xx = rpmtpmErr(tpm, "ReadPermanentFlags", 0,
93  TPM_ReadPermanentFlags(&tb, 0, &permanentFlags, resp.used));
94  if (xx)
95  goto exit;
96 
97  tpm->enabled = permanentFlags.physicalPresenceCMDEnable;
98 
99 exit:
100 #endif /* WITH_LIBTPM */
101 
102  return xx;
103 }
104 
105 /*==============================================================*/
106 
107 #if defined(WITH_LIBTPM)
108 extern int _rpmio_popt_context_flags; /* XXX POPT_CONTEXT_POSIXMEHARDER */
109 
117 static void rpmtpmInitPopt(rpmtpm tpm, int ac, char ** av, poptOption tbl)
118  /*@modifies tpm @*/
119 {
120  poptContext con;
121  int rc;
122 
123  if (av == NULL || av[0] == NULL || av[1] == NULL)
124  goto exit;
125 
126  /* Initialize. */
127  _tpm->keysize = 2048;
128  _tpm->ix = -1;
129  _tpm->keytype = 's';
130  _tpm->ordinal = -1;
131  _tpm->audit = TRUE;
132  _tpm->use_ca = TRUE;
133  _tpm->bitname = -1;
134  _tpm->bitvalue = -1;
135  _tpm->disable = TRUE;
136  _tpm->deactivated = TRUE;
137  _tpm->size = 0xffffffff;
138  _tpm->val = 0xffffffff;
139  _tpm->type = 0xffffffff;
140 
141  con = poptGetContext(av[0], ac, (const char **)av, tbl,
143 
144  /* Process all options into _tpm, whine if unknown options. */
145  while ((rc = poptGetNextOpt(con)) > 0) {
146  const char * arg = poptGetOptArg(con);
147  arg = _free(arg);
148  switch (rc) {
149  default:
150  fprintf(stderr, _("%s: option table misconfigured (%d)\n"),
151  __FUNCTION__, rc);
152  break;
153  }
154  }
155  /* XXX FIXME: arrange error return iff rc < -1. */
156 if (rc < -1) {
157 fprintf(stderr, "%s: poptGetNextOpt rc(%d): %s\n", __FUNCTION__, rc, poptStrerror(rc));
158 argvPrint(__FUNCTION__, (ARGV_t)av, NULL);
159 }
160 
161  /* Move the POPT parsed values into the current rpmtpm object. */
162 #ifdef NOTYET
163  tpm->av = argvFree(tpm->av);
164  rc = argvAppend(&tpm->av, poptGetArgs(con));
165 
166  con = poptFreeContext(con);
167 #else
168  /* XXX move the just parsed options */
169 
170  memcpy(((char *) tpm)+sizeof(tpm->_item),
171  ((char *)_tpm)+sizeof(tpm->_item),
172  sizeof(*tpm)-sizeof(tpm->_item));
173  memset(((char *)_tpm)+sizeof(tpm->_item),
174  0,
175  sizeof(*tpm)-sizeof(tpm->_item));
176 
177  tpm->av = argvFree(tpm->av);
178  rc = argvAppend(&tpm->av, poptGetArgs(con));
179  tpm->ac = argvCount(tpm->av);
180 
181  tpm->con = con;
182 #endif
183 
184 exit:
185 TPMDBG((stderr, "<== %s(%p, %p[%u], %p)\n", __FUNCTION__, tpm, av, (unsigned)ac, tbl));
186 }
187 #endif /* defined(WITH_LIBTPM) */
188 
189 static void rpmtpmFini(void * _tpm)
190  /*@globals fileSystem @*/
191  /*@modifies *_tpm, fileSystem @*/
192 {
193  rpmtpm tpm = (rpmtpm) _tpm;
194 
195  tpm->digest = _free(tpm->digest);
196  tpm->digestlen = 0;
197 
198  tpm->av = argvFree(tpm->av);
199  tpm->con = poptFreeContext(tpm->con); /* XXX FIXME */
200 
201  if (tpm->fp)
202  fclose(tpm->fp);
203  tpm->fp = NULL;
204 
205  tpm->ix = -1;
206  tpm->ic_str = _free(tpm->ic_str);
207  tpm->av_ix = argvFree(tpm->av_ix);
208 
209  tpm->label = _free(tpm->label);
210 
211  tpm->b = _free(tpm->b);
212  tpm->nb = 0;
213 
214  tpm->ifn = _free(tpm->ifn);
215  tpm->ofn = _free(tpm->ofn);
216  tpm->kfn = _free(tpm->kfn);
217  tpm->sfn = _free(tpm->sfn);
218  tpm->msafn = _free(tpm->msafn);
219 
220  tpm->ownerpass = _free(tpm->ownerpass);
221  tpm->keypass = _free(tpm->keypass);
222  tpm->parpass = _free(tpm->parpass);
223  tpm->certpass = _free(tpm->certpass);
224  tpm->newpass = _free(tpm->newpass);
225  tpm->areapass = _free(tpm->areapass);
226  tpm->sigpass = _free(tpm->sigpass);
227  tpm->migpass = _free(tpm->migpass);
228  tpm->datpass = _free(tpm->datpass);
229 
230  tpm->hk_str = _free(tpm->hk_str);
231  tpm->hp_str = _free(tpm->hp_str);
232  tpm->hc_str = _free(tpm->hc_str);
233  tpm->hs_str = _free(tpm->hs_str);
234  tpm->hm_str = _free(tpm->hm_str);
235  tpm->ha_str = _free(tpm->ha_str);
236  tpm->ix_str = _free(tpm->ix_str);
237 
238  tpm->cap_str = _free(tpm->cap_str);
239  tpm->scap_str = _free(tpm->scap_str);
240  tpm->scapd_str = _free(tpm->scapd_str);
241 
242  tpm->per1_str = _free(tpm->per1_str);
243  tpm->per2_str = _free(tpm->per2_str);
244 
245  tpm->es_str = _free(tpm->es_str);
246  tpm->bm_str = _free(tpm->bm_str);
247  tpm->kt_str = _free(tpm->kt_str);
248 
249 }
250 
251 /*@unchecked@*/ /*@only@*/ /*@null@*/
253 
254 static rpmtpm rpmtpmGetPool(/*@null@*/ rpmioPool pool)
255  /*@globals _rpmtpmPool, fileSystem @*/
256  /*@modifies pool, _rpmtpmPool, fileSystem @*/
257 {
258  rpmtpm tpm;
259 
260  if (_rpmtpmPool == NULL) {
261  _rpmtpmPool = rpmioNewPool("tpm", sizeof(*tpm), -1, _rpmtpm_debug,
262  NULL, NULL, rpmtpmFini);
263  pool = _rpmtpmPool;
264  }
265  tpm = (rpmtpm) rpmioGetPool(pool, sizeof(*tpm));
266  memset(((char *)tpm)+sizeof(tpm->_item), 0, sizeof(*tpm)-sizeof(tpm->_item));
267  return tpm;
268 }
269 
270 rpmtpm rpmtpmNew(int ac, char ** av, struct poptOption *tbl, uint32_t flags)
271 {
272  rpmtpm tpm = rpmtpmGetPool(_rpmtpmPool);
273 
274 #if defined(WITH_LIBTPM)
275  if (tbl)
276  rpmtpmInitPopt(tpm, ac, av, tbl);
277 
278  TPM_setlog(rpmIsVerbose() ? 1 : 0);
279 
280  if (tpm->ownerpass) {
281  TSS_sha1(tpm->ownerpass, strlen(tpm->ownerpass), tpm->pwdohash);
282  tpm->pwdo = tpm->pwdohash;
283  }
284  if (tpm->keypass) {
285  TSS_sha1(tpm->keypass, strlen(tpm->keypass), tpm->pwdkhash);
286  tpm->pwdk = tpm->pwdkhash;
287  }
288  if (tpm->parpass) {
289  TSS_sha1(tpm->parpass, strlen(tpm->parpass), tpm->pwdphash);
290  tpm->pwdp = tpm->pwdphash;
291  }
292  if (tpm->certpass) {
293  TSS_sha1(tpm->certpass, strlen(tpm->certpass), tpm->pwdchash);
294  tpm->pwdc = tpm->pwdchash;
295  }
296  if (tpm->newpass) {
297  TSS_sha1(tpm->newpass, strlen(tpm->newpass), tpm->pwdnhash);
298  tpm->pwdn = tpm->pwdnhash;
299  }
300  if (tpm->areapass) {
301  TSS_sha1(tpm->areapass, strlen(tpm->areapass), tpm->pwdahash);
302  tpm->pwda = tpm->pwdahash;
303  }
304  if (tpm->sigpass) {
305  TSS_sha1(tpm->sigpass, strlen(tpm->sigpass), tpm->pwdshash);
306  tpm->pwds = tpm->pwdshash;
307  }
308  if (tpm->migpass) {
309  TSS_sha1(tpm->migpass, strlen(tpm->migpass), tpm->pwdmhash);
310  tpm->pwdm = tpm->pwdmhash;
311  }
312  if (tpm->datpass) {
313  TSS_sha1(tpm->datpass, strlen(tpm->datpass), tpm->pwddhash);
314  tpm->pwdd = tpm->pwddhash;
315  }
316  if (tpm->hk_str) sscanf(tpm->hk_str, "%x", &tpm->keyhandle);
317  if (tpm->hp_str) sscanf(tpm->hp_str, "%x", &tpm->parhandle);
318  if (tpm->hc_str) sscanf(tpm->hc_str, "%x", &tpm->certhandle);
319  if (tpm->hs_str) sscanf(tpm->hs_str, "%x", &tpm->sighandle);
320  if (tpm->hm_str) sscanf(tpm->hm_str, "%x", &tpm->mighandle);
321  if (tpm->ha_str) sscanf(tpm->ha_str, "%x", &tpm->handle);
322  if (tpm->ix_str) sscanf(tpm->ix_str, "%x", &tpm->ix);
323 
324  if (tpm->bm_str) sscanf(tpm->bm_str, "%x", &tpm->restrictions);
325  if (tpm->kt_str) tpm->keytype = tpm->kt_str[0];
326 
327  if (tpm->cap_str) sscanf(tpm->cap_str, "%x", &tpm->cap);
328  if (tpm->scap_str) sscanf(tpm->scap_str, "%x", &tpm->scap);
329  if (tpm->scapd_str) sscanf(tpm->scapd_str, "%d", &tpm->scap);
330 
331  if (tpm->per1_str) sscanf(tpm->per1_str, "%x", &tpm->per1);
332  if (tpm->per2_str) sscanf(tpm->per2_str, "%x", &tpm->per2);
333 
334 #endif
335 
336  return rpmtpmLink(tpm);
337 }
rpmtpm rpmtpmLink(rpmtpm tpm)
Reference a TPM wrapper instance.
const bson * b
Definition: bson.h:280
#define TPMDBG(_l)
Definition: rpmtpm.c:31
int argvAppend(ARGV_t *argvp, ARGV_t av)
Append one argv array to another.
Definition: argv.c:216
rpmtpm rpmtpmNew(int ac, char **av, struct poptOption *tbl, uint32_t flags)
Create and load a TPM wrapper.
Definition: rpmtpm.c:270
static void rpmtpmFini(void *_tpm)
Definition: rpmtpm.c:189
rpmioPool _rpmtpmPool
Definition: rpmtpm.c:252
#define TRUE
Definition: rpmgrep.c:53
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
Definition: rpmmalloc.c:220
int argvCount(const ARGV_t argv)
Return no.
Definition: argv.c:71
mongo_error_t err
Definition: mongo.h:922
ARGV_t argvFree(ARGV_t argv)
Destroy an argv array.
Definition: argv.c:44
struct rpmtpm_s * rpmtpm
Definition: rpmtpm.h:24
int rpmtpmErr(rpmtpm tpm, const char *msg, uint32_t mask, uint32_t rc)
Definition: rpmtpm.c:37
const char const char int arg
Definition: mongo.h:777
const char const bson int mongo_write_concern int flags
Definition: mongo.h:485
void argvPrint(const char *msg, ARGV_t argv, FILE *fp)
Print argv array elements.
Definition: argv.c:19
static int rpmtpmGetPhysicalCMDEnable(rpmtpm tpm)
Definition: rpmtpm.c:72
int _rpmio_popt_context_flags
Definition: poptIO.c:145
int _rpmtpm_debug
Definition: rpmtpm.c:30
const char const int i
Definition: bson.h:778
void rpmtpmDump(rpmtpm tpm, const char *msg, unsigned char *b, size_t nb)
Definition: rpmtpm.c:57
rpmioPool rpmioNewPool(const char *name, size_t size, int limit, int flags, char *(*dbg)(void *item), void(*init)(void *item), void(*fini)(void *item))
Create a memory pool.
Definition: rpmmalloc.c:109
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
Definition: rpmiotypes.h:756
#define rpmIsVerbose()
Definition: rpmcb.h:21
rpmtpm _tpm
Definition: rpmtpm.c:35
#define _(Text)
Definition: system.h:29
ARGstr_t * ARGV_t
Definition: argv.h:12
static rpmtpm rpmtpmGetPool(rpmioPool pool)
Definition: rpmtpm.c:254
struct rpmtpm_s __tpm
Definition: rpmtpm.c:33