def token_auth(token) -> bool: """ HTTP bearer token authorization """ jwt = JWT(current_app.config['SECRET_KEY']) try: data = jwt.loads(token) except Exception: raise AuthFailed(field='token') if data.get('consumer_id'): # todo consumer user auth ? ... else: # Normal user if ('user_id' or 'role_id') not in data: raise AuthFailed(field='token') if data['role_id'] != 1 and not data.get('tenant_uid'): raise AuthFailed(field='token') user = User.query \ .filter(User.roleIntID == data['role_id'], User.id == data['user_id'], User.tenantID == data['tenant_uid']).first() if not user: raise AuthFailed(field='token') g.user_id: int = user.id g.tenant_uid: str = user.tenantID g.role_id: int = user.roleIntID g.app_uid: str = None g.user_auth_type: int = user.userAuthType user.lastRequestTime = arrow.now().naive user.update() return True
def generate_auth_token(self): expires_in = current_app.config['TOKEN_LIFETIME_INVITATION'] s = JWT(current_app.config['SECRET_KEY'], expires_in=expires_in) token = s.dumps({'invitation_id': self.id}) if isinstance(token, bytes): token = token.decode('utf-8') return token
def add_header(response): response.headers['Access-Control-Allow-Origin'] = '*' response.headers['Access-Control-Allow-Credentials'] = True response.headers['Access-Control-Expose-Headers'] = 'Content-Type,Token' if response.status_code < 400 and hasattr(g, 'user') and g.user is not None: jwt = JWT(current_app.config['SECRET_KEY'], expires_in=86400) response.headers['Token'] = jwt.dumps({'username': g.user.name}) return response
def generate_auth_token(self, user, expiration=3600): '''This method is responsible for generating an auth token''' jwt = JWT(config['secret'], expires_in=expiration) return jwt.dumps({ 'id': str(user[0].id), 'profile': str(user[0].profile), 'name': str(user[0].name), 'username': str(user[0].username) })
def verify_token(token): jwt = JWT(current_app.config['SECRET_KEY']) try: data = jwt.loads(token) except SignatureExpired: return None except BadSignature: return None user = User.query.get(data['id']) return user
def verify_token(token): '''This method is responsible for handling and validating tokens''' jwt = JWT(config['secret']) try: data = jwt.loads(token) auth.user = data except SignatureExpired: abort(403) except BadSignature: abort(403) return True
def generate_auth_token(self, remember=False): if remember: expires_in = current_app.config['TOKEN_LIFETIME_REMEMBER'] else: expires_in = current_app.config['TOKEN_LIFETIME'] s = JWT(current_app.config['SECRET_KEY'], expires_in=expires_in) token = s.dumps({ 'user_id': self.id, 'role_id': self.roleIntID, 'tenant_uid': self.tenantID}) return self._byte_to_str(token)
def verify_token(token): g.current_user = AnonymousUser jwt = JWT(current_app.config['SECRET_KEY'], expires_in = 3600) try: data = jwt.loads(token) except: return False if 'id' in data: g.current_user = User.query.get(data['id']) if g.current_user is not None: return True return False
def authenticate(self, request): """ Returns a two-tuple of `User` and token if a valid signature has been supplied using JWT-based authentication. Otherwise returns `None`. """ jwt_value = self.get_jwt_value(request) if jwt_value is None: return None s = JWT(current_app.config['SECRET_KEY']) try: payload = s.loads(jwt_value) except SignatureExpired: msg = 'Signature has expired.' raise exceptions.AuthenticationFailed(msg) except BadSignature: msg = 'Error decoding signature.' raise exceptions.AuthenticationFailed(msg) user = self.authenticate_credentials(payload) return (user, payload)
def signup_invite_user(token): jwt = JWT(current_app.config['SECRET_KEY']) try: data = jwt.loads(token) except Exception: raise FormInvalid(field='token') if not data.get('invitation_id'): raise FormInvalid(field='invitation') invitation = Invitation.query \ .join(Tenant, Tenant.tenantID == Invitation.tenantID) \ .filter(Invitation.id == data.get('invitation_id'), Invitation.inviteStatus == 0, Tenant.enable == 1) \ .first() if not invitation: raise DataNotFound(field='invitation') invitation.inviteStatus = 1 invite_user = { 'roleIntID': invitation.roleIntID, 'tenantID': invitation.tenantID } return invite_user
def generate_auth_token(self): expires_in = current_app.config['TOKEN_LIFETIME_INVITATION'] s = JWT(current_app.config['SECRET_KEY'], expires_in=expires_in) return s.dumps({'invitation_id': self.id})
from flask import Flask, g, request, abort from flask_login import LoginManager, UserMixin, login_required, current_user from itsdangerous import TimedJSONWebSignatureSerializer as JWT app = Flask(__name__) login_manager = LoginManager() login_manager.init_app(app) JWT_EXPIRES_IN = 20 app.config['SECRET_KEY'] = "SECRET_KEY" jwt = JWT(app.config['SECRET_KEY'], expires_in=JWT_EXPIRES_IN) class User(UserMixin): def __init__(self, username, password, age): self.id = username self.username = username self.password = password self.age = age USERS = [User("Kitty", "123", 10), User("John", "123", 20)] @login_manager.request_loader def load_user_from_request(req): token = req.headers.get('Token') if not token: return None try:
def _jwt_serializer(): global _jwt_serializer_instance if _jwt_serializer_instance is None: _jwt_serializer_instance = JWT(app.config['SECRET_KEY'], 2 * 60 * 60) return _jwt_serializer_instance
def generate_auth_token(self, expiration=36000): jwt = JWT(current_app.config['SECRET_KEY'], expires_in=expiration) return jwt.dumps({'id': self.id})
from flask_sqlalchemy import SQLAlchemy from flask_httpauth import HTTPTokenAuth from itsdangerous import TimedJSONWebSignatureSerializer as JWT import json import datetime from flask import Flask, jsonify, make_response from flask_cors import CORS application = Flask(__name__) CORS(application) application.config.from_object('config.DevelopmentConfig') db = SQLAlchemy(application) import models jwt = JWT(application.config['SECRET_KEY'], expires_in=172800) auth = HTTPTokenAuth('Bearer') @auth.verify_token def verify_token(token): temp = token temp_list = temp.split('.') id = temp_list[-1] del temp_list try: user = models.Users.query.filter_by(User_id=id).first() except Exception as e: print(str(e)) return False if not user: return False
from server.schema import schema import json import os from itsdangerous import TimedJSONWebSignatureSerializer as JWT from flask_httpauth import HTTPTokenAuth is_developoment = 'FLASK_DEBUG' in os.environ and os.environ[ 'FLASK_DEBUG'] == '1' app = Flask(__name__) CORS(app) app.config['SECRET_KEY'] = 'top secret!' app.debug = True jwt = JWT(app.config['SECRET_KEY'], expires_in=3600) auth = HTTPTokenAuth(scheme='Token') @app.route("/login", methods=['POST']) def login(): from server.main import User user = User(request.json) return jsonify({ 'token': user.get_token().decode('utf-8'), 'username': user.username, 'firstName': user.first_name, 'surname': user.surname, 'partnerCode': user.partner_code })
from flask import Flask from itsdangerous import TimedJSONWebSignatureSerializer as JWT from flask_httpauth import HTTPTokenAuth from flask_sqlalchemy import SQLAlchemy from flask_mail import Mail app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) mail = Mail(app) jwt_st = JWT(app.config['SECRET_KEY'], expires_in=3600, algorithm_name='HS256') jwt_lt = JWT(app.config['SECRET_KEY'], expires_in=604800, algorithm_name='HS256') auth = HTTPTokenAuth('Bearer') from .views.user import user from .views.board import board from .views.todo import todo from .views.member import member from .views.memo import memo from .views.meetup import meetup from .views.upload import upload app.register_blueprint(user, url_prefix='/user') app.register_blueprint(board, url_prefix='/board') app.register_blueprint(member, url_prefix='/member') app.register_blueprint(todo, url_prefix='/todo') app.register_blueprint(memo, url_prefix='/memo') app.register_blueprint(meetup, url_prefix='/meetup') app.register_blueprint(upload, url_prefix='/upload')
@babel.localeselector def get_locale(): # need to see if json in request. return request.accept_languages.best_match(config.LANGUAGES.keys()) sentry = Sentry( dsn= 'https://*****:*****@sentry.io/292734' ) mobile = Mobility() crf_protection = CSRFProtect() jwt = JWT(config.SECRET_KEY, expires_in=3600) mailer = Client(auth=(config.MAIL_USERNAME, config.MAIL_PASSWORD), version='v3.1') def search_street(street, lang='en'): location = None try: geolocator = Nominatim() location = geolocator.geocode(street, language=lang) except: try: geolocator = GoogleV3(api_key=config.GOOGLE_API_KEY) location = geolocator.geocode(street, language=lang) except:
#!/usr/bin/python # -*- coding: utf-8 -*- from flask_httpauth import HTTPTokenAuth from itsdangerous import TimedJSONWebSignatureSerializer as JWT # JWT creation. jwt = JWT('top secret!', expires_in=3600) # Refresh token creation. refresh_jwt = JWT('telelelele', expires_in=7200) # Auth object creation. auth = HTTPTokenAuth('Bearer') def get_username(token): data = jwt.loads(token) return data['username']
def create_app(self): app_test.config.from_object('config.TestingConfig') self.jwt = JWT(app_test.config['SECRET_KEY'], expires_in=3600) self.app_t = app_test return app_test
from flask_httpauth import HTTPTokenAuth from itsdangerous import TimedJSONWebSignatureSerializer as JWT # JWT creation. jwt = JWT('UbuQgGIdry*H&&I@', expires_in=6000) # Refresh token creation. refresh_jwt = JWT('Ag93ZQ3KcGg&KUhR', expires_in=17200) # Email token creation confirm_email_jwt = JWT('HuGIUMKXLoHi4Y2S', expires_in=17200) # Auth object creation. auth = HTTPTokenAuth('Bearer')
def generate_a_token(user): JWT(app.config['SECRET_KEY'], expires_in=3600) token = jwt.dumps({'username': user}) return token.decode(encoding="utf-8")
from functools import wraps from flask_restful import abort from flask import request, g from app import config from storage import UserSingletone as _Users from storage.common.base import Format #from storage.cache import cached from flask_httpauth import HTTPBasicAuth, HTTPTokenAuth, MultiAuth from itsdangerous import TimedJSONWebSignatureSerializer as JWT basic_auth = HTTPBasicAuth() token_auth = HTTPTokenAuth('Bearer') multi_auth = MultiAuth(basic_auth, token_auth) jwt = JWT(config['SECRET_KEY'], expires_in=config['SECRET_EXPIRES']) @basic_auth.verify_password def verify_password(username, password): g.user = None result = _Users.verify_password(id=username, password=password) if result: g.user = _Users.get(id=username) return result @token_auth.verify_token #@cached def verify_token(token): g.user = None try:
DNSIMPLE_ACCOUNT_ID = os.getenv('DNSIMPLE_ACCOUNT_ID') DNSIMPLE_ACCOUNT_TOKEN = os.getenv('DNSIMPLE_ACCOUNT_TOKEN') DNSIMPLE_DOMAIN_TTL = int(os.getenv('DNSIMPLE_DOMAIN_TTL', 60)) DNSIMPLE_DOMAINS = os.getenv('DNSIMPLE_DOMAINS').split(',') DNSIMPLE_DOMAINS = filter(None, DNSIMPLE_DOMAINS) SECRET_KEY = os.getenv('SECRET_KEY', 'secret key') VALID_USERS = os.getenv('VALID_USERS', '').split(',') VALID_USERS = filter(None, VALID_USERS) BASE_URL = 'https://api.dnsimple.com/v2/{0}'.format(DNSIMPLE_ACCOUNT_ID) app = Flask(__name__) app.config['SECRET_KEY'] = SECRET_KEY app.config['SQLALCHEMY_DATABASE_URI'] = DATABASE_URL app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) jwt = JWT(app.config['SECRET_KEY']) auth = HTTPTokenAuth('Bearer') def _json_data(self, key, default): if not getattr(self, 'data_json', None): self.data_json = {} try: self.data_json = json.loads(self.data) except: pass if type(self.data_json) is not dict: self.data_json = {} return self.data_json.get(key, default)
from oauth2client import client, file import httplib2 from googleapiclient.discovery import build import json from database_setup import Base, User, Category, LearningItem, Resource from ui_classes import ItemUI app = Flask(__name__) auth = HTTPTokenAuth(scheme="Bearer") # secret_key for API token generation # validity one hour # "".join(random.choice(string.ascii_uppercase + string.digits) # for x in range(32)) secret_key = "3K78ONCNMYYNGSSFKZMIA1T76Y99WTT6" VALIDITY = 3600 jwt = JWT(secret_key, expires_in=VALIDITY) engine = create_engine("sqlite:///tolearn.db") Base.metadata.bind = engine DBSession = sessionmaker(bind=engine) session = DBSession() # User authentication @app.route("/") def show_login(): # generate CSRF token and store it in user session cookie state = ( "".join(random.choice(string.ascii_uppercase + string.digits) for x in range(32))
def initialize_token_serializer(config): global jwt jwt = JWT(config['SECRET_KEY'], expires_in=config['TOKEN_VALIDITY'])
def generate_auth_token(self): jwt = JWT(app.config['SECRET_KEY']) token = jwt.dumps({'id': self.id}) return token