PyOTP 2.2.8__py2.py3-none-any.whl → 2.4.0__py2.py3-none-any.whl

pyotp/__init__.py

@@ -1,23 +1,102 @@
-from __future__ import (absolute_import, division,
-                        print_function, unicode_literals)
+from typing import Any, Dict, Sequence
 
-from pyotp.hotp import HOTP  # noqa
-from pyotp.otp import OTP  # noqa
-from pyotp.totp import TOTP  # noqa
-from . import utils  # noqa
+import hashlib
+from re import split
+from urllib.parse import unquote, urlparse, parse_qsl
 
-def random_base32(length=16, random=None,
-                  chars=list('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567')):
+from .compat import random
+from .hotp import HOTP as HOTP
+from .otp import OTP as OTP
+from .totp import TOTP as TOTP
 
-    # Use secrets module if available (Python version >= 3.6) per PEP 506
-    try:
-        import secrets
-        random = secrets.SystemRandom()
-    except ImportError:
-        import random as _random
-        random = _random.SystemRandom()
+
+def random_base32(
+        length: int = 16,
+        chars: Sequence[str] = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567')) -> str:
+    if length < 16:
+        raise Exception("Secrets should be at least 128 bits")
 
     return ''.join(
         random.choice(chars)
         for _ in range(length)
     )
+
+
+def random_hex(
+        length: int = 32,
+        chars: Sequence[str] = list('ABCDEF0123456789')) -> str:
+    if length < 32:
+        raise Exception("Secrets should be at least 128 bits")
+    return random_base32(length=length, chars=chars)
+
+
+def parse_uri(uri: str) -> OTP:
+    """
+    Parses the provisioning URI for the OTP; works for either TOTP or HOTP.
+
+    See also:
+        https://github.com/google/google-authenticator/wiki/Key-Uri-Format
+
+    :param uri: the hotp/totp URI to parse
+    :returns: OTP object
+    """
+
+    # Secret (to be filled in later)
+    secret = None
+
+    # Data we'll parse to the correct constructor
+    otp_data = {}  # type: Dict[str, Any]
+
+    # Parse with URLlib
+    parsed_uri = urlparse(unquote(uri))
+
+    if parsed_uri.scheme != 'otpauth':
+        raise ValueError('Not an otpauth URI')
+
+    # Parse issuer/accountname info
+    accountinfo_parts = split(':|%3A', parsed_uri.path[1:], maxsplit=1)
+    if len(accountinfo_parts) == 1:
+        otp_data['name'] = accountinfo_parts[0]
+    else:
+        otp_data['issuer'] = accountinfo_parts[0]
+        otp_data['name'] = accountinfo_parts[1]
+
+    # Parse values
+    for key, value in parse_qsl(parsed_uri.query):
+        if key == 'secret':
+            secret = value
+        elif key == 'issuer':
+            if 'issuer' in otp_data and otp_data['issuer'] is not None and otp_data['issuer'] != value:
+                raise ValueError('If issuer is specified in both label and parameters, it should be equal.')
+            otp_data['issuer'] = value
+        elif key == 'algorithm':
+            if value == 'SHA1':
+                otp_data['digest'] = hashlib.sha1
+            elif value == 'SHA256':
+                otp_data['digest'] = hashlib.sha256
+            elif value == 'SHA512':
+                otp_data['digest'] = hashlib.sha512
+            else:
+                raise ValueError('Invalid value for algorithm, must be SHA1, SHA256 or SHA512')
+        elif key == 'digits':
+            digits = int(value)
+            if digits not in [6, 8]:
+                raise ValueError('Digits may only be 6 or 8')
+            otp_data['digits'] = digits
+        elif key == 'period':
+            otp_data['interval'] = value
+        elif key == 'counter':
+            otp_data['initial_count'] = value
+        else:
+            raise ValueError('{} is not a valid parameter'.format(key))
+
+    if not secret:
+        raise ValueError('No secret found in URI')
+
+    # Create objects
+    if parsed_uri.netloc == 'totp':
+        return TOTP(secret, **otp_data)
+    elif parsed_uri.netloc == 'hotp':
+        return HOTP(secret, **otp_data)
+
+    raise ValueError('Not a supported OTP type')

pyotp/compat.py

@@ -1,10 +1,7 @@
-from __future__ import absolute_import, division, print_function, unicode_literals
+# Use secrets module if available (Python version >= 3.6) per PEP 506
+try:
+    from secrets import SystemRandom  # type: ignore
+except ImportError:
+    from random import SystemRandom
 
-import sys
-
-USING_PYTHON2 = True if sys.version_info < (3, 0) else False
-
-if USING_PYTHON2:
-    str = unicode  # noqa
-else:
-    str = str
+random = SystemRandom()

pyotp/hotp.py

@@ -1,36 +1,43 @@
-from __future__ import absolute_import, division, print_function, unicode_literals
+from typing import Any, Optional
 
 from . import utils
 from .otp import OTP
-from .compat import str
+
 
 class HOTP(OTP):
     """
     Handler for HMAC-based OTP counters.
     """
-    def at(self, count):
+    def __init__(self, *args: Any, initial_count: int = 0, **kwargs: Any) -> None:
+        """
+        :param initial_count: starting HMAC counter value, defaults to 0
+        """
+        self.initial_count = initial_count
+        super(HOTP, self).__init__(*args, **kwargs)
+
+    def at(self, count: int) -> str:
         """
         Generates the OTP for the given count.
 
         :param count: the OTP HMAC counter
-        :type count: int
         :returns: OTP
-        :rtype: str
         """
         return self.generate_otp(count)
 
-    def verify(self, otp, counter):
+    def verify(self, otp: str, counter: int) -> bool:
         """
         Verifies the OTP passed in against the current counter OTP.
 
         :param otp: the OTP to check against
-        :type otp: str
-        :param count: the OTP HMAC counter
-        :type count: int
+        :param counter: the OTP HMAC counter
         """
         return utils.strings_equal(str(otp), str(self.at(counter)))
 
-    def provisioning_uri(self, name, initial_count=0, issuer_name=None):
+    def provisioning_uri(
+            self,
+            name: Optional[str] = None,
+            initial_count: Optional[int] = None,
+            issuer_name: Optional[str] = None) -> str:
         """
         Returns the provisioning URI for the OTP.  This can then be
         encoded in a QR Code and used to provision an OTP app like
@@ -40,19 +47,16 @@ class HOTP(OTP):
             https://github.com/google/google-authenticator/wiki/Key-Uri-Format
 
         :param name: name of the user account
-        :type name: str
         :param initial_count: starting HMAC counter value, defaults to 0
-        :type initial_count: int
         :param issuer_name: the name of the OTP issuer; this will be the
             organization title of the OTP entry in Authenticator
         :returns: provisioning URI
-        :rtype: str
         """
         return utils.build_uri(
             self.secret,
-            name,
-            initial_count=initial_count,
-            issuer_name=issuer_name,
+            name=name if name else self.name,
+            initial_count=initial_count if initial_count else self.initial_count,
+            issuer=issuer_name if issuer_name else self.issuer,
             algorithm=self.digest().name,
             digits=self.digits
         )

pyotp/otp.py

@@ -1,32 +1,39 @@
-from __future__ import absolute_import, division, print_function, unicode_literals
+from typing import Any, Optional
 
 import base64
 import hashlib
 import hmac
-from .compat import str
+
 
 class OTP(object):
     """
     Base class for OTP handlers.
     """
-    def __init__(self, s, digits=6, digest=hashlib.sha1):
+    def __init__(
+        self,
+        s: str,
+        digits: int = 6,
+        digest: Any = hashlib.sha1,
+        name: Optional[str] = None,
+        issuer: Optional[str] = None
+    ) -> None:
         """
         :param s: secret in base32 format
-        :type s: str
         :param digits: number of integers in the OTP. Some apps expect this to be 6 digits, others support more.
-        :type digits: int
         :param digest: digest function to use in the HMAC (expected to be sha1)
-        :type digest: callable
+        :param name: account name
+        :param issuer: issuer
         """
         self.digits = digits
         self.digest = digest
         self.secret = s
+        self.name = name or 'Secret'
+        self.issuer = issuer
 
-    def generate_otp(self, input):
+    def generate_otp(self, input: int) -> str:
         """
         :param input: the HMAC counter value to use as the OTP input.
             Usually either the counter, or the computed integer based on the Unix timestamp
-        :type input: int
         """
         if input < 0:
             raise ValueError('input must be positive integer')
@@ -43,14 +50,14 @@ class OTP(object):
 
         return str_code
 
-    def byte_secret(self):
+    def byte_secret(self) -> bytes:
         missing_padding = len(self.secret) % 8
         if missing_padding != 0:
             self.secret += '=' * (8 - missing_padding)
         return base64.b32decode(self.secret, casefold=True)
 
     @staticmethod
-    def int_to_bytestring(i, padding=8):
+    def int_to_bytestring(i: int, padding: int = 8) -> bytes:
         """
         Turns an integer to the OATH specified
         bytestring, which is fed to the HMAC

pyotp/totp.py

@@ -1,60 +1,57 @@
-from __future__ import absolute_import, division, print_function, unicode_literals
+from typing import Any, Union, Optional
 
 import datetime
 import time
 
 from . import utils
 from .otp import OTP
-from .compat import str
+
 
 class TOTP(OTP):
     """
     Handler for time-based OTP counters.
     """
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, interval: int = 30, **kwargs: Any) -> None:
         """
         :param interval: the time interval in seconds
             for OTP. This defaults to 30.
-        :type interval: int
         """
-        self.interval = kwargs.pop('interval', 30)
+        self.interval = interval
         super(TOTP, self).__init__(*args, **kwargs)
 
-    def at(self, for_time, counter_offset=0):
+    def at(self, for_time: Union[int, datetime.datetime], counter_offset: int = 0) -> str:
         """
         Accepts either a Unix timestamp integer or a datetime object.
 
+        To get the time until the next timecode change (seconds until the current OTP expires), use this instead::
+
+            totp = pyotp.TOTP(...)
+            time_remaining = totp.interval - datetime.datetime.now().timestamp() % totp.interval
+
         :param for_time: the time to generate an OTP for
-        :type for_time: int or datetime
         :param counter_offset: the amount of ticks to add to the time counter
         :returns: OTP value
-        :rtype: str
         """
         if not isinstance(for_time, datetime.datetime):
             for_time = datetime.datetime.fromtimestamp(int(for_time))
         return self.generate_otp(self.timecode(for_time) + counter_offset)
 
-    def now(self):
+    def now(self) -> str:
         """
         Generate the current time OTP
 
         :returns: OTP value
-        :rtype: str
         """
         return self.generate_otp(self.timecode(datetime.datetime.now()))
 
-    def verify(self, otp, for_time=None, valid_window=0):
+    def verify(self, otp: str, for_time: Optional[datetime.datetime] = None, valid_window: int = 0) -> bool:
         """
         Verifies the OTP passed in against the current time OTP.
 
         :param otp: the OTP to check against
-        :type otp: str
         :param for_time: Time to check OTP at (defaults to now)
-        :type for_time: int or datetime
         :param valid_window: extends the validity to this many counter ticks before and after the current one
-        :type valid_window: int
         :returns: True if verification succeeded, False otherwise
-        :rtype: bool
         """
         if for_time is None:
             for_time = datetime.datetime.now()
@@ -67,7 +64,7 @@ class TOTP(OTP):
 
         return utils.strings_equal(str(otp), str(self.at(for_time)))
 
-    def provisioning_uri(self, name, issuer_name=None):
+    def provisioning_uri(self, name: Optional[str] = None, issuer_name: Optional[str] = None) -> str:
         """
         Returns the provisioning URI for the OTP.  This can then be
         encoded in a QR Code and used to provision an OTP app like
@@ -76,17 +73,12 @@ class TOTP(OTP):
         See also:
             https://github.com/google/google-authenticator/wiki/Key-Uri-Format
 
-        :param name: name of the user account
-        :type name: str
-        :param issuer_name: the name of the OTP issuer; this will be the
-            organization title of the OTP entry in Authenticator
-        :returns: provisioning URI
-        :rtype: str
         """
-        return utils.build_uri(self.secret, name, issuer_name=issuer_name,
+        return utils.build_uri(self.secret, name if name else self.name,
+                               issuer=issuer_name if issuer_name else self.issuer,
                                algorithm=self.digest().name,
                                digits=self.digits, period=self.interval)
 
-    def timecode(self, for_time):
+    def timecode(self, for_time: datetime.datetime) -> int:
         i = time.mktime(for_time.timetuple())
         return int(i / self.interval)

pyotp/utils.py

@@ -1,19 +1,18 @@
-from __future__ import absolute_import, division, print_function, unicode_literals
+from typing import Dict, Optional, Union
 
 import unicodedata
-try:
-    from itertools import izip_longest
-except ImportError:
-    from itertools import zip_longest as izip_longest
-
-try:
-    from urllib.parse import quote, urlencode
-except ImportError:
-    from urllib import quote, urlencode
-
-
-def build_uri(secret, name, initial_count=None, issuer_name=None,
-              algorithm=None, digits=None, period=None):
+from hmac import compare_digest
+from urllib.parse import quote, urlencode
+
+
+def build_uri(
+        secret: str,
+        name: str,
+        initial_count: Optional[int] = None,
+        issuer: Optional[str] = None,
+        algorithm: Optional[str] = None,
+        digits: Optional[int] = None,
+        period: Optional[int] = None) -> str:
     """
     Returns the provisioning URI for the OTP; works for either TOTP or HOTP.
 
@@ -26,24 +25,16 @@ def build_uri(secret, name, initial_count=None, issuer_name=None,
         https://github.com/google/google-authenticator/wiki/Key-Uri-Format
 
     :param secret: the hotp/totp secret used to generate the URI
-    :type secret: str
     :param name: name of the account
-    :type name: str
     :param initial_count: starting counter value, defaults to None.
         If none, the OTP type will be assumed as TOTP.
-    :type initial_count: int
-    :param issuer_name: the name of the OTP issuer; this will be the
+    :param issuer: the name of the OTP issuer; this will be the
         organization title of the OTP entry in Authenticator
-    :type issuer_name: str
     :param algorithm: the algorithm used in the OTP generation.
-    :type algorithm: str
     :param digits: the length of the OTP generated code.
-    :type digits: int
     :param period: the number of seconds the OTP generator is set to
         expire every code.
-    :type period: int
     :returns: provisioning uri
-    :rtype: str
     """
     # initial_count may be 0 as a valid param
     is_initial_count_present = (initial_count is not None)
@@ -56,17 +47,17 @@ def build_uri(secret, name, initial_count=None, issuer_name=None,
     otp_type = 'hotp' if is_initial_count_present else 'totp'
     base_uri = 'otpauth://{0}/{1}?{2}'
 
-    url_args = {'secret': secret}
+    url_args = {'secret': secret}  # type: Dict[str, Union[None, int, str]]
 
     label = quote(name)
-    if issuer_name is not None:
-        label = quote(issuer_name) + ':' + label
-        url_args['issuer'] = issuer_name
+    if issuer is not None:
+        label = quote(issuer) + ':' + label
+        url_args['issuer'] = issuer
 
     if is_initial_count_present:
         url_args['counter'] = initial_count
     if is_algorithm_set:
-        url_args['algorithm'] = algorithm.upper()
+        url_args['algorithm'] = algorithm.upper()  # type: ignore
     if is_digits_set:
         url_args['digits'] = digits
     if is_period_set:
@@ -76,26 +67,7 @@ def build_uri(secret, name, initial_count=None, issuer_name=None,
     return uri
 
 
-def _compare_digest(s1, s2):
-    differences = 0
-    for c1, c2 in izip_longest(s1, s2):
-        if c1 is None or c2 is None:
-            differences = 1
-            continue
-        differences |= ord(c1) ^ ord(c2)
-    return differences == 0
-
-
-try:
-    # Python 3.3+ and 2.7.7+ include a timing-attack-resistant
-    # comparison function, which is probably more reliable than ours.
-    # Use it if available.
-    from hmac import compare_digest
-except ImportError:
-    compare_digest = _compare_digest
-
-
-def strings_equal(s1, s2):
+def strings_equal(s1: str, s2: str) -> bool:
     """
     Timing-attack resistant string comparison.
 
@@ -106,4 +78,4 @@ def strings_equal(s1, s2):
     """
     s1 = unicodedata.normalize('NFKC', s1)
     s2 = unicodedata.normalize('NFKC', s2)
-    return compare_digest(s1.encode(), s2.encode())
+    return compare_digest(s1.encode("utf-8"), s2.encode("utf-8"))

{pyotp-2.2.8.dist-info → pyotp-2.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyotp
-Version: 2.2.8
+Version: 2.4.0
 Summary: Python One Time Password Library
 Home-page: https://github.com/pyotp/pyotp
 Author: PyOTP contributors
@@ -13,7 +13,6 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3.4
 Classifier: Programming Language :: Python :: 3.5
 Classifier: Programming Language :: Python :: 3.6
@@ -98,11 +97,15 @@ Counter-based OTPs
     hotp.verify('316439', 1401) # => True
     hotp.verify('316439', 1402) # => False
 
-Generating a base32 Secret Key
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-::
+Generating a Secret Key
+~~~~~~~~~~~~~~~~~~~~~~~
+A helper function is provided to generate a 16 character base32 secret, compatible with Google Authenticator and other OTP apps::
+
+    pyotp.random_base32()
 
-    pyotp.random_base32() # returns a 16 character base32 secret. Compatible with Google Authenticator and other OTP apps
+Some applications want the secret key to be formatted as a hex-encoded string::
+
+    pyotp.random_hex()  # returns a 32-character hex-encoded secret
 
 Google Authenticator Compatible
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -110,17 +113,27 @@ Google Authenticator Compatible
 PyOTP works with the Google Authenticator iPhone and Android app, as well as other OTP apps like Authy. PyOTP includes the
 ability to generate provisioning URIs for use with the QR Code scanner built into these MFA client apps::
 
-    pyotp.totp.TOTP('JBSWY3DPEHPK3PXP').provisioning_uri("alice@google.com", issuer_name="Secure App")
+    pyotp.totp.TOTP('JBSWY3DPEHPK3PXP').provisioning_uri(name='alice@google.com', issuer_name='Secure App')
 
     >>> 'otpauth://totp/Secure%20App:alice%40google.com?secret=JBSWY3DPEHPK3PXP&issuer=Secure%20App'
 
-    pyotp.hotp.HOTP('JBSWY3DPEHPK3PXP').provisioning_uri("alice@google.com", initial_count=0, issuer_name="Secure App")
+    pyotp.hotp.HOTP('JBSWY3DPEHPK3PXP').provisioning_uri(name="alice@google.com", issuer_name="Secure App", initial_count=0)
 
     >>> 'otpauth://hotp/Secure%20App:alice%40google.com?secret=JBSWY3DPEHPK3PXP&issuer=Secure%20App&counter=0'
 
 This URL can then be rendered as a QR Code (for example, using https://github.com/neocotic/qrious) which can then be scanned
 and added to the users list of OTP credentials.
 
+Parsing these URLs is also supported::
+
+    pyotp.parse_uri('otpauth://totp/Secure%20App:alice%40google.com?secret=JBSWY3DPEHPK3PXP&issuer=Secure%20App')
+
+    >>> <pyotp.totp.TOTP object at 0xFFFFFFFF>
+
+    pyotp.parse_uri('otpauth://hotp/Secure%20App:alice%40google.com?secret=JBSWY3DPEHPK3PXP&issuer=Secure%20App&counter=0'
+
+    >>> <pyotp.totp.HOTP object at 0xFFFFFFFF>
+
 Working example
 ~~~~~~~~~~~~~~~
 
@@ -137,10 +150,10 @@ Now run the following and compare the output::
 Links
 ~~~~~
 
-* `Project home page (GitHub) <https://github.com/pyotp/pyotp>`_
+* `Project home page (GitHub) <https://github.com/pyauth/pyotp>`_
 * `Documentation (Read the Docs) <https://pyotp.readthedocs.io/en/latest/>`_
 * `Package distribution (PyPI) <https://pypi.python.org/pypi/pyotp>`_
-* `Change log <https://github.com/pyotp/pyotp/blob/master/Changes.rst>`_
+* `Change log <https://github.com/pyauth/pyotp/blob/master/Changes.rst>`_
 * `RFC 4226: HOTP: An HMAC-Based One-Time Password <https://tools.ietf.org/html/rfc4226>`_
 * `RFC 6238: TOTP: Time-Based One-Time Password Algorithm <https://tools.ietf.org/html/rfc6238>`_
 * `ROTP <https://github.com/mdp/rotp>`_ - Original Ruby OTP library by `Mark Percival <https://github.com/mdp>`_
@@ -153,10 +166,10 @@ For new applications:
 * `WebAuthn <https://www.w3.org/TR/webauthn/>`_
 * `PyWARP <https://github.com/pyauth/pywarp>`_
 
-.. image:: https://img.shields.io/travis/pyotp/pyotp.svg
-        :target: https://travis-ci.org/pyotp/pyotp
-.. image:: https://img.shields.io/codecov/c/github/pyotp/pyotp/master.svg
-        :target: https://codecov.io/github/pyotp/pyotp?branch=master
+.. image:: https://github.com/pyauth/pyotp/workflows/Python%20package/badge.svg
+        :target: https://github.com/pyauth/pyotp/actions
+.. image:: https://img.shields.io/codecov/c/github/pyauth/pyotp/master.svg
+        :target: https://codecov.io/github/pyauth/pyotp?branch=master
 .. image:: https://img.shields.io/pypi/v/pyotp.svg
         :target: https://pypi.python.org/pypi/pyotp
 .. image:: https://img.shields.io/pypi/l/pyotp.svg

pyotp-2.4.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyotp/__init__.py,sha256=z4ctyTv87_opGZTwvwlM8_EBaDaJsmGPxrKuipjxcg4,3223
+pyotp/compat.py,sha256=i-pxcRWpShxkMTMucqPJdPJibYUaVtEhL9pyweKQ84k,209
+pyotp/hotp.py,sha256=07e4wuWnCc9OJnQ8YX39vtsjSpSXPN_cue7S728Lmv0,2048
+pyotp/otp.py,sha256=AHBnORBETYKnLqYzJUZnram6JddpNFvnHzedRpQbbyk,2479
+pyotp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyotp/totp.py,sha256=uawrXOPiimcCys0WdYMD0vJqrIoe4l648Sv4R1mURT4,3140
+pyotp/utils.py,sha256=6HBmC7ILxGOlFB6499Py_fufE4eyQvd4PU1gRngsydU,2836
+pyotp-2.4.0.dist-info/LICENSE,sha256=f1C5lELlDYN3777_-tBjT7mgRr6HCXrzppnWNwsOG2M,1174
+pyotp-2.4.0.dist-info/METADATA,sha256=DRJnqAlfj7tT58wV4Ci8wcU9mwO6XrJILgf1Sg4t-dg,8539
+pyotp-2.4.0.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+pyotp-2.4.0.dist-info/top_level.txt,sha256=rFDgz6Sm4nbkYk6tlSRiMcJPyYdnY6LcZiAaYTxVc5k,6
+pyotp-2.4.0.dist-info/RECORD,,

{pyotp-2.2.8.dist-info → pyotp-2.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.33.4)
+Generator: bdist_wheel (0.34.2)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

pyotp-2.2.8.dist-info/RECORD

@@ -1,11 +0,0 @@
-pyotp/__init__.py,sha256=hamm6NeVXq0-y6jlBlVnO7oct5n5EHWltinaBxge8xk,685
-pyotp/compat.py,sha256=QVb4buImn4PyP0qe5uLiXsO2-p4ItTGl01Vbt2dILNE,222
-pyotp/hotp.py,sha256=Jotukhsjpwpbx05iHHPYgH0HzpAFUvRAnWauQ_4N69M,1772
-pyotp/otp.py,sha256=QPyHxZ7fY7_zlrMVVveGQrCfn6gatpaHO3-ok9XwCaU,2344
-pyotp/totp.py,sha256=EHnv9irTDDt2cLUIxy3w_80QaqtduAM08Xq7rU2bIm0,3168
-pyotp/utils.py,sha256=smffRHfGU9fwpzmkLrKz6Z3xt07-PEJ2lf8mJ1Tvn7I,3513
-pyotp-2.2.8.dist-info/LICENSE,sha256=f1C5lELlDYN3777_-tBjT7mgRr6HCXrzppnWNwsOG2M,1174
-pyotp-2.2.8.dist-info/METADATA,sha256=OHVMnmqShG3BbmFJPG9C6bi50zdvLZ27XJHr_NOq148,8004
-pyotp-2.2.8.dist-info/WHEEL,sha256=h_aVn5OB2IERUjMbi2pucmR_zzWJtk303YXvhh60NJ8,110
-pyotp-2.2.8.dist-info/top_level.txt,sha256=rFDgz6Sm4nbkYk6tlSRiMcJPyYdnY6LcZiAaYTxVc5k,6
-pyotp-2.2.8.dist-info/RECORD,,