# ============================================================================= # Author: falseuser # Created Time: 2019-08-26 15:31:19 # Last modified: 2019-08-26 15:31:57 # Description: api.py # ============================================================================= from flask import Flask from flask_restful import Api, Resource from flask_httpauth import HTTPTokenAuth APP = Flask(__name__) API = Api(APP) AUTH = HTTPTokenAuth(scheme='AUTH') @AUTH.verify_token def verify_token(token): print(token) if token == "11111": return True else: return False class TestAPI(Resource): @AUTH.login_required def get(self): return 1 API.add_resource(TestAPI, "/test/")
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ from flask_httpauth import HTTPTokenAuth from itsdangerous import TimedJSONWebSignatureSerializer as Serializer from itsdangerous import BadSignature, SignatureExpired from app import account from app.common import utils # -H "Authorization: Token <jws-token>" AUTH = HTTPTokenAuth(scheme='Token') def create(username, expire): """ create a token for account """ token = Serializer(secret_key="secret_key", expires_in=expire) \ .dumps({"user": username}) \ .decode("utf-8") return token @AUTH.verify_token def verify(token): """
import redis from google.oauth2 import id_token from google.auth.transport import requests conf = config('server', default={ 'main_url': 'http://127.0.0.1:8080', 'max_count_per_query': 20, 'redis_host': 'localhost', 'redis_port': 6379, 'redis_prefix': 'memes_', 'google_client_id': 'Google client id' }) app = Flask(__name__) auth = HTTPTokenAuth(scheme='Token') cache = redis.StrictRedis(host=conf['redis_host'], port=conf['redis_port'], charset="utf-8", decode_responses=True) def get_google_id(token): try: id_info = id_token.verify_oauth2_token(token, requests.Request(), conf['google_client_id']) if id_info['iss'] not in [ 'accounts.google.com', 'https://accounts.google.com' ]: raise ValueError('Wrong issuer.')
#coding:utf-8 ''' - token设置 ''' from flask_httpauth import HTTPTokenAuth from flask import g auth1 = HTTPTokenAuth(scheme='fCa1eb4cxjBkIuiVvK328qp6LEl79rsG') tokens = { "Access_Key_SecretKey_1": "John-acce_Kye1123123CCaavcxwer", "Access_Key_SecretKey_2": "Susan_acce_Kye1123123CCaavcxwer" } @auth1.verify_token def verify_token(token): g.user = None if token in tokens: g.user = tokens[token] return True else: return False
from flask import Flask, jsonify, request, redirect, make_response, g from flask_httpauth import HTTPBasicAuth, HTTPTokenAuth basic_auth = HTTPBasicAuth() auth = HTTPTokenAuth('Bearer') from werkzeug import secure_filename import face_recognition as fr from L6SOsgE6HT import users, tokens import uuid import cv2 import os from web_utils import * # from flasgger import Swagger, swag_from from companies_view import companies_api swagger_template = { 'securityDefinitions': { 'Bearer': { 'type': 'apiKey', 'name': 'Authorization', 'in': 'header' } }, } # HTTP basic auth # Two separate auth, one for username and password for generating token # Second for token for API endpoint app = Flask(__name__, static_url_path='/static') # swagger = Swagger(app, template=swagger_template) app.register_blueprint(companies_api)
""" Token验证 """ from collections import namedtuple from flask import current_app, g, request from flask_httpauth import HTTPTokenAuth from itsdangerous import TimedJSONWebSignatureSerializer as Serializer, BadSignature, SignatureExpired from app.libs.scope import is_in_scope from app.libs.wyy_exception import AuthFailedException, ForbiddenException auth = HTTPTokenAuth(scheme='WYY') User = namedtuple('User', ['uid', 'ac_type', 'scope']) @auth.verify_token def verify_token(token): user = verigy_auth_token(token) if not user: return False else: g.user = user return True def verigy_auth_token(token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token)
from flask import Blueprint, g from flask_httpauth import HTTPTokenAuth from app.models.participant import Participant api_v1 = Blueprint('v1', __name__) auth_basic = HTTPTokenAuth(scheme='Bearer') auth_super = HTTPTokenAuth(scheme='Bearer') @auth_basic.verify_token def verify_basic_token(token): participant = Participant.verify_auth_token(token) if participant: g.user = participant g.token = token return True return False @auth_super.verify_token def verify_super_token(token): participant = Participant.verify_auth_token(token) if participant and participant.is_superuser: g.user = participant g.token = token return True return False from . import participants, notifications, skills, auth
import secrets import string import sys from flask import Flask, jsonify, request, json from flask_cors import CORS from flask_restful import Api, Resource, abort, reqparse from flask_httpauth import HTTPTokenAuth from flask_sqlalchemy import SQLAlchemy import itsdangerous app = Flask(__name__) CORS(app) api = Api(app) auth = HTTPTokenAuth(header="X-Auth-Token") app.config['SECRET_KEY'] = secrets.token_bytes(32) if "SQLALCHEMY_DATABASE_URI" not in os.environ: os.environ["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:" app.config["SQLALCHEMY_DATABASE_URI"] = os.environ["SQLALCHEMY_DATABASE_URI"] app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) if 'JOB_LOCATION' in os.environ: app.config['JOB_LOCATION'] = os.environ['JOB_LOCATION'] if 'SUBMISSION_LOCATION' in os.environ: app.config['SUBMISSION_LOCATION'] = os.environ['SUBMISSION_LOCATION']
#!/usr/bin/env python import os from flask import current_app as app from flask import Flask, abort, request, jsonify, g, url_for from .user_model import db, User from . import user_controller from . import rule_controller from . import engine_controller from time import gmtime, strftime import datetime from flask_httpauth import HTTPTokenAuth, HTTPBasicAuth, MultiAuth auth = HTTPBasicAuth() auth_token = HTTPTokenAuth('Bearer') multi_auth = MultiAuth(auth, auth_token) @auth.verify_password def verify_password(username_or_token, password): return user_controller.test_password(username_or_token, password) @auth_token.verify_token def verify_token(username_or_token): return user_controller.test_token(username_or_token) @app.route('/api/users', methods=['POST']) def add_new_user(): return user_controller.new_user()
from flask import g from flask_httpauth import HTTPTokenAuth auth = HTTPTokenAuth(scheme='Hcloud') tokens = {"secret-token-1": "John", "secret-token-2": "Susan"} @auth.verify_token def verify_token(token): g.user = None if token in tokens: g.user = tokens[token] return True return False
import os import sys import operator import json import logging import git from settings import ROLES_DIR import subprocess from listroles import listRoles from flask import Flask, make_response, request, Response, jsonify from flask_httpauth import HTTPTokenAuth app = Flask(__name__) auth = HTTPTokenAuth("Token") @auth.verify_token def verify_token(token): return token == os.getenv("BY7_KEY") @app.errorhandler(404) def not_found(error=None): message = { 'status': 404, 'message': 'Not Found: ' + request.url, } resp = jsonify(message) resp.status_code = 404
from flask import jsonify, g from app.models.user import User from flask_httpauth import HTTPBasicAuth, HTTPTokenAuth, MultiAuth basic_auth = HTTPBasicAuth() token_auth = HTTPTokenAuth('JWT') multi_auth = MultiAuth(basic_auth, token_auth) @basic_auth.verify_password def verify_password(username, password): user = User.query.filter_by(username=username).first() if not user or not user.verify_password(password): return False g.auth_user = user return True @token_auth.verify_token def verify_token(token): if token: user = User.verify_token(token) if user: g.auth_user = user return True return False return False @basic_auth.error_handler def unauthorized(message=None):
from flask_debugtoolbar import DebugToolbarExtension from flask_httpauth import HTTPTokenAuth, HTTPBasicAuth from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate # from flask_wtf import CSRFProtect from flask_caching import Cache db = SQLAlchemy() migrate = Migrate() bootstrap = Bootstrap() toolbar = DebugToolbarExtension() auth_token = HTTPTokenAuth() auth_cms = HTTPBasicAuth() auth_pa = HTTPBasicAuth() cache = Cache(config={"CACHE_TYPE": "redis", "CACHE_REDIS_PASSWORD": ""}) # csrf = CSRFProtect() def ext_init(app): db.init_app(app=app) migrate.init_app(app=app, db=db) bootstrap.init_app(app=app) # toolbar.init_app(app=app) cache.init_app(app=app) # csrf.init_app(app=app)
import os import requests from flask import Flask, current_app, g from flask_httpauth import HTTPTokenAuth from jose import JWTError, jwt app = Flask(__name__) app.config['SECRET_KEY'] = 'secret key here' app.config['OAUTH_CLIENT_ID'] = 'your-registered-client-id' app.config['OAUTH_CLIENT_SECRET'] = 'client-secret-returned-by-oauth-server' app.config['OAUTH_JWT_PUB_KEY'] = os.environ.get('OAUTH_JWT_PUB_KEY') jwt_auth = HTTPTokenAuth('Bearer') introspect_auth = HTTPTokenAuth('Bearer') @jwt_auth.verify_token def verify_jwt_token(token): g.user = None try: claims = jwt.decode(token, current_app.config['OAUTH_JWT_PUB_KEY'], algorithms=['RS256']) g.user = claims['user'] return True except JWTError: return False return False
api = Api(app) # 关于flask SQLAlchemy实现ORM框架操作的一些基础配置 app.config['SECRET_KEY'] = 'dqwecf29vbneuirjnf2i3n0f2i302n' # 数据库连接信息配置 app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite' # 是否自动提交sql执行 app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True # 是否显示修改回执 app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True # SQLAlchemy实例化 db = SQLAlchemy(app) # 引入基础认证、token认证模块 auth = HTTPBasicAuth() token_m = HTTPTokenAuth() todos = [{ "id": 0, "title": u'吃饭', "message": u'ab', "status": False, "add_time": u'0410', "end_time": u'0411' }, { "id": 1, "title": u'睡觉', "message": u'sleep', "status": False, "add_time": time.time(), "end_time": None }]
from flask import g from flask_httpauth import HTTPTokenAuth from itsdangerous import TimedJSONWebSignatureSerializer as Serializer from bucketlist import app from bucketlist.models import User auth_token = HTTPTokenAuth("Token") def verify_password(username, password): """ Login verification """ g.user = User.query.filter_by(username=username).first() if not g.user: return False elif g.user.check_password(password): return g.user def generate_auth_token(user_id, expires_in=3600): """ Generates a token using the user's ID """ signature = Serializer(app.config["SECRET_KEY"], expires_in=expires_in) return signature.dumps({"id": g.user.id}) @auth_token.verify_token def verify_auth_token(token): """
from flask_httpauth import HTTPTokenAuth from flask import jsonify, g from app.models import User # Setting up the Authorization header with a token profix token_auth = HTTPTokenAuth("Bearer") # Verifying the user security validity @token_auth.verify_token def verify_token(token): """ Verifies the user authentication token""" user_active_id = User.comfirm_token(token) if user_active_id: g.user = User.query.filter_by(id=user_active_id).first() return True return False @token_auth.error_handler def auth_error(): """ Returns messege from unauthorised Access """ return jsonify({"messege":"Access not Allowed, Invalid token"}), 401
from flask_httpauth import HTTPBasicAuth, HTTPTokenAuth auth = HTTPTokenAuth() #HTTPBasicAuth() # HTTPTokenAuth from flask import jsonify, g, request from .errors import unauthorized, forbidden from ..models import User from . import api # auth必须要实现的装饰器,return True表示验证通过, nestjs也有这玩意 # 问题参数从头信息获取的,头信息用什么格式传呢? 要使用Basic Auth(不安全) # @auth.verify_password # def verify_password(email_or_token, password): # print(email_or_token) # if email_or_token == '' or email_or_token is None: # return False # print(email_or_token) # if password == '' or passowrd is None: # g.current_user = User.verify_auth_token(email_or_token) # g.token_used = True # return g.current_user is not None # user = User.query.filter_by(email = email).first() # if not user: # return False # # 写入上下文 # g.current_user = user # g.token_used = False # return user.verify_password(password)
from flask import g from flask_httpauth import HTTPBasicAuth, HTTPTokenAuth from BaseModel import Student auth = HTTPBasicAuth() auth2 = HTTPTokenAuth() @auth.verify_password def verify_password(username_or_token, password): user = Student.verify_auth_token(username_or_token) if not user: try: user = Student.get(Student.student_number == username_or_token) except: user = None if not user or not user.verify_password(password): return False g.user = user return True @auth2.verify_token def verify_token(token): user = Student.verify_auth_token(token) if user: g.user = user return True return False
import sys from urllib.parse import urlparse # Third-party imports... from flask import Flask, abort, jsonify, request, make_response from flask_httpauth import HTTPTokenAuth from wtforms import Form, BooleanField, StringField, PasswordField, validators # Local imports... from .matrix_api import create_account from . import config from . import tokens app = Flask(__name__) auth = HTTPTokenAuth(scheme='SharedSecret') logger = logging.getLogger(__name__) re_mxid = re.compile(r'^@?[a-zA-Z_\-=\.\/0-9]+(:[a-zA-Z\-\.:\/0-9]+)?$') def validate_token(form, token): """ validates token Parameters ---------- arg1 : Form object arg2 : str token name, e.g. 'DoubleWizardSki'
import datetime from flask import Flask, jsonify, request, __version__ as flaskVersion from flask_httpauth import HTTPTokenAuth from environment import getDockerSecret from judge import evaluate app = Flask(__name__) auth = HTTPTokenAuth(scheme="Bearer") startDatetime = datetime.datetime.now() @auth.verify_token def verify_token(token): return token == getDockerSecret("judge_token") @app.route("/status", methods=["GET", "POST"]) @auth.login_required def status(): data = { "flask_version": flaskVersion, "start_datetime": startDatetime.isoformat() } return jsonify(data), 200 @app.route("/judge", methods=["POST"]) @auth.login_required def judge():
# -*- coding: utf-8 -*- from flask import Flask from flask_restful import Api from flask_httpauth import HTTPBasicAuth, HTTPTokenAuth from flask_sqlalchemy import SQLAlchemy from app.config import DATABASE, TOKEN_SCHEME # API SERVER APPLICATION app = Flask(__name__) api = Api(app) # DATABASE app.config['SQLALCHEMY_ECHO'] = False app.config['SQLALCHEMY_DATABASE_URI'] = DATABASE app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True db = SQLAlchemy(app) # BASIC AUTH AUTHENTICATION basic_auth = HTTPBasicAuth() # TOKEN AUTH AUTHENTICATION token_auth = HTTPTokenAuth(scheme=TOKEN_SCHEME)
""" import sqlalchemy import sqlalchemy.orm import sqlalchemy.ext.declarative from flask import Flask, g from flask_restful import reqparse, Api, Resource from flask_httpauth import HTTPTokenAuth # Flask相关变量声明 app = Flask(__name__) api = Api(app) # 认证相关 auth = HTTPTokenAuth(scheme="token") TOKENS = { "fejiasdfhu", "fejiuufjeh" } @auth.verify_token def verify_token(token): if token in TOKENS: g.current_user = token return True return False # 数据库相关变量声明
app.config['SECRET_KEY'] = 'the Nebula NCUHome' app.config['MAIL_SERVER'] = 'smtp.qq.com' app.config['MAIL_PORT'] = 465 app.config['MAIL_USE_TLS'] = False app.config['MAIL_USE_SSL'] = True app.config['MAIL_USERNAME'] = '******' app.config['MAIL_PASSWORD'] = '******' app.config['TP_MAIL_SUBJECT_PREFIX'] = ['Team Planets'] app.config['TP_MAIL_SENDER'] = 'Team Planets Admin <*****@*****.**>' app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://guest:123456@localhost/new?charset=utf8mb4' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) mail = Mail(app) auth = HTTPTokenAuth(app) class User(db.Model): __tablename__ = 'users' user_id = db.Column(db.INTEGER, primary_key=True, autoincrement=True) user_name = db.Column(db.VARCHAR(16), nullable=False) user_email = db.Column(db.VARCHAR(64), nullable=False, unique=True) password_hash = db.Column(db.VARCHAR(200), nullable=False) user_token = db.Column(db.VARCHAR(200), nullable=False) user_active = db.Column(db.Boolean) @property def password(self): raise AttributeError('Password is not a readable attribute.')
import requests from requests.auth import HTTPBasicAuth import logging import inspect import hashlib if sys.argv[0] != os.path.split(os.path.realpath(__file__))[1]: os.chdir(os.path.split(sys.argv[0])[0]) print("当前工作路径:" + str(os.getcwd())) if not os.path.exists("log"): os.mkdir("log") app = Flask(__name__) app.static_folder CORS(app, supports_credentials=True) auth = HTTPTokenAuth(scheme='Bearer') # app.add_url_rule('/favicon.ico', redirect_to=url_for('static', filename='favicon.ico')) ctx = app.app_context() ctx.push() def md5sum(filename): """ 用于获取文件的md5值 :param filename: 文件名 :return: MD5码 """ if not os.path.isfile(filename): # 如果校验md5的文件不是文件,返回空 return myhash = hashlib.md5() f = open(filename, 'rb')
from flask import Flask, g from flask_httpauth import HTTPTokenAuth from itsdangerous import TimedJSONWebSignatureSerializer as Serializer from itsdangerous import SignatureExpired, BadSignature app = Flask(__name__) # 实例化Flask类 app.config['SECRET_KEY'] = 'mrsoft' # 设置秘钥 token_serializer = Serializer(app.config['SECRET_KEY'], expires_in=1800) # 实例化Serializer,设置过期时间 auth = HTTPTokenAuth('Bearer') # 基于Token的Bearer方式认证 @auth.verify_token def verify_token(token): '''验证Token''' g.username = None try: data = token_serializer.loads(token) # 将Token反序列化为字典对象 except SignatureExpired: # Token 过期失效 msg = 'token expired' app.logger.warning(msg) return False except BadSignature: # Token 错误 msg = 'badSignature of token' app.logger.warning(msg) return False except: # 其他错误 msg = 'wrong token with unknown reason' app.logger.warning(msg) return False if 'username' in data: # 判断字典对象中是否包含username g.username = data['username'] return True
from flask import g, current_app from flask_httpauth import HTTPBasicAuth, HTTPTokenAuth from app.api.errors import error_response from app.models import User basic_auth = HTTPBasicAuth() token_auth = HTTPTokenAuth() @basic_auth.verify_password def verify_password(username_or_token, password): #first try to authenticate by token user = User.verify_auth_token(username_or_token) if user is None: user = User.query.filter_by(username=username_or_token).first() if not user or not user.check_password(password): return False g.current_user = user return True @basic_auth.error_handler def basic_auth_error(): return error_response(401) @token_auth.verify_token def verify_token(token): g.current_user = User.check_token(token) if token else None
payload = { 'token': auth_token, 'sub': 'ethanee' } return { 'status': 'success', 'message': 'Token decoded.', 'data': payload } except jwt.ExpiredSignatureError: return { 'status': 'fail', 'message': 'Signature expired.' } except jwt.InvalidTokenError: return { 'status': 'fail', 'message': 'Invalid token.' } TOKEN_AUTH = HTTPTokenAuth() @TOKEN_AUTH.verify_token def verify_token(auth_token): response = OfficerAuthService.decode_auth_token(auth_token) token_data = response.get('data') if response.get('status') == 'success': return token_data.get('sub')
from flask import g, request, Blueprint from flask_api import status from flask_babel import gettext from flask_httpauth import HTTPTokenAuth from flask_login import current_user from project.server import db from project.server.main.serializers import CartSchema, CartItemSchema from project.server.main.utils import error_response, validation_error, update_cart from project.server.models import User, Cart, Product, CartItem from project.server.user import admin_user_token api_blueprint = Blueprint('api', __name__, url_prefix='/api') api_blueprint.config = {} auth = HTTPTokenAuth('Token') @api_blueprint.record def record_params(setup_state): """Make app config available in blueprint""" app = setup_state.app api_blueprint.config = dict([(key, value) for (key, value) in app.config.items()]) @auth.verify_token def authenticate(token): """ Combine session auth and token auth by checking token or current_user.
import bcrypt from uuid import uuid4 import peewee from playhouse.shortcuts import model_to_dict from flask import g, current_app from flask_httpauth import HTTPTokenAuth import flask_principal as p from flask_principal import Principal from app import components TOKEN_EXPIRATION = 30 * 24 * 60 * 60 auth_api = HTTPTokenAuth(scheme="Bearer") principal = Principal(use_sessions=False, skip_static=True) class Role(components.BaseRole): pass class User(components.BaseUser): class Meta: table_name = "users" display_name = peewee.TextField(null=True) created = peewee.DateTimeField(null=False, default=datetime.now, formats=["%s"])