def menu_click_lock(self, widget, ssid, bssid, wificard): if bssid in open(wpa_supplican).read(): connectToSsid(ssid, wificard) else: Authentication(ssid, bssid, wificard) self.updateinfo() self.ifruning = False
def __init__(self, username=None, api_key=None, **kwargs): """ Accepts keyword arguments for Mosso username and api key. Optionally, you can omit these keywords and supply an Authentication object using the auth keyword. @type username: str @param username: a Mosso username @type api_key: str @param api_key: a Mosso API key """ self.cdn_enabled = False self.cdn_args = None self.connection_args = None self.cdn_connection = None self.connection = None self.token = None self.debuglevel = int(kwargs.get('debuglevel', 0)) socket.setdefaulttimeout = int(kwargs.get('timeout', 5)) self.auth = kwargs.has_key('auth') and kwargs['auth'] or None if not self.auth: authurl = kwargs.get('authurl', consts.default_authurl) if username and api_key and authurl: self.auth = Authentication(username, api_key, authurl) else: raise TypeError("Incorrect or invalid arguments supplied") self._authenticate()
def __init__(self, username=None, api_key=None, timeout=10, **kwargs): """ Accepts keyword arguments for Rackspace Cloud username and api key. Optionally, you can omit these keywords and supply an Authentication object using the auth keyword. @type username: str @param username: a Rackspace Cloud username @type api_key: str @param api_key: a Rackspace Cloud API key """ self.connection_args = None self.connection = None self.token = None self.debuglevel = int(kwargs.get('debuglevel', 0)) self.user_agent = kwargs.get('useragent', consts.user_agent) self.timeout = timeout self._total_domains = -1 self.auth = 'auth' in kwargs and kwargs['auth'] or None if not self.auth: authurl = kwargs.get('authurl', consts.us_authurl) if username and api_key and authurl: self.auth = Authentication(username, api_key, authurl=authurl, useragent=self.user_agent) else: raise TypeError("Incorrect or invalid arguments supplied") self._authenticate()
def test_authentication_change_password_fail(self): fake_persist = FakePersist() fake_persist.custom_retrieve_value = {} auth = Authentication(fake_persist) auth.add_user('foobar', 'baz', 'student') self.assertDictEqual(auth.change_password('foobar', 'qux', 'wobble'), {})
def authenticate_umls(self): # TODO sort imports out from authentication import Authentication import creds auth = Authentication(apikey=creds.apikey) tgt = auth.gettgt() return auth, tgt
def get_vendor(self, card_num): validity = Authentication().verify_card( card_num ) #call verify card method fron Authentication class and assign it to variable #check for validity if validity == 'Valid': first_digit = str(card_num)[0] #assign first digits of card number industry = '' #declare which type of industry card belongs to if first_digit == '1' or first_digit == '2': #if first digit of card is 1 or 2 industry = 'Airline' #it is in airline industry elif first_digit == '3': #if digit is 3 industry = 'Travel & Entertainment' issuer = 'American Express' #amex card elif first_digit == '4' or first_digit == '5' or first_digit == '6': #if digits are 4 or 5 or 6 industry = 'Banking' # it is banking industry if first_digit == '4': #if digit is 4 issuer = 'Visa' #card is VISA elif first_digit == '5': #if digit is 5 issuer = 'MasterCard' #it is Mastercard else: issuer = 'Discover' #any other digit is Discover return '\tIndustry: {0} \n\tIssuer: {1}'.format(industry, issuer) else: self.vendor = "Invalid card has no Vendor" #otherwise card has no vendor return self.vendor
class TestAuthentication(unittest.TestCase): test_authen = Authentication("jake", "jake") def test_credential_manager(self): # Checking the result when a user is found in the database self.assertNotEqual(self.test_authen.credential_manager("jake"), False) # Checking the result when a user is not found self.assertFalse(self.test_authen.credential_manager("barrybluejeans")) def test_check_login(self): # Checking the result when the login credentials are correct for an admin self.assertEqual(self.test_authen.check_login("dev", "dev"), "admin") # Checking the result when the login credentials are correct for a user self.assertEqual(self.test_authen.check_login("jamie", "jamie"), "user") # Checking the result when the login credentials are incorrect self.assertRaises(Exception, self.test_authen.check_login("jake", "notjake")) def test_db_credentials(self): # Checking if an exception is raised when the user can't log in with the provided details with self.assertRaises(Exception): self.test_authen.db_credentials(False) # Checking if checking_admin_tuple = ("jake", "user") self.assertTupleEqual(checking_admin_tuple, self.test_authen.db_credentials("user"))
def setup_clients(self): """ A method to seting up authentication and necessary clients for the tool - Called by Constructor """ auth = Authentication() self.novaclient = NovaClient(auth) self.keystoneclient = KeystoneClient(auth)
def userSignUp(request): if request.method == 'POST': serializer = UserSerializer(data=request.data) if serializer.is_valid(): save = serializer.save() auth = Authentication() user, token = auth.authenticate( serializer.validated_data.get('mobile'), serializer.validated_data.get('password')) data = AuthUserSerializer(user).data result = {'token': token} result.update(data) wallet = WalletSerializer(data={'win_bal': '0', 'wal_bal': '10'}) if wallet.is_valid(): user_wallet = wallet.save() user_wallet.user = save user_wallet.save() user_txn = TransactionSerializer( data={ 'txn_status': 'credit', 'txn_amount': '10', 'txn_description': 'Signup bonus' }) if user_txn.is_valid(): user_txn1 = user_txn.save() user_txn1.user = save user_txn1.save() return Response(data=result, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_login(self): auth = Authentication() login_url = auth.login() print(login_url) match = re.search( r'https://slack\.com/oauth/authorize\?response_type=code&client_id=.*&state=.*', login_url).group() self.assertEqual(match, login_url)
def main(): encryption_main() if checking_hashfile(): arc4_decoder(HASH_KEY) root = Tk() from authentication import Authentication my_gui = Authentication(root) root.mainloop()
def menu_click_lock(self, widget, ssid, bssid): if ssid in open(wpa_supplican).read(): connectToSsid(ssid) else: Authentication(ssid, bssid) if not self.thr.is_alive(): self.thr.start() else: self.nmMenu = self.nm_menu()
def auth(): data = request.get_json() token = uuid4() status = 'SUCCESS' if data.get('username') != 'user_01': status = 'FAILED' auth_result = Authentication(token, status) tokens.append(str(token)) return auth_result.to_json()
def main(): codeUser, wordObjects = Authentication().login() correctAnswer = True while correctAnswer: userInput = input( 'Would you like to do the wordtrainer (WT) or crossword puzzle (CW): ' ) if userInput.lower() == 'wt': WordTrainer().keepAsking(codeUser, wordObjects) elif userInput.lower() == 'cw': correctAnswer = Crossword(wordObjects)
def userSignIn(request): if request.method == 'POST': serializer = UserLoginSerializer(data=request.data) if serializer.is_valid(): auth = Authentication() user, token = auth.authenticate(**serializer.validated_data) data = AuthUserSerializer(user).data result = {'token': token} result.update(data) return Response(data=result, status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def __init__(self): self.authentication = Authentication() self.menu = ConsoleMenu("Library Management System", "Reception") self.user = None self.faceid = FaceID() function_item_login = FunctionItem("Login", self.login) function_item_faceid = FunctionItem("Face-ID Login", self.login_faceid) function_item_register = FunctionItem("Register", self.register) self.menu.append_item(function_item_login) self.menu.append_item(function_item_faceid) self.menu.append_item(function_item_register) self.menu.show()
def authenticate_user(self): global AUTHENTICATED from authentication import Authentication # we should check to see if we are already authenticated before blindly # doing it again if (AUTHENTICATED is False): obj = Authentication(self.configuration.vipr_hostname, self.configuration.vipr_port) # cookiedir = os.getcwd() cookiedir = self.configuration.vipr_cookiedir obj.authenticate_user(self.configuration.vipr_username, self.configuration.vipr_password, cookiedir, None) AUTHENTICATED = True
class Follow: @app.route("/follow", methods=['POST']) def followUser(): try: req_json = request.get_json() except Exception, e: print e profile_api = req_json['profile_api'] profile_user = req_json['profile_user'] endpoint = "https://api.twitter.com/1.1/friendships/create.json?screen_name=" + profile_user + "&follow=true" api_handler = Authentication().twitter(profile_api) res, data = api_handler.request(endpoint, "POST") return data
def __init__(self, username=None, api_key=None, timeout=5, **kwargs): """ Accepts keyword arguments for Mosso username and api key. Optionally, you can omit these keywords and supply an Authentication object using the auth keyword. Setting the argument servicenet to True will make use of Rackspace servicenet network. @type username: str @param username: a Mosso username @type api_key: str @param api_key: a Mosso API key @type servicenet: bool @param servicenet: Use Rackspace servicenet to access Cloud Files. @type cdn_log_retention: bool @param cdn_log_retention: set logs retention for this cdn enabled container. """ self.cdn_enabled = False self.cdn_args = None self.connection_args = None self.cdn_connection = None self.connection = None self.token = None self.debuglevel = int(kwargs.get('debuglevel', 0)) self.servicenet = kwargs.get('servicenet', False) self.user_agent = kwargs.get('useragent', consts.user_agent) self.timeout = timeout # if the environement variable RACKSPACE_SERVICENET is set (to # anything) it will automatically set servicenet=True if not 'servicenet' in kwargs \ and 'RACKSPACE_SERVICENET' in os.environ: self.servicenet = True self.auth = 'auth' in kwargs and kwargs['auth'] or None if not self.auth: authurl = kwargs.get('authurl', consts.us_authurl) if username and api_key and authurl: self.auth = Authentication(username, api_key, authurl=authurl, useragent=self.user_agent, timeout=self.timeout) else: raise TypeError("Incorrect or invalid arguments supplied") self._authenticate()
def __init__(self): self.db = Database() self.command = commands.Commands() self.encrypt = Encrypt() self.auth = Authentication() self.commands = { "help": self.command.help, "new": self.command.new, "show": self.command.show, "save": self.command.save, "search": self.command.search, "delete": self.command.delete, "update": self.command.update_master_password, "security": self.command.security }
def __init__(self, port): self.BACKLOG = 1024 # size of the queue for pending connections self.ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) self.ssl_context.load_cert_chain('ssl/certificate.crt', 'ssl/private.key') self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.s.bind(('', port)) # Bind to the port self.s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.s = self.ssl_context.wrap_socket(self.s, server_side=True) self.db_handler = DBHandler() self.auth = Authentication() self.logger = self.configure_logging()
def __init__(self, username=None, api_key=None, timeout=5, **kwargs): """ Accepts keyword arguments for chouti username and api key. Optionally, you can omit these keywords and supply an Authentication object using the auth keyword. @type username: str @param username: a chouti username, pattern is account:admin @type api_key: str @param api_key: a chouti password container. """ self.connection_args = None self.connection = None self.token = None self.debuglevel = int(kwargs.get('debuglevel', 0)) self.servicenet = kwargs.get('servicenet', False) self.user_agent = kwargs.get('useragent', consts.user_agent) self.timeout = timeout self.username = username self.api_key = api_key self._share_user_uri = kwargs.get('_share_user_uri', None) self._share_request = kwargs.get('_share_request', False) if kwargs.get('share_request', False): # 产生一个专为共享请求的请求连接方法 self.make_request = self.make_share_requst self.auth = 'auth' in kwargs and kwargs['auth'] or None if not self.auth: authurl = kwargs.get('authurl', consts.chouti_authurl) if username and api_key and authurl: # 此处的auth为Authentication类的实例 self.auth = Authentication(username, api_key, authurl=authurl, useragent=self.user_agent) else: raise TypeError("Incorrect or invalid arguments supplied") self._authenticate()
def get_vendor(self, card_num): validity = Authentication().verify_card(card_num) if validity == 'Valid': first_digit = str(card_num)[0] industry = '' if first_digit == '1' or first_digit == '2': industry = 'Airline' elif first_digit == '3': industry = 'Travel & Entertainment' issuer = 'American Express' elif first_digit == '4' or first_digit == '5' or first_digit == '6': industry = 'Banking' if first_digit == '4': issuer = 'Visa' elif first_digit == '5': issuer = 'MasterCard' else: issuer = 'Discover' return '\tIndustry: {0} \n\tIssuer: {1}'.format(industry, issuer) else: return "Invalid card has no Vendor"
def back_to_auth_screen(self): self.root.destroy() screen = Tk() from authentication import Authentication sign_up = Authentication(screen) screen.mainloop()
from flask import Flask, render_template, request, jsonify, redirect, abort, Response, make_response import re from typing import Optional # noqa: F401 import config import json from gregorian_calendar import GregorianCalendar from calendar_data import CalendarData from authentication import Authentication from app_utils import (previous_month_link, next_month_link, new_session_id, add_session, authenticated, get_session_username, authorized) app = Flask(__name__) authentication = Authentication(data_folder=config.USERS_DATA_FOLDER, password_salt=config.PASSWORD_SALT) @app.route("/", methods=["GET"]) @authenticated def index() -> Response: username = get_session_username(session_id=str(request.cookies.get("sid"))) user_data = authentication.user_data(username=username) return redirect("/{}/".format(user_data["default_calendar"])) @app.route("/login", methods=["GET"]) def login() -> Response: return render_template("login.html")
def test_authentication_login(self): auth = Authentication(FakePersist()) auth.add_user('foobar', 'baz', 'professor') self.assertDictEqual(auth.login('foobar', 'baz'), {})
def authentication() -> Authentication: return Authentication(data_folder="test/fixtures", password_salt="a test salt", failed_login_delay_base=0)
def test_authentication_login_wrong_password_fail(self): auth = Authentication(FakePersist()) auth.add_user('wobble', 'spam', 'student') self.assertDictEqual(auth.login('wobble', 'wrong_password'), {})
def test_authentication_login_unknown_user_fail(self): auth = Authentication(FakePersist()) self.assertDictEqual(auth.login('foobar', 'baz'), { 'success': False, 'message': 'User does not exist.' })
def test_authentication_change_password(self): auth = Authentication(FakePersist()) auth.add_user('foobar', 'baz', 'student') auth.login('foobar', 'baz') self.assertDictEqual(auth.change_password('foobar', 'qux'), {})