pollutri
/
res_levis_API
1
0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5 Commits
1 Branch
203 MiB
 
 
 
 
Branch: master
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van 'master'
${ noResults }
res_levis_API/lib/python3.6/site-packages/passlib/tests/test_totp.py

1603 regels
64 KiB
Ruw Permalink Blame Geschiedenis 

  1. """passlib.tests -- test passlib.totp"""

  2. #=============================================================================

  3. # imports

  4. #=============================================================================

  5. # core

  6. import datetime

  7. from functools import partial

  8. import logging; log = logging.getLogger(__name__)

  9. import sys

  10. import time as _time

  11. # site

  12. # pkg

  13. from passlib import exc

  14. from passlib.utils.compat import unicode, u

  15. from passlib.tests.utils import TestCase, time_call

  16. # subject

  17. from passlib import totp as totp_module

  18. from passlib.totp import TOTP, AppWallet, AES_SUPPORT

  19. # local

  20. __all__ = [

  21.     "EngineTest",

  22. ]

  23. 

  24. #=============================================================================

  25. # helpers

  26. #=============================================================================

  27. 

  28. # XXX: python 3 changed what error base64.b16decode() throws, from TypeError to base64.Error().

  29. #      it wasn't until 3.3 that base32decode() also got changed.

  30. #      really should normalize this in the code to a single BinaryDecodeError,

  31. #      predicting this cross-version is getting unmanagable.

  32. Base32DecodeError = Base16DecodeError = TypeError

  33. if sys.version_info >= (3,0):

  34.     from binascii import Error as Base16DecodeError

  35. if sys.version_info >= (3,3):

  36.     from binascii import Error as Base32DecodeError

  37. 

  38. PASS1 = "abcdef"

  39. PASS2 = b"\x00\xFF"

  40. KEY1 = '4AOGGDBBQSYHNTUZ'

  41. KEY1_RAW = b'\xe0\x1cc\x0c!\x84\xb0v\xce\x99'

  42. KEY2_RAW = b'\xee]\xcb9\x870\x06 D\xc8y/\xa54&\xe4\x9c\x13\xc2\x18'

  43. KEY3 = 'S3JDVB7QD2R7JPXX' # used in docstrings

  44. KEY4 = 'JBSWY3DPEHPK3PXP' # from google keyuri spec

  45. KEY4_RAW = b'Hello!\xde\xad\xbe\xef'

  46. 

  47. # NOTE: for randtime() below,

  48. #       * want at least 7 bits on fractional side, to test fractional times to at least 0.01s precision

  49. #       * want at least 32 bits on integer side, to test for 32-bit epoch issues.

  50. #       most systems *should* have 53 bit mantissa, leaving plenty of room on both ends,

  51. #       so using (1<<37) as scale, to allocate 16 bits on fractional side, but generate reasonable # of > 1<<32 times.

  52. #       sanity check that we're above 44 ensures minimum requirements (44 - 37 int = 7 frac)

  53. assert sys.float_info.radix == 2, "unexpected float_info.radix"

  54. assert sys.float_info.mant_dig >= 44, "double precision unexpectedly small"

  55. 

  56. def _get_max_time_t():

  57.     """

  58.     helper to calc max_time_t constant (see below)

  59.     """

  60.     value = 1 << 30  # even for 32 bit systems will handle this

  61.     year = 0

  62.     while True:

  63.         next_value = value << 1

  64.         try:

  65.             next_year = datetime.datetime.utcfromtimestamp(next_value-1).year

  66.         except (ValueError, OSError, OverflowError):

  67.             # utcfromtimestamp() may throw any of the following:

  68.             #

  69.             # * year out of range for datetime:

  70.             #   py < 3.6 throws ValueError.

  71.             #   (py 3.6.0 returns odd value instead, see workaround below)

  72.             #

  73.             # * int out of range for host's gmtime/localtime:

  74.             #   py2 throws ValueError, py3 throws OSError.

  75.             #

  76.             # * int out of range for host's time_t:

  77.             #   py2 throws ValueError, py3 throws OverflowError.

  78.             #

  79.             break

  80. 

  81.         # Workaround for python 3.6.0 issue --

  82.         # Instead of throwing ValueError if year out of range for datetime,

  83.         # Python 3.6 will do some weird behavior that masks high bits

  84.         # e.g. (1<<40) -> year 36812, but (1<<41) -> year 6118.

  85.         # (Appears to be bug http://bugs.python.org/issue29100)

  86.         # This check stops at largest non-wrapping bit size.

  87.         if next_year < year:

  88.             break

  89. 

  90.         value = next_value

  91. 

  92.     # 'value-1' is maximum.

  93.     value -= 1

  94. 

  95.     # check for crazy case where we're beyond what datetime supports

  96.     # (caused by bug 29100 again). compare to max value that datetime

  97.     # module supports -- datetime.datetime(9999, 12, 31, 23, 59, 59, 999999)

  98.     max_datetime_timestamp = 253402318800

  99.     return min(value, max_datetime_timestamp)

  100. 

  101. #: Rough approximation of max value acceptable by hosts's time_t.

  102. #: This is frequently ~2**37 on 64 bit, and ~2**31 on 32 bit systems.

  103. max_time_t = _get_max_time_t()

  104. 

  105. def to_b32_size(raw_size):

  106.     return (raw_size * 8 + 4) // 5

  107. 

  108. #=============================================================================

  109. # wallet

  110. #=============================================================================

  111. class AppWalletTest(TestCase):

  112.     descriptionPrefix = "passlib.totp.AppWallet"

  113. 

  114.     #=============================================================================

  115.     # constructor

  116.     #=============================================================================

  117. 

  118.     def test_secrets_types(self):

  119.         """constructor -- 'secrets' param -- input types"""

  120. 

  121.         # no secrets

  122.         wallet = AppWallet()

  123.         self.assertEqual(wallet._secrets, {})

  124.         self.assertFalse(wallet.has_secrets)

  125. 

  126.         # dict

  127.         ref = {"1": b"aaa", "2": b"bbb"}

  128.         wallet = AppWallet(ref)

  129.         self.assertEqual(wallet._secrets, ref)

  130.         self.assertTrue(wallet.has_secrets)

  131. 

  132.         # # list

  133.         # wallet = AppWallet(list(ref.items()))

  134.         # self.assertEqual(wallet._secrets, ref)

  135. 

  136.         # # iter

  137.         # wallet = AppWallet(iter(ref.items()))

  138.         # self.assertEqual(wallet._secrets, ref)

  139. 

  140.         # "tag:value" string

  141.         wallet = AppWallet("\n 1: aaa\n# comment\n \n2: bbb   ")

  142.         self.assertEqual(wallet._secrets, ref)

  143. 

  144.         # ensure ":" allowed in secret

  145.         wallet = AppWallet("1: aaa: bbb \n# comment\n \n2: bbb   ")

  146.         self.assertEqual(wallet._secrets, {"1": b"aaa: bbb", "2": b"bbb"})

  147. 

  148.         # json dict

  149.         wallet = AppWallet('{"1":"aaa","2":"bbb"}')

  150.         self.assertEqual(wallet._secrets, ref)

  151. 

  152.         # # json list

  153.         # wallet = AppWallet('[["1","aaa"],["2","bbb"]]')

  154.         # self.assertEqual(wallet._secrets, ref)

  155. 

  156.         # invalid type

  157.         self.assertRaises(TypeError, AppWallet, 123)

  158. 

  159.         # invalid json obj

  160.         self.assertRaises(TypeError, AppWallet, "[123]")

  161. 

  162.         # # invalid list items

  163.         # self.assertRaises(ValueError, AppWallet, ["1", b"aaa"])

  164. 

  165.         # forbid empty secret

  166.         self.assertRaises(ValueError, AppWallet, {"1": "aaa", "2": ""})

  167. 

  168.     def test_secrets_tags(self):

  169.         """constructor -- 'secrets' param -- tag/value normalization"""

  170. 

  171.         # test reference

  172.         ref = {"1": b"aaa", "02": b"bbb", "C": b"ccc"}

  173.         wallet = AppWallet(ref)

  174.         self.assertEqual(wallet._secrets, ref)

  175. 

  176.         # accept unicode

  177.         wallet = AppWallet({u("1"): b"aaa", u("02"): b"bbb", u("C"): b"ccc"})

  178.         self.assertEqual(wallet._secrets, ref)

  179. 

  180.         # normalize int tags

  181.         wallet = AppWallet({1: b"aaa", "02": b"bbb", "C": b"ccc"})

  182.         self.assertEqual(wallet._secrets, ref)

  183. 

  184.         # forbid non-str/int tags

  185.         self.assertRaises(TypeError, AppWallet, {(1,): "aaa"})

  186. 

  187.         # accept valid tags

  188.         wallet = AppWallet({"1-2_3.4": b"aaa"})

  189. 

  190.         # forbid invalid tags

  191.         self.assertRaises(ValueError, AppWallet, {"-abc": "aaa"})

  192.         self.assertRaises(ValueError, AppWallet, {"ab*$": "aaa"})

  193. 

  194.         # coerce value to bytes

  195.         wallet = AppWallet({"1": u("aaa"), "02": "bbb", "C": b"ccc"})

  196.         self.assertEqual(wallet._secrets, ref)

  197. 

  198.         # forbid invalid value types

  199.         self.assertRaises(TypeError, AppWallet, {"1": 123})

  200.         self.assertRaises(TypeError, AppWallet, {"1": None})

  201.         self.assertRaises(TypeError, AppWallet, {"1": []})

  202. 

  203.     # TODO: test secrets_path

  204. 

  205.     def test_default_tag(self):

  206.         """constructor -- 'default_tag' param"""

  207. 

  208.         # should sort numerically

  209.         wallet = AppWallet({"1": "one", "02": "two"})

  210.         self.assertEqual(wallet.default_tag, "02")

  211.         self.assertEqual(wallet.get_secret(wallet.default_tag), b"two")

  212. 

  213.         # should sort alphabetically if non-digit present

  214.         wallet = AppWallet({"1": "one", "02": "two", "A": "aaa"})

  215.         self.assertEqual(wallet.default_tag, "A")

  216.         self.assertEqual(wallet.get_secret(wallet.default_tag), b"aaa")

  217. 

  218.         # should use honor custom tag

  219.         wallet = AppWallet({"1": "one", "02": "two", "A": "aaa"}, default_tag="1")

  220.         self.assertEqual(wallet.default_tag, "1")

  221.         self.assertEqual(wallet.get_secret(wallet.default_tag), b"one")

  222. 

  223.         # throw error on unknown value

  224.         self.assertRaises(KeyError, AppWallet, {"1": "one", "02": "two", "A": "aaa"},

  225.                           default_tag="B")

  226. 

  227.         # should be empty

  228.         wallet = AppWallet()

  229.         self.assertEqual(wallet.default_tag, None)

  230.         self.assertRaises(KeyError, wallet.get_secret, None)

  231. 

  232.     # TODO: test 'cost' param

  233. 

  234.     #=============================================================================

  235.     # encrypt_key() & decrypt_key() helpers

  236.     #=============================================================================

  237.     def require_aes_support(self, canary=None):

  238.         if AES_SUPPORT:

  239.             canary and canary()

  240.         else:

  241.             canary and self.assertRaises(RuntimeError, canary)

  242.             raise self.skipTest("'cryptography' package not installed")

  243. 

  244.     def test_decrypt_key(self):

  245.         """.decrypt_key()"""

  246. 

  247.         wallet = AppWallet({"1": PASS1, "2": PASS2})

  248. 

  249.         # check for support

  250.         CIPHER1 = dict(v=1, c=13, s='6D7N7W53O7HHS37NLUFQ',

  251.                        k='MHCTEGSNPFN5CGBJ', t='1')

  252.         self.require_aes_support(canary=partial(wallet.decrypt_key, CIPHER1))

  253. 

  254.         # reference key

  255.         self.assertEqual(wallet.decrypt_key(CIPHER1)[0], KEY1_RAW)

  256. 

  257.         # different salt used to encrypt same raw key

  258.         CIPHER2 = dict(v=1, c=13, s='SPZJ54Y6IPUD2BYA4C6A',

  259.                        k='ZGDXXTVQOWYLC2AU', t='1')

  260.         self.assertEqual(wallet.decrypt_key(CIPHER2)[0], KEY1_RAW)

  261. 

  262.         # different sized key, password, and cost

  263.         CIPHER3 = dict(v=1, c=8, s='FCCTARTIJWE7CPQHUDKA',

  264.                        k='D2DRS32YESGHHINWFFCELKN7Z6NAHM4M', t='2')

  265.         self.assertEqual(wallet.decrypt_key(CIPHER3)[0], KEY2_RAW)

  266. 

  267.         # wrong password should silently result in wrong key

  268.         temp = CIPHER1.copy()

  269.         temp.update(t='2')

  270.         self.assertEqual(wallet.decrypt_key(temp)[0], b'\xafD6.F7\xeb\x19\x05Q')

  271. 

  272.         # missing tag should throw error

  273.         temp = CIPHER1.copy()

  274.         temp.update(t='3')

  275.         self.assertRaises(KeyError, wallet.decrypt_key, temp)

  276. 

  277.         # unknown version should throw error

  278.         temp = CIPHER1.copy()

  279.         temp.update(v=999)

  280.         self.assertRaises(ValueError, wallet.decrypt_key, temp)

  281. 

  282.     def test_decrypt_key_needs_recrypt(self):

  283.         """.decrypt_key() -- needs_recrypt flag"""

  284.         self.require_aes_support()

  285. 

  286.         wallet = AppWallet({"1": PASS1, "2": PASS2}, encrypt_cost=13)

  287. 

  288.         # ref should be accepted

  289.         ref = dict(v=1, c=13, s='AAAA', k='AAAA', t='2')

  290.         self.assertFalse(wallet.decrypt_key(ref)[1])

  291. 

  292.         # wrong cost

  293.         temp = ref.copy()

  294.         temp.update(c=8)

  295.         self.assertTrue(wallet.decrypt_key(temp)[1])

  296. 

  297.         # wrong tag

  298.         temp = ref.copy()

  299.         temp.update(t="1")

  300.         self.assertTrue(wallet.decrypt_key(temp)[1])

  301. 

  302.         # XXX: should this check salt_size?

  303. 

  304.     def assertSaneResult(self, result, wallet, key, tag="1",

  305.                          needs_recrypt=False):

  306.         """check encrypt_key() result has expected format"""

  307. 

  308.         self.assertEqual(set(result), set(["v", "t", "c", "s", "k"]))

  309. 

  310.         self.assertEqual(result['v'], 1)

  311.         self.assertEqual(result['t'], tag)

  312.         self.assertEqual(result['c'], wallet.encrypt_cost)

  313. 

  314.         self.assertEqual(len(result['s']), to_b32_size(wallet.salt_size))

  315.         self.assertEqual(len(result['k']), to_b32_size(len(key)))

  316. 

  317.         result_key, result_needs_recrypt = wallet.decrypt_key(result)

  318.         self.assertEqual(result_key, key)

  319.         self.assertEqual(result_needs_recrypt, needs_recrypt)

  320. 

  321.     def test_encrypt_key(self):

  322.         """.encrypt_key()"""

  323. 

  324.         # check for support

  325.         wallet = AppWallet({"1": PASS1}, encrypt_cost=5)

  326.         self.require_aes_support(canary=partial(wallet.encrypt_key, KEY1_RAW))

  327. 

  328.         # basic behavior

  329.         result = wallet.encrypt_key(KEY1_RAW)

  330.         self.assertSaneResult(result, wallet, KEY1_RAW)

  331. 

  332.         # creates new salt each time

  333.         other = wallet.encrypt_key(KEY1_RAW)

  334.         self.assertSaneResult(result, wallet, KEY1_RAW)

  335.         self.assertNotEqual(other['s'], result['s'])

  336.         self.assertNotEqual(other['k'], result['k'])

  337. 

  338.         # honors custom cost

  339.         wallet2 = AppWallet({"1": PASS1}, encrypt_cost=6)

  340.         result = wallet2.encrypt_key(KEY1_RAW)

  341.         self.assertSaneResult(result, wallet2, KEY1_RAW)

  342. 

  343.         # honors default tag

  344.         wallet2 = AppWallet({"1": PASS1, "2": PASS2})

  345.         result = wallet2.encrypt_key(KEY1_RAW)

  346.         self.assertSaneResult(result, wallet2, KEY1_RAW, tag="2")

  347. 

  348.         # honor salt size

  349.         wallet2 = AppWallet({"1": PASS1})

  350.         wallet2.salt_size = 64

  351.         result = wallet2.encrypt_key(KEY1_RAW)

  352.         self.assertSaneResult(result, wallet2, KEY1_RAW)

  353. 

  354.         # larger key

  355.         result = wallet.encrypt_key(KEY2_RAW)

  356.         self.assertSaneResult(result, wallet, KEY2_RAW)

  357. 

  358.         # border case: empty key

  359.         # XXX: might want to allow this, but documenting behavior for now

  360.         self.assertRaises(ValueError, wallet.encrypt_key, b"")

  361. 

  362.     def test_encrypt_cost_timing(self):

  363.         """verify cost parameter via timing"""

  364.         self.require_aes_support()

  365. 

  366.         # time default cost

  367.         wallet = AppWallet({"1": "aaa"})

  368.         wallet.encrypt_cost -= 2

  369.         delta, _ = time_call(partial(wallet.encrypt_key, KEY1_RAW), maxtime=0)

  370. 

  371.         # this should take (2**3=8) times as long

  372.         wallet.encrypt_cost += 3

  373.         delta2, _ = time_call(partial(wallet.encrypt_key, KEY1_RAW), maxtime=0)

  374. 

  375.         self.assertAlmostEqual(delta2, delta*8, delta=(delta*8)*0.5)

  376. 

  377.     #=============================================================================

  378.     # eoc

  379.     #=============================================================================

  380. 

  381. #=============================================================================

  382. # common OTP code

  383. #=============================================================================

  384. 

  385. #: used as base value for RFC test vector keys

  386. RFC_KEY_BYTES_20 = "12345678901234567890".encode("ascii")

  387. RFC_KEY_BYTES_32 = (RFC_KEY_BYTES_20*2)[:32]

  388. RFC_KEY_BYTES_64 = (RFC_KEY_BYTES_20*4)[:64]

  389. 

  390. # TODO: this class is separate from TotpTest due to historical issue,

  391. #       when there was a base class, and a separate HOTP class.

  392. #       these test case classes should probably be combined.

  393. class TotpTest(TestCase):

  394.     """

  395.     common code shared by TotpTest & HotpTest

  396.     """

  397.     #=============================================================================

  398.     # class attrs

  399.     #=============================================================================

  400. 

  401.     descriptionPrefix = "passlib.totp.TOTP"

  402. 

  403.     #=============================================================================

  404.     # setup

  405.     #=============================================================================

  406.     def setUp(self):

  407.         super(TotpTest, self).setUp()

  408. 

  409.         # clear norm_hash_name() cache so 'unknown hash' warnings get emitted each time

  410.         from passlib.crypto.digest import lookup_hash

  411.         lookup_hash.clear_cache()

  412. 

  413.         # monkeypatch module's rng to be deterministic

  414.         self.patchAttr(totp_module, "rng", self.getRandom())

  415. 

  416.     #=============================================================================

  417.     # general helpers

  418.     #=============================================================================

  419.     def randtime(self):

  420.         """

  421.         helper to generate random epoch time

  422.         :returns float: epoch time

  423.         """

  424.         return self.getRandom().random() * max_time_t

  425. 

  426.     def randotp(self, cls=None, **kwds):

  427.         """

  428.         helper which generates a random TOTP instance.

  429.         """

  430.         rng = self.getRandom()

  431.         if "key" not in kwds:

  432.             kwds['new'] = True

  433.         kwds.setdefault("digits", rng.randint(6, 10))

  434.         kwds.setdefault("alg", rng.choice(["sha1", "sha256", "sha512"]))

  435.         kwds.setdefault("period", rng.randint(10, 120))

  436.         return (cls or TOTP)(**kwds)

  437. 

  438.     def test_randotp(self):

  439.         """

  440.         internal test -- randotp()

  441.         """

  442.         otp1 = self.randotp()

  443.         otp2 = self.randotp()

  444. 

  445.         self.assertNotEqual(otp1.key, otp2.key, "key not randomized:")

  446. 

  447.         # NOTE: has (1/5)**10 odds of failure

  448.         for _ in range(10):

  449.             if otp1.digits != otp2.digits:

  450.                 break

  451.             otp2 = self.randotp()

  452.         else:

  453.             self.fail("digits not randomized")

  454. 

  455.         # NOTE: has (1/3)**10 odds of failure

  456.         for _ in range(10):

  457.             if otp1.alg != otp2.alg:

  458.                 break

  459.             otp2 = self.randotp()

  460.         else:

  461.             self.fail("alg not randomized")

  462. 

  463.     #=============================================================================

  464.     # reference vector helpers

  465.     #=============================================================================

  466. 

  467.     #: default options used by test vectors (unless otherwise stated)

  468.     vector_defaults = dict(format="base32", alg="sha1", period=30, digits=8)

  469. 

  470.     #: various TOTP test vectors,

  471.     #: each element in list has format [options, (time, token <, int(expires)>), ...]

  472.     vectors = [

  473. 

  474.         #-------------------------------------------------------------------------

  475.         # passlib test vectors

  476.         #-------------------------------------------------------------------------

  477. 

  478.         # 10 byte key, 6 digits

  479.         [dict(key="ACDEFGHJKL234567", digits=6),

  480.             # test fencepost to make sure we're rounding right

  481.             (1412873399, '221105'), # == 29 mod 30

  482.             (1412873400, '178491'), # == 0 mod 30

  483.             (1412873401, '178491'), # == 1 mod 30

  484.             (1412873429, '178491'), # == 29 mod 30

  485.             (1412873430, '915114'), # == 0 mod 30

  486.         ],

  487. 

  488.         # 10 byte key, 8 digits

  489.         [dict(key="ACDEFGHJKL234567", digits=8),

  490.             # should be same as 6 digits (above), but w/ 2 more digits on left side of token.

  491.             (1412873399, '20221105'), # == 29 mod 30

  492.             (1412873400, '86178491'), # == 0 mod 30

  493.             (1412873401, '86178491'), # == 1 mod 30

  494.             (1412873429, '86178491'), # == 29 mod 30

  495.             (1412873430, '03915114'), # == 0 mod 30

  496.         ],

  497. 

  498.         # sanity check on key used in docstrings

  499.         [dict(key="S3JD-VB7Q-D2R7-JPXX", digits=6),

  500.             (1419622709, '000492'),

  501.             (1419622739, '897212'),

  502.         ],

  503. 

  504.         #-------------------------------------------------------------------------

  505.         # reference vectors taken from http://tools.ietf.org/html/rfc6238, appendix B

  506.         # NOTE: while appendix B states same key used for all tests, the reference

  507.         #       code in the appendix repeats the key up to the alg's block size,

  508.         #       and uses *that* as the secret... so that's what we're doing here.

  509.         #-------------------------------------------------------------------------

  510. 

  511.         # sha1 test vectors

  512.         [dict(key=RFC_KEY_BYTES_20, format="raw", alg="sha1"),

  513.             (59, '94287082'),

  514.             (1111111109, '07081804'),

  515.             (1111111111, '14050471'),

  516.             (1234567890, '89005924'),

  517.             (2000000000, '69279037'),

  518.             (20000000000, '65353130'),

  519.         ],

  520. 

  521.         # sha256 test vectors

  522.         [dict(key=RFC_KEY_BYTES_32, format="raw", alg="sha256"),

  523.             (59, '46119246'),

  524.             (1111111109, '68084774'),

  525.             (1111111111, '67062674'),

  526.             (1234567890, '91819424'),

  527.             (2000000000, '90698825'),

  528.             (20000000000, '77737706'),

  529.         ],

  530. 

  531.         # sha512 test vectors

  532.         [dict(key=RFC_KEY_BYTES_64, format="raw", alg="sha512"),

  533.             (59, '90693936'),

  534.             (1111111109, '25091201'),

  535.             (1111111111, '99943326'),

  536.             (1234567890, '93441116'),

  537.             (2000000000, '38618901'),

  538.             (20000000000, '47863826'),

  539.         ],

  540. 

  541.         #-------------------------------------------------------------------------

  542.         # other test vectors

  543.         #-------------------------------------------------------------------------

  544. 

  545.         # generated at http://blog.tinisles.com/2011/10/google-authenticator-one-time-password-algorithm-in-javascript

  546.         [dict(key="JBSWY3DPEHPK3PXP", digits=6), (1409192430, '727248'), (1419890990, '122419')],

  547.         [dict(key="JBSWY3DPEHPK3PXP", digits=9, period=41), (1419891152, '662331049')],

  548. 

  549.         # found in https://github.com/eloquent/otis/blob/develop/test/suite/Totp/Value/TotpValueGeneratorTest.php, line 45

  550.         [dict(key=RFC_KEY_BYTES_20, format="raw", period=60), (1111111111, '19360094')],

  551.         [dict(key=RFC_KEY_BYTES_32, format="raw", alg="sha256", period=60), (1111111111, '40857319')],

  552.         [dict(key=RFC_KEY_BYTES_64, format="raw", alg="sha512", period=60), (1111111111, '37023009')],

  553. 

  554.     ]

  555. 

  556.     def iter_test_vectors(self):

  557.         """

  558.         helper to iterate over test vectors.

  559.         yields ``(totp, time, token, expires, prefix)`` tuples.

  560.         """

  561.         from passlib.totp import TOTP

  562.         for row in self.vectors:

  563.             kwds = self.vector_defaults.copy()

  564.             kwds.update(row[0])

  565.             for entry in row[1:]:

  566.                 if len(entry) == 3:

  567.                     time, token, expires = entry

  568.                 else:

  569.                     time, token = entry

  570.                     expires = None

  571.                 # NOTE: not re-using otp between calls so that stateful methods

  572.                 #       (like .match) don't have problems.

  573.                 log.debug("test vector: %r time=%r token=%r expires=%r", kwds, time, token, expires)

  574.                 otp = TOTP(**kwds)

  575.                 prefix = "alg=%r time=%r token=%r: " % (otp.alg, time, token)

  576.                 yield otp, time, token, expires, prefix

  577. 

  578.     #=============================================================================

  579.     # constructor tests

  580.     #=============================================================================

  581.     def test_ctor_w_new(self):

  582.         """constructor -- 'new'  parameter"""

  583. 

  584.         # exactly one of 'key' or 'new' is required

  585.         self.assertRaises(TypeError, TOTP)

  586.         self.assertRaises(TypeError, TOTP, key='4aoggdbbqsyhntuz', new=True)

  587. 

  588.         # generates new key

  589.         otp = TOTP(new=True)

  590.         otp2 = TOTP(new=True)

  591.         self.assertNotEqual(otp.key, otp2.key)

  592. 

  593.     def test_ctor_w_size(self):

  594.         """constructor -- 'size'  parameter"""

  595. 

  596.         # should default to digest size, per RFC

  597.         self.assertEqual(len(TOTP(new=True, alg="sha1").key), 20)

  598.         self.assertEqual(len(TOTP(new=True, alg="sha256").key), 32)

  599.         self.assertEqual(len(TOTP(new=True, alg="sha512").key), 64)

  600. 

  601.         # explicit key size

  602.         self.assertEqual(len(TOTP(new=True, size=10).key), 10)

  603.         self.assertEqual(len(TOTP(new=True, size=16).key), 16)

  604. 

  605.         # for new=True, maximum size enforced (based on alg)

  606.         self.assertRaises(ValueError, TOTP, new=True, size=21, alg="sha1")

  607. 

  608.         # for new=True, minimum size enforced

  609.         self.assertRaises(ValueError, TOTP, new=True, size=9)

  610. 

  611.         # for existing key, minimum size is only warned about

  612.         with self.assertWarningList([

  613.                 dict(category=exc.PasslibSecurityWarning, message_re=".*for security purposes, secret key must be.*")

  614.                 ]):

  615.             _ = TOTP('0A'*9, 'hex')

  616. 

  617.     def test_ctor_w_key_and_format(self):

  618.         """constructor -- 'key' and 'format' parameters"""

  619. 

  620.         # handle base32 encoding (the default)

  621.         self.assertEqual(TOTP(KEY1).key, KEY1_RAW)

  622. 

  623.             # .. w/ lower case

  624.         self.assertEqual(TOTP(KEY1.lower()).key, KEY1_RAW)

  625. 

  626.             # .. w/ spaces (e.g. user-entered data)

  627.         self.assertEqual(TOTP(' 4aog gdbb qsyh ntuz ').key, KEY1_RAW)

  628. 

  629.             # .. w/ invalid char

  630.         self.assertRaises(Base32DecodeError, TOTP, 'ao!ggdbbqsyhntuz')

  631. 

  632.         # handle hex encoding

  633.         self.assertEqual(TOTP('e01c630c2184b076ce99', 'hex').key, KEY1_RAW)

  634. 

  635.             # .. w/ invalid char

  636.         self.assertRaises(Base16DecodeError, TOTP, 'X01c630c2184b076ce99', 'hex')

  637. 

  638.         # handle raw bytes

  639.         self.assertEqual(TOTP(KEY1_RAW, "raw").key, KEY1_RAW)

  640. 

  641.     def test_ctor_w_alg(self):

  642.         """constructor -- 'alg' parameter"""

  643. 

  644.         # normalize hash names

  645.         self.assertEqual(TOTP(KEY1, alg="SHA-256").alg, "sha256")

  646.         self.assertEqual(TOTP(KEY1, alg="SHA256").alg, "sha256")

  647. 

  648.         # invalid alg

  649.         self.assertRaises(ValueError, TOTP, KEY1, alg="SHA-333")

  650. 

  651.     def test_ctor_w_digits(self):

  652.         """constructor -- 'digits' parameter"""

  653.         self.assertRaises(ValueError, TOTP, KEY1, digits=5)

  654.         self.assertEqual(TOTP(KEY1, digits=6).digits, 6)  # min value

  655.         self.assertEqual(TOTP(KEY1, digits=10).digits, 10)  # max value

  656.         self.assertRaises(ValueError, TOTP, KEY1, digits=11)

  657. 

  658.     def test_ctor_w_period(self):

  659.         """constructor -- 'period' parameter"""

  660. 

  661.         # default

  662.         self.assertEqual(TOTP(KEY1).period, 30)

  663. 

  664.         # explicit value

  665.         self.assertEqual(TOTP(KEY1, period=63).period, 63)

  666. 

  667.         # reject wrong type

  668.         self.assertRaises(TypeError, TOTP, KEY1, period=1.5)

  669.         self.assertRaises(TypeError, TOTP, KEY1, period='abc')

  670. 

  671.         # reject non-positive values

  672.         self.assertRaises(ValueError, TOTP, KEY1, period=0)

  673.         self.assertRaises(ValueError, TOTP, KEY1, period=-1)

  674. 

  675.     def test_ctor_w_label(self):

  676.         """constructor -- 'label' parameter"""

  677.         self.assertEqual(TOTP(KEY1).label, None)

  678.         self.assertEqual(TOTP(KEY1, label="foo@bar").label, "foo@bar")

  679.         self.assertRaises(ValueError, TOTP, KEY1, label="foo:bar")

  680. 

  681.     def test_ctor_w_issuer(self):

  682.         """constructor -- 'issuer' parameter"""

  683.         self.assertEqual(TOTP(KEY1).issuer, None)

  684.         self.assertEqual(TOTP(KEY1, issuer="foo.com").issuer, "foo.com")

  685.         self.assertRaises(ValueError, TOTP, KEY1, issuer="foo.com:bar")

  686. 

  687.     #=============================================================================

  688.     # using() tests

  689.     #=============================================================================

  690. 

  691.     # TODO: test using() w/ 'digits', 'alg', 'issue', 'wallet', **wallet_kwds

  692. 

  693.     def test_using_w_period(self):

  694.         """using() -- 'period' parameter"""

  695. 

  696.         # default

  697.         self.assertEqual(TOTP(KEY1).period, 30)

  698. 

  699.         # explicit value

  700.         self.assertEqual(TOTP.using(period=63)(KEY1).period, 63)

  701. 

  702.         # reject wrong type

  703.         self.assertRaises(TypeError, TOTP.using, period=1.5)

  704.         self.assertRaises(TypeError, TOTP.using, period='abc')

  705. 

  706.         # reject non-positive values

  707.         self.assertRaises(ValueError, TOTP.using, period=0)

  708.         self.assertRaises(ValueError, TOTP.using, period=-1)

  709. 

  710.     def test_using_w_now(self):

  711.         """using -- 'now' parameter"""

  712. 

  713.         # NOTE: reading time w/ normalize_time() to make sure custom .now actually has effect.

  714. 

  715.         # default -- time.time

  716.         otp = self.randotp()

  717.         self.assertIs(otp.now, _time.time)

  718.         self.assertAlmostEqual(otp.normalize_time(None), int(_time.time()))

  719. 

  720.         # custom function

  721.         counter = [123.12]

  722.         def now():

  723.             counter[0] += 1

  724.             return counter[0]

  725.         otp = self.randotp(cls=TOTP.using(now=now))

  726.         # NOTE: TOTP() constructor invokes this as part of test, using up counter values 124 & 125

  727.         self.assertEqual(otp.normalize_time(None), 126)

  728.         self.assertEqual(otp.normalize_time(None), 127)

  729. 

  730.         # require callable

  731.         self.assertRaises(TypeError, TOTP.using, now=123)

  732. 

  733.         # require returns int/float

  734.         msg_re = r"now\(\) function must return non-negative"

  735.         self.assertRaisesRegex(AssertionError, msg_re, TOTP.using, now=lambda: 'abc')

  736. 

  737.         # require returns non-negative value

  738.         self.assertRaisesRegex(AssertionError, msg_re, TOTP.using, now=lambda: -1)

  739. 

  740.     #=============================================================================

  741.     # internal method tests

  742.     #=============================================================================

  743. 

  744.     def test_normalize_token_instance(self, otp=None):

  745.         """normalize_token() -- instance method"""

  746.         if otp is None:

  747.             otp = self.randotp(digits=7)

  748. 

  749.         # unicode & bytes

  750.         self.assertEqual(otp.normalize_token(u('1234567')), '1234567')

  751.         self.assertEqual(otp.normalize_token(b'1234567'), '1234567')

  752. 

  753.         # int

  754.         self.assertEqual(otp.normalize_token(1234567), '1234567')

  755. 

  756.         # int which needs 0 padding

  757.         self.assertEqual(otp.normalize_token(234567), '0234567')

  758. 

  759.         # reject wrong types (float, None)

  760.         self.assertRaises(TypeError, otp.normalize_token, 1234567.0)

  761.         self.assertRaises(TypeError, otp.normalize_token, None)

  762. 

  763.         # too few digits

  764.         self.assertRaises(exc.MalformedTokenError, otp.normalize_token, '123456')

  765. 

  766.         # too many digits

  767.         self.assertRaises(exc.MalformedTokenError, otp.normalize_token, '01234567')

  768.         self.assertRaises(exc.MalformedTokenError, otp.normalize_token, 12345678)

  769. 

  770.     def test_normalize_token_class(self):

  771.         """normalize_token() -- class method"""

  772.         self.test_normalize_token_instance(otp=TOTP.using(digits=7))

  773. 

  774.     def test_normalize_time(self):

  775.         """normalize_time()"""

  776.         TotpFactory = TOTP.using()

  777.         otp = self.randotp(TotpFactory)

  778. 

  779.         for _ in range(10):

  780.             time = self.randtime()

  781.             tint = int(time)

  782. 

  783.             self.assertEqual(otp.normalize_time(time), tint)

  784.             self.assertEqual(otp.normalize_time(tint + 0.5), tint)

  785. 

  786.             self.assertEqual(otp.normalize_time(tint), tint)

  787. 

  788.             dt = datetime.datetime.utcfromtimestamp(time)

  789.             self.assertEqual(otp.normalize_time(dt), tint)

  790. 

  791.             orig = TotpFactory.now

  792.             try:

  793.                 TotpFactory.now = staticmethod(lambda: time)

  794.                 self.assertEqual(otp.normalize_time(None), tint)

  795.             finally:

  796.                 TotpFactory.now = orig

  797. 

  798.         self.assertRaises(TypeError, otp.normalize_time, '1234')

  799. 

  800.     #=============================================================================

  801.     # key attr tests

  802.     #=============================================================================

  803. 

  804.     def test_key_attrs(self):

  805.         """pretty_key() and .key attributes"""

  806.         rng = self.getRandom()

  807. 

  808.         # test key attrs

  809.         otp = TOTP(KEY1_RAW, "raw")

  810.         self.assertEqual(otp.key, KEY1_RAW)

  811.         self.assertEqual(otp.hex_key, 'e01c630c2184b076ce99')

  812.         self.assertEqual(otp.base32_key, KEY1)

  813. 

  814.         # test pretty_key()

  815.         self.assertEqual(otp.pretty_key(), '4AOG-GDBB-QSYH-NTUZ')

  816.         self.assertEqual(otp.pretty_key(sep=" "), '4AOG GDBB QSYH NTUZ')

  817.         self.assertEqual(otp.pretty_key(sep=False), KEY1)

  818.         self.assertEqual(otp.pretty_key(format="hex"), 'e01c-630c-2184-b076-ce99')

  819. 

  820.         # quick fuzz test: make attr access works for random key & random size

  821.         otp = TOTP(new=True, size=rng.randint(10, 20))

  822.         _ = otp.hex_key

  823.         _ = otp.base32_key

  824.         _ = otp.pretty_key()

  825. 

  826.     #=============================================================================

  827.     # generate() tests

  828.     #=============================================================================

  829.     def test_totp_token(self):

  830.         """generate() -- TotpToken() class"""

  831.         from passlib.totp import TOTP, TotpToken

  832. 

  833.         # test known set of values

  834.         otp = TOTP('s3jdvb7qd2r7jpxx')

  835.         result = otp.generate(1419622739)

  836.         self.assertIsInstance(result, TotpToken)

  837.         self.assertEqual(result.token, '897212')

  838.         self.assertEqual(result.counter, 47320757)

  839.         ##self.assertEqual(result.start_time, 1419622710)

  840.         self.assertEqual(result.expire_time, 1419622740)

  841.         self.assertEqual(result, ('897212', 1419622740))

  842.         self.assertEqual(len(result), 2)

  843.         self.assertEqual(result[0], '897212')

  844.         self.assertEqual(result[1], 1419622740)

  845.         self.assertRaises(IndexError, result.__getitem__, -3)

  846.         self.assertRaises(IndexError, result.__getitem__, 2)

  847.         self.assertTrue(result)

  848. 

  849.         # time dependant bits...

  850.         otp.now = lambda : 1419622739.5

  851.         self.assertEqual(result.remaining, 0.5)

  852.         self.assertTrue(result.valid)

  853. 

  854.         otp.now = lambda : 1419622741

  855.         self.assertEqual(result.remaining, 0)

  856.         self.assertFalse(result.valid)

  857. 

  858.         # same time -- shouldn't return same object, but should be equal

  859.         result2 = otp.generate(1419622739)

  860.         self.assertIsNot(result2, result)

  861.         self.assertEqual(result2, result)

  862. 

  863.         # diff time in period -- shouldn't return same object, but should be equal

  864.         result3 = otp.generate(1419622711)

  865.         self.assertIsNot(result3, result)

  866.         self.assertEqual(result3, result)

  867. 

  868.         # shouldn't be equal

  869.         result4 = otp.generate(1419622999)

  870.         self.assertNotEqual(result4, result)

  871. 

  872.     def test_generate(self):

  873.         """generate()"""

  874.         from passlib.totp import TOTP

  875. 

  876.         # generate token

  877.         otp = TOTP(new=True)

  878.         time = self.randtime()

  879.         result = otp.generate(time)

  880.         token = result.token

  881.         self.assertIsInstance(token, unicode)

  882.         start_time = result.counter * 30

  883. 

  884.         # should generate same token for next 29s

  885.         self.assertEqual(otp.generate(start_time + 29).token, token)

  886. 

  887.         # and new one at 30s

  888.         self.assertNotEqual(otp.generate(start_time + 30).token, token)

  889. 

  890.         # verify round-trip conversion of datetime

  891.         dt = datetime.datetime.utcfromtimestamp(time)

  892.         self.assertEqual(int(otp.normalize_time(dt)), int(time))

  893. 

  894.         # handle datetime object

  895.         self.assertEqual(otp.generate(dt).token, token)

  896. 

  897.         # omitting value should use current time

  898.         otp2 = TOTP.using(now=lambda: time)(key=otp.base32_key)

  899.         self.assertEqual(otp2.generate().token, token)

  900. 

  901.         # reject invalid time

  902.         self.assertRaises(ValueError, otp.generate, -1)

  903. 

  904.     def test_generate_w_reference_vectors(self):

  905.         """generate() -- reference vectors"""

  906.         for otp, time, token, expires, prefix in self.iter_test_vectors():

  907.             # should output correct token for specified time

  908.             result = otp.generate(time)

  909.             self.assertEqual(result.token, token, msg=prefix)

  910.             self.assertEqual(result.counter, time // otp.period, msg=prefix)

  911.             if expires:

  912.                 self.assertEqual(result.expire_time, expires)

  913. 

  914.     #=============================================================================

  915.     # TotpMatch() tests

  916.     #=============================================================================

  917. 

  918.     def assertTotpMatch(self, match, time, skipped=0, period=30, window=30, msg=''):

  919.         from passlib.totp import TotpMatch

  920. 

  921.         # test type

  922.         self.assertIsInstance(match, TotpMatch)

  923. 

  924.         # totp sanity check

  925.         self.assertIsInstance(match.totp, TOTP)

  926.         self.assertEqual(match.totp.period, period)

  927. 

  928.         # test attrs

  929.         self.assertEqual(match.time, time, msg=msg + " matched time:")

  930.         expected = time // period

  931.         counter = expected + skipped

  932.         self.assertEqual(match.counter, counter, msg=msg + " matched counter:")

  933.         self.assertEqual(match.expected_counter, expected, msg=msg + " expected counter:")

  934.         self.assertEqual(match.skipped, skipped, msg=msg + " skipped:")

  935.         self.assertEqual(match.cache_seconds, period + window)

  936.         expire_time = (counter + 1) * period

  937.         self.assertEqual(match.expire_time, expire_time)

  938.         self.assertEqual(match.cache_time, expire_time + window)

  939. 

  940.         # test tuple

  941.         self.assertEqual(len(match), 2)

  942.         self.assertEqual(match, (counter, time))

  943.         self.assertRaises(IndexError, match.__getitem__, -3)

  944.         self.assertEqual(match[0], counter)

  945.         self.assertEqual(match[1], time)

  946.         self.assertRaises(IndexError, match.__getitem__, 2)

  947. 

  948.         # test bool

  949.         self.assertTrue(match)

  950. 

  951.     def test_totp_match_w_valid_token(self):

  952.         """match() -- valid TotpMatch object"""

  953.         time = 141230981

  954.         token = '781501'

  955.         otp = TOTP.using(now=lambda: time + 24 * 3600)(KEY3)

  956.         result = otp.match(token, time)

  957.         self.assertTotpMatch(result, time=time, skipped=0)

  958. 

  959.     def test_totp_match_w_older_token(self):

  960.         """match() -- valid TotpMatch object with future token"""

  961.         from passlib.totp import TotpMatch

  962. 

  963.         time = 141230981

  964.         token = '781501'

  965.         otp = TOTP.using(now=lambda: time + 24 * 3600)(KEY3)

  966.         result = otp.match(token, time - 30)

  967.         self.assertTotpMatch(result, time=time - 30, skipped=1)

  968. 

  969.     def test_totp_match_w_new_token(self):

  970.         """match() -- valid TotpMatch object with past token"""

  971.         time = 141230981

  972.         token = '781501'

  973.         otp = TOTP.using(now=lambda: time + 24 * 3600)(KEY3)

  974.         result = otp.match(token, time + 30)

  975.         self.assertTotpMatch(result, time=time + 30, skipped=-1)

  976. 

  977.     def test_totp_match_w_invalid_token(self):

  978.         """match() -- invalid TotpMatch object"""

  979.         time = 141230981

  980.         token = '781501'

  981.         otp = TOTP.using(now=lambda: time + 24 * 3600)(KEY3)

  982.         self.assertRaises(exc.InvalidTokenError, otp.match, token, time + 60)

  983. 

  984.     #=============================================================================

  985.     # match() tests

  986.     #=============================================================================

  987. 

  988.     def assertVerifyMatches(self, expect_skipped, token, time,  # *

  989.                             otp, gen_time=None, **kwds):

  990.         """helper to test otp.match() output is correct"""

  991.         # NOTE: TotpMatch return type tested more throughly above ^^^

  992.         msg = "key=%r alg=%r period=%r token=%r gen_time=%r time=%r:" % \

  993.               (otp.base32_key, otp.alg, otp.period, token, gen_time, time)

  994.         result = otp.match(token, time, **kwds)

  995.         self.assertTotpMatch(result,

  996.                              time=otp.normalize_time(time),

  997.                              period=otp.period,

  998.                              window=kwds.get("window", 30),

  999.                              skipped=expect_skipped,

  1000.                              msg=msg)

  1001. 

  1002.     def assertVerifyRaises(self, exc_class, token, time,  # *

  1003.                           otp, gen_time=None,

  1004.                           **kwds):

  1005.         """helper to test otp.match() throws correct error"""

  1006.         # NOTE: TotpMatch return type tested more throughly above ^^^

  1007.         msg = "key=%r alg=%r period=%r token=%r gen_time=%r time=%r:" % \

  1008.               (otp.base32_key, otp.alg, otp.period, token, gen_time, time)

  1009.         return self.assertRaises(exc_class, otp.match, token, time,

  1010.                                  __msg__=msg, **kwds)

  1011. 

  1012.     def test_match_w_window(self):

  1013.         """match() -- 'time' and 'window' parameters"""

  1014. 

  1015.         # init generator & helper

  1016.         otp = self.randotp()

  1017.         period = otp.period

  1018.         time = self.randtime()

  1019.         token = otp.generate(time).token

  1020.         common = dict(otp=otp, gen_time=time)

  1021.         assertMatches = partial(self.assertVerifyMatches, **common)

  1022.         assertRaises = partial(self.assertVerifyRaises, **common)

  1023. 

  1024.         #-------------------------------

  1025.         # basic validation, and 'window' parameter

  1026.         #-------------------------------

  1027. 

  1028.         # validate against previous counter (passes if window >= period)

  1029.         assertRaises(exc.InvalidTokenError, token, time - period, window=0)

  1030.         assertMatches(+1, token, time - period, window=period)

  1031.         assertMatches(+1, token, time - period, window=2 * period)

  1032. 

  1033.         # validate against current counter

  1034.         assertMatches(0, token, time, window=0)

  1035. 

  1036.         # validate against next counter (passes if window >= period)

  1037.         assertRaises(exc.InvalidTokenError, token, time + period, window=0)

  1038.         assertMatches(-1, token, time + period, window=period)

  1039.         assertMatches(-1, token, time + period, window=2 * period)

  1040. 

  1041.         # validate against two time steps later (should never pass)

  1042.         assertRaises(exc.InvalidTokenError, token, time + 2 * period, window=0)

  1043.         assertRaises(exc.InvalidTokenError, token, time + 2 * period, window=period)

  1044.         assertMatches(-2, token, time + 2 * period, window=2 * period)

  1045. 

  1046.         # TODO: test window values that aren't multiples of period

  1047.         #       (esp ensure counter rounding works correctly)

  1048. 

  1049.         #-------------------------------

  1050.         # time normalization

  1051.         #-------------------------------

  1052. 

  1053.         # handle datetimes

  1054.         dt = datetime.datetime.utcfromtimestamp(time)

  1055.         assertMatches(0, token, dt, window=0)

  1056. 

  1057.         # reject invalid time

  1058.         assertRaises(ValueError, token, -1)

  1059. 

  1060.     def test_match_w_skew(self):

  1061.         """match() -- 'skew' parameters"""

  1062.         # init generator & helper

  1063.         otp = self.randotp()

  1064.         period = otp.period

  1065.         time = self.randtime()

  1066.         common = dict(otp=otp, gen_time=time)

  1067.         assertMatches = partial(self.assertVerifyMatches, **common)

  1068.         assertRaises = partial(self.assertVerifyRaises, **common)

  1069. 

  1070.         # assume client is running far behind server / has excessive transmission delay

  1071.         skew = 3 * period

  1072.         behind_token = otp.generate(time - skew).token

  1073.         assertRaises(exc.InvalidTokenError, behind_token, time, window=0)

  1074.         assertMatches(-3, behind_token, time, window=0, skew=-skew)

  1075. 

  1076.         # assume client is running far ahead of server

  1077.         ahead_token = otp.generate(time + skew).token

  1078.         assertRaises(exc.InvalidTokenError, ahead_token, time, window=0)

  1079.         assertMatches(+3, ahead_token, time, window=0, skew=skew)

  1080. 

  1081.         # TODO: test skew + larger window

  1082. 

  1083.     def test_match_w_reuse(self):

  1084.         """match() -- 'reuse' and 'last_counter' parameters"""

  1085. 

  1086.         # init generator & helper

  1087.         otp = self.randotp()

  1088.         period = otp.period

  1089.         time = self.randtime()

  1090.         tdata = otp.generate(time)

  1091.         token = tdata.token

  1092.         counter = tdata.counter

  1093.         expire_time = tdata.expire_time

  1094.         common = dict(otp=otp, gen_time=time)

  1095.         assertMatches = partial(self.assertVerifyMatches, **common)

  1096.         assertRaises = partial(self.assertVerifyRaises, **common)

  1097. 

  1098.         # last counter unset --

  1099.         # previous period's token should count as valid

  1100.         assertMatches(-1, token, time + period, window=period)

  1101. 

  1102.         # last counter set 2 periods ago --

  1103.         # previous period's token should count as valid

  1104.         assertMatches(-1, token, time + period, last_counter=counter-1,

  1105.                       window=period)

  1106. 

  1107.         # last counter set 2 periods ago --

  1108.         # 2 periods ago's token should NOT count as valid

  1109.         assertRaises(exc.InvalidTokenError, token, time + 2 * period,

  1110.                      last_counter=counter, window=period)

  1111. 

  1112.         # last counter set 1 period ago --

  1113.         # previous period's token should now be rejected as 'used'

  1114.         err = assertRaises(exc.UsedTokenError, token, time + period,

  1115.                            last_counter=counter, window=period)

  1116.         self.assertEqual(err.expire_time, expire_time)

  1117. 

  1118.         # last counter set to current period --

  1119.         # current period's token should be rejected

  1120.         err = assertRaises(exc.UsedTokenError, token, time,

  1121.                            last_counter=counter, window=0)

  1122.         self.assertEqual(err.expire_time, expire_time)

  1123. 

  1124.     def test_match_w_token_normalization(self):

  1125.         """match() -- token normalization"""

  1126.         # setup test helper

  1127.         otp = TOTP('otxl2f5cctbprpzx')

  1128.         match = otp.match

  1129.         time = 1412889861

  1130. 

  1131.         # separators / spaces should be stripped (orig token '332136')

  1132.         self.assertTrue(match('    3 32-136  ', time))

  1133. 

  1134.         # ascii bytes

  1135.         self.assertTrue(match(b'332136', time))

  1136. 

  1137.         # too few digits

  1138.         self.assertRaises(exc.MalformedTokenError, match, '12345', time)

  1139. 

  1140.         # invalid char

  1141.         self.assertRaises(exc.MalformedTokenError, match, '12345X', time)

  1142. 

  1143.         # leading zeros count towards size

  1144.         self.assertRaises(exc.MalformedTokenError, match, '0123456', time)

  1145. 

  1146.     def test_match_w_reference_vectors(self):

  1147.         """match() -- reference vectors"""

  1148.         for otp, time, token, expires, msg in self.iter_test_vectors():

  1149.             # create wrapper

  1150.             match = otp.match

  1151. 

  1152.             # token should match against time

  1153.             result = match(token, time)

  1154.             self.assertTrue(result)

  1155.             self.assertEqual(result.counter, time // otp.period, msg=msg)

  1156. 

  1157.             # should NOT match against another time

  1158.             self.assertRaises(exc.InvalidTokenError, match, token, time + 100, window=0)

  1159. 

  1160.     #=============================================================================

  1161.     # verify() tests

  1162.     #=============================================================================

  1163.     def test_verify(self):

  1164.         """verify()"""

  1165.         # NOTE: since this is thin wrapper around .from_source() and .match(),

  1166.         #       just testing basic behavior here.

  1167. 

  1168.         from passlib.totp import TOTP

  1169. 

  1170.         time = 1412889861

  1171.         TotpFactory = TOTP.using(now=lambda: time)

  1172. 

  1173.         # successful match

  1174.         source1 = dict(v=1, type="totp", key='otxl2f5cctbprpzx')

  1175.         match = TotpFactory.verify('332136', source1)

  1176.         self.assertTotpMatch(match, time=time)

  1177. 

  1178.         # failed match

  1179.         source1 = dict(v=1, type="totp", key='otxl2f5cctbprpzx')

  1180.         self.assertRaises(exc.InvalidTokenError, TotpFactory.verify, '332155', source1)

  1181. 

  1182.         # bad source

  1183.         source1 = dict(v=1, type="totp")

  1184.         self.assertRaises(ValueError, TotpFactory.verify, '332155', source1)

  1185. 

  1186.         # successful match -- json source

  1187.         source1json = '{"v": 1, "type": "totp", "key": "otxl2f5cctbprpzx"}'

  1188.         match = TotpFactory.verify('332136', source1json)

  1189.         self.assertTotpMatch(match, time=time)

  1190. 

  1191.         # successful match -- URI

  1192.         source1uri = 'otpauth://totp/Label?secret=otxl2f5cctbprpzx'

  1193.         match = TotpFactory.verify('332136', source1uri)

  1194.         self.assertTotpMatch(match, time=time)

  1195. 

  1196.     #=============================================================================

  1197.     # serialization frontend tests

  1198.     #=============================================================================

  1199.     def test_from_source(self):

  1200.         """from_source()"""

  1201.         from passlib.totp import TOTP

  1202.         from_source = TOTP.from_source

  1203. 

  1204.         # uri (unicode)

  1205.         otp = from_source(u("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&"

  1206.                             "issuer=Example"))

  1207.         self.assertEqual(otp.key, KEY4_RAW)

  1208. 

  1209.         # uri (bytes)

  1210.         otp = from_source(b"otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&"

  1211.                           b"issuer=Example")

  1212.         self.assertEqual(otp.key, KEY4_RAW)

  1213. 

  1214.         # dict

  1215.         otp = from_source(dict(v=1, type="totp", key=KEY4))

  1216.         self.assertEqual(otp.key, KEY4_RAW)

  1217. 

  1218.         # json (unicode)

  1219.         otp = from_source(u('{"v": 1, "type": "totp", "key": "JBSWY3DPEHPK3PXP"}'))

  1220.         self.assertEqual(otp.key, KEY4_RAW)

  1221. 

  1222.         # json (bytes)

  1223.         otp = from_source(b'{"v": 1, "type": "totp", "key": "JBSWY3DPEHPK3PXP"}')

  1224.         self.assertEqual(otp.key, KEY4_RAW)

  1225. 

  1226.         # TOTP object -- return unchanged

  1227.         self.assertIs(from_source(otp), otp)

  1228. 

  1229.         # TOTP object w/ different wallet -- return new one.

  1230.         wallet1 = AppWallet()

  1231.         otp1 = TOTP.using(wallet=wallet1).from_source(otp)

  1232.         self.assertIsNot(otp1, otp)

  1233.         self.assertEqual(otp1.to_dict(), otp.to_dict())

  1234. 

  1235.         # TOTP object w/ same wallet -- return original

  1236.         otp2 = TOTP.using(wallet=wallet1).from_source(otp1)

  1237.         self.assertIs(otp2, otp1)

  1238. 

  1239.         # random string

  1240.         self.assertRaises(ValueError, from_source, u("foo"))

  1241.         self.assertRaises(ValueError, from_source, b"foo")

  1242. 

  1243.     #=============================================================================

  1244.     # uri serialization tests

  1245.     #=============================================================================

  1246.     def test_from_uri(self):

  1247.         """from_uri()"""

  1248.         from passlib.totp import TOTP

  1249.         from_uri = TOTP.from_uri

  1250. 

  1251.         # URIs from https://code.google.com/p/google-authenticator/wiki/KeyUriFormat

  1252. 

  1253.         #--------------------------------------------------------------------------------

  1254.         # canonical uri

  1255.         #--------------------------------------------------------------------------------

  1256.         otp = from_uri("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&"

  1257.                        "issuer=Example")

  1258.         self.assertIsInstance(otp, TOTP)

  1259.         self.assertEqual(otp.key, KEY4_RAW)

  1260.         self.assertEqual(otp.label, "alice@google.com")

  1261.         self.assertEqual(otp.issuer, "Example")

  1262.         self.assertEqual(otp.alg, "sha1") # default

  1263.         self.assertEqual(otp.period, 30) # default

  1264.         self.assertEqual(otp.digits, 6) # default

  1265. 

  1266.         #--------------------------------------------------------------------------------

  1267.         # secret param

  1268.         #--------------------------------------------------------------------------------

  1269. 

  1270.         # secret case insensitive

  1271.         otp = from_uri("otpauth://totp/Example:alice@google.com?secret=jbswy3dpehpk3pxp&"

  1272.                        "issuer=Example")

  1273.         self.assertEqual(otp.key, KEY4_RAW)

  1274. 

  1275.         # missing secret

  1276.         self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?digits=6")

  1277. 

  1278.         # undecodable secret

  1279.         self.assertRaises(Base32DecodeError, from_uri, "otpauth://totp/Example:alice@google.com?"

  1280.                                                        "secret=JBSWY3DPEHP@3PXP")

  1281. 

  1282.         #--------------------------------------------------------------------------------

  1283.         # label param

  1284.         #--------------------------------------------------------------------------------

  1285. 

  1286.         # w/ encoded space

  1287.         otp = from_uri("otpauth://totp/Provider1:Alice%20Smith?secret=JBSWY3DPEHPK3PXP&"

  1288.                        "issuer=Provider1")

  1289.         self.assertEqual(otp.label, "Alice Smith")

  1290.         self.assertEqual(otp.issuer, "Provider1")

  1291. 

  1292.         # w/ encoded space and colon

  1293.         # (note url has leading space before 'alice') -- taken from KeyURI spec

  1294.         otp = from_uri("otpauth://totp/Big%20Corporation%3A%20alice@bigco.com?"

  1295.                        "secret=JBSWY3DPEHPK3PXP")

  1296.         self.assertEqual(otp.label, "alice@bigco.com")

  1297.         self.assertEqual(otp.issuer, "Big Corporation")

  1298. 

  1299.         #--------------------------------------------------------------------------------

  1300.         # issuer param / prefix

  1301.         #--------------------------------------------------------------------------------

  1302. 

  1303.         # 'new style' issuer only

  1304.         otp = from_uri("otpauth://totp/alice@bigco.com?secret=JBSWY3DPEHPK3PXP&issuer=Big%20Corporation")

  1305.         self.assertEqual(otp.label, "alice@bigco.com")

  1306.         self.assertEqual(otp.issuer, "Big Corporation")

  1307. 

  1308.         # new-vs-old issuer mismatch

  1309.         self.assertRaises(ValueError, TOTP.from_uri,

  1310.                           "otpauth://totp/Provider1:alice?secret=JBSWY3DPEHPK3PXP&issuer=Provider2")

  1311. 

  1312.         #--------------------------------------------------------------------------------

  1313.         # algorithm param

  1314.         #--------------------------------------------------------------------------------

  1315. 

  1316.         # custom alg

  1317.         otp = from_uri("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&algorithm=SHA256")

  1318.         self.assertEqual(otp.alg, "sha256")

  1319. 

  1320.         # unknown alg

  1321.         self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?"

  1322.                                                 "secret=JBSWY3DPEHPK3PXP&algorithm=SHA333")

  1323. 

  1324.         #--------------------------------------------------------------------------------

  1325.         # digit param

  1326.         #--------------------------------------------------------------------------------

  1327. 

  1328.         # custom digits

  1329.         otp = from_uri("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&digits=8")

  1330.         self.assertEqual(otp.digits, 8)

  1331. 

  1332.         # digits out of range / invalid

  1333.         self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&digits=A")

  1334.         self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&digits=%20")

  1335.         self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&digits=15")

  1336. 

  1337.         #--------------------------------------------------------------------------------

  1338.         # period param

  1339.         #--------------------------------------------------------------------------------

  1340. 

  1341.         # custom period

  1342.         otp = from_uri("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&period=63")

  1343.         self.assertEqual(otp.period, 63)

  1344. 

  1345.         # reject period < 1

  1346.         self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?"

  1347.                                                 "secret=JBSWY3DPEHPK3PXP&period=0")

  1348. 

  1349.         self.assertRaises(ValueError, from_uri, "otpauth://totp/Example:alice@google.com?"

  1350.                                                 "secret=JBSWY3DPEHPK3PXP&period=-1")

  1351. 

  1352.         #--------------------------------------------------------------------------------

  1353.         # unrecognized param

  1354.         #--------------------------------------------------------------------------------

  1355. 

  1356.         # should issue warning, but otherwise ignore extra param

  1357.         with self.assertWarningList([

  1358.             dict(category=exc.PasslibRuntimeWarning, message_re="unexpected parameters encountered")

  1359.         ]):

  1360.             otp = from_uri("otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&"

  1361.                            "foo=bar&period=63")

  1362.         self.assertEqual(otp.base32_key, KEY4)

  1363.         self.assertEqual(otp.period, 63)

  1364. 

  1365.     def test_to_uri(self):

  1366.         """to_uri()"""

  1367. 

  1368.         #-------------------------------------------------------------------------

  1369.         # label & issuer parameters

  1370.         #-------------------------------------------------------------------------

  1371. 

  1372.         # with label & issuer

  1373.         otp = TOTP(KEY4, alg="sha1", digits=6, period=30)

  1374.         self.assertEqual(otp.to_uri("alice@google.com", "Example Org"),

  1375.                          "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP&"

  1376.                          "issuer=Example%20Org")

  1377. 

  1378.         # label is required

  1379.         self.assertRaises(ValueError, otp.to_uri, None, "Example Org")

  1380. 

  1381.         # with label only

  1382.         self.assertEqual(otp.to_uri("alice@google.com"),

  1383.                          "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP")

  1384. 

  1385.         # with default label from constructor

  1386.         otp.label = "alice@google.com"

  1387.         self.assertEqual(otp.to_uri(),

  1388.                          "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP")

  1389. 

  1390.         # with default label & default issuer from constructor

  1391.         otp.issuer = "Example Org"

  1392.         self.assertEqual(otp.to_uri(),

  1393.                          "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP"

  1394.                          "&issuer=Example%20Org")

  1395. 

  1396.         # reject invalid label

  1397.         self.assertRaises(ValueError, otp.to_uri, "label:with:semicolons")

  1398. 

  1399.         # reject invalid issue

  1400.         self.assertRaises(ValueError, otp.to_uri, "alice@google.com", "issuer:with:semicolons")

  1401. 

  1402.         #-------------------------------------------------------------------------

  1403.         # algorithm parameter

  1404.         #-------------------------------------------------------------------------

  1405.         self.assertEqual(TOTP(KEY4, alg="sha256").to_uri("alice@google.com"),

  1406.                          "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP&"

  1407.                          "algorithm=SHA256")

  1408. 

  1409.         #-------------------------------------------------------------------------

  1410.         # digits parameter

  1411.         #-------------------------------------------------------------------------

  1412.         self.assertEqual(TOTP(KEY4, digits=8).to_uri("alice@google.com"),

  1413.                          "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP&"

  1414.                          "digits=8")

  1415. 

  1416.         #-------------------------------------------------------------------------

  1417.         # period parameter

  1418.         #-------------------------------------------------------------------------

  1419.         self.assertEqual(TOTP(KEY4, period=63).to_uri("alice@google.com"),

  1420.                          "otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP&"

  1421.                          "period=63")

  1422. 

  1423.     #=============================================================================

  1424.     # dict serialization tests

  1425.     #=============================================================================

  1426.     def test_from_dict(self):

  1427.         """from_dict()"""

  1428.         from passlib.totp import TOTP

  1429.         from_dict = TOTP.from_dict

  1430. 

  1431.         #--------------------------------------------------------------------------------

  1432.         # canonical simple example

  1433.         #--------------------------------------------------------------------------------

  1434.         otp = from_dict(dict(v=1, type="totp", key=KEY4, label="alice@google.com", issuer="Example"))

  1435.         self.assertIsInstance(otp, TOTP)

  1436.         self.assertEqual(otp.key, KEY4_RAW)

  1437.         self.assertEqual(otp.label, "alice@google.com")

  1438.         self.assertEqual(otp.issuer, "Example")

  1439.         self.assertEqual(otp.alg, "sha1")  # default

  1440.         self.assertEqual(otp.period, 30)  # default

  1441.         self.assertEqual(otp.digits, 6)  # default

  1442. 

  1443.         #--------------------------------------------------------------------------------

  1444.         # metadata

  1445.         #--------------------------------------------------------------------------------

  1446. 

  1447.         # missing version

  1448.         self.assertRaises(ValueError, from_dict, dict(type="totp", key=KEY4))

  1449. 

  1450.         # invalid version

  1451.         self.assertRaises(ValueError, from_dict, dict(v=0, type="totp", key=KEY4))

  1452.         self.assertRaises(ValueError, from_dict, dict(v=999, type="totp", key=KEY4))

  1453. 

  1454.         # missing type

  1455.         self.assertRaises(ValueError, from_dict, dict(v=1, key=KEY4))

  1456. 

  1457.         #--------------------------------------------------------------------------------

  1458.         # secret param

  1459.         #--------------------------------------------------------------------------------

  1460. 

  1461.         # secret case insensitive

  1462.         otp = from_dict(dict(v=1, type="totp", key=KEY4.lower(), label="alice@google.com", issuer="Example"))

  1463.         self.assertEqual(otp.key, KEY4_RAW)

  1464. 

  1465.         # missing secret

  1466.         self.assertRaises(ValueError, from_dict, dict(v=1, type="totp"))

  1467. 

  1468.         # undecodable secret

  1469.         self.assertRaises(Base32DecodeError, from_dict,

  1470.                           dict(v=1, type="totp", key="JBSWY3DPEHP@3PXP"))

  1471. 

  1472.         #--------------------------------------------------------------------------------

  1473.         # label & issuer params

  1474.         #--------------------------------------------------------------------------------

  1475. 

  1476.         otp = from_dict(dict(v=1, type="totp", key=KEY4, label="Alice Smith", issuer="Provider1"))

  1477.         self.assertEqual(otp.label, "Alice Smith")

  1478.         self.assertEqual(otp.issuer, "Provider1")

  1479. 

  1480.         #--------------------------------------------------------------------------------

  1481.         # algorithm param

  1482.         #--------------------------------------------------------------------------------

  1483. 

  1484.         # custom alg

  1485.         otp = from_dict(dict(v=1, type="totp", key=KEY4, alg="sha256"))

  1486.         self.assertEqual(otp.alg, "sha256")

  1487. 

  1488.         # unknown alg

  1489.         self.assertRaises(ValueError, from_dict, dict(v=1, type="totp", key=KEY4, alg="sha333"))

  1490. 

  1491.         #--------------------------------------------------------------------------------

  1492.         # digit param

  1493.         #--------------------------------------------------------------------------------

  1494. 

  1495.         # custom digits

  1496.         otp = from_dict(dict(v=1, type="totp", key=KEY4, digits=8))

  1497.         self.assertEqual(otp.digits, 8)

  1498. 

  1499.         # digits out of range / invalid

  1500.         self.assertRaises(TypeError, from_dict, dict(v=1, type="totp", key=KEY4, digits="A"))

  1501.         self.assertRaises(ValueError, from_dict, dict(v=1, type="totp", key=KEY4, digits=15))

  1502. 

  1503.         #--------------------------------------------------------------------------------

  1504.         # period param

  1505.         #--------------------------------------------------------------------------------

  1506. 

  1507.         # custom period

  1508.         otp = from_dict(dict(v=1, type="totp", key=KEY4, period=63))

  1509.         self.assertEqual(otp.period, 63)

  1510. 

  1511.         # reject period < 1

  1512.         self.assertRaises(ValueError, from_dict, dict(v=1, type="totp", key=KEY4, period=0))

  1513.         self.assertRaises(ValueError, from_dict, dict(v=1, type="totp", key=KEY4, period=-1))

  1514. 

  1515.         #--------------------------------------------------------------------------------

  1516.         # unrecognized param

  1517.         #--------------------------------------------------------------------------------

  1518.         self.assertRaises(TypeError, from_dict, dict(v=1, type="totp", key=KEY4, INVALID=123))

  1519. 

  1520.     def test_to_dict(self):

  1521.         """to_dict()"""

  1522. 

  1523.         #-------------------------------------------------------------------------

  1524.         # label & issuer parameters

  1525.         #-------------------------------------------------------------------------

  1526. 

  1527.         # without label or issuer

  1528.         otp = TOTP(KEY4, alg="sha1", digits=6, period=30)

  1529.         self.assertEqual(otp.to_dict(), dict(v=1, type="totp", key=KEY4))

  1530. 

  1531.         # with label & issuer from constructor

  1532.         otp = TOTP(KEY4, alg="sha1", digits=6, period=30,

  1533.                    label="alice@google.com", issuer="Example Org")

  1534.         self.assertEqual(otp.to_dict(),

  1535.                          dict(v=1, type="totp", key=KEY4,

  1536.                               label="alice@google.com", issuer="Example Org"))

  1537. 

  1538.         # with label only

  1539.         otp = TOTP(KEY4, alg="sha1", digits=6, period=30,

  1540.                    label="alice@google.com")

  1541.         self.assertEqual(otp.to_dict(),

  1542.                          dict(v=1, type="totp", key=KEY4,

  1543.                               label="alice@google.com"))

  1544. 

  1545.         # with issuer only

  1546.         otp = TOTP(KEY4, alg="sha1", digits=6, period=30,

  1547.                    issuer="Example Org")

  1548.         self.assertEqual(otp.to_dict(),

  1549.                          dict(v=1, type="totp", key=KEY4,

  1550.                               issuer="Example Org"))

  1551. 

  1552.         # don't serialize default issuer

  1553.         TotpFactory = TOTP.using(issuer="Example Org")

  1554.         otp = TotpFactory(KEY4)

  1555.         self.assertEqual(otp.to_dict(), dict(v=1, type="totp", key=KEY4))

  1556. 

  1557.         # don't serialize default issuer *even if explicitly set*

  1558.         otp = TotpFactory(KEY4, issuer="Example Org")

  1559.         self.assertEqual(otp.to_dict(),  dict(v=1, type="totp", key=KEY4))

  1560. 

  1561.         #-------------------------------------------------------------------------

  1562.         # algorithm parameter

  1563.         #-------------------------------------------------------------------------

  1564.         self.assertEqual(TOTP(KEY4, alg="sha256").to_dict(),

  1565.                          dict(v=1, type="totp", key=KEY4, alg="sha256"))

  1566. 

  1567.         #-------------------------------------------------------------------------

  1568.         # digits parameter

  1569.         #-------------------------------------------------------------------------

  1570.         self.assertEqual(TOTP(KEY4, digits=8).to_dict(),

  1571.                          dict(v=1, type="totp", key=KEY4, digits=8))

  1572. 

  1573.         #-------------------------------------------------------------------------

  1574.         # period parameter

  1575.         #-------------------------------------------------------------------------

  1576.         self.assertEqual(TOTP(KEY4, period=63).to_dict(),

  1577.                          dict(v=1, type="totp", key=KEY4, period=63))

  1578. 

  1579.     # TODO: to_dict()

  1580.     #           with encrypt=False

  1581.     #           with encrypt="auto" + wallet + secrets

  1582.     #           with encrypt="auto" + wallet + no secrets

  1583.     #           with encrypt="auto" + no wallet

  1584.     #           with encrypt=True + wallet + secrets

  1585.     #           with encrypt=True + wallet + no secrets

  1586.     #           with encrypt=True + no wallet

  1587.     #           that 'changed' is set for old versions, and old encryption tags.

  1588. 

  1589.     #=============================================================================

  1590.     # json serialization tests

  1591.     #=============================================================================

  1592. 

  1593.     # TODO: from_json() / to_json().

  1594.     #       (skipped for right now cause just wrapper for from_dict/to_dict)

  1595. 

  1596.     #=============================================================================

  1597.     # eoc

  1598.     #=============================================================================

  1599. 

  1600. #=============================================================================

  1601. # eof

  1602. #=============================================================================