• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• aiohttp-security-master
  • demo
    • simple_example_auth.py
    • dictionary_auth
      • users.py
      • main.py
      • handlers.py
      • authz.py
    • database_auth
      • sql
        • init_db.sql
        • sample_data.sql
      • db.py
      • db_auth.py
      • main.py
      • handlers.py
  • Makefile
  • CHANGES.txt
  • .coveragerc
  • LICENSE
  • README.rst
  • setup.py
  • requirements-dev.txt
  • setup.cfg
  • .travis.yml
  • aiohttp_security
    • api.py
    • __init__.py
    • abc.py
    • cookies_identity.py
    • session_identity.py
    • jwt_identity.py
  • tests
    • test_jwt_identity.py
    • test_dict_autz.py
    • test_no_auth.py
    • test_cookies_identity.py
    • test_session_identity.py
    • test_no_identity.py
    • conftest.py
  • .gitignore
  • docs
    • Makefile
    • example_db_auth.rst
    • make.bat
    • reference.rst
    • glossary.rst
    • aiohttp-icon.ico
    • usage.rst
    • aiohttp_doctools.py
    • index.rst
    • conf.py
    • _static
    • example.rst
  • MANIFEST.in
  • .pyup.yml

import sqlalchemy as sa

from aiohttp_security.abc import AbstractAuthorizationPolicy
from passlib.hash import sha256_crypt

from . import db


class DBAuthorizationPolicy(AbstractAuthorizationPolicy):
    def __init__(self, dbengine):
        self.dbengine = dbengine

    async def authorized_userid(self, identity):
        async with self.dbengine.acquire() as conn:
            where = sa.and_(db.users.c.login == identity,
                            sa.not_(db.users.c.disabled))
            query = db.users.count().where(where)
            ret = await conn.scalar(query)
            if ret:
                return identity
            else:
                return None

    async def permits(self, identity, permission, context=None):
        if identity is None:
            return False

        async with self.dbengine.acquire() as conn:
            where = sa.and_(db.users.c.login == identity,
                            sa.not_(db.users.c.disabled))
            query = db.users.select().where(where)
            ret = await conn.execute(query)
            user = await ret.fetchone()
            if user is not None:
                user_id = user[0]
                is_superuser = user[3]
                if is_superuser:
                    return True

                where = db.permissions.c.user_id == user_id
                query = db.permissions.select().where(where)
                ret = await conn.execute(query)
                result = await ret.fetchall()
                if ret is not None:
                    for record in result:
                        if record.perm_name == permission:
                            return True

            return False


async def check_credentials(db_engine, username, password):
    async with db_engine.acquire() as conn:
        where = sa.and_(db.users.c.login == username,
                        sa.not_(db.users.c.disabled))
        query = db.users.select().where(where)
        ret = await conn.execute(query)
        user = await ret.fetchone()
        if user is not None:
            hashed = user[2]
            return sha256_crypt.verify(password, hashed)
    return False