Ticket #70: database-cc.py

# -*- coding: iso8859-1 -*-
#
# Copyright (C) 2005 yellowTAB GmbH http://www.yellowtab.com/
#
# Released under modified BSD licence
#
# Author: Charlie Clark <charlie.clark@yellowtab.com>

from __future__ import generators
import crypt
from trac.core import *
from api import IPasswordStore
from binascii import hexlify

try:
    from os import urandom
except ImportError:
    def urandom(n):
        return open('/dev/urandom').read(n)

def salt():
    s = ''
    v = long(hexlify(urandom(4)), 16)
    itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
    for i in range(8):
        s += itoa64[v & 0x3f]; v >>= 6
    return s


class AbstractPasswordDatabaseStore(Component):
    """Base class for managing passwords stored in databases such as imported from Bugzilla

    Sub-classes must provide relation and relvars preferably through configs
    """

    sql_select_all_users = "SELECT %s FROM %s"
    sql_select_user = "SELECT %s FROM %s WHERE %s = %%s"
    sql_delete_user = "DELETE FROM %s WHERE %s = %%s"
    sql_insert_user = "INSERT INTO %s (%s, %s) VALUES (%%s, %%s)"
    sql_update_user = "UPDATE %s SET %s = %%s WHERE %s = %%s"

    def __init__(self):
        """get information from config file. Must be implemented in subclass"""
        pass

    def __init__(self):
        self.relation = self.config.get("account-manager", "relation")
        self.rel_user = self.config.get("account-manager", "username_variable")
        self.rel_password = self.config.get("account-manager", "password_variable")
        self.log.error("table %s, user %s, pw %s" %(self.relation, self.rel_user, self.rel_password))


    def has_user(self, user):
        db = self.env.get_db_cnx()
        c = db.cursor()
        sql = self.sql_select_user %(self.rel_user, self.relation, self.rel_user)
        c.execute(sql, (user,))
        users = c.fetchone()
        if users:
            return users[0]
        return None

    def get_users(self):
        db = self.env.get_db_cnx()
        c = db.cursor()
        sql = self.sql_select_all_users %(self.relation)
        c.execute(sql)
        users = c.fetchall()
        if users:
            return [user[0] for user in users]
        return []

    def set_password(self, user, password):
        db = self.env.get_db_cnx()
        c = db.cursor()
        if self.has_user(user):
            sql = self.sql_update_user %(self.relation, self.rel_user, self.rel_password)
        else:
            sql = self.sql_insert_user %(self.relation, self.rel_user, self.rel_password)
        password = self.crypt_password(password)
        c.execute(sql, (user, password))
        db.commit()

    def delete_user(self, user):
        db = self.env.get_db_cnx()
        c = db.cursor()
        sql = self.sql_delete_user %(self.relation, self.rel_user)
        c.execute(sql, (user,))
        db.commit()

    def crypt_password(self, password):
        return password

class CryptDatabasePasswdStore(AbstractPasswordDatabaseStore):
    """Manages user accounts stored in the database
       password encryption matches Bugzilla

    To use this implementation add the following configuration section to trac.ini
    {{{
    [account-manager]
    password_format = crypt_db
    username_variable = username or whatever
    password_variable = password or whatever
        }}}
    """
    implements(IPasswordStore)


    def config_key(self):
        return 'crypt_db'

    def crypt_password(self, password):
         return crypt.crypt(password, salt())