Table Of Contents

Previous topic

repoze.what – Authorization in TurboGears 2 applications

Next topic

Adding a custom login cleaner

Customizing authentication and authorization

Status:Official

Here you will learn how to customize the way TurboGears configures repoze.what (and thus repoze.who indirectly) for you, using the repoze.what SQL plugin. This is all done from {yourproject}.config.app_cfg.

Customizing authentication settings

It’s very easy for you to customize authentication and identification settings in repoze.who from {yourproject}.config.app_cfg.sa_auth. The available directives are all optional:

  • form_plugin: An instance of your custom repoze.who challenger.

  • form_identifies (bool): Whether your custom challenger should also be used as an identifier (e.g., an instance of repoze.who.plugins.form.RedirectingFormPlugin).

  • You may also customize the parameters sent to repoze.who.middleware.PluggableAuthenticationMiddleware. For example, to set an additional repoze.who authenticator, you may use something like this in {yourproject}.config.app_cfg:

    # ...
    from repoze.who.plugins.htpasswd import HTPasswdPlugin, crypt_check
    # ...
    htpasswd_auth = HTPasswdPlugin('/path/to/users.htpasswd', crypt_check)
    app_cfg.sa_auth.authenticators = [('htpasswd_auth', htpasswd_auth)]
    # ...
    

Customizing the model structure assumed by the quickstart

Your auth-related model doesn’t have to be like the default one, where the class for your users, groups and permissions are, respectively, User, Group and Permission, and your users’ user name is available in User.user_name. What if you prefer Member and Team instead of User and Group, respectively? Or what if you prefer Group.members instead of Group.users? Read on!

Changing class names

Changing the name of an auth-related class (User, Group or Permission) is a rather simple task. Just rename it in your model, and then make sure to update {yourproject}.config.app_cfg accordingly.

For example, if you renamed User to Member, {yourproject}.config.app_cfg should look like this:

# ...
from yourproject import model
# ...
base_config.sa_auth.user_class = model.Member
# ...

Changing attribute names

You can also change the name of the attributes assumed by repoze.what in your auth-related classes, such as renaming User.groups by User.memberships.

Changing such values is what repoze.what calls “translating”. You may set the translations for the attributes of the models repoze.what deals with in {yourproject}.config.app_cfg. For example, if you want to replace Group.users by Group.members, you may set the following translation in that file:

base_config.sa_auth.translations.users = 'members'
These are the translations you may set in base_config.sa_auth.translations:
  • user_name: The translation for the attribute in User.user_name.
  • users: The translation for the attribute in Group.users.
  • group_name: The translation for the attribute in Group.group_name.
  • groups: The translation for the attribute in User.groups and Permission.groups.
  • permission_name: The translation for the attribute in Permission.permission_name.
  • permissions: The translation for the attribute in User.permissions and Group.permissions.
  • validate_password: The translation for the method in User.validate_password.

Enabling the quickstart in an existing project

To enable authentication and authorization via repoze.what‘s quickstart, you should follow the instructions described in this section:

  1. Go to {yourproject}.config.app_cfg and define the following settings:
    • base_config.auth_backend: The name of the authentication/authorization backend. Set it to “sqlalchemy”.
    • base_config.sa_auth.dbsession: Your model’s SQLAlchemy session.
    • base_config.sa_auth.user_class: Your user class.
    • base_config.sa_auth.group_class: Your group class.
    • base_config.sa_auth.permission_class: Your permission class.

    It may look like this:

    # ...
    from yourproject import model
    # ...
    base_config.auth_backend = 'sqlalchemy'
    base_config.sa_auth.dbsession = model.DBSession
    base_config.sa_auth.user_class = model.User
    base_config.sa_auth.group_class = model.Group
    base_config.sa_auth.permission_class = model.Permission
    # ...
    
  2. Now define your auth-related data model in, say, {yourproject}.model.auth, with at least the definitions below (you may add more columns if you want):

    import md5
    import sha
    from datetime import datetime
    
    from tg import config
    from sqlalchemy import Table, ForeignKey, Column
    from sqlalchemy.types import String, Unicode, UnicodeText, Integer, DateTime, \
                                 Boolean, Float
    from sqlalchemy.orm import relation, backref, synonym
    
    from yourproject.model import DeclarativeBase, metadata, DBSession
    
    
    # This is the association table for the many-to-many relationship between
    # groups and permissions.
    group_permission_table = Table('tg_group_permission', metadata,
        Column('group_id', Integer, ForeignKey('tg_group.group_id',
            onupdate="CASCADE", ondelete="CASCADE")),
        Column('permission_id', Integer, ForeignKey('tg_permission.permission_id',
            onupdate="CASCADE", ondelete="CASCADE"))
    )
    
    # This is the association table for the many-to-many relationship between
    # groups and members - this is, the memberships.
    user_group_table = Table('tg_user_group', metadata,
        Column('user_id', Integer, ForeignKey('tg_user.user_id',
            onupdate="CASCADE", ondelete="CASCADE")),
        Column('group_id', Integer, ForeignKey('tg_group.group_id',
            onupdate="CASCADE", ondelete="CASCADE"))
    )
    
    # auth model
    
    class Group(DeclarativeBase):
        """An ultra-simple group definition.
        """
        __tablename__ = 'tg_group'
    
        group_id = Column(Integer, autoincrement=True, primary_key=True)
    
        group_name = Column(Unicode(16), unique=True)
    
        display_name = Column(Unicode(255))
    
        created = Column(DateTime, default=datetime.now)
    
        users = relation('User', secondary=user_group_table, backref='groups')
    
        def __repr__(self):
            return (u'<Group: name=%s>' % self.group_name).encode('utf-8')
    
    
    class User(DeclarativeBase):
        """Reasonably basic User definition. Probably would want additional
        attributes.
        """
        __tablename__ = 'tg_user'
    
        user_id = Column(Integer, autoincrement=True, primary_key=True)
    
        user_name = Column(Unicode(16), unique=True)
    
        email_address = Column(Unicode(255), unique=True)
    
        display_name = Column(Unicode(255))
    
        _password = Column('password', Unicode(40))
    
        created = Column(DateTime, default=datetime.now)
    
        def __repr__(self):
            return (u'<User: email="%s", display name="%s">' % (
                    self.email_address, self.display_name)).encode('utf-8')
    
        @property
        def permissions(self):
            perms = set()
            for g in self.groups:
                perms = perms | set(g.permissions)
            return perms
    
        def _set_password(self, password):
            """encrypts password on the fly using the encryption
            algo defined in the configuration
            """
            algorithm = self.get_encryption_method()
            self._password = self.__encrypt_password(algorithm, password)
    
        def _get_password(self):
            """returns password
            """
            return self._password
    
        password = synonym('password', descriptor=property(_get_password,
                                                           _set_password))
    
        def __encrypt_password(self, algorithm, password):
            """Hash the given password with the specified algorithm. Valid values
            for algorithm are 'md5' and 'sha1'. All other algorithm values will
            be essentially a no-op."""
            hashed_password = password
    
            if isinstance(password, unicode):
                password_8bit = password.encode('UTF-8')
    
            else:
                password_8bit = password
    
            if "md5" == algorithm:
                hashed_password = md5.new(password_8bit).hexdigest()
    
            elif "sha1" == algorithm:
                hashed_password = sha.new(password_8bit).hexdigest()
    
            # TODO: re-add the possibility to provide own hashing algo
            # here... just get the real config...
    
            #elif "custom" == algorithm:
            #    custom_encryption_path = turbogears.config.get(
            #        "auth.custom_encryption", None )
            #
            #    if custom_encryption_path:
            #        custom_encryption = turbogears.util.load_class(
            #            custom_encryption_path)
    
            #    if custom_encryption:
            #        hashed_password = custom_encryption(password_8bit)
    
            # make sure the hashed password is an UTF-8 object at the end of the
            # process because SQLAlchemy _wants_ a unicode object for Unicode columns
            if not isinstance(hashed_password, unicode):
                hashed_password = hashed_password.decode('UTF-8')
    
            return hashed_password
    
        def get_encryption_method(self):
            """returns the encryption method from the config
            If None is set, or auth is disabled this will return None
            """
            auth_system = config.get('sa_auth', None)
            if auth_system is None:
                # if auth is not activated in the config we should warn
                # the admin through the logs... and return None
                return None
    
            return auth_system.get('password_encryption_method', None)
    
        def validate_password(self, password):
            """Check the password against existing credentials.
            this method _MUST_ return a boolean.
    
            @param password: the password that was provided by the user to
            try and authenticate. This is the clear text version that we will
            need to match against the (possibly) encrypted one in the database.
            @type password: unicode object
            """
            algorithm = self.get_encryption_method()
            return self.password == self.__encrypt_password(algorithm, password)
    
    
    class Permission(DeclarativeBase):
        """A relationship that determines what each Group can do"""
        __tablename__ = 'tg_permission'
    
        permission_id = Column(Integer, autoincrement=True, primary_key=True)
    
        permission_name = Column(Unicode(16), unique=True)
    
        description = Column(Unicode(255))
    
        groups = relation(Group, secondary=group_permission_table,
                          backref='permissions')
    

    Finally, make sure these classes are imported at the end of your {yourproject}/model/__init__.py:

    from auth import User, Group, Permission
    
  3. Finally, you may want to create some default users, groups and permissions to try authorization in your application. In {yourproject}.websetup you may add a code like this in your setup_config() function:

    # ...
    
    model.metadata.create_all(bind=config['pylons.app_globals'].sa_engine)
    
    u = model.User()
    u.user_name = u'manager'
    u.display_name = u'Example manager'
    u.email_address = u'manager@somedomain.com'
    u.password = u'managepass'
    
    model.DBSession.add(u)
    
    g = model.Group()
    g.group_name = u'managers'
    g.display_name = u'Managers Group'
    
    g.users.append(u)
    
    model.DBSession.add(g)
    
    p = model.Permission()
    p.permission_name = u'manage'
    p.description = u'This permission give an administrative right to the bearer'
    p.groups.append(g)
    
    model.DBSession.add(p)
    model.DBSession.flush()
    
    u1 = model.User()
    u1.user_name = u'editor'
    u1.display_name = u'Example editor'
    u1.email_address = u'editor@somedomain.com'
    u1.password = u'editpass'
    
    model.DBSession.add(u1)
    model.DBSession.flush()
    
    transaction.commit()
    print "Successfully setup"
    

    And then populate your test database with these rows. To do so, first delete the file devdata.db from your project’s root directory, and finally run the command below from the same directory:

    paster setup-app development.ini

Note

You may also want to define a short-cut to the identity dictionary in the WSGI request and the template context. To do so, in {yourproject}.lib.base.BaseController, add the following lines in the __call__ method:

# ...
request.identity = request.environ.get('repoze.who.identity')
tmpl_context.identity = request.identity
# ...

Disabling authentication and authorization

If you need more flexibility than that provided by the quickstart, or you are not going to use repoze.who and repoze.what, you should prevent TurboGears from dealing with authentication/authorization by removing (or commenting) the following line from {yourproject}.config.app_cfg:

base_config.auth_backend = '{whatever you find here}'

Then you may also want to delete those settings like base_config.sa_auth.* – they’ll be ignored.

Warning

DANGER! The use of the convenient “booleanized” predicates from repoze.what within TurboGears means that almost all TurboGears code relies on the truth value of a predicate being True/False. By disabling the TurboGears customization this behaviour will cease and all predicates will evaluate to True in all cases.

Your site is “failing open”! Every user now has manage permission (and every other permission!).

You must call this function on initialization:

from repoze.what.plugins.pylonshq import booleanize_predicates
booleanize_predicates()

To restore this critical behavior and protect your site!

Next Steps

  • Using who.ini – describes how to integrate the repoze.who who.ini configuration scheme into your application. This allows you to use any repoze.who plugin, such as the OpenID or LDAP plugins.
  • Adding OpenID Support – describes how to use a repoze.who plugin to authenticate users via the OpenID mechanism