Authenticate Via External Cookie

   1 # +++++++++++++++ beginning of external_cookie  example
   2 
   3 # This is some sample code you might find useful when you want to use some
   4 # external cookie (made by some other program, not moin) with moin.
   5 # See the +++ places for customizing it to your needs.  Copy this
   6 # code into your farmconfig.py or wikiconfig.py by pasting it over the current:
   7 #
   8 #    class Config(DefaultConfig):
   9 # OR
  10 #    class FarmConfig(DefaultConfig):
  11 
  12 
  13 from MoinMoin.config.multiconfig import DefaultConfig
  14 from MoinMoin.auth import BaseAuth
  15     
  16 # This is included in case you want to create a log file during testing
  17 import time
  18 def writeLog(*args): 
  19     '''Write an entry in a log file with a timestamp and all of the args.'''
  20     s = time.strftime('%Y-%m-%d %H:%M:%S ',time.localtime())
  21     for a in args:
  22         s = '%s %s;' % (s,a)
  23     log = open('/mywiki/cookie.log', 'a') # +++ location for log file
  24     log.write('\n' + s + '\n')
  25     log.close()
  26     return
  27     
  28 # these 2 methods are examples of how to "authenticate" the other application cookie
  29 import MySQLdb
  30 def verifySession(sidHash): # +++ to use this, uncomment a procedure call below in ExternalCookie
  31     """Return True if sidHash value exists (meaning user is currently logged on), false otherwise.  
  32     
  33     If you are not a MySQL user, find another way to store this information.  ActiveSession is a two-column table
  34     containing a hashed cookie value (sidHash) plus a date-time stamp (tStamp).
  35     Your other application must add an entry to this table each time a user logs on and delete the entry when the user logs off.
  36     """
  37     db = MySQLdb.connect(db='mydb',user='myuserid',passwd='mypw') #+++ user ID needs read access
  38     c = db.cursor()
  39     q = 'select sidHash from ActiveSession where sidHash="%s"' % sidHash
  40     result = c.execute(q)
  41     c.close()
  42     if result == 1:
  43         return True
  44     return False
  45     
  46 def verifySessionPlus(sidHash,timeout=3600*4): # +++ to use this, uncomment a procedure call below in ExternalCookie
  47     """Return True if sidHash value exists (meaning user is currently logged on), false otherwise.  
  48     
  49     This version of verifySession deletes entries inactive for more than 4 hours and
  50     updates the tStamp field with each moin transaction.  If performance is 
  51     important, find another way to delete inactive sessions.
  52     """
  53     db = MySQLdb.connect(db='mydb',user='myuserid',passwd='mypw') # +++ user ID needs write access
  54     c = db.cursor()
  55     q = 'delete from ActiveSession where tStamp<"%s"' % int(time.time() - timeout) # delete inactive entries
  56     result = c.execute(q)
  57     q = 'update ActiveSession set tStamp=%s where sidHash="%s"' % (int(time.time()),sidHash)
  58     result = c.execute(q)
  59     c.close()
  60     if result == 1:
  61         return True
  62     return False
  63     
  64 
  65 class ExternalCookie(BaseAuth):
  66     name = 'external_cookie'
  67     # +++ The next 2 lines may be useful if you are overriding the username method in your themes.
  68     # +++  If commented out, wiki pages will not have login or logout hyperlinks
  69     login_inputs = ['username', 'password'] # +++ required to get a login hyperlink in wiki navigation area
  70     logout_possible = True # +++ required to get a logout hyperlink in wiki navigation area
  71 
  72     def request(self, request, user_obj, **kw):
  73         """Return (user-obj,False) if user is authenticated, else return (None,True). """
  74         # login = kw.get('login') # +++ example does not use this; login is expected in other application
  75         # user_obj = kw.get('user_obj')  # +++ example does not use this
  76         # username = kw.get('name') # +++ example does not use this
  77         # logout = kw.get('logout') # +++ example does not use this; logout is expected in other application
  78         import Cookie
  79         user = None  # user is not authenticated
  80         try_next = True  # if True, moin tries the next auth method in auth list
  81         
  82         otherAppCookie = "MoinAuth" # +++ username, email,useralias, session ID separated by #
  83         try:
  84             cookie = Cookie.SimpleCookie(request.saved_cookie)
  85         except Cookie.CookieError:
  86             cookie = None # ignore invalid cookies
  87 
  88         if cookie and otherAppCookie in cookie: # having this cookie means user auth has already been done in other application
  89             import urllib
  90             cookievalue = cookie[otherAppCookie].value
  91             # +++ decode and parse the cookie value - edit this to fit your needs.
  92             cookievalue = urllib.unquote(cookievalue) # cookie value is urlencoded, decode it
  93             cookievalue = cookievalue.decode('iso-8859-1') # decode cookie charset to unicode
  94             cookievalue = cookievalue.split('#') # cookie has format loginname#email#aliasname#sessionid
  95 
  96             email = aliasname = sessionid = ''
  97             try:  # extract fields from other app cookie
  98                 auth_username = cookievalue[0] # the wiki username
  99                 email = cookievalue[1] # email is required for user to change and save user preferences
 100                 aliasname = cookievalue[2] # aliasname is useful only if auth_username is not wiki-like
 101                 sessionid = cookievalue[3] # optional other app session ID  -- a unique timestamp or random number 
 102             except IndexError: 
 103                 pass  # do not need aliasname or sessionid unless you uncomment lines below
 104             #~ writeLog('auth_username',auth_username)
 105             #~ writeLog('email',email)
 106             #~ writeLog('aliasname',aliasname)
 107             #~ writeLog('sessionid',sessionid)
 108 
 109             # +++ any hacker can create a cookie, uncomment these lines to verify the cookie was created by the other application
 110             # if auth_username:
 111                 # import hashlib  # +++ python 2.5; see http://code.krypto.org/python/hashlib for 2.3, 2.4 download
 112                 # sidHash = hashlib.md5(cookie[otherAppCookie].value).hexdigest() 
 113                 # sidOK = verifySession(sidHash) # verify user is currently logged on to the other application +++ or use verifySessionPlus
 114                 # if not sidOK:
 115                     # auth_username = None
 116                     
 117             if auth_username:
 118                 # we have an authorized user, create the moin user object
 119                 from MoinMoin.user import User
 120                 # giving auth_username to User constructor means that authentication has already been done.
 121                 user = User(request, name=auth_username, auth_username=auth_username, auth_method=self.name)
 122                 changed = False
 123                 if email != user.email: # was the email addr externally updated?
 124                     user.email = email ; 
 125                     changed = True # yes -> update user profile
 126                 # if aliasname != user.aliasname: # +++ was the aliasname externally updated?
 127                     # user.aliasname = aliasname ; 
 128                     # changed = True # yes -> update user profile
 129 
 130                 if user:
 131                     user.create_or_update(changed)
 132                 if user and user.valid: 
 133                     try_next = False # have valid user; stop processing auth method list
 134         #~ writeLog(str(user), try_next)
 135         return user, try_next 
 136 
 137 
 138 class Config(DefaultConfig):
 139 #~ class FarmConfig(DefaultConfig):
 140 
 141     # from MoinMoin.auth import MoinAuth
 142     # auth = [ExternalCookie(), MoinAuth()] # try external_cookie, then normal moin login
 143     auth = [ExternalCookie()] # only way to login is external application
 144     
 145     # +++ these are suggested changes to the user preferences form if the  external_cookie  is the only auth method
 146     user_form_disable = ['name', 'aliasname', 'email',] # don't let the user change these, but show them
 147     user_form_remove = ['password', 'password2', 'css_url', 'logout', 'create', 'account_sendmail','jid'] # remove completely
 148 
 149     user_autocreate = True # +++ Moin will autocreate a new user ID if none exists
 150 
 151 # +++++++++++++++ end of external_cookie  example,  your custom configurations continue below 

   1     def username(self, d):
   2         """ Assemble the username / userprefs link
   3         
   4         @param d: parameter dictionary
   5         @rtype: unicode
   6         @return: username html
   7         """
   8         request = self.request
   9         _ = request.getText
  10 
  11         userlinks = []
  12         # Add username/homepage link for registered users. We don't care
  13         # if it exists, the user can create it.
  14         if request.user.valid and request.user.name:
  15             interwiki = wikiutil.getInterwikiHomePage(request)
  16             name = request.user.name
  17             aliasname = request.user.aliasname
  18             if not aliasname:
  19                 aliasname = name
  20             title = "%s @ %s" % (aliasname, interwiki[0])
  21             # link to (interwiki) user homepage
  22             homelink = (request.formatter.interwikilink(1, title=title, id="userhome", generated=True, *interwiki) +
  23                         request.formatter.text(name) +
  24                         request.formatter.interwikilink(0, title=title, id="userhome", *interwiki))
  25             userlinks.append(homelink)
  26             # link to userprefs action
  27             if 'userprefs' not in self.request.cfg.actions_excluded:
  28                 userlinks.append(d['page'].link_to(request, text=_('Settings'),
  29                                                querystr={'action': 'userprefs'}, id='userprefs', rel='nofollow'))
  30 
  31         if request.user.valid:  
  32             if request.user.auth_method in request.cfg.auth_can_logout:
  33                 userlinks.append('<a href="/myapp/Logout">%s</a>' % _('Logout', formatted=False)) # +++ other app logout page
  34         else:
  35             query = {'action': 'login'}
  36             # special direct-login link if the auth methods want no input
  37             if request.cfg.auth_login_inputs == ['special_no_input']:
  38                 query['login'] = '1'
  39             if request.cfg.auth_have_login:
  40                 userlinks.append('<a  href="/myapp/Login">%s</a>' % _("Login", formatted=False)) # +++ other app login page
  41 
  42         userlinks = [u'<li>%s</li>' % link for link in userlinks]
  43         html = u'<ul id="username">%s</ul>' % ''.join(userlinks)
  44         return html