tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1# SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2
3import hashlib
4import os
5import socket
6import struct
7import sys
8import unittest
9from fcntl import ioctl
10
11
12TPM2_ST_NO_SESSIONS = 0x8001
13TPM2_ST_SESSIONS = 0x8002
14
15TPM2_CC_FIRST = 0x01FF
16
17TPM2_CC_CREATE_PRIMARY = 0x0131
18TPM2_CC_DICTIONARY_ATTACK_LOCK_RESET = 0x0139
19TPM2_CC_CREATE = 0x0153
20TPM2_CC_LOAD = 0x0157
21TPM2_CC_UNSEAL = 0x015E
22TPM2_CC_FLUSH_CONTEXT = 0x0165
23TPM2_CC_START_AUTH_SESSION = 0x0176
24TPM2_CC_GET_CAPABILITY = 0x017A
25TPM2_CC_PCR_READ = 0x017E
26TPM2_CC_POLICY_PCR = 0x017F
27TPM2_CC_PCR_EXTEND = 0x0182
28TPM2_CC_POLICY_PASSWORD = 0x018C
29TPM2_CC_POLICY_GET_DIGEST = 0x0189
30
31TPM2_SE_POLICY = 0x01
32TPM2_SE_TRIAL = 0x03
33
34TPM2_ALG_RSA = 0x0001
35TPM2_ALG_SHA1 = 0x0004
36TPM2_ALG_AES = 0x0006
37TPM2_ALG_KEYEDHASH = 0x0008
38TPM2_ALG_SHA256 = 0x000B
39TPM2_ALG_NULL = 0x0010
40TPM2_ALG_CBC = 0x0042
41TPM2_ALG_CFB = 0x0043
42
43TPM2_RH_OWNER = 0x40000001
44TPM2_RH_NULL = 0x40000007
45TPM2_RH_LOCKOUT = 0x4000000A
46TPM2_RS_PW = 0x40000009
47
48TPM2_RC_SIZE = 0x01D5
49TPM2_RC_AUTH_FAIL = 0x098E
50TPM2_RC_POLICY_FAIL = 0x099D
51TPM2_RC_COMMAND_CODE = 0x0143
52
53TSS2_RC_LAYER_SHIFT = 16
54TSS2_RESMGR_TPM_RC_LAYER = (11 << TSS2_RC_LAYER_SHIFT)
55
56TPM2_CAP_HANDLES = 0x00000001
57TPM2_CAP_COMMANDS = 0x00000002
58TPM2_CAP_TPM_PROPERTIES = 0x00000006
59
60TPM2_PT_FIXED = 0x100
61TPM2_PT_TOTAL_COMMANDS = TPM2_PT_FIXED + 41
62
63HR_SHIFT = 24
64HR_LOADED_SESSION = 0x02000000
65HR_TRANSIENT = 0x80000000
66
67SHA1_DIGEST_SIZE = 20
68SHA256_DIGEST_SIZE = 32
69
70TPM2_VER0_ERRORS = {
71 0x000: "TPM_RC_SUCCESS",
72 0x030: "TPM_RC_BAD_TAG",
73}
74
75TPM2_VER1_ERRORS = {
76 0x000: "TPM_RC_FAILURE",
77 0x001: "TPM_RC_FAILURE",
78 0x003: "TPM_RC_SEQUENCE",
79 0x00B: "TPM_RC_PRIVATE",
80 0x019: "TPM_RC_HMAC",
81 0x020: "TPM_RC_DISABLED",
82 0x021: "TPM_RC_EXCLUSIVE",
83 0x024: "TPM_RC_AUTH_TYPE",
84 0x025: "TPM_RC_AUTH_MISSING",
85 0x026: "TPM_RC_POLICY",
86 0x027: "TPM_RC_PCR",
87 0x028: "TPM_RC_PCR_CHANGED",
88 0x02D: "TPM_RC_UPGRADE",
89 0x02E: "TPM_RC_TOO_MANY_CONTEXTS",
90 0x02F: "TPM_RC_AUTH_UNAVAILABLE",
91 0x030: "TPM_RC_REBOOT",
92 0x031: "TPM_RC_UNBALANCED",
93 0x042: "TPM_RC_COMMAND_SIZE",
94 0x043: "TPM_RC_COMMAND_CODE",
95 0x044: "TPM_RC_AUTHSIZE",
96 0x045: "TPM_RC_AUTH_CONTEXT",
97 0x046: "TPM_RC_NV_RANGE",
98 0x047: "TPM_RC_NV_SIZE",
99 0x048: "TPM_RC_NV_LOCKED",
100 0x049: "TPM_RC_NV_AUTHORIZATION",
101 0x04A: "TPM_RC_NV_UNINITIALIZED",
102 0x04B: "TPM_RC_NV_SPACE",
103 0x04C: "TPM_RC_NV_DEFINED",
104 0x050: "TPM_RC_BAD_CONTEXT",
105 0x051: "TPM_RC_CPHASH",
106 0x052: "TPM_RC_PARENT",
107 0x053: "TPM_RC_NEEDS_TEST",
108 0x054: "TPM_RC_NO_RESULT",
109 0x055: "TPM_RC_SENSITIVE",
110 0x07F: "RC_MAX_FM0",
111}
112
113TPM2_FMT1_ERRORS = {
114 0x001: "TPM_RC_ASYMMETRIC",
115 0x002: "TPM_RC_ATTRIBUTES",
116 0x003: "TPM_RC_HASH",
117 0x004: "TPM_RC_VALUE",
118 0x005: "TPM_RC_HIERARCHY",
119 0x007: "TPM_RC_KEY_SIZE",
120 0x008: "TPM_RC_MGF",
121 0x009: "TPM_RC_MODE",
122 0x00A: "TPM_RC_TYPE",
123 0x00B: "TPM_RC_HANDLE",
124 0x00C: "TPM_RC_KDF",
125 0x00D: "TPM_RC_RANGE",
126 0x00E: "TPM_RC_AUTH_FAIL",
127 0x00F: "TPM_RC_NONCE",
128 0x010: "TPM_RC_PP",
129 0x012: "TPM_RC_SCHEME",
130 0x015: "TPM_RC_SIZE",
131 0x016: "TPM_RC_SYMMETRIC",
132 0x017: "TPM_RC_TAG",
133 0x018: "TPM_RC_SELECTOR",
134 0x01A: "TPM_RC_INSUFFICIENT",
135 0x01B: "TPM_RC_SIGNATURE",
136 0x01C: "TPM_RC_KEY",
137 0x01D: "TPM_RC_POLICY_FAIL",
138 0x01F: "TPM_RC_INTEGRITY",
139 0x020: "TPM_RC_TICKET",
140 0x021: "TPM_RC_RESERVED_BITS",
141 0x022: "TPM_RC_BAD_AUTH",
142 0x023: "TPM_RC_EXPIRED",
143 0x024: "TPM_RC_POLICY_CC",
144 0x025: "TPM_RC_BINDING",
145 0x026: "TPM_RC_CURVE",
146 0x027: "TPM_RC_ECC_POINT",
147}
148
149TPM2_WARN_ERRORS = {
150 0x001: "TPM_RC_CONTEXT_GAP",
151 0x002: "TPM_RC_OBJECT_MEMORY",
152 0x003: "TPM_RC_SESSION_MEMORY",
153 0x004: "TPM_RC_MEMORY",
154 0x005: "TPM_RC_SESSION_HANDLES",
155 0x006: "TPM_RC_OBJECT_HANDLES",
156 0x007: "TPM_RC_LOCALITY",
157 0x008: "TPM_RC_YIELDED",
158 0x009: "TPM_RC_CANCELED",
159 0x00A: "TPM_RC_TESTING",
160 0x010: "TPM_RC_REFERENCE_H0",
161 0x011: "TPM_RC_REFERENCE_H1",
162 0x012: "TPM_RC_REFERENCE_H2",
163 0x013: "TPM_RC_REFERENCE_H3",
164 0x014: "TPM_RC_REFERENCE_H4",
165 0x015: "TPM_RC_REFERENCE_H5",
166 0x016: "TPM_RC_REFERENCE_H6",
167 0x018: "TPM_RC_REFERENCE_S0",
168 0x019: "TPM_RC_REFERENCE_S1",
169 0x01A: "TPM_RC_REFERENCE_S2",
170 0x01B: "TPM_RC_REFERENCE_S3",
171 0x01C: "TPM_RC_REFERENCE_S4",
172 0x01D: "TPM_RC_REFERENCE_S5",
173 0x01E: "TPM_RC_REFERENCE_S6",
174 0x020: "TPM_RC_NV_RATE",
175 0x021: "TPM_RC_LOCKOUT",
176 0x022: "TPM_RC_RETRY",
177 0x023: "TPM_RC_NV_UNAVAILABLE",
178 0x7F: "TPM_RC_NOT_USED",
179}
180
181RC_VER1 = 0x100
182RC_FMT1 = 0x080
183RC_WARN = 0x900
184
185ALG_DIGEST_SIZE_MAP = {
186 TPM2_ALG_SHA1: SHA1_DIGEST_SIZE,
187 TPM2_ALG_SHA256: SHA256_DIGEST_SIZE,
188}
189
190ALG_HASH_FUNCTION_MAP = {
191 TPM2_ALG_SHA1: hashlib.sha1,
192 TPM2_ALG_SHA256: hashlib.sha256
193}
194
195NAME_ALG_MAP = {
196 "sha1": TPM2_ALG_SHA1,
197 "sha256": TPM2_ALG_SHA256,
198}
199
200
201class UnknownAlgorithmIdError(Exception):
202 def __init__(self, alg):
203 self.alg = alg
204
205 def __str__(self):
206 return '0x%0x' % (alg)
207
208
209class UnknownAlgorithmNameError(Exception):
210 def __init__(self, name):
211 self.name = name
212
213 def __str__(self):
214 return name
215
216
217class UnknownPCRBankError(Exception):
218 def __init__(self, alg):
219 self.alg = alg
220
221 def __str__(self):
222 return '0x%0x' % (alg)
223
224
225class ProtocolError(Exception):
226 def __init__(self, cc, rc):
227 self.cc = cc
228 self.rc = rc
229
230 if (rc & RC_FMT1) == RC_FMT1:
231 self.name = TPM2_FMT1_ERRORS.get(rc & 0x3f, "TPM_RC_UNKNOWN")
232 elif (rc & RC_WARN) == RC_WARN:
233 self.name = TPM2_WARN_ERRORS.get(rc & 0x7f, "TPM_RC_UNKNOWN")
234 elif (rc & RC_VER1) == RC_VER1:
235 self.name = TPM2_VER1_ERRORS.get(rc & 0x7f, "TPM_RC_UNKNOWN")
236 else:
237 self.name = TPM2_VER0_ERRORS.get(rc & 0x7f, "TPM_RC_UNKNOWN")
238
239 def __str__(self):
240 if self.cc:
241 return '%s: cc=0x%08x, rc=0x%08x' % (self.name, self.cc, self.rc)
242 else:
243 return '%s: rc=0x%08x' % (self.name, self.rc)
244
245
246class AuthCommand(object):
247 """TPMS_AUTH_COMMAND"""
248
249 def __init__(self, session_handle=TPM2_RS_PW, nonce='', session_attributes=0,
250 hmac=''):
251 self.session_handle = session_handle
252 self.nonce = nonce
253 self.session_attributes = session_attributes
254 self.hmac = hmac
255
256 def __str__(self):
257 fmt = '>I H%us B H%us' % (len(self.nonce), len(self.hmac))
258 return struct.pack(fmt, self.session_handle, len(self.nonce),
259 self.nonce, self.session_attributes, len(self.hmac),
260 self.hmac)
261
262 def __len__(self):
263 fmt = '>I H%us B H%us' % (len(self.nonce), len(self.hmac))
264 return struct.calcsize(fmt)
265
266
267class SensitiveCreate(object):
268 """TPMS_SENSITIVE_CREATE"""
269
270 def __init__(self, user_auth='', data=''):
271 self.user_auth = user_auth
272 self.data = data
273
274 def __str__(self):
275 fmt = '>H%us H%us' % (len(self.user_auth), len(self.data))
276 return struct.pack(fmt, len(self.user_auth), self.user_auth,
277 len(self.data), self.data)
278
279 def __len__(self):
280 fmt = '>H%us H%us' % (len(self.user_auth), len(self.data))
281 return struct.calcsize(fmt)
282
283
284class Public(object):
285 """TPMT_PUBLIC"""
286
287 FIXED_TPM = (1 << 1)
288 FIXED_PARENT = (1 << 4)
289 SENSITIVE_DATA_ORIGIN = (1 << 5)
290 USER_WITH_AUTH = (1 << 6)
291 RESTRICTED = (1 << 16)
292 DECRYPT = (1 << 17)
293
294 def __fmt(self):
295 return '>HHIH%us%usH%us' % \
296 (len(self.auth_policy), len(self.parameters), len(self.unique))
297
298 def __init__(self, object_type, name_alg, object_attributes, auth_policy='',
299 parameters='', unique=''):
300 self.object_type = object_type
301 self.name_alg = name_alg
302 self.object_attributes = object_attributes
303 self.auth_policy = auth_policy
304 self.parameters = parameters
305 self.unique = unique
306
307 def __str__(self):
308 return struct.pack(self.__fmt(),
309 self.object_type,
310 self.name_alg,
311 self.object_attributes,
312 len(self.auth_policy),
313 self.auth_policy,
314 self.parameters,
315 len(self.unique),
316 self.unique)
317
318 def __len__(self):
319 return struct.calcsize(self.__fmt())
320
321
322def get_digest_size(alg):
323 ds = ALG_DIGEST_SIZE_MAP.get(alg)
324 if not ds:
325 raise UnknownAlgorithmIdError(alg)
326 return ds
327
328
329def get_hash_function(alg):
330 f = ALG_HASH_FUNCTION_MAP.get(alg)
331 if not f:
332 raise UnknownAlgorithmIdError(alg)
333 return f
334
335
336def get_algorithm(name):
337 alg = NAME_ALG_MAP.get(name)
338 if not alg:
339 raise UnknownAlgorithmNameError(name)
340 return alg
341
342
343def hex_dump(d):
344 d = [format(ord(x), '02x') for x in d]
345 d = [d[i: i + 16] for i in xrange(0, len(d), 16)]
346 d = [' '.join(x) for x in d]
347 d = os.linesep.join(d)
348
349 return d
350
351class Client:
352 FLAG_DEBUG = 0x01
353 FLAG_SPACE = 0x02
354 TPM_IOC_NEW_SPACE = 0xa200
355
356 def __init__(self, flags = 0):
357 self.flags = flags
358
359 if (self.flags & Client.FLAG_SPACE) == 0:
360 self.tpm = open('/dev/tpm0', 'r+b')
361 else:
362 self.tpm = open('/dev/tpmrm0', 'r+b')
363
364 def close(self):
365 self.tpm.close()
366
367 def send_cmd(self, cmd):
368 self.tpm.write(cmd)
369 rsp = self.tpm.read()
370
371 if (self.flags & Client.FLAG_DEBUG) != 0:
372 sys.stderr.write('cmd' + os.linesep)
373 sys.stderr.write(hex_dump(cmd) + os.linesep)
374 sys.stderr.write('rsp' + os.linesep)
375 sys.stderr.write(hex_dump(rsp) + os.linesep)
376
377 rc = struct.unpack('>I', rsp[6:10])[0]
378 if rc != 0:
379 cc = struct.unpack('>I', cmd[6:10])[0]
380 raise ProtocolError(cc, rc)
381
382 return rsp
383
384 def read_pcr(self, i, bank_alg = TPM2_ALG_SHA1):
385 pcrsel_len = max((i >> 3) + 1, 3)
386 pcrsel = [0] * pcrsel_len
387 pcrsel[i >> 3] = 1 << (i & 7)
388 pcrsel = ''.join(map(chr, pcrsel))
389
390 fmt = '>HII IHB%us' % (pcrsel_len)
391 cmd = struct.pack(fmt,
392 TPM2_ST_NO_SESSIONS,
393 struct.calcsize(fmt),
394 TPM2_CC_PCR_READ,
395 1,
396 bank_alg,
397 pcrsel_len, pcrsel)
398
399 rsp = self.send_cmd(cmd)
400
401 pcr_update_cnt, pcr_select_cnt = struct.unpack('>II', rsp[10:18])
402 assert pcr_select_cnt == 1
403 rsp = rsp[18:]
404
405 alg2, pcrsel_len2 = struct.unpack('>HB', rsp[:3])
406 assert bank_alg == alg2 and pcrsel_len == pcrsel_len2
407 rsp = rsp[3 + pcrsel_len:]
408
409 digest_cnt = struct.unpack('>I', rsp[:4])[0]
410 if digest_cnt == 0:
411 return None
412 rsp = rsp[6:]
413
414 return rsp
415
416 def extend_pcr(self, i, dig, bank_alg = TPM2_ALG_SHA1):
417 ds = get_digest_size(bank_alg)
418 assert(ds == len(dig))
419
420 auth_cmd = AuthCommand()
421
422 fmt = '>HII I I%us IH%us' % (len(auth_cmd), ds)
423 cmd = struct.pack(
424 fmt,
425 TPM2_ST_SESSIONS,
426 struct.calcsize(fmt),
427 TPM2_CC_PCR_EXTEND,
428 i,
429 len(auth_cmd),
430 str(auth_cmd),
431 1, bank_alg, dig)
432
433 self.send_cmd(cmd)
434
435 def start_auth_session(self, session_type, name_alg = TPM2_ALG_SHA1):
436 fmt = '>HII IIH16sHBHH'
437 cmd = struct.pack(fmt,
438 TPM2_ST_NO_SESSIONS,
439 struct.calcsize(fmt),
440 TPM2_CC_START_AUTH_SESSION,
441 TPM2_RH_NULL,
442 TPM2_RH_NULL,
443 16,
444 '\0' * 16,
445 0,
446 session_type,
447 TPM2_ALG_NULL,
448 name_alg)
449
450 return struct.unpack('>I', self.send_cmd(cmd)[10:14])[0]
451
452 def __calc_pcr_digest(self, pcrs, bank_alg = TPM2_ALG_SHA1,
453 digest_alg = TPM2_ALG_SHA1):
454 x = []
455 f = get_hash_function(digest_alg)
456
457 for i in pcrs:
458 pcr = self.read_pcr(i, bank_alg)
459 if pcr == None:
460 return None
461 x += pcr
462
463 return f(bytearray(x)).digest()
464
465 def policy_pcr(self, handle, pcrs, bank_alg = TPM2_ALG_SHA1,
466 name_alg = TPM2_ALG_SHA1):
467 ds = get_digest_size(name_alg)
468 dig = self.__calc_pcr_digest(pcrs, bank_alg, name_alg)
469 if not dig:
470 raise UnknownPCRBankError(bank_alg)
471
472 pcrsel_len = max((max(pcrs) >> 3) + 1, 3)
473 pcrsel = [0] * pcrsel_len
474 for i in pcrs:
475 pcrsel[i >> 3] |= 1 << (i & 7)
476 pcrsel = ''.join(map(chr, pcrsel))
477
478 fmt = '>HII IH%usIHB3s' % ds
479 cmd = struct.pack(fmt,
480 TPM2_ST_NO_SESSIONS,
481 struct.calcsize(fmt),
482 TPM2_CC_POLICY_PCR,
483 handle,
484 len(dig), str(dig),
485 1,
486 bank_alg,
487 pcrsel_len, pcrsel)
488
489 self.send_cmd(cmd)
490
491 def policy_password(self, handle):
492 fmt = '>HII I'
493 cmd = struct.pack(fmt,
494 TPM2_ST_NO_SESSIONS,
495 struct.calcsize(fmt),
496 TPM2_CC_POLICY_PASSWORD,
497 handle)
498
499 self.send_cmd(cmd)
500
501 def get_policy_digest(self, handle):
502 fmt = '>HII I'
503 cmd = struct.pack(fmt,
504 TPM2_ST_NO_SESSIONS,
505 struct.calcsize(fmt),
506 TPM2_CC_POLICY_GET_DIGEST,
507 handle)
508
509 return self.send_cmd(cmd)[12:]
510
511 def flush_context(self, handle):
512 fmt = '>HIII'
513 cmd = struct.pack(fmt,
514 TPM2_ST_NO_SESSIONS,
515 struct.calcsize(fmt),
516 TPM2_CC_FLUSH_CONTEXT,
517 handle)
518
519 self.send_cmd(cmd)
520
521 def create_root_key(self, auth_value = ''):
522 attributes = \
523 Public.FIXED_TPM | \
524 Public.FIXED_PARENT | \
525 Public.SENSITIVE_DATA_ORIGIN | \
526 Public.USER_WITH_AUTH | \
527 Public.RESTRICTED | \
528 Public.DECRYPT
529
530 auth_cmd = AuthCommand()
531 sensitive = SensitiveCreate(user_auth=auth_value)
532
533 public_parms = struct.pack(
534 '>HHHHHI',
535 TPM2_ALG_AES,
536 128,
537 TPM2_ALG_CFB,
538 TPM2_ALG_NULL,
539 2048,
540 0)
541
542 public = Public(
543 object_type=TPM2_ALG_RSA,
544 name_alg=TPM2_ALG_SHA1,
545 object_attributes=attributes,
546 parameters=public_parms)
547
548 fmt = '>HIII I%us H%us H%us HI' % \
549 (len(auth_cmd), len(sensitive), len(public))
550 cmd = struct.pack(
551 fmt,
552 TPM2_ST_SESSIONS,
553 struct.calcsize(fmt),
554 TPM2_CC_CREATE_PRIMARY,
555 TPM2_RH_OWNER,
556 len(auth_cmd),
557 str(auth_cmd),
558 len(sensitive),
559 str(sensitive),
560 len(public),
561 str(public),
562 0, 0)
563
564 return struct.unpack('>I', self.send_cmd(cmd)[10:14])[0]
565
566 def seal(self, parent_key, data, auth_value, policy_dig,
567 name_alg = TPM2_ALG_SHA1):
568 ds = get_digest_size(name_alg)
569 assert(not policy_dig or ds == len(policy_dig))
570
571 attributes = 0
572 if not policy_dig:
573 attributes |= Public.USER_WITH_AUTH
574 policy_dig = ''
575
576 auth_cmd = AuthCommand()
577 sensitive = SensitiveCreate(user_auth=auth_value, data=data)
578
579 public = Public(
580 object_type=TPM2_ALG_KEYEDHASH,
581 name_alg=name_alg,
582 object_attributes=attributes,
583 auth_policy=policy_dig,
584 parameters=struct.pack('>H', TPM2_ALG_NULL))
585
586 fmt = '>HIII I%us H%us H%us HI' % \
587 (len(auth_cmd), len(sensitive), len(public))
588 cmd = struct.pack(
589 fmt,
590 TPM2_ST_SESSIONS,
591 struct.calcsize(fmt),
592 TPM2_CC_CREATE,
593 parent_key,
594 len(auth_cmd),
595 str(auth_cmd),
596 len(sensitive),
597 str(sensitive),
598 len(public),
599 str(public),
600 0, 0)
601
602 rsp = self.send_cmd(cmd)
603
604 return rsp[14:]
605
606 def unseal(self, parent_key, blob, auth_value, policy_handle):
607 private_len = struct.unpack('>H', blob[0:2])[0]
608 public_start = private_len + 2
609 public_len = struct.unpack('>H', blob[public_start:public_start + 2])[0]
610 blob = blob[:private_len + public_len + 4]
611
612 auth_cmd = AuthCommand()
613
614 fmt = '>HII I I%us %us' % (len(auth_cmd), len(blob))
615 cmd = struct.pack(
616 fmt,
617 TPM2_ST_SESSIONS,
618 struct.calcsize(fmt),
619 TPM2_CC_LOAD,
620 parent_key,
621 len(auth_cmd),
622 str(auth_cmd),
623 blob)
624
625 data_handle = struct.unpack('>I', self.send_cmd(cmd)[10:14])[0]
626
627 if policy_handle:
628 auth_cmd = AuthCommand(session_handle=policy_handle, hmac=auth_value)
629 else:
630 auth_cmd = AuthCommand(hmac=auth_value)
631
632 fmt = '>HII I I%us' % (len(auth_cmd))
633 cmd = struct.pack(
634 fmt,
635 TPM2_ST_SESSIONS,
636 struct.calcsize(fmt),
637 TPM2_CC_UNSEAL,
638 data_handle,
639 len(auth_cmd),
640 str(auth_cmd))
641
642 try:
643 rsp = self.send_cmd(cmd)
644 finally:
645 self.flush_context(data_handle)
646
647 data_len = struct.unpack('>I', rsp[10:14])[0] - 2
648
649 return rsp[16:16 + data_len]
650
651 def reset_da_lock(self):
652 auth_cmd = AuthCommand()
653
654 fmt = '>HII I I%us' % (len(auth_cmd))
655 cmd = struct.pack(
656 fmt,
657 TPM2_ST_SESSIONS,
658 struct.calcsize(fmt),
659 TPM2_CC_DICTIONARY_ATTACK_LOCK_RESET,
660 TPM2_RH_LOCKOUT,
661 len(auth_cmd),
662 str(auth_cmd))
663
664 self.send_cmd(cmd)
665
666 def __get_cap_cnt(self, cap, pt, cnt):
667 handles = []
668 fmt = '>HII III'
669
670 cmd = struct.pack(fmt,
671 TPM2_ST_NO_SESSIONS,
672 struct.calcsize(fmt),
673 TPM2_CC_GET_CAPABILITY,
674 cap, pt, cnt)
675
676 rsp = self.send_cmd(cmd)[10:]
677 more_data, cap, cnt = struct.unpack('>BII', rsp[:9])
678 rsp = rsp[9:]
679
680 for i in xrange(0, cnt):
681 handle = struct.unpack('>I', rsp[:4])[0]
682 handles.append(handle)
683 rsp = rsp[4:]
684
685 return handles, more_data
686
687 def get_cap(self, cap, pt):
688 handles = []
689
690 more_data = True
691 while more_data:
692 next_handles, more_data = self.__get_cap_cnt(cap, pt, 1)
693 handles += next_handles
694 pt += 1
695
696 return handles