diffie-hellman: Add a bool return value to set_other_public_value()
[strongswan.git] / src / libimcv / pts / pts.c
1 /*
2 * Copyright (C) 2011-2012 Sansar Choinyambuu
3 * Copyright (C) 2012-2014 Andreas Steffen
4 * HSR Hochschule fuer Technik Rapperswil
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or (at your
9 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * for more details.
15 */
16
17 #include "pts.h"
18
19 #include <utils/debug.h>
20 #include <crypto/hashers/hasher.h>
21 #include <bio/bio_writer.h>
22 #include <bio/bio_reader.h>
23
24 #ifdef TSS_TROUSERS
25 #ifdef _BASETSD_H_
26 /* MinGW defines _BASETSD_H_, but TSS checks for _BASETSD_H */
27 # define _BASETSD_H
28 #endif
29 #include <trousers/tss.h>
30 #include <trousers/trousers.h>
31 #else
32 #ifndef TPM_TAG_QUOTE_INFO2
33 #define TPM_TAG_QUOTE_INFO2 0x0036
34 #endif
35 #ifndef TPM_LOC_ZERO
36 #define TPM_LOC_ZERO 0x01
37 #endif
38 #endif
39
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <libgen.h>
43 #include <unistd.h>
44 #include <errno.h>
45
46 typedef struct private_pts_t private_pts_t;
47
48 /**
49 * Private data of a pts_t object.
50 *
51 */
52 struct private_pts_t {
53
54 /**
55 * Public pts_t interface.
56 */
57 pts_t public;
58
59 /**
60 * PTS Protocol Capabilities
61 */
62 pts_proto_caps_flag_t proto_caps;
63
64 /**
65 * PTS Measurement Algorithm
66 */
67 pts_meas_algorithms_t algorithm;
68
69 /**
70 * DH Hash Algorithm
71 */
72 pts_meas_algorithms_t dh_hash_algorithm;
73
74 /**
75 * PTS Diffie-Hellman Secret
76 */
77 diffie_hellman_t *dh;
78
79 /**
80 * PTS Diffie-Hellman Initiator Nonce
81 */
82 chunk_t initiator_nonce;
83
84 /**
85 * PTS Diffie-Hellman Responder Nonce
86 */
87 chunk_t responder_nonce;
88
89 /**
90 * Secret assessment value to be used for TPM Quote as an external data
91 */
92 chunk_t secret;
93
94 /**
95 * Primary key of platform entry in database
96 */
97 int platform_id;
98
99 /**
100 * TRUE if IMC-PTS, FALSE if IMV-PTS
101 */
102 bool is_imc;
103
104 /**
105 * Do we have an activated TPM
106 */
107 bool has_tpm;
108
109 /**
110 * Contains a TPM_CAP_VERSION_INFO struct
111 */
112 chunk_t tpm_version_info;
113
114 /**
115 * Contains TSS Blob structure for AIK
116 */
117 chunk_t aik_blob;
118
119 /**
120 * Contains a Attestation Identity Key or Certificate
121 */
122 certificate_t *aik;
123
124 /**
125 * Primary key referening AIK in database
126 */
127 int aik_id;
128
129 /**
130 * Shadow PCR set
131 */
132 pts_pcr_t *pcrs;
133
134 };
135
136 METHOD(pts_t, get_proto_caps, pts_proto_caps_flag_t,
137 private_pts_t *this)
138 {
139 return this->proto_caps;
140 }
141
142 METHOD(pts_t, set_proto_caps, void,
143 private_pts_t *this, pts_proto_caps_flag_t flags)
144 {
145 this->proto_caps = flags;
146 DBG2(DBG_PTS, "supported PTS protocol capabilities: %s%s%s%s%s",
147 flags & PTS_PROTO_CAPS_C ? "C" : ".",
148 flags & PTS_PROTO_CAPS_V ? "V" : ".",
149 flags & PTS_PROTO_CAPS_D ? "D" : ".",
150 flags & PTS_PROTO_CAPS_T ? "T" : ".",
151 flags & PTS_PROTO_CAPS_X ? "X" : ".");
152 }
153
154 METHOD(pts_t, get_meas_algorithm, pts_meas_algorithms_t,
155 private_pts_t *this)
156 {
157 return this->algorithm;
158 }
159
160 METHOD(pts_t, set_meas_algorithm, void,
161 private_pts_t *this, pts_meas_algorithms_t algorithm)
162 {
163 hash_algorithm_t hash_alg;
164
165 hash_alg = pts_meas_algo_to_hash(algorithm);
166 DBG2(DBG_PTS, "selected PTS measurement algorithm is %N",
167 hash_algorithm_names, hash_alg);
168 if (hash_alg != HASH_UNKNOWN)
169 {
170 this->algorithm = algorithm;
171 }
172 }
173
174 METHOD(pts_t, get_dh_hash_algorithm, pts_meas_algorithms_t,
175 private_pts_t *this)
176 {
177 return this->dh_hash_algorithm;
178 }
179
180 METHOD(pts_t, set_dh_hash_algorithm, void,
181 private_pts_t *this, pts_meas_algorithms_t algorithm)
182 {
183 hash_algorithm_t hash_alg;
184
185 hash_alg = pts_meas_algo_to_hash(algorithm);
186 DBG2(DBG_PTS, "selected DH hash algorithm is %N",
187 hash_algorithm_names, hash_alg);
188 if (hash_alg != HASH_UNKNOWN)
189 {
190 this->dh_hash_algorithm = algorithm;
191 }
192 }
193
194
195 METHOD(pts_t, create_dh_nonce, bool,
196 private_pts_t *this, pts_dh_group_t group, int nonce_len)
197 {
198 diffie_hellman_group_t dh_group;
199 chunk_t *nonce;
200 rng_t *rng;
201
202 dh_group = pts_dh_group_to_ike(group);
203 DBG2(DBG_PTS, "selected PTS DH group is %N",
204 diffie_hellman_group_names, dh_group);
205 DESTROY_IF(this->dh);
206 this->dh = lib->crypto->create_dh(lib->crypto, dh_group);
207
208 rng = lib->crypto->create_rng(lib->crypto, RNG_STRONG);
209 if (!rng)
210 {
211 DBG1(DBG_PTS, "no rng available");
212 return FALSE;
213 }
214 DBG2(DBG_PTS, "nonce length is %d", nonce_len);
215 nonce = this->is_imc ? &this->responder_nonce : &this->initiator_nonce;
216 chunk_free(nonce);
217 if (!rng->allocate_bytes(rng, nonce_len, nonce))
218 {
219 DBG1(DBG_PTS, "failed to allocate nonce");
220 rng->destroy(rng);
221 return FALSE;
222 }
223 rng->destroy(rng);
224 return TRUE;
225 }
226
227 METHOD(pts_t, get_my_public_value, bool,
228 private_pts_t *this, chunk_t *value, chunk_t *nonce)
229 {
230 if (!this->dh->get_my_public_value(this->dh, value))
231 {
232 return FALSE;
233 }
234 *nonce = this->is_imc ? this->responder_nonce : this->initiator_nonce;
235 return TRUE;
236 }
237
238 METHOD(pts_t, set_peer_public_value, bool,
239 private_pts_t *this, chunk_t value, chunk_t nonce)
240 {
241 if (!this->dh->set_other_public_value(this->dh, value))
242 {
243 return FALSE;
244 }
245
246 nonce = chunk_clone(nonce);
247 if (this->is_imc)
248 {
249 this->initiator_nonce = nonce;
250 }
251 else
252 {
253 this->responder_nonce = nonce;
254 }
255 return TRUE;
256 }
257
258 METHOD(pts_t, calculate_secret, bool,
259 private_pts_t *this)
260 {
261 hasher_t *hasher;
262 hash_algorithm_t hash_alg;
263 chunk_t shared_secret;
264
265 /* Check presence of nonces */
266 if (!this->initiator_nonce.len || !this->responder_nonce.len)
267 {
268 DBG1(DBG_PTS, "initiator and/or responder nonce is not available");
269 return FALSE;
270 }
271 DBG3(DBG_PTS, "initiator nonce: %B", &this->initiator_nonce);
272 DBG3(DBG_PTS, "responder nonce: %B", &this->responder_nonce);
273
274 /* Calculate the DH secret */
275 if (!this->dh->get_shared_secret(this->dh, &shared_secret))
276 {
277 DBG1(DBG_PTS, "shared DH secret computation failed");
278 return FALSE;
279 }
280 DBG3(DBG_PTS, "shared DH secret: %B", &shared_secret);
281
282 /* Calculate the secret assessment value */
283 hash_alg = pts_meas_algo_to_hash(this->dh_hash_algorithm);
284 hasher = lib->crypto->create_hasher(lib->crypto, hash_alg);
285
286 if (!hasher ||
287 !hasher->get_hash(hasher, chunk_from_chars('1'), NULL) ||
288 !hasher->get_hash(hasher, this->initiator_nonce, NULL) ||
289 !hasher->get_hash(hasher, this->responder_nonce, NULL) ||
290 !hasher->allocate_hash(hasher, shared_secret, &this->secret))
291 {
292 DESTROY_IF(hasher);
293 return FALSE;
294 }
295 hasher->destroy(hasher);
296
297 /* The DH secret must be destroyed */
298 chunk_clear(&shared_secret);
299
300 /*
301 * Truncate the hash to 20 bytes to fit the ExternalData
302 * argument of the TPM Quote command
303 */
304 this->secret.len = min(this->secret.len, 20);
305 DBG3(DBG_PTS, "secret assessment value: %B", &this->secret);
306 return TRUE;
307 }
308
309 #ifdef TSS_TROUSERS
310
311 /**
312 * Print TPM 1.2 Version Info
313 */
314 static void print_tpm_version_info(private_pts_t *this)
315 {
316 TPM_CAP_VERSION_INFO *info;
317
318 info = (TPM_CAP_VERSION_INFO*)this->tpm_version_info.ptr;
319
320 if (this->tpm_version_info.len >=
321 sizeof(*info) - sizeof(info->vendorSpecific))
322 {
323 DBG2(DBG_PTS, "TPM Version Info: Chip Version: %u.%u.%u.%u, "
324 "Spec Level: %u, Errata Rev: %u, Vendor ID: %.4s",
325 info->version.major, info->version.minor,
326 info->version.revMajor, info->version.revMinor,
327 untoh16(&info->specLevel), info->errataRev, info->tpmVendorID);
328 }
329 else
330 {
331 DBG1(DBG_PTS, "could not parse tpm version info");
332 }
333 }
334
335 #else
336
337 static void print_tpm_version_info(private_pts_t *this)
338 {
339 DBG1(DBG_PTS, "unknown TPM version: no TSS implementation available");
340 }
341
342 #endif /* TSS_TROUSERS */
343
344 METHOD(pts_t, get_platform_id, int,
345 private_pts_t *this)
346 {
347 return this->platform_id;
348 }
349
350 METHOD(pts_t, set_platform_id, void,
351 private_pts_t *this, int pid)
352 {
353 this->platform_id = pid;
354 }
355
356 METHOD(pts_t, get_tpm_version_info, bool,
357 private_pts_t *this, chunk_t *info)
358 {
359 if (!this->has_tpm)
360 {
361 return FALSE;
362 }
363 *info = this->tpm_version_info;
364 print_tpm_version_info(this);
365 return TRUE;
366 }
367
368 METHOD(pts_t, set_tpm_version_info, void,
369 private_pts_t *this, chunk_t info)
370 {
371 this->tpm_version_info = chunk_clone(info);
372 print_tpm_version_info(this);
373 }
374
375 /**
376 * Load an AIK Blob (TSS_TSPATTRIB_KEYBLOB_BLOB attribute)
377 */
378 static void load_aik_blob(private_pts_t *this)
379 {
380 char *path;
381 chunk_t *map;
382
383 path = lib->settings->get_str(lib->settings,
384 "%s.plugins.imc-attestation.aik_blob", NULL, lib->ns);
385 if (path)
386 {
387 map = chunk_map(path, FALSE);
388 if (map)
389 {
390 DBG2(DBG_PTS, "loaded AIK Blob from '%s'", path);
391 DBG3(DBG_PTS, "AIK Blob: %B", map);
392 this->aik_blob = chunk_clone(*map);
393 chunk_unmap(map);
394 }
395 else
396 {
397 DBG1(DBG_PTS, "unable to map AIK Blob file '%s': %s",
398 path, strerror(errno));
399 }
400 }
401 else
402 {
403 DBG1(DBG_PTS, "AIK Blob is not available");
404 }
405 }
406
407 /**
408 * Load an AIK certificate or public key
409 * the certificate having precedence over the public key if both are present
410 */
411 static void load_aik(private_pts_t *this)
412 {
413 char *cert_path, *key_path;
414
415 cert_path = lib->settings->get_str(lib->settings,
416 "%s.plugins.imc-attestation.aik_cert", NULL, lib->ns);
417 key_path = lib->settings->get_str(lib->settings,
418 "%s.plugins.imc-attestation.aik_pubkey", NULL, lib->ns);
419
420 if (cert_path)
421 {
422 this->aik = lib->creds->create(lib->creds, CRED_CERTIFICATE,
423 CERT_X509, BUILD_FROM_FILE,
424 cert_path, BUILD_END);
425 if (this->aik)
426 {
427 DBG2(DBG_PTS, "loaded AIK certificate from '%s'", cert_path);
428 return;
429 }
430 }
431 if (key_path)
432 {
433 this->aik = lib->creds->create(lib->creds, CRED_CERTIFICATE,
434 CERT_TRUSTED_PUBKEY, BUILD_FROM_FILE,
435 key_path, BUILD_END);
436 if (this->aik)
437 {
438 DBG2(DBG_PTS, "loaded AIK public key from '%s'", key_path);
439 return;
440 }
441 }
442
443 DBG1(DBG_PTS, "neither AIK certificate nor public key is available");
444 }
445
446 METHOD(pts_t, get_aik, certificate_t*,
447 private_pts_t *this)
448 {
449 return this->aik;
450 }
451
452 METHOD(pts_t, set_aik, void,
453 private_pts_t *this, certificate_t *aik, int aik_id)
454 {
455 DESTROY_IF(this->aik);
456 this->aik = aik->get_ref(aik);
457 this->aik_id = aik_id;
458 }
459
460 METHOD(pts_t, get_aik_id, int,
461 private_pts_t *this)
462 {
463 return this->aik_id;
464 }
465
466 METHOD(pts_t, is_path_valid, bool,
467 private_pts_t *this, char *path, pts_error_code_t *error_code)
468 {
469 struct stat st;
470
471 *error_code = 0;
472
473 if (!stat(path, &st))
474 {
475 return TRUE;
476 }
477 else if (errno == ENOENT || errno == ENOTDIR)
478 {
479 DBG1(DBG_PTS, "file/directory does not exist %s", path);
480 *error_code = TCG_PTS_FILE_NOT_FOUND;
481 }
482 else if (errno == EFAULT)
483 {
484 DBG1(DBG_PTS, "bad address %s", path);
485 *error_code = TCG_PTS_INVALID_PATH;
486 }
487 else
488 {
489 DBG1(DBG_PTS, "error: %s occurred while validating path: %s",
490 strerror(errno), path);
491 return FALSE;
492 }
493
494 return TRUE;
495 }
496
497 /**
498 * Obtain statistical information describing a file
499 */
500 static bool file_metadata(char *pathname, pts_file_metadata_t **entry)
501 {
502 struct stat st;
503 pts_file_metadata_t *this;
504
505 this = malloc_thing(pts_file_metadata_t);
506
507 if (stat(pathname, &st))
508 {
509 DBG1(DBG_PTS, "unable to obtain statistics about '%s'", pathname);
510 free(this);
511 return FALSE;
512 }
513
514 if (S_ISREG(st.st_mode))
515 {
516 this->type = PTS_FILE_REGULAR;
517 }
518 else if (S_ISDIR(st.st_mode))
519 {
520 this->type = PTS_FILE_DIRECTORY;
521 }
522 else if (S_ISCHR(st.st_mode))
523 {
524 this->type = PTS_FILE_CHAR_SPEC;
525 }
526 else if (S_ISBLK(st.st_mode))
527 {
528 this->type = PTS_FILE_BLOCK_SPEC;
529 }
530 else if (S_ISFIFO(st.st_mode))
531 {
532 this->type = PTS_FILE_FIFO;
533 }
534 #ifndef WIN32
535 else if (S_ISLNK(st.st_mode))
536 {
537 this->type = PTS_FILE_SYM_LINK;
538 }
539 else if (S_ISSOCK(st.st_mode))
540 {
541 this->type = PTS_FILE_SOCKET;
542 }
543 #endif /* WIN32 */
544 else
545 {
546 this->type = PTS_FILE_OTHER;
547 }
548
549 this->filesize = st.st_size;
550 this->created = st.st_ctime;
551 this->modified = st.st_mtime;
552 this->accessed = st.st_atime;
553 this->owner = st.st_uid;
554 this->group = st.st_gid;
555
556 *entry = this;
557 return TRUE;
558 }
559
560 METHOD(pts_t, get_metadata, pts_file_meta_t*,
561 private_pts_t *this, char *pathname, bool is_directory)
562 {
563 pts_file_meta_t *metadata;
564 pts_file_metadata_t *entry;
565
566 /* Create a metadata object */
567 metadata = pts_file_meta_create();
568
569 if (is_directory)
570 {
571 enumerator_t *enumerator;
572 char *rel_name, *abs_name;
573 struct stat st;
574
575 enumerator = enumerator_create_directory(pathname);
576 if (!enumerator)
577 {
578 DBG1(DBG_PTS," directory '%s' can not be opened, %s", pathname,
579 strerror(errno));
580 metadata->destroy(metadata);
581 return NULL;
582 }
583 while (enumerator->enumerate(enumerator, &rel_name, &abs_name, &st))
584 {
585 /* measure regular files only */
586 if (S_ISREG(st.st_mode) && *rel_name != '.')
587 {
588 if (!file_metadata(abs_name, &entry))
589 {
590 enumerator->destroy(enumerator);
591 metadata->destroy(metadata);
592 return NULL;
593 }
594 entry->filename = strdup(rel_name);
595 metadata->add(metadata, entry);
596 }
597 }
598 enumerator->destroy(enumerator);
599 }
600 else
601 {
602 if (!file_metadata(pathname, &entry))
603 {
604 metadata->destroy(metadata);
605 return NULL;
606 }
607 entry->filename = path_basename(pathname);
608 metadata->add(metadata, entry);
609 }
610
611 return metadata;
612 }
613
614
615 #ifdef TSS_TROUSERS
616
617 METHOD(pts_t, read_pcr, bool,
618 private_pts_t *this, u_int32_t pcr_num, chunk_t *pcr_value)
619 {
620 TSS_HCONTEXT hContext;
621 TSS_HTPM hTPM;
622 TSS_RESULT result;
623 BYTE *buf;
624 UINT32 len;
625
626 bool success = FALSE;
627
628 result = Tspi_Context_Create(&hContext);
629 if (result != TSS_SUCCESS)
630 {
631 DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x", result);
632 return FALSE;
633 }
634
635 result = Tspi_Context_Connect(hContext, NULL);
636 if (result != TSS_SUCCESS)
637 {
638 goto err;
639 }
640 result = Tspi_Context_GetTpmObject (hContext, &hTPM);
641 if (result != TSS_SUCCESS)
642 {
643 goto err;
644 }
645 result = Tspi_TPM_PcrRead(hTPM, pcr_num, &len, &buf);
646 if (result != TSS_SUCCESS)
647 {
648 goto err;
649 }
650 *pcr_value = chunk_clone(chunk_create(buf, len));
651 DBG3(DBG_PTS, "PCR %d value:%B", pcr_num, pcr_value);
652 success = TRUE;
653
654 err:
655 if (!success)
656 {
657 DBG1(DBG_PTS, "TPM not available: tss error 0x%x", result);
658 }
659 Tspi_Context_FreeMemory(hContext, NULL);
660 Tspi_Context_Close(hContext);
661
662 return success;
663 }
664
665 METHOD(pts_t, extend_pcr, bool,
666 private_pts_t *this, u_int32_t pcr_num, chunk_t input, chunk_t *output)
667 {
668 TSS_HCONTEXT hContext;
669 TSS_HTPM hTPM;
670 TSS_RESULT result;
671 u_int32_t pcr_length;
672 chunk_t pcr_value = chunk_empty;
673
674 result = Tspi_Context_Create(&hContext);
675 if (result != TSS_SUCCESS)
676 {
677 DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x",
678 result);
679 return FALSE;
680 }
681 result = Tspi_Context_Connect(hContext, NULL);
682 if (result != TSS_SUCCESS)
683 {
684 goto err;
685 }
686 result = Tspi_Context_GetTpmObject (hContext, &hTPM);
687 if (result != TSS_SUCCESS)
688 {
689 goto err;
690 }
691
692 pcr_value = chunk_alloc(PTS_PCR_LEN);
693 result = Tspi_TPM_PcrExtend(hTPM, pcr_num, PTS_PCR_LEN, input.ptr,
694 NULL, &pcr_length, &pcr_value.ptr);
695 if (result != TSS_SUCCESS)
696 {
697 goto err;
698 }
699
700 *output = pcr_value;
701 *output = chunk_clone(*output);
702
703 DBG3(DBG_PTS, "PCR %d extended with: %B", pcr_num, &input);
704 DBG3(DBG_PTS, "PCR %d value after extend: %B", pcr_num, output);
705
706 chunk_clear(&pcr_value);
707 Tspi_Context_FreeMemory(hContext, NULL);
708 Tspi_Context_Close(hContext);
709
710 return TRUE;
711
712 err:
713 DBG1(DBG_PTS, "TPM not available: tss error 0x%x", result);
714
715 chunk_clear(&pcr_value);
716 Tspi_Context_FreeMemory(hContext, NULL);
717 Tspi_Context_Close(hContext);
718
719 return FALSE;
720 }
721
722 METHOD(pts_t, quote_tpm, bool,
723 private_pts_t *this, bool use_quote2, chunk_t *pcr_comp, chunk_t *quote_sig)
724 {
725 TSS_HCONTEXT hContext;
726 TSS_HTPM hTPM;
727 TSS_HKEY hAIK;
728 TSS_HKEY hSRK;
729 TSS_HPOLICY srkUsagePolicy;
730 TSS_UUID SRK_UUID = TSS_UUID_SRK;
731 BYTE secret[] = TSS_WELL_KNOWN_SECRET;
732 TSS_HPCRS hPcrComposite;
733 TSS_VALIDATION valData;
734 TSS_RESULT result;
735 chunk_t quote_info;
736 BYTE* versionInfo;
737 u_int32_t versionInfoSize, pcr;
738 enumerator_t *enumerator;
739 bool success = FALSE;
740
741 result = Tspi_Context_Create(&hContext);
742 if (result != TSS_SUCCESS)
743 {
744 DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x",
745 result);
746 return FALSE;
747 }
748 result = Tspi_Context_Connect(hContext, NULL);
749 if (result != TSS_SUCCESS)
750 {
751 goto err1;
752 }
753 result = Tspi_Context_GetTpmObject (hContext, &hTPM);
754 if (result != TSS_SUCCESS)
755 {
756 goto err1;
757 }
758
759 /* Retrieve SRK from TPM and set the authentication to well known secret*/
760 result = Tspi_Context_LoadKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM,
761 SRK_UUID, &hSRK);
762 if (result != TSS_SUCCESS)
763 {
764 goto err1;
765 }
766
767 result = Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE, &srkUsagePolicy);
768 if (result != TSS_SUCCESS)
769 {
770 goto err1;
771 }
772 result = Tspi_Policy_SetSecret(srkUsagePolicy, TSS_SECRET_MODE_SHA1,
773 20, secret);
774 if (result != TSS_SUCCESS)
775 {
776 goto err1;
777 }
778
779 result = Tspi_Context_LoadKeyByBlob (hContext, hSRK, this->aik_blob.len,
780 this->aik_blob.ptr, &hAIK);
781 if (result != TSS_SUCCESS)
782 {
783 goto err1;
784 }
785
786 /* Create PCR composite object */
787 result = use_quote2 ?
788 Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_PCRS,
789 TSS_PCRS_STRUCT_INFO_SHORT, &hPcrComposite) :
790 Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_PCRS,
791 TSS_PCRS_STRUCT_DEFAULT, &hPcrComposite);
792 if (result != TSS_SUCCESS)
793 {
794 goto err2;
795 }
796
797 /* Select PCRs */
798 enumerator = this->pcrs->create_enumerator(this->pcrs);
799 while (enumerator->enumerate(enumerator, &pcr))
800 {
801 result = use_quote2 ?
802 Tspi_PcrComposite_SelectPcrIndexEx(hPcrComposite, pcr,
803 TSS_PCRS_DIRECTION_RELEASE) :
804 Tspi_PcrComposite_SelectPcrIndex(hPcrComposite, pcr);
805 if (result != TSS_SUCCESS)
806 {
807 break;
808 }
809 }
810 enumerator->destroy(enumerator);
811
812 if (result != TSS_SUCCESS)
813 {
814 goto err3;
815 }
816
817 /* Set the Validation Data */
818 valData.ulExternalDataLength = this->secret.len;
819 valData.rgbExternalData = (BYTE *)this->secret.ptr;
820
821
822 /* TPM Quote */
823 result = use_quote2 ?
824 Tspi_TPM_Quote2(hTPM, hAIK, FALSE, hPcrComposite, &valData,
825 &versionInfoSize, &versionInfo):
826 Tspi_TPM_Quote(hTPM, hAIK, hPcrComposite, &valData);
827 if (result != TSS_SUCCESS)
828 {
829 goto err4;
830 }
831
832 /* Set output chunks */
833 *pcr_comp = chunk_alloc(HASH_SIZE_SHA1);
834
835 if (use_quote2)
836 {
837 /* TPM_Composite_Hash is last 20 bytes of TPM_Quote_Info2 structure */
838 memcpy(pcr_comp->ptr, valData.rgbData + valData.ulDataLength - HASH_SIZE_SHA1,
839 HASH_SIZE_SHA1);
840 }
841 else
842 {
843 /* TPM_Composite_Hash is 8-28th bytes of TPM_Quote_Info structure */
844 memcpy(pcr_comp->ptr, valData.rgbData + 8, HASH_SIZE_SHA1);
845 }
846 DBG3(DBG_PTS, "Hash of PCR Composite: %#B", pcr_comp);
847
848 quote_info = chunk_create(valData.rgbData, valData.ulDataLength);
849 DBG3(DBG_PTS, "TPM Quote Info: %B",&quote_info);
850
851 *quote_sig = chunk_clone(chunk_create(valData.rgbValidationData,
852 valData.ulValidationDataLength));
853 DBG3(DBG_PTS, "TPM Quote Signature: %B",quote_sig);
854
855 success = TRUE;
856
857 /* Cleanup */
858 err4:
859 Tspi_Context_FreeMemory(hContext, NULL);
860
861 err3:
862 Tspi_Context_CloseObject(hContext, hPcrComposite);
863
864 err2:
865 Tspi_Context_CloseObject(hContext, hAIK);
866
867 err1:
868 Tspi_Context_Close(hContext);
869 if (!success)
870 {
871 DBG1(DBG_PTS, "TPM not available: tss error 0x%x", result);
872 }
873 return success;
874 }
875
876 #else /* TSS_TROUSERS */
877
878 METHOD(pts_t, read_pcr, bool,
879 private_pts_t *this, u_int32_t pcr_num, chunk_t *pcr_value)
880 {
881 return FALSE;
882 }
883
884 METHOD(pts_t, extend_pcr, bool,
885 private_pts_t *this, u_int32_t pcr_num, chunk_t input, chunk_t *output)
886 {
887 return FALSE;
888 }
889
890 METHOD(pts_t, quote_tpm, bool,
891 private_pts_t *this, bool use_quote2, chunk_t *pcr_comp, chunk_t *quote_sig)
892 {
893 return FALSE;
894 }
895
896 #endif /* TSS_TROUSERS */
897
898 /**
899 * TPM_QUOTE_INFO structure:
900 * 4 bytes of version
901 * 4 bytes 'Q' 'U' 'O' 'T'
902 * 20 byte SHA1 of TCPA_PCR_COMPOSITE
903 * 20 byte nonce
904 *
905 * TPM_QUOTE_INFO2 structure:
906 * 2 bytes Tag 0x0036 TPM_Tag_Quote_info2
907 * 4 bytes 'Q' 'U' 'T' '2'
908 * 20 bytes nonce
909 * 26 bytes PCR_INFO_SHORT
910 */
911
912 METHOD(pts_t, get_quote_info, bool,
913 private_pts_t *this, bool use_quote2, bool use_ver_info,
914 pts_meas_algorithms_t comp_hash_algo,
915 chunk_t *out_pcr_comp, chunk_t *out_quote_info)
916 {
917 chunk_t selection, pcr_comp, hash_pcr_comp;
918 bio_writer_t *writer;
919 hasher_t *hasher;
920
921 if (!this->pcrs->get_count(this->pcrs))
922 {
923 DBG1(DBG_PTS, "No extended PCR entries available, "
924 "unable to construct TPM Quote Info");
925 return FALSE;
926 }
927 if (!this->secret.ptr)
928 {
929 DBG1(DBG_PTS, "Secret assessment value unavailable, ",
930 "unable to construct TPM Quote Info");
931 return FALSE;
932 }
933 if (use_quote2 && use_ver_info && !this->tpm_version_info.ptr)
934 {
935 DBG1(DBG_PTS, "TPM Version Information unavailable, ",
936 "unable to construct TPM Quote Info2");
937 return FALSE;
938 }
939
940 pcr_comp = this->pcrs->get_composite(this->pcrs);
941
942
943 /* Output the TPM_PCR_COMPOSITE expected from IMC */
944 if (comp_hash_algo)
945 {
946 hash_algorithm_t algo;
947
948 algo = pts_meas_algo_to_hash(comp_hash_algo);
949 hasher = lib->crypto->create_hasher(lib->crypto, algo);
950
951 /* Hash the PCR Composite Structure */
952 if (!hasher || !hasher->allocate_hash(hasher, pcr_comp, out_pcr_comp))
953 {
954 DESTROY_IF(hasher);
955 free(pcr_comp.ptr);
956 return FALSE;
957 }
958 DBG3(DBG_PTS, "constructed PCR Composite hash: %#B", out_pcr_comp);
959 hasher->destroy(hasher);
960 }
961 else
962 {
963 *out_pcr_comp = chunk_clone(pcr_comp);
964 }
965
966 /* SHA1 hash of PCR Composite to construct TPM_QUOTE_INFO */
967 hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA1);
968 if (!hasher || !hasher->allocate_hash(hasher, pcr_comp, &hash_pcr_comp))
969 {
970 DESTROY_IF(hasher);
971 chunk_free(out_pcr_comp);
972 free(pcr_comp.ptr);
973 return FALSE;
974 }
975 hasher->destroy(hasher);
976
977 /* Construct TPM_QUOTE_INFO/TPM_QUOTE_INFO2 structure */
978 writer = bio_writer_create(TPM_QUOTE_INFO_LEN);
979
980 if (use_quote2)
981 {
982 /* TPM Structure Tag */
983 writer->write_uint16(writer, TPM_TAG_QUOTE_INFO2);
984
985 /* Magic QUT2 value */
986 writer->write_data(writer, chunk_create("QUT2", 4));
987
988 /* Secret assessment value 20 bytes (nonce) */
989 writer->write_data(writer, this->secret);
990
991 /* PCR selection */
992 selection.ptr = pcr_comp.ptr;
993 selection.len = 2 + this->pcrs->get_selection_size(this->pcrs);
994 writer->write_data(writer, selection);
995
996 /* TPM Locality Selection */
997 writer->write_uint8(writer, TPM_LOC_ZERO);
998
999 /* PCR Composite Hash */
1000 writer->write_data(writer, hash_pcr_comp);
1001
1002 if (use_ver_info)
1003 {
1004 /* TPM version Info */
1005 writer->write_data(writer, this->tpm_version_info);
1006 }
1007 }
1008 else
1009 {
1010 /* Version number */
1011 writer->write_data(writer, chunk_from_chars(1, 1, 0, 0));
1012
1013 /* Magic QUOT value */
1014 writer->write_data(writer, chunk_create("QUOT", 4));
1015
1016 /* PCR Composite Hash */
1017 writer->write_data(writer, hash_pcr_comp);
1018
1019 /* Secret assessment value 20 bytes (nonce) */
1020 writer->write_data(writer, this->secret);
1021 }
1022
1023 /* TPM Quote Info */
1024 *out_quote_info = writer->extract_buf(writer);
1025 DBG3(DBG_PTS, "constructed TPM Quote Info: %B", out_quote_info);
1026
1027 writer->destroy(writer);
1028 free(pcr_comp.ptr);
1029 free(hash_pcr_comp.ptr);
1030
1031 return TRUE;
1032 }
1033
1034 METHOD(pts_t, verify_quote_signature, bool,
1035 private_pts_t *this, chunk_t data, chunk_t signature)
1036 {
1037 public_key_t *aik_pub_key;
1038
1039 aik_pub_key = this->aik->get_public_key(this->aik);
1040 if (!aik_pub_key)
1041 {
1042 DBG1(DBG_PTS, "failed to get public key from AIK certificate");
1043 return FALSE;
1044 }
1045
1046 if (!aik_pub_key->verify(aik_pub_key, SIGN_RSA_EMSA_PKCS1_SHA1,
1047 data, signature))
1048 {
1049 DBG1(DBG_PTS, "signature verification failed for TPM Quote Info");
1050 DESTROY_IF(aik_pub_key);
1051 return FALSE;
1052 }
1053
1054 aik_pub_key->destroy(aik_pub_key);
1055 return TRUE;
1056 }
1057
1058 METHOD(pts_t, get_pcrs, pts_pcr_t*,
1059 private_pts_t *this)
1060 {
1061 return this->pcrs;
1062 }
1063
1064 METHOD(pts_t, destroy, void,
1065 private_pts_t *this)
1066 {
1067 DESTROY_IF(this->pcrs);
1068 DESTROY_IF(this->aik);
1069 DESTROY_IF(this->dh);
1070 free(this->initiator_nonce.ptr);
1071 free(this->responder_nonce.ptr);
1072 free(this->secret.ptr);
1073 free(this->aik_blob.ptr);
1074 free(this->tpm_version_info.ptr);
1075 free(this);
1076 }
1077
1078
1079 #ifdef TSS_TROUSERS
1080
1081 /**
1082 * Check for a TPM by querying for TPM Version Info
1083 */
1084 static bool has_tpm(private_pts_t *this)
1085 {
1086 TSS_HCONTEXT hContext;
1087 TSS_HTPM hTPM;
1088 TSS_RESULT result;
1089 u_int32_t version_info_len;
1090
1091 result = Tspi_Context_Create(&hContext);
1092 if (result != TSS_SUCCESS)
1093 {
1094 DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x",
1095 result);
1096 return FALSE;
1097 }
1098 result = Tspi_Context_Connect(hContext, NULL);
1099 if (result != TSS_SUCCESS)
1100 {
1101 goto err;
1102 }
1103 result = Tspi_Context_GetTpmObject (hContext, &hTPM);
1104 if (result != TSS_SUCCESS)
1105 {
1106 goto err;
1107 }
1108 result = Tspi_TPM_GetCapability(hTPM, TSS_TPMCAP_VERSION_VAL, 0, NULL,
1109 &version_info_len,
1110 &this->tpm_version_info.ptr);
1111 this->tpm_version_info.len = version_info_len;
1112 if (result != TSS_SUCCESS)
1113 {
1114 goto err;
1115 }
1116 this->tpm_version_info = chunk_clone(this->tpm_version_info);
1117
1118 Tspi_Context_FreeMemory(hContext, NULL);
1119 Tspi_Context_Close(hContext);
1120 return TRUE;
1121
1122 err:
1123 DBG1(DBG_PTS, "TPM not available: tss error 0x%x", result);
1124 Tspi_Context_FreeMemory(hContext, NULL);
1125 Tspi_Context_Close(hContext);
1126 return FALSE;
1127 }
1128
1129 #else /* TSS_TROUSERS */
1130
1131 static bool has_tpm(private_pts_t *this)
1132 {
1133 return FALSE;
1134 }
1135
1136 #endif /* TSS_TROUSERS */
1137
1138
1139 /**
1140 * See header
1141 */
1142 pts_t *pts_create(bool is_imc)
1143 {
1144 private_pts_t *this;
1145 pts_pcr_t *pcrs;
1146
1147 pcrs = pts_pcr_create();
1148 if (!pcrs)
1149 {
1150 DBG1(DBG_PTS, "shadow PCR set could not be created");
1151 return NULL;
1152 }
1153
1154 INIT(this,
1155 .public = {
1156 .get_proto_caps = _get_proto_caps,
1157 .set_proto_caps = _set_proto_caps,
1158 .get_meas_algorithm = _get_meas_algorithm,
1159 .set_meas_algorithm = _set_meas_algorithm,
1160 .get_dh_hash_algorithm = _get_dh_hash_algorithm,
1161 .set_dh_hash_algorithm = _set_dh_hash_algorithm,
1162 .create_dh_nonce = _create_dh_nonce,
1163 .get_my_public_value = _get_my_public_value,
1164 .set_peer_public_value = _set_peer_public_value,
1165 .calculate_secret = _calculate_secret,
1166 .get_platform_id = _get_platform_id,
1167 .set_platform_id = _set_platform_id,
1168 .get_tpm_version_info = _get_tpm_version_info,
1169 .set_tpm_version_info = _set_tpm_version_info,
1170 .get_aik = _get_aik,
1171 .set_aik = _set_aik,
1172 .get_aik_id = _get_aik_id,
1173 .is_path_valid = _is_path_valid,
1174 .get_metadata = _get_metadata,
1175 .read_pcr = _read_pcr,
1176 .extend_pcr = _extend_pcr,
1177 .quote_tpm = _quote_tpm,
1178 .get_pcrs = _get_pcrs,
1179 .get_quote_info = _get_quote_info,
1180 .verify_quote_signature = _verify_quote_signature,
1181 .destroy = _destroy,
1182 },
1183 .is_imc = is_imc,
1184 .proto_caps = PTS_PROTO_CAPS_V,
1185 .algorithm = PTS_MEAS_ALGO_SHA256,
1186 .dh_hash_algorithm = PTS_MEAS_ALGO_SHA256,
1187 .pcrs = pcrs,
1188 );
1189
1190 if (is_imc)
1191 {
1192 if (has_tpm(this))
1193 {
1194 this->has_tpm = TRUE;
1195 this->proto_caps |= PTS_PROTO_CAPS_T | PTS_PROTO_CAPS_D;
1196 load_aik(this);
1197 load_aik_blob(this);
1198 }
1199 }
1200 else
1201 {
1202 this->proto_caps |= PTS_PROTO_CAPS_T | PTS_PROTO_CAPS_D;
1203 }
1204
1205 return &this->public;
1206 }