security - uso - Cómo asegurar el panel de administración del matraz con la seguridad del matraz

matraz uso

Question

Estoy buscando una API web segura hecha con Flask e integrada con flask-admin para proporcionar una interfaz de administración. Busqué y encontré que flask-admin tiene un panel de administración en /admin y por defecto cualquiera puede tener acceso a él. No proporciona un sistema de autenticación y está completamente abierto (sin ningún tipo de seguridad) ya que no asumieron lo que se usaría para proporcionar seguridad. Esta API debe usarse en producción, por lo que no podemos tener una ruta abierta /admin para todos los que golpean la URL. Se necesita una autenticación adecuada.

En views.py no puedo simplemente colocar la ruta /admin y proporcionar autenticación a través del decorador, ya que se views.py la ruta existente que creó flask-admin para causar un error.

Investigaciones posteriores muestran que hay dos módulos flask-admin y flask-security . Sé que is_accessible flask-admin tiene is_accessible método is_accessible para asegurarla, pero no proporciona mucha funcionalidad que es proporcionada por flask-security .

No he encontrado ningún método para asegurar el punto final /admin más todos los demás puntos finales que comienzan con /admin como /admin/<something> .

Estoy buscando específicamente hacer esta tarea con la seguridad del matraz. Si no es posible, por favor sugiera alternativas.

PD: Sé que puedo bloquear ngnix , pero esa sería la última opción. Si puedo tener un sistema de autenticación a través del flask-security eso sería bueno.

Answer 1

Dado que este es el primer resultado de la búsqueda de Google "flask-security admin", y todavía no hay una solución lista para usar, creo que puedo contribuir.

Se hizo una pregunta similar en la Lista de problemas del proyecto flask-admin y aquí se proporciona un ejemplo simple que usa flask-login y mogodb.

Hice un ejemplo utilizando SQLAchemy para una base de datos sqlite y flask-security. Vea la aplicación matraz de muestra a continuación:

 #!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import os.path as op
from flask import Flask, render_template, url_for, request
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.event import listens_for
from flask.ext.security import current_user, login_required, RoleMixin, Security, SQLAlchemyUserDatastore, UserMixin
from flask_admin import Admin, AdminIndexView
from flask_admin.contrib import sqla
# Create application
app = Flask(__name__)
# Create dummy secrety key so we can use sessions
app.config[''SECRET_KEY''] = ''123456790''
# Create in-memory database
app.config[''DATABASE_FILE''] = ''sample_db.sqlite''
app.config[''SQLALCHEMY_DATABASE_URI''] = ''sqlite:///'' + app.config[''DATABASE_FILE'']
app.config[''SQLALCHEMY_ECHO''] = True
db = SQLAlchemy(app)
# Create directory for file fields to use
file_path = op.join(op.dirname(__file__), ''static/files'')
# flask-security models
roles_users = db.Table(''roles_users'',
db.Column(''user_id'', db.Integer(), db.ForeignKey(''user.id'')),
db.Column(''role_id'', db.Integer(), db.ForeignKey(''role.id'')))
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship(''Role'', secondary=roles_users,
backref=db.backref(''users'', lazy=''dynamic''))
# Create Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
# Only needed on first execution to create first user
#@app.before_first_request
#def create_user():
# db.create_all()
# user_datastore.create_user(email=''[email protected]'', password=''pass'')
# db.session.commit()
class AnyModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(64))
def __unicode__(self):
return self.name
class MyAdminIndexView(AdminIndexView):
def is_accessible(self):
return current_user.is_authenticated() # This does the trick rendering the view only if the user is authenticated
# Create admin. In this block you pass your custom admin index view to your admin area
admin = Admin(app, ''Admin Area'', template_mode=''bootstrap3'', index_view=MyAdminIndexView())
# Add views
admin.add_view(sqla.ModelView(AnyModel, db.session))
# To acess the logout just type the route /logout on browser. That redirects you to the index
@login_required
@app.route(''/login'')
def login():
return redirect(''/admin'')
@app.route(''/'')
def index():
return render_template(''index.html'')
if __name__ == ''__main__'':
# Build sample db on the fly, if one does not exist yet.
db.create_all()
app.run(debug=True)

Consulte los documentos de seguridad del matraz para saber cómo personalizar la página de inicio de sesión .

Espero que esto ayude.

Answer 2

Deberías revisar el proyecto Flask-Security-Admin , creo que cubre bastante claramente lo que estás buscando.

Tomado directamente desde el enlace de arriba:

• Cuando visite la página de inicio de la aplicación por primera vez, se le pedirá que inicie sesión, gracias a Flask-Security.
• Si inicia sesión con [email protected] y password = password, tendrá el rol de "usuario final".
• Si inicia sesión con [email protected] y contraseña = contraseña, tendrá el rol de "administrador".
• Cualquiera de los dos roles está permitido para acceder a la página de inicio.
• Cualquiera de los roles tiene permiso para acceder a la página / admin. Sin embargo, a menos que tenga el rol de "administrador", no verá las pestañas para la administración de usuarios y roles en esta página.
• Solo el rol de administrador tiene permiso para acceder a las subpáginas de / admin como, por ejemplo, / admin / userview. De lo contrario, obtendrás una respuesta "prohibida".
• Tenga en cuenta que, al editar un usuario, los nombres de los roles se completan automáticamente gracias a Flask-Admin.
• Puedes agregar y editar usuarios y roles. Los usuarios resultantes podrán iniciar sesión (a menos que establezca activo = falso) y, si tienen el rol de "administrador", podrán realizar la administración.

El código relevante está ubicado en main.py, y está claramente comentado para explicar cómo replicar el proceso de asegurar el panel de administración del matraz utilizando la seguridad del matraz.

La pieza más básica y relevante para usted es la siguiente (línea 152-):

# Prevent administration of Users unless the currently logged-in user has the "admin" role
def is_accessible(self):
return current_user.has_role(''admin'')

Espero que esto sea útil.

Answer 3

Hay una sección sobre seguridad en la documentación de Flask-Admin: http://flask-admin.readthedocs.io/en/latest/introduction/#authorization-permissions

Answer 4

Utilizo la respuesta de @RamiMac para todas las subvistas, pero para el índice uno (por defecto /admin ), utilizo este método, re-envuelve el método con un rol de admin requerido para ver.

@app.before_first_request
def restrict_admin_url():
endpoint = ''admin.index''
url = url_for(endpoint)
admin_index = app.view_functions.pop(endpoint)
@app.route(url, endpoint=endpoint)
@roles_required(''admin'')
def secure_admin_index():
return admin_index()

En mi proyecto, esto va directamente después de todo mi código Flask-Admin , que se encuentra en su propio script de inicio, custom_flaskadmin.py .