PyOTP 1.3.0__tar.gz

pyotp-1.3.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: pyotp
+Version: 1.3.0
+Summary: https://github.com/nathforge/pyotp
+Home-page: https://github.com/nathforge/pyotp
+Author: Mark Percival (ported by Nathan Reynolds to Python)
+Author-email: nath@nreynolds.co.uk
+License: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN

pyotp-1.3.0/README.markdown

@@ -0,0 +1,78 @@
+# PYOTP - The Python One Time Password Library
+
+A Python library for generating one time passwords according to[ RFC 4226 ](http://tools.ietf.org/html/rfc4226) and the [ HOTP RFC ](http://tools.ietf.org/html/draft-mraihi-totp-timebased-00), ported from Mark Percival's [ ROTP ](https://github.com/mdp/rotp).
+
+This is compatible with Google Authenticator apps available for Android and iPhone, and now in use on GMail
+
+## Quick overview of using One Time Passwords on your phone
+
+* OTP's involve a shared secret, stored both on the phone and the server
+* OTP's can be generated on a phone without internet connectivity(AT&T mode)
+* OTP's should always be used as a second factor of authentication(if your phone is lost, you account is still secured with a password)
+* Google Authenticator allows you to store multiple OTP secrets and provision those using a QR Code(no more typing in the secret)
+
+## Installation
+
+    pip install pyotp
+
+## Use
+
+### Time based OTP's
+
+    totp = pyotp.TOTP('base32secret3232')
+    totp.now() # => 492039
+
+    # OTP verified for current time
+    totp.verify(492039) # => True
+    time.sleep(30)
+    totp.verify(492039) # => False
+
+### Counter based OTP's
+
+    hotp = pyotp.HOTP('base32secret3232')
+    hotp.at(0) # => 260182
+    hotp.at(1) # => 55283
+    hotp.at(1401) # => 316439
+
+    # OTP verified with a counter
+    hotp.verify(316439, 1401) # => True
+    hotp.verify(316439, 1402) # => False
+
+### Generating a Base32 Secret key
+
+    pyotp.random_base32() # returns a 16 character base32 secret. Compatible with Google Authenticator
+
+### Google Authenticator Compatible
+
+The library works with the Google Authenticator iPhone and Android app, and also
+includes the ability to generate provisioning URI's for use with the QR Code scanner
+built into the app.
+
+    totp.provisioning_uri("alice@google.com") # => 'otpauth://totp/alice@google.com?secret=JBSWY3DPEHPK3PXP'
+    hotp.provisioning_uri("alice@google.com", 0) # => 'otpauth://hotp/alice@google.com?secret=JBSWY3DPEHPK3PXP&counter=0'
+
+This can then be rendered as a QR Code which can then be scanned and added to the users
+list of OTP credentials.
+
+#### Working example
+
+Scan the following barcode with your phone, using Google Authenticator
+
+![QR Code for OTP](http://chart.apis.google.com/chart?cht=qr&chs=250x250&chl=otpauth%3A%2F%2Ftotp%2Falice%40google.com%3Fsecret%3DJBSWY3DPEHPK3PXP)
+
+Now run the following and compare the output
+
+    import pyotp
+    totp = pyotp.TOTP("JBSWY3DPEHPK3PXP")
+    print "Current OTP: %s" % totp.now()
+
+### Changelog
+
+####1.3.0
+
+- Ported to Python
+
+### See also:
+
+Original Ruby version of ROTP by [Mark Percival](https://github.com/mdp) - [ROTP](https://github.com/mdp/rotp)
+PHP port of ROTP by [Le Lag](https://github.com/lelag) - [OTPHP](https://github.com/lelag/otphp)

pyotp-1.3.0/setup.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+
+from distutils.core import setup
+
+setup(
+    version='1.3.0',
+    url='https://github.com/nathforge/pyotp',
+    name='pyotp',
+    description='https://github.com/nathforge/pyotp',
+    author='Mark Percival (ported by Nathan Reynolds to Python)',
+    author_email='nath@nreynolds.co.uk',
+    packages=['pyotp'],
+    package_dir={'': 'src'},
+)

pyotp-1.3.0/src/pyotp/__init__.py

@@ -0,0 +1,16 @@
+from pyotp.otp import OTP
+from pyotp.hotp import HOTP
+from pyotp.totp import TOTP
+import base64
+import random
+
+
+VERSION = '1.3.0'
+
+
+def random_base32(length=16, random=random.SystemRandom(),
+                  chars=base64._b32alphabet.values()):
+    return ''.join(
+        random.choice(chars)
+        for i in xrange(length)
+    )

pyotp-1.3.0/src/pyotp/hotp.py

@@ -0,0 +1,35 @@
+from pyotp.otp import OTP
+import urllib
+
+
+class HOTP(OTP):
+    def at(self, count):
+        """
+        Generates the OTP for the given count
+        @param [Integer] count counter
+        @returns [Integer] OTP
+        """
+        return self.generate_otp(count)
+    
+    def verify(self, otp, counter):
+        """
+        Verifies the OTP passed in against the current time OTP
+        @param [String/Integer] otp the OTP to check against
+        @param [Integer] counter the counter of the OTP
+        """
+        return otp == self.at(counter)
+    
+    def provisioning_uri(self, name, initial_count=0):
+        """
+        Returns the provisioning URI for the OTP
+        This can then be encoded in a QR Code and used
+        to provision the Google Authenticator app
+        @param [String] name of the account
+        @param [Integer] initial_count starting counter value, defaults to 0
+        @return [String] provisioning uri
+        """
+        return 'otpauth://hotp/%(name)s?secret=%(secret)s&counter=%(initial_count)s' % {
+            'name': urllib.quote(name, safe='@'),
+            'secret': self.secret,
+            'initial_count': initial_count,
+        }

pyotp-1.3.0/src/pyotp/otp.py

@@ -0,0 +1,54 @@
+import base64
+import hashlib
+import hmac
+
+
+class OTP(object):
+    def __init__(self, s, digits=6, digest=hashlib.sha1):
+        """
+        @param [String] secret in the form of base32
+        @option options digits [Integer] (6)
+            Number of integers in the OTP
+            Google Authenticate only supports 6 currently
+        @option options digest [Callable] (hashlib.sha1)
+            Digest used in the HMAC
+            Google Authenticate only supports 'sha1' currently
+        @returns [OTP] OTP instantiation
+        """
+        self.digits = digits
+        self.digest = digest
+        self.secret = s
+    
+    def generate_otp(self, input):
+        """
+        @param [Integer] input the number used seed the HMAC
+        Usually either the counter, or the computed integer
+        based on the Unix timestamp
+        """
+        hmac_hash = hmac.new(
+            self.byte_secret(),
+            self.int_to_bytestring(input),
+            self.digest,
+        ).digest()
+        
+        offset = ord(hmac_hash[19]) & 0xf
+        code = ((ord(hmac_hash[offset]) & 0x7f) << 24 |
+            (ord(hmac_hash[offset + 1]) & 0xff) << 16 |
+            (ord(hmac_hash[offset + 2]) & 0xff) << 8 |
+            (ord(hmac_hash[offset + 3]) & 0xff))
+        return code % 10 ** self.digits
+    
+    def byte_secret(self):
+        return base64.b32decode(self.secret, casefold=True)
+    
+    def int_to_bytestring(self, int, padding=8):
+        """
+        Turns an integer to the OATH specified
+        bytestring, which is fed to the HMAC
+        along with the secret
+        """
+        result = []
+        while int != 0:
+            result.append(chr(int & 0xFF))
+            int = int >> 8
+        return ''.join(reversed(result)).rjust(padding, '\0')

pyotp-1.3.0/src/pyotp/totp.py

@@ -0,0 +1,57 @@
+from pyotp.otp import OTP
+import datetime
+import time
+import urllib
+
+
+class TOTP(OTP):
+    def __init__(self, *args, **kwargs):
+        """
+        @option options [Integer] interval (30) the time interval in seconds for OTP
+            This defaults to 30 which is standard.
+        """
+        self.interval = kwargs.pop('interval', 30)
+        super(TOTP, self).__init__(*args, **kwargs)
+    
+    def at(self, for_time):
+        """
+        Accepts either a Unix timestamp integer or a Time object.
+        Time objects will be adjusted to UTC automatically
+        @param [Time/Integer] time the time to generate an OTP for
+        """
+        if not isinstance(for_time, datetime.datetime):
+            for_time = datetime.datetime.fromtimestamp(int(for_time))
+        return self.generate_otp(self.timecode(for_time))
+    
+    def now(self):
+        """
+        Generate the current time OTP
+        @return [Integer] the OTP as an integer
+        """
+        return self.generate_otp(self.timecode(datetime.datetime.now()))
+    
+    def verify(self, otp, for_time=None):
+        """
+        Verifies the OTP passed in against the current time OTP
+        @param [String/Integer] otp the OTP to check against
+        """
+        if for_time is None:
+            for_time = datetime.datetime.now()
+        return otp == self.at(for_time)
+    
+    def provisioning_uri(self, name):
+        """
+        Returns the provisioning URI for the OTP
+        This can then be encoded in a QR Code and used
+        to provision the Google Authenticator app
+        @param [String] name of the account
+        @return [String] provisioning uri
+        """
+        return 'otpauth://totp/%(name)s?secret=%(secret)s' % {
+            'name': urllib.quote(name, safe='@'),
+            'secret': self.secret,
+        }
+    
+    def timecode(self, for_time):
+        i = time.mktime(for_time.timetuple())
+        return int(i / self.interval)

pyotp-1.3.0/test.py

@@ -0,0 +1,87 @@
+from __future__ import with_statement
+import datetime
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+import pyotp
+
+
+class HOTPExampleValuesFromTheRFC(unittest.TestCase):
+    def testMatchTheRFC(self):
+        # 12345678901234567890 in Bas32
+        # GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ
+        hotp = pyotp.HOTP('GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ')
+        self.assertEqual(hotp.at(0), 755224)
+        self.assertEqual(hotp.at(1), 287082)
+        self.assertEqual(hotp.at(2), 359152)
+        self.assertEqual(hotp.at(3), 969429)
+        self.assertEqual(hotp.at(4), 338314)
+        self.assertEqual(hotp.at(5), 254676)
+        self.assertEqual(hotp.at(6), 287922)
+        self.assertEqual(hotp.at(7), 162583)
+        self.assertEqual(hotp.at(8), 399871)
+        self.assertEqual(hotp.at(9), 520489)
+    
+    def testVerifyAnOTPAndNowAllowReuse(self):
+        hotp = pyotp.HOTP('GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ')
+        self.assertTrue(hotp.verify(520489, 9))
+        self.assertFalse(hotp.verify(520489, 10))
+    
+    def testProvisioningURI(self):
+        hotp = pyotp.HOTP('wrn3pqx5uqxqvnqr')
+        self.assertEqual(hotp.provisioning_uri('mark@percival'), 'otpauth://hotp/mark@percival?secret=wrn3pqx5uqxqvnqr&counter=0')
+
+
+class TOTPExampleValuesFromTheRFC(unittest.TestCase):
+    def testMatchTheRFC(self):
+        totp = pyotp.TOTP('GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ')
+        self.assertEqual(totp.at(1111111111), 50471)
+        self.assertEqual(totp.at(1234567890), 5924)
+        self.assertEqual(totp.at(2000000000), 279037)
+    
+    def testMatchTheGoogleAuthenticatorOutput(self):
+        totp = pyotp.TOTP('wrn3pqx5uqxqvnqr')
+        with Timecop(1297553958):
+            self.assertEqual(totp.now(), 102705)
+    
+    def testValidateATimeBasedOTP(self):
+        totp = pyotp.TOTP('wrn3pqx5uqxqvnqr')
+        with Timecop(1297553958):
+            self.assertTrue(totp.verify(102705))
+        with Timecop(1297553958 + 30):
+            self.assertFalse(totp.verify(102705))
+    
+    def testProvisioningURI(self):
+        totp = pyotp.TOTP('wrn3pqx5uqxqvnqr')
+        self.assertEqual(totp.provisioning_uri('mark@percival'), 'otpauth://totp/mark@percival?secret=wrn3pqx5uqxqvnqr')
+
+
+class Timecop(object):
+    """
+    Half-assed clone of timecop.rb, just enough to pass our tests.
+    """
+    
+    def __init__(self, freeze_timestamp):
+        self.freeze_timestamp = freeze_timestamp
+    
+    def __enter__(self):
+        self.real_datetime = datetime.datetime
+        datetime.datetime = self.frozen_datetime()
+    
+    def __exit__(self, type, value, traceback):
+        datetime.datetime = self.real_datetime
+    
+    def frozen_datetime(self):
+        class FrozenDateTime(datetime.datetime):
+            @classmethod
+            def now(cls):
+                return cls.fromtimestamp(timecop.freeze_timestamp)
+        
+        timecop = self
+        return FrozenDateTime
+
+
+if __name__ == '__main__':
+    unittest.main()