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
