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 __init__(self, autocreate=False):
  73         self.autocreate = autocreate
  74         BaseAuth.__init__(self)
  75 
  76     def request(self, request, user_obj, **kw):
  77         """Return (user-obj,False) if user is authenticated, else return (None,True). """
  78         # login = kw.get('login') # +++ example does not use this; login is expected in other application
  79         # user_obj = kw.get('user_obj')  # +++ example does not use this
  80         # username = kw.get('name') # +++ example does not use this
  81         # logout = kw.get('logout') # +++ example does not use this; logout is expected in other application
  82         import Cookie
  83         user = None  # user is not authenticated
  84         try_next = True  # if True, moin tries the next auth method in auth list
  85         
  86         otherAppCookie = "MoinAuth" # +++ username, email,useralias, session ID separated by #
  87         try:
  88             cookie = Cookie.SimpleCookie(request.saved_cookie)
  89         except Cookie.CookieError:
  90             cookie = None # ignore invalid cookies
  91 
  92         if cookie and otherAppCookie in cookie: # having this cookie means user auth has already been done in other application
  93             import urllib
  94             cookievalue = cookie[otherAppCookie].value
  95             # +++ decode and parse the cookie value - edit this to fit your needs.
  96             cookievalue = urllib.unquote(cookievalue) # cookie value is urlencoded, decode it
  97             cookievalue = cookievalue.decode('iso-8859-1') # decode cookie charset to unicode
  98             cookievalue = cookievalue.split('#') # cookie has format loginname#email#aliasname#sessionid
  99 
 100             email = aliasname = sessionid = ''
 101             try:  # extract fields from other app cookie
 102                 auth_username = cookievalue[0] # the wiki username
 103                 email = cookievalue[1] # email is required for user to change and save user preferences
 104                 aliasname = cookievalue[2] # aliasname is useful only if auth_username is not wiki-like
 105                 sessionid = cookievalue[3] # optional other app session ID  -- a unique timestamp or random number 
 106             except IndexError: 
 107                 pass  # do not need aliasname or sessionid unless you uncomment lines below
 108             #~ writeLog('auth_username',auth_username)
 109             #~ writeLog('email',email)
 110             #~ writeLog('aliasname',aliasname)
 111             #~ writeLog('sessionid',sessionid)
 112 
 113             # +++ any hacker can create a cookie, uncomment these lines to verify the cookie was created by the other application
 114             # if auth_username:
 115                 # import hashlib  # +++ python 2.5; see http://code.krypto.org/python/hashlib for 2.3, 2.4 download
 116                 # sidHash = hashlib.md5(cookie[otherAppCookie].value).hexdigest() 
 117                 # sidOK = verifySession(sidHash) # verify user is currently logged on to the other application +++ or use verifySessionPlus
 118                 # if not sidOK:
 119                     # auth_username = None
 120                     
 121             if auth_username:
 122                 # we have an authorized user, create the moin user object
 123                 from MoinMoin.user import User
 124                 # giving auth_username to User constructor means that authentication has already been done.
 125                 user = User(request, name=auth_username, auth_username=auth_username, auth_method=self.name)
 126                 changed = False
 127                 if email != user.email: # was the email addr externally updated?
 128                     user.email = email ; 
 129                     changed = True # yes -> update user profile
 130                 # if aliasname != user.aliasname: # +++ was the aliasname externally updated?
 131                     # user.aliasname = aliasname ; 
 132                     # changed = True # yes -> update user profile
 133 
 134                 if user:
 135                     user.create_or_update(changed)
 136                 if user and user.valid: 
 137                     try_next = False # have valid user; stop processing auth method list
 138         #~ writeLog(str(user), try_next)
 139         return user, try_next 
 140 
 141 
 142 class Config(DefaultConfig):
 143 #~ class FarmConfig(DefaultConfig):
 144 
 145     # from MoinMoin.auth import MoinAuth
 146     # auth = [ExternalCookie(autocreate=True), MoinAuth()] # try external_cookie, then normal moin login
 147     auth = [ExternalCookie(autocreate=True)] # only way to login is external application; create a new user if none exists
 148     
 149     # +++ these are suggested changes to the user preferences form if the  external_cookie  is the only auth method
 150     user_form_disable = ['name', 'aliasname', 'email',] # don't let the user change these, but show them
 151     user_form_remove = ['password', 'password2', 'css_url', 'logout', 'create', 'account_sendmail','jid'] # remove completely
 152 
 153 # +++++++++++++++ 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