← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to www/auth/authenticate.py

  • Committer: mattgiuca
  • Date: 2008-01-31 01:44:30 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:345
Global CSS change: ivlebody no longer has 1em of padding (it has none).
This is because most apps were disabling it (and it had to change anyway for
other reasons -- see below).

Hence, all apps which WERE disabling the padding have had that removed, and
just work by default. (console, browser, tutorial)
All apps which WEREN'T disabling the padding (very few) now have to manually
include an extra div. This has been done on all such apps, and has been
heavily documented (both in the CSS file and doc/app_howto). (help, dummy,
debuginfo).

media/common/ivle.css: 
    The real change here (which isn't yet being used) is that ivlebody is now
    positioned absolutely and takes up all the space on the canvas. This is
    to be used for full-page layouts in console and browser.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/auth/authenticate.py
17
17
 
18
18
# Module: authenticate
19
19
# Author: Matt Giuca
20
 
# Date:   19/2/2008
 
20
# Date:   21/12/2007
21
21
 
22
22
# Provides a mechanism for authenticating a username and password, and
23
23
# returning a yes/no response.
24
24
 
25
 
# Has a plugin interface for authentication modules.
26
 
# An authentication module is a callable object which accepts 3 positional
27
 
# arguments.
28
 
# plugin_auth_func(dbconn, login, password, user)
29
 
# dbconn is an open connection to the IVLE database.
30
 
# login and password are required strings, password is cleartext.
31
 
# user is a User object or None.
32
 
# If it's a User object, it must return the same object if it returns a user.
33
 
# This object should describe the user logging in.
34
 
# It may be None if the user is not known to this DB.
35
 
# Returns either a User object or None, or raises an AuthError.
36
 
# Returning a User object implies success, and also gives details about the
37
 
# user if none were known to the DB (such details will be written to the DB).
38
 
# Returning None implies a soft failure, and that another auth method should
39
 
# be found.
40
 
# Raising an AuthError implies a hard failure, with an appropriate error
41
 
# message. No more auth will be done.
42
 
 
43
 
import conf
44
 
import common.db
45
 
import common.user
46
 
import ldap
47
 
 
48
 
class AuthError(Exception):
49
 
    def __init__(self, message="Invalid username or password."):
50
 
        self.message = message
51
 
        self.args = (message,)
52
 
 
53
 
def authenticate(login, password):
54
 
    """Determines whether a particular login/password combination is
55
 
    valid. The password is in cleartext.
56
 
 
57
 
    Returns a User object containing the user's details on success.
58
 
    Raises an AuthError containing an appropriate error message on failure.
59
 
 
60
 
    The User returned is guaranteed to be in the IVLE database.
61
 
    This could be from reading or writing to the DB. If authenticate can't
62
 
    find the user in the DB, it may get user data from some other source
63
 
    (such as LDAP) and actually write it to the DB before returning.
64
 
    """
 
25
def authenticate(username, password):
 
26
    """Determines whether a particular username/password combination is
 
27
    valid. Returns True or False. The password is in cleartext."""
 
28
 
65
29
    # WARNING: Both username and password may contain any characters, and must
66
30
    # be sanitized within this function.
67
 
    # (Not SQL-sanitized, just sanitized to our particular constraints).
68
 
    # TODO Sanitize username
69
 
 
70
 
    # Spawn a DB object just for making this call.
71
 
    # (This should not spawn a DB connection on each page reload, only when
72
 
    # there is no session object to begin with).
73
 
    dbconn = common.db.DB()
74
 
 
75
 
    try:
76
 
        user = dbconn.get_user(login)
77
 
        for m in auth_modules:
78
 
            # May raise an AuthError - allow to propagate
79
 
            auth_result = m(dbconn, login, password, user)
80
 
            if auth_result is None:
81
 
                # Can't auth with this module; try another
82
 
                pass
83
 
            elif auth_result == False:
84
 
                return None
85
 
            elif isinstance(auth_result, common.user.User):
86
 
                if user is not None and auth_result is not user:
87
 
                    # If user is not None, then it must return the same user
88
 
                    raise AuthError("Internal error: "
89
 
                        "Bad authentication module (changed user)")
90
 
                elif user is None:
91
 
                    # We just got ourselves some user details from an external
92
 
                    # source. Put them in the DB.
93
 
                    # TODO: Write user to DB
94
 
                    pass
95
 
                return auth_result
96
 
            else:
97
 
                raise AuthError("Internal error: "
98
 
                    "Bad authentication module (bad return type)")
99
 
        # No auths checked out; fail.
100
 
        raise AuthError()
101
 
    except common.db.DBException:
102
 
        # If our attempt to get the named user from the db fails,
103
 
        # then the login name is unknown.
104
 
        raise AuthError()
105
 
    finally:
106
 
        dbconn.close()
107
 
 
108
 
def simple_db_auth(dbconn, login, password, user):
109
 
    """
110
 
    A plugin auth function, as described above.
111
 
    This one just authenticates against the local database.
112
 
    Returns None if the password in the DB is NULL, indicating that another
113
 
    auth method should be used.
114
 
    Raises an AuthError if mismatched, indicating failure to auth.
115
 
    """
116
 
    auth_result = dbconn.user_authenticate(login, password)
117
 
    # auth_result is either True, False (fail) or None (try another)
118
 
    if auth_result is None:
119
 
        return None
120
 
    elif auth_result:
121
 
        return user
122
 
    else:
123
 
        raise AuthError()
124
 
 
125
 
def ldap_auth(dbconn, login, password, user):
126
 
    """
127
 
    A plugin auth function, as described above.
128
 
    This one authenticates against an LDAP server.
129
 
    Returns user if successful. Raises AuthError if unsuccessful.
130
 
    Also raises AuthError if the LDAP server had an unexpected error.
131
 
    """
132
 
    try:
133
 
        l = ldap.initialize(conf.ldap_url)
134
 
        # ldap_format_string contains a "%s" to put the login name
135
 
        l.simple_bind_s(conf.ldap_format_string % login, password)
136
 
    except ldap.INVALID_CREDENTIALS:
137
 
        raise AuthError()
138
 
    except Exception, msg:
139
 
        raise AuthError("Internal error (LDAP auth): %s" % repr(msg))
140
 
    # Got here - Must have successfully authenticated with LDAP
141
 
    return user
142
 
 
143
 
# List of auth plugin modules, in the order to try them
144
 
auth_modules = [
145
 
    simple_db_auth,
146
 
    ldap_auth,
147
 
]
 
31
    # TEMP: Just allow any user to log in
 
32
    return True
 
33
    ## TEMP: Just a hardcoded login
 
34
    #return username == 'user' and password == 'pass'