def test_change_email_when_wrong_password(self):
        from pyotp import TOTP

        self.create_user()
        self.login()
        self.add_evidence_sms()
        self.generate_sms_code(self.principal)

        validation_token = ValidationToken.objects.create(
            identifier='email',
            identifier_value=self.email,
            principal=self.principal,
            type='email_change',
        )
        code = (OneTimePasswordCredential.objects.last())

        totp = TOTP(code.salt.decode())

        data = {
            'sms_code': totp.now(),
            'password': '******',
            'secret': validation_token.secret
        }

        response = self.client.put(self.email_change_insecure_url, data=data)

        self.assertResponseStatus(response, status.HTTP_400_BAD_REQUEST)
        self.assertListEqual(
            response.data.get('error').get('password'), ['password_invalid'])
        self.assertListEqual(
            response.data.get('details').get('password'),
            ['Password is incorrect'])
Exemple #2
0
 def __init__(self, token):
     """
     :param token: the OTP token.
     """
     TOTP.__init__(self, token)
     self.pin = None
     self.update()
Exemple #3
0
    def verify(self, user_name, object_dn, key):

        # Do we have read permissions for the requested attribute
        self.__check_acl(user_name, object_dn, "r")

        # Get the object for the given dn
        uuid = self.__dn_to_uuid(object_dn)
        factor_method = self.get_method_from_user(uuid)
        user_settings = self.__settings[uuid] if uuid in self.__settings else {}
        if factor_method == "otp":
            totp = TOTP(user_settings.get('otp_secret'))
            return totp.verify(key)

        elif factor_method == "u2f":

            challenge = user_settings.pop('_u2f_challenge_')
            data = loads(key)
            device, c, t = complete_authentication(challenge, data, [self.facet])
            return {
                'keyHandle': device['keyHandle'],
                'touch': t,
                'counter': c
            }

        elif factor_method is None:
            return True

        return False
Exemple #4
0
    def is_correct_two_factor_code(self, code: str) -> bool:
        """Verify that a TOTP/backup code is correct."""
        if not self.two_factor_secret:
            raise ValueError("User does not have 2FA enabled")

        totp = TOTP(self.two_factor_secret)

        code = code.strip().replace(" ", "").lower()

        # some possible user input (such as unicode) can cause an error in the totp
        # library, catch that and treat it the same as an invalid code
        try:
            is_valid_code = totp.verify(code)
        except TypeError:
            is_valid_code = False

        if is_valid_code:
            return True
        elif self.two_factor_backup_codes and code in self.two_factor_backup_codes:
            # Need to set the attribute so SQLAlchemy knows it changed
            self.two_factor_backup_codes = [
                backup_code
                for backup_code in self.two_factor_backup_codes
                if backup_code != code
            ]
            return True

        return False
    def test_change_email_when_success(self):
        from pyotp import TOTP

        self.create_user()
        self.login()
        self.add_evidence_sms()
        self.generate_sms_code(self.principal)

        email_to_change = "*****@*****.**"
        validation_token = ValidationToken.objects.create(
            identifier='email',
            identifier_value=email_to_change,
            principal=self.principal,
            type='email_change',
        )
        code = (OneTimePasswordCredential.objects.last())

        totp = TOTP(code.salt.decode())

        data = {
            'otp_code': totp.now(),
            'password': self.password,
            'secret': validation_token.secret
        }

        response = self.client.put(self.email_change_insecure_url, data=data)

        changed_pricipal = Principal.objects.last()

        self.assertResponseStatus(response)
        self.assertEquals(changed_pricipal.email, email_to_change)
Exemple #6
0
    def verify(self, user_name, object_dn, key):

        # Do we have read permissions for the requested attribute
        self.__check_acl(user_name, object_dn, "r")

        # Get the object for the given dn
        uuid = self.__dn_to_uuid(object_dn)
        factor_method = self.get_method_from_user(uuid)
        user_settings = self.__settings[
            uuid] if uuid in self.__settings else {}
        if factor_method == "otp":
            totp = TOTP(user_settings.get('otp_secret'))
            return totp.verify(key)

        elif factor_method == "u2f":

            challenge = user_settings.pop('_u2f_challenge_')
            data = loads(key)
            device, c, t = complete_authentication(challenge, data,
                                                   [self.facet])
            return {'keyHandle': device['keyHandle'], 'touch': t, 'counter': c}

        elif factor_method is None:
            return True

        return False
    def test_password_change_secure(self):
        from talos.models import OneTimePasswordCredential
        from talos.models import Principal
        from pyotp import TOTP

        self.create_user()
        self.login()
        self.add_evidence_google()

        self.assertEqual(OneTimePasswordCredential.objects.all().count(), 1)
        google_otp_credential = OneTimePasswordCredential.objects.last()
        secret = google_otp_credential.salt
        totp = TOTP(secret)
        google_otp_code = totp.now()

        data = {
            'password': self.password,
            'new_password': '******',
            'otp_code': google_otp_code
        }

        response = self.client.put(self.url, data, format='json')

        self.assertResponseStatus(response, status.HTTP_200_OK)

        principal = Principal.objects.last()
        self.assertFalse(principal.check_password(self.password))
        self.assertTrue(principal.check_password('1234567'))
Exemple #8
0
    def verify(self, user_name, object_dn, key):

        # Do we have read permissions for the requested attribute
        self.__check_acl(user_name, object_dn, "r")

        # Get the object for the given dn
        user = ObjectProxy(object_dn)
        factor_method = self.get_method_from_user(user)
        user_settings = self.__settings[
            user.uuid] if user.uuid in self.__settings else {}
        if factor_method == "otp":
            totp = TOTP(user_settings.get('otp_secret'))
            return totp.verify(key)

        elif factor_method == "u2f":
            devices = [
                DeviceRegistration.wrap(device)
                for device in user_settings.get('_u2f_devices_', [])
            ]

            challenge = user_settings.pop('_u2f_challenge_')
            data = loads(key)
            c, t = verify_authenticate(devices, challenge, data, [self.facet])
            return {'touch': t, 'counter': c}

        elif factor_method is None:
            return True

        return False
Exemple #9
0
def auth():
    if not current_user.can_admin:
        abort(404)
    form = TOTPForm()
    try:
        user_secret = UserMetadata.get((UserMetadata.uid == current_user.uid)
                                       & (UserMetadata.key == 'totp_secret'))
    except UserMetadata.DoesNotExist:
        return engine.get_template('admin/totp.html').render({
            'authform':
            form,
            'error':
            _('No TOTP secret found.')
        })
    if form.validate_on_submit():
        totp = TOTP(user_secret.value)
        if totp.verify(form.totp.data):
            session['apriv'] = time.time()
            return redirect(url_for('admin.index'))
        else:
            return engine.get_template('admin/totp.html').render({
                'authform':
                form,
                'error':
                _('Invalid or expired token.')
            })
    return engine.get_template('admin/totp.html').render({
        'authform': form,
        'error': None
    })
Exemple #10
0
def index():
    if request.method == "POST":
        totp = TOTP(app.config["TOTP_SECRET"])
        if "authcode" not in request.form:
            flash("Missing OTP", 'error')
            return redirect(request.url)

        if not totp.verify(request.form["authcode"]):
            flash("Incorrect OTP", "error")
            return redirect(request.url)

        if not request.files:
            flash("No files field", "error")
            return redirect(request.url)

        files = (f for f in request.files.getlist("files") if f.filename != "")

        if not files:
            flash("No files specified", "error")
            return redirect(request.url)

        for file in files:
            file.save(os.path.join(app.config["UPLOAD_DIR"], file.filename))

        flash("Files uploaded correctly!", "success")
        return redirect("/drop")

    return render_template("drop.html")
Exemple #11
0
    def verify(self, user_name, object_dn, key):

        # Do we have read permissions for the requested attribute
        self.__check_acl(user_name, object_dn, "r")

        # Get the object for the given dn
        user = ObjectProxy(object_dn)
        factor_method = self.get_method_from_user(user)
        user_settings = self.__settings[user.uuid] if user.uuid in self.__settings else {}
        if factor_method == "otp":
            totp = TOTP(user_settings.get('otp_secret'))
            return totp.verify(key)

        elif factor_method == "u2f":
            devices = [DeviceRegistration.wrap(device)
                       for device in user_settings.get('_u2f_devices_', [])]

            challenge = user_settings.pop('_u2f_challenge_')
            data = loads(key)
            c, t = verify_authenticate(devices, challenge, data, [self.facet])
            return {
                'touch': t,
                'counter': c
            }

        elif factor_method is None:
            return True

        return False
Exemple #12
0
def main():
    token = input("Please input your token found on your android: ")
    data = list(bytes.fromhex(token))
    assert len(data) == len(masks)
    # xor every byte with masks
    for i in range(0, len(data)):
        b = data[i]
        m = masks[i]
        b = b ^ m
        data[i] = b
    data_str = bytes(data).decode()
    secret_hex = data_str[:40]
    serial = data_str[40:]
    # use base32 to encode the first 40 bytes to be used in totp
    secret = base64.b32encode(bytes.fromhex(secret_hex)).decode()
    from pyotp import TOTP
    totp = TOTP(secret, digits=8)
    key = totp.now()
    print(secret)
    print(serial)
    print(key)

    url = "otpauth://totp/{0}:{0}?secret={1}&issuer={0}&digits=8".format(
        serial, secret)
    print(url)
 def __init__(self, token):
     """
     :param token: the OTP token.
     """
     TOTP.__init__(self, token)
     self.pin = None
     self.update()
    def otp(self, otp: str) -> None:
        updated = False

        # Some sites give the secret in chunks split by spaces for easy reading
        # lets strip those as they'll produce an invalid secret.
        otp = otp.replace(" ", "")

        if not otp and self._otp:
            # Delete existing
            self._otp = None
            self._element.delete_custom_property("otp")
            self.updated()
        elif self._otp and self._otp.secret != otp:
            # Changing an existing OTP
            self._otp.secret = otp
            updated = True
        elif otp:
            # Creating brand new OTP.
            self._otp = TOTP(otp, issuer=self.name)
            updated = True

        if updated:
            self._element.set_custom_property("otp",
                                              self._otp.provisioning_uri())
            self.updated()
Exemple #15
0
def test_user_change_password(journalist_app, test_journo):
    """Test that a journalist can successfully login after changing
    their password"""

    with journalist_app.test_client() as app:
        _login_user(app, test_journo)
        # change password
        new_pw = 'another correct horse battery staply long password'
        assert new_pw != test_journo['password']  # precondition
        app.post('/account/new-password',
                 data=dict(password=new_pw,
                           current_password=test_journo['password'],
                           token=TOTP(test_journo['otp_secret']).now()))
        # logout
        app.get('/logout')

    # start a new client/context to be sure we've cleared the session
    with journalist_app.test_client() as app:
        # login with new credentials should redirect to index page
        with InstrumentedApp(journalist_app) as ins:
            resp = app.post('/login',
                            data=dict(username=test_journo['username'],
                                      password=new_pw,
                                      token=TOTP(
                                          test_journo['otp_secret']).now()))
            ins.assert_redirects(resp, '/')
Exemple #16
0
def get_otpauth_url(serial: str, secret: str) -> str:
    """
	Get the OTPAuth URL for the serial/secret pair
	https://github.com/google/google-authenticator/wiki/Key-Uri-Format
	"""
    totp = TOTP(secret, digits=8)

    return totp.provisioning_uri(serial, issuer_name="Blizzard")
Exemple #17
0
 def __init__(self, log_to_file, bank_channel_id, bank_role_id, totp_secret):
     super().__init__()
     self._log_to_file = log_to_file
     self._bank_channel_id = bank_channel_id
     self._bank_role_id = bank_role_id
     self._totp = TOTP(totp_secret)
     self.bank_roles = []
     self.bank_channels = []
Exemple #18
0
 def __init__(self, log_to_file, bank_channel_id, bank_role_id,
              guild_server_id, totp_secret):
     super().__init__()
     self._log_to_file = log_to_file
     self._bank_channel_id = bank_channel_id
     self._bank_role_id = bank_role_id
     self._guild_server_id = guild_server_id
     self._totp = TOTP(totp_secret)
def main():
    parser = ArgumentParser(path.basename(__file__))
    parser.add_argument('--source-url', required=True)
    parser.add_argument('--journo-url', required=True)
    args = parser.parse_args()

    totp = TOTP('JHCOGO7VCER3EJ4L')
    auth = UserPassOtp('journalist', 'WEjwn8ZyczDhQSK24YKM8C9a', totp.now())
    client = Client(args.journo_url, auth)
Exemple #20
0
    def set_totp(self, totp_secret):
        """Set the secret for generating MFA tokens to authorize

        Args:
          totp_secret (str): The secret token set on an Application in the Gem
            Developer Console.
        """
        self.totp = TOTP(totp_secret)
        return self
Exemple #21
0
 def create(self):
     """
         Create a tfa code
     """
     try:
         self._totp = TOTP(self._token)
         self._secret_code = self._totp.now()
     except Exception as e:
         Logger.error("Couldn't generate two factor code : %s" % str(e))
Exemple #22
0
 def __init__(self, master=None):
     super().__init__(master)
     self.master = master
     self.totp = TOTP(get_secret())
     self.totp_qr = get_secret_qr(self.totp)
     self.create_widgets()
     self.pack()
     self.update_pin_label()
     self.set_scheduler()
Exemple #23
0
 def create(self):
     """
         Create a tfa code
     """
     try:
         self.totp = TOTP(self.secret_code)
         self.password = self.totp.now()
     except Exception as e:
         logging.error("Couldn't generate two factor code : %s" % str(e))
Exemple #24
0
    def __enable_otp(self, user):
        if user.uuid not in self.__settings:
            self.__settings[user.uuid] = {}

        user_settings = self.__settings[user.uuid]
        secret = random_base32()
        totp = TOTP(secret)
        user_settings['otp_secret'] = secret
        self.__save_settings()
        return totp.provisioning_uri("%s@%s.gosa" % (user.uid, self.env.domain))
Exemple #25
0
    def __enable_otp(self, user):
        if user.uuid not in self.__settings:
            self.__settings[user.uuid] = {}

        user_settings = self.__settings[user.uuid]
        secret = random_base32()
        totp = TOTP(secret)
        user_settings['otp_secret'] = secret
        self.__save_settings()
        return totp.provisioning_uri("%s@%s.gosa" %
                                     (user.uid, self.env.domain))
Exemple #26
0
def show(ctx: click.Context, serial: str, interactive: bool) -> None:
	secret = ctx.obj.get_secret(serial)
	totp = TOTP(secret, digits=8)
	if interactive:
		click.echo("Ctrl-C to exit")
		while True:
			token = totp.now()
			sys.stdout.write("\r" + token)
			sys.stdout.flush()
			sleep(1)
	else:
		click.echo(totp.now())
Exemple #27
0
 def test_2fa(self):
     """The authentication should be failed because otp is not correct."""
     from pyotp import TOTP
     otp = TOTP(self.secret.secret)
     query = {
         "username": "******",
         "password": "******",
         "otp_auth": str((int(otp.now()) + 1) % 1000000).zfill(6)
     }
     form = self.form_cls(None, query)
     self.assertFalse(form.is_valid())
     self.assertTrue(form.errors)
    def validate_code(self, code):
        from pyotp import TOTP

        if not self.request.session.get('secret_key_activated', False):
            raise serializers.ValidationError(
                'You did not activated google authenticator',
                code=constants.GOOGLE_OTP_NOT_ACTIVATED_CODE)

        totp = TOTP(self.request.session['temp_otp_secret_key'])
        if not totp.verify(code, valid_window=1):
            raise serializers.ValidationError(
                'Code is incorrect', code=constants.GOOGLE_OTP_INVALID_CODE)
        return code
Exemple #29
0
def OTP(request):
     getd = unquote(request.GET.get('key'))
     signerverify = signer.unsign(getd, max_age=int(settings.PYADSELFSERVICE_STOUT))
     if request.method == 'POST':
        form = renderotp(request.POST)
        if form.is_valid():
           base32 = calc_base32(signerverify)
           totp = TOTP(base32)
           otp = totp.verify(form.cleaned_data['otp'], valid_window=5)
           data = signer.sign(signerverify)
           if otp == True:
             return HttpResponseRedirect('/resetpass?key=' + quote(data))
     return render(request, 'index.html', {'form': renderotp()})
Exemple #30
0
 def test_2fa(self):
     """2fa should be valid."""
     from pyotp import TOTP
     otp = TOTP(self.secret.secret)
     query = {
         "username": "******",
         "password": "******",
         "otp_auth": otp.now()
     }
     form = self.form_cls(None, query)
     self.assertTrue(form.is_valid(),
                     "Form is invalid: {}".format(dict(form.errors)))
     self.assertDictEqual(query, form.clean())
Exemple #31
0
def token_print(secret, n):
    preferred_offset = 0 if time_left > 7 else 1
    for i in range(n):
        totp = TOTP(secret)
        token = totp.at(cur_time, i)
        token_formatted = token[:3] + '-' + token[3:]
        if (i == preferred_offset):
            token_formatted = colored(token_formatted, "green")
            try: 
                copy(token)
            except Exception as e:
                pass
        print(token_formatted)
    def test_clear_evidences_for_other_users(self):
        from datetime import datetime, timedelta
        from talos.models import OneTimePasswordCredential
        from talos.models import Principal
        from talos.models import Session
        from django.db.models import Q
        from pyotp import TOTP

        self.create_user()
        self.login()
        self.add_evidence_sms()

        self.assertEqual(OneTimePasswordCredential.objects.all().count(), 1)
        sms_otp_credential = OneTimePasswordCredential.objects.last()

        totp = TOTP(sms_otp_credential.salt.decode())
        sms_code = totp.now()

        data = {
            'password': self.password,
            'new_password': '******',
            'otp_code': sms_code
        }

        Session.objects.create(principal=self.principal, evidences='evidences')
        Session.objects.create(principal=self.principal, evidences='evidences')

        # Add another Session where valid_till is invalid (less than current time)
        Session.objects.create(principal=self.principal,
                               evidences='evidences',
                               valid_till=datetime.now() - timedelta(hours=24))

        self.assertEqual(4, Session.objects.all().count())

        response = self.client.put(self.url, data, format='json')

        self.assertResponseStatus(response, status.HTTP_200_OK)

        principal = Principal.objects.last()
        self.assertFalse(principal.check_password(self.password))
        self.assertTrue(principal.check_password('1234567'))

        # Two row has been updated correctly (principal, valid_till)
        self.assertEqual(
            2,
            Session.objects.filter(principal=self.principal,
                                   evidences=None).count())
        self.assertEqual(
            2,
            Session.objects.filter(Q(principal=self.principal),
                                   ~Q(evidences=None)).count())
Exemple #33
0
    def authenticate(self, request=None, **kwargs):
        """Check form validity."""
        django_version = tuple(
            [int(s) for s in django.get_version().split(".")])
        otp_auth = kwargs.pop("otp_auth", None)
        auth_user = partial(
            super(OTPAuthenticationBackend, self).authenticate, **kwargs)

        user = auth_user() if django_version < (1, 11) else auth_user(request)
        if hasattr(user, "otp_secret"):
            auth_provider = TOTP(user.otp_secret.secret)
            if not auth_provider.verify(otp_auth):
                user = None
        return user
Exemple #34
0
 def get(self, request, totp):
     chatrooms = Chatroom.objects.all()
     for chatroom in chatrooms:
         salt = chatroom.salt
         validator = TOTP(salt)
         if validator.verify(totp):
             data = ChatroomSerializer(chatroom).data
             token = jwt.encode(data, SECRET_KEY)
             body = {"token": token}
             body.update(
                 serializer_to_body(ChatroomSerializer, chatroom,
                                    "chatroom"))
             return Response(body, status=status.HTTP_200_OK)
     return Response(status=status.HTTP_403_FORBIDDEN)
Exemple #35
0
def auth(userID,OTP,path = 'Unknow'):
    from pyotp import TOTP
    from setting import OTPAdminLOG, Log_t_format
    from time import strftime, localtime as now

    User = OTPKeys[int(userID)]
    OTPi = TOTP(User[1])
    f = open(OTPAdminLOG,'a')
    if (OTPi.verify(OTP)):
        f.writelines( strftime(Log_t_format,now())+"\t"+path+"\tAuthencate Successful\n" )
        f.close()
        return True
    else:
        f.writelines( strftime(Log_t_format,now())+"\t"+path+"\tAuthencate Failed!!!!\n" )
        f.close()
        return False
    def set_totp(self, totp_secret):
        """Set the secret for generating MFA tokens to authorize

        Args:
          totp_secret (str): The secret token set on an Application in the Gem
            Developer Console.
        """
        self.totp = TOTP(totp_secret)
        return self
Exemple #37
0
class Code:
    password = None

    def __init__(self, secret_code):
        self.secret_code = secret_code
        self.create()

    @staticmethod
    def is_valid(code):
        """
            Check if the secret code is a valid one
        """
        try:
            b32decode(code, casefold=True)
            return True
        except (binascii.Error, ValueError):
            return False

    def create(self):
        """
            Create a tfa code
        """
        try:
            self.totp = TOTP(self.secret_code)
            self.password = self.totp.now()
        except Exception as e:
            logging.error("Couldn't generate two factor code : %s" % str(e))

    def update(self):
        """
            Update the code
        """
        self.password = self.totp.now()

    def get_secret_code(self):
        try:
            if self.password:
                return self.password
            else:
                raise AttributeError
        except AttributeError as e:
            logging.error("Couldn't generate the code : %s " % str(e))
            return None
Exemple #38
0
class Application(Wrapper, Updatable):
    """Representation of a Gem integration.

    Attributes:
      api_token (str)
      totp (pyotp.TOTP): A TOTP MFA token generator (initialized with set_totp)
      users (round.Users): A collection of Users who have an active device
        authorization on this Application.
    """

    def set_totp(self, totp_secret):
        """Set the secret for generating MFA tokens to authorize

        Args:
          totp_secret (str): The secret token set on an Application in the Gem
            Developer Console.
        """
        self.totp = TOTP(totp_secret)
        return self

    def get_mfa(self):
        """Return the currently-valid MFA token for this application."""
        token = str(self.totp.now())
        # PyOTP doesn't pre-pad tokens shorter than 6 characters
        # ROTP does, so we have to.
        while len(token) < 6:
            token = '0{}'.format(token)
        return token

    def reset(self, *args):
        """Resets any of the tokens for this Application.
        Note that you may have to reauthenticate afterwards.

        Usage:
          application.reset('api_token')
          application.reset('api_token', 'totp_secret')

        Args:
          *args (list of str): one or more of
            ['api_token', 'subscription_token', 'totp_secret']

        Returns:
          The Application.
        """
        self.resource = self.resource.reset(list(args))
        return self

    @property
    @cacheable
    def users(self):
        """Returned the cached Users associated with this application."""
        return self.get_users()

    def get_users(self, fetch=True):
        """Return this Applications's users object, populating it if fetch
        is True."""
        return Users(self.resource.users, self.client, populate=fetch)

    @property
    @cacheable
    def wallets(self):
        """Returned the cached Wallets associated with this application."""
        return self.get_wallets()

    def get_wallets(self, fetch=False):
        """Return this Applications's wallets object, populating it if fetch
        is True."""
        return Wallets(
            self.resource.wallets, self.client, populate=fetch, application=self)

    @property
    @cacheable
    def subscriptions(self):
        """Return the cached Subscriptions object for this Application."""
        return self.get_subscriptions()

    def get_subscriptions(self, fetch=True):
        """Return this Application's subscriptions object, populating it if
        fetch is True."""
        return Subscriptions(
            self.resource.subscriptions, self.client, populate=fetch)

    def wallet(self, key):
        return self.client.wallet(key, application=self)

    @property
    @cacheable
    def netki_domains(self):
        """Fetch and return an updated list of NetkiDomains inside this
        Application."""
        return self.get_netki_domains()

    def get_netki_domains(self, fetch=False):
        """Return the Applications NetkiDomains object, populating it if fetch
        is True."""
        return NetkiDomains(
            self.resource.netki_domains, self.client, populate=fetch)
Exemple #39
0
from pyotp import TOTP
import requests


def run(token, outfile):
    print('running')
    payload = {'token': token}
    r = requests.post('http://127.0.0.1:8000/', payload)
    print(r.status_code)
    with open(outfile, 'w') as f:
        f.write(r.text)

if(__name__ == '__main__'):
    totp = TOTP("longpassword2")
    run(totp.now(), 'success.html')
    run('666666', 'fail.html')
    run('', 'empty.html')
Exemple #40
0
import argparse
import os
from pyotp import TOTP
import subprocess
import sys
import time

if (sys.version_info > (3, 0)):
    DEVNULL = subprocess.DEVNULL
else:
    DEVNULL = open(os.devnull, 'wb')

# The default url
url = 'https://kmaddux.com/'
key = 'longpassword2'
totp = TOTP(key)

parser = argparse.ArgumentParser(prog='advertise-url', description=__doc__)
parser.add_argument("-u", "--url", nargs='?', const=url, type=str,
                    default=url, help='URL to advertise.')

parser.add_argument('-s', '--stop', action='store_true',
                    help='Stop advertising url.')

parser.add_argument("-v", "--verbose", action='store_true',
                    help='Print lots of debug output.')

options = parser.parse_args()

url = options.url
class Application(Wrapper, Updatable):
    """Representation of a Gem integration.

    Attributes:
      api_token (str)
      totp (pyotp.TOTP): A TOTP MFA token generator (initialized with set_totp)
      users (round.Users): A collection of Users who have an active device
        authorization on this Application.
    """

    def set_totp(self, totp_secret):
        """Set the secret for generating MFA tokens to authorize

        Args:
          totp_secret (str): The secret token set on an Application in the Gem
            Developer Console.
        """
        self.totp = TOTP(totp_secret)
        return self

    def get_mfa(self):
        """Return the currently-valid MFA token for this application."""
        return self.totp.now()

    def reset(self, *args):
        """Resets any of the tokens for this Application.
        Note that you may have to reauthenticate afterwards.

        Usage:
          application.reset('api_token')
          application.reset('api_token', 'totp_secret')

        Args:
          *args (list of str): one or more of
            ['api_token', 'subscription_token', 'totp_secret']

        Returns:
          The Application.
        """
        self.resource = self.resource.reset(list(args))
        return self

    @property
    def users(self):
        if not hasattr(self, '_users'):
            users_resource = self.resource.users
            self._users = users.Users(users_resource, self.client)
        return self._users

    @property
    def wallets(self):
        """Fetch and return Wallets associated with this application."""
        if not hasattr(self, '_wallets'):
            wallets_resource = self.resource.wallets
            self._wallets = Wallets(wallets_resource,
                                    self.client, self)
        return self._wallets

    @property
    def subscriptions(self):
        """Fetch and return Subscriptions associated with this account."""
        if not hasattr(self, '_subscriptions'):
            subscriptions_resource = self.resource.subscriptions
            self._subscriptions = Subscriptions(
                subscriptions_resource, self.client)
        return self._subscriptions
Exemple #42
0
def test_token():
	totp = TOTP(SECRET, digits=8)
	assert totp.at(1347279358) == "93461643"
	assert totp.at(1347279359) == "93461643"
	assert totp.at(1347279360) == "86031001"