So sichern Sie die Flasche-Admin-Panel mit Kolben-Sicherheit

Question

Ich bin auf der Suche nach Web-API mit Flask und integrierte mit flask-admin, um eine Admin-Schnittstelle zur Verfügung stellen. Ich habe gesucht und gefunden, dass Flask-Admin ein Admin-Panel bei /admin hat und standardmäßig kann jeder Zugriff darauf haben. Es bietet kein Authentifizierungssystem und ist vollständig offen (ohne Sicherheit), da nicht davon ausgegangen wird, was zur Gewährleistung der Sicherheit verwendet wird. Diese API muss in der Produktion verwendet werden, so dass wir keine offene /admin Route für alle Benutzer der URL haben können. Eine ordnungsgemäße Authentifizierung ist erforderlich.

In views.py kann ich nicht einfach die /admin Route setzen und Authentifizierung durch Dekorator als das wäre überschreiben die bestehende Route bereits von flask-admin erstellt, so dass würde einen Fehler verursachen würde.

Weitere Forschung zeigt, dass es zwei Module flask-admin und flask-security gibt. Ich weiß, dass flask-admin hat is_accessible Methode, um es zu sichern, aber es bietet nicht viel Funktionalität, die von flask-security bereitgestellt wird.

Ich habe keine Methode dort gefunden, um den Endpunkt /admin plus alle anderen Endpunkte zu sichern, die mit /admin wie /admin/<something> beginnen.

Ich suche speziell diese Aufgabe mit Flasch-Sicherheit. Wenn es nicht möglich ist, schlagen Sie bitte Alternativen vor.

PS: Ich weiß, ich kann ngnix selbst sperren, aber das wäre die letzte Option. Wenn ich ein Authentifizierungssystem durch flask-security haben könnte, wäre das gut.

Answer 1

Sie sollten überprüfen, die Flask-Security-Admin Projekt, ich denke, es ist ziemlich klar deckt, was Sie suchen.

direkt aus dem obigen Link Genommen:

• Beim ersten der App-Homepage besuchen, werden Sie aufgefordert, sich anzumelden, dank Flask-Sicherheit.
• Wenn Sie sich mit username=someone@example.com und password = password anmelden, haben Sie die Rolle "Endbenutzer".
• Wenn Sie sich mit username=admin@example.com und password = password anmelden, haben Sie die Rolle "admin".
• Beide Rollen dürfen auf die Homepage zugreifen.
• Beide Rollen dürfen auf die Seite/admin zugreifen. Wenn Sie jedoch nicht die Rolle "admin" haben, werden auf dieser Seite die Registerkarten für die Verwaltung von Benutzern und Rollen nicht angezeigt.
• Nur die Administratorrolle darf auf Unterseiten von/admin-Seite wie/admin/userview zugreifen. Andernfalls erhalten Sie eine "verbotene" Antwort.
• Beachten Sie, dass beim Bearbeiten eines Benutzers die Namen der Rollen dank Flask-Admin automatisch ausgefüllt werden.
• Sie können Benutzer und Rollen hinzufügen und bearbeiten. Die resultierenden Benutzer können sich anmelden (es sei denn, Sie haben active = false festgelegt) und können, wenn sie die Rolle "admin" haben, die Administration durchführen.

Der entsprechende Code wird in main.py, und ist eindeutig zu erklären, kommentiert, wie der Prozess der Sicherung des Kolben-Admin-Panel mit Kolben-Sicherheit zu replizieren.

Das grundlegendste, relevantes Stück ist für Sie die folgende (Linie 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') 

Ich hoffe, dass dies hilfreich ist.

Answer 2

Es gibt Abschnitt über die Sicherheit in Flask-Admin Dokumentation: http://flask-admin.readthedocs.io/en/latest/introduction/#authorization-permissions

Answer 3

Da dies das erste Ergebnis für die "Google Chrome-Sicherheit Secure Admin" Google-Suche ist, und es gibt keine Out-of-the-Box-Lösung noch, ich denke, ich kann dazu beitragen.

Eine ähnliche Frage wurde auf dem flask-admin Projekt Issue List gestellt und ein einfaches Beispiel mit flask-login und mogodb wird zur Verfügung gestellt here.

Ich machte ein Beispiel mit SQLAchemy für eine SQLite-Datenbank und Flasch-Sicherheit. Siehe die Probenkolben App unter:

#!/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='yourmail@mail.com', 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) 

Bitte beachten Sie die Kolben-Sicherheit docs how to customize the login page zu lernen.

Hoffe, das hilft.

Answer 4

Ich benutze @ RamiMacs Antwort für alle Unteransichten, aber für den Index eins (standardmäßig /admin), ich benutze diese Methode, wickeln Sie die Methode mit einer admin Rolle erforderlich, um anzuzeigen.

@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() 

In meinem Projekt geht dieser direkt nach all meinem Flask-Admin Code, der selbst Skript in seinem eigenen Start ist, custom_flaskadmin.py.