source: TI07-MOLES/trunk/StubB/XSLT/browse/portal/cgi/browse/secure.py @ 1211

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI07-MOLES/trunk/StubB/XSLT/browse/portal/cgi/browse/secure.py@1211
Revision 1211, 7.7 KB checked in by lawrence, 13 years ago (diff)

More tiny modifications ..

Line 
1from Utilities import wrapGetText
2from NDG.SecurityClient import *
3
4class AccessControl:
5       
6        ''' Handle the access control metadata and provide three attributes of the
7        access control: exists (existence), status (modified elsewhere for whether
8        user can access data), and html (a message about the constraints). '''
9       
10        def __init__(self,e):
11                if e is None:
12                        self.status=1
13                        self.exist=0
14                        self.html=''
15                else:
16                        #for now assume everything with a simplecondition is deny
17                        self.html='Need Role: %s'%wrapGetText(e,'dgSecurityCondition/simpleCondition/attrauthRole')
18                        self.htmlLong=wrapGetText(e,'dgSecurityCondition/conditionExplanationText')
19                        sc='dgSecurityCondition/simpleCondition/'
20                        self.SimpleCondition=(wrapGetText(e,sc+'attrauthRole'),
21                                              wrapGetText(e,sc+'dgAttributeAuthority'))
22                        if self.SimpleCondition==('',''): self.SimpleCondition=None
23                        self.status=0
24                        self.exist=1
25               
26class gateway2NDGsession:
27       
28        ''' This class provides a gateway to the NDG session manager and methods upon it '''
29
30        def __init__(self,url,config,desiredAA=None,cookie=None,cmdLine=None):
31               
32                ''' The use case is that we attempt to establish a gateway to an
33                existing NDG session. If it exists, fine, if it doesn't, then we
34                don't do anything, but wait til a check call before attempting
35                to establish a connection ... that way we can prompt with an appropriate
36                set of hosts.
37               
38                If an NDG cookie exists, or we have it on the commandline, we use it
39                by reEstablishing to the existing session.
40                '''
41               
42                #First we have to see if the ndgsecurity info is in the cooki
43                self.url=url
44                self.connected=0
45                self.config=config
46                self.cookie=cookie
47               
48                if cookie is not None:
49                    self.cookieContents=self.__SecCookie()
50                    if self.cookieContents is not None: 
51                        self.__reEstablish()
52                        return
53                if cmdLine is not None:
54                    self.__reEstablish()
55                    self.cookieContents=cmdLine
56               
57               
58        def check(self, parsedSimpleCondition):
59                ''' can the credentials in the wallet support access to the resource requiring
60                the role at wsdlAA - parsedSimpleCondition is a tuple - (role, wsdlAA) '''
61                #connect using cookie
62
63                #first make sure we've got real conditions, if not, deny ...
64                if parsedSimpleCondition is None: return 0
65
66                #if not connected, get connected
67                if not self.connected: return self.__Establish(parsedSimpleCondition)
68
69                sessID,eSMWSDLuri=self.cookieContents
70                resp = self.smClient.reqAuthorisation(
71                                sessID=sessID,
72                                encrSessMgrWSDLuri=eSMWSDLuri,
73                                reqRole=parsedSimpleCondition[0],
74                                aaWSDL=parsedSimpleCondition[1],
75                                mapFromTrustedHosts=True,
76                                            clntPriKeyPwd=None # not using encrypted yet
77                                                        )
78                if 'errMsg' in resp:
79                    msgSfx = ": " + resp['errMsg']
80                else:
81                    msgSfx = ""
82
83                return resp['statCode'] + msgSfx
84               
85        def __SecCookie(self):
86                ''' Check the current cookie and see if it contains security information, but
87                we (the CGI) don't need to parse it - that's done in the NDG session client'''
88                if self.cookie is None:
89                    return None
90                else:
91                    try:
92                        for i in ('NDG-ID1','NDG-ID2'): 
93                            if i not in self.cookie: return None
94                    except: 
95                        return None
96                return (self.cookie['NDG-ID1'].value,self.cookie['NDG-ID2'].value)
97
98                                               
99        def __Establish(self,parsedSimpleCondition):
100                ''' Establish an NDG security session. We work out who to login
101                with by getting the list of trusted hosts from the parsedSimpleCondition
102                (which is just a tuple - role, attribute authority). This results in
103                a redirect to a user chosen host, after which we get back a URI with
104                the cookie posted as a (hidden) uri argument '''
105               
106                AA=AttAuthorityClient(aaWSDL=parsedSimpleCondition[1])
107                hostInfo = AA.getHostInfo()
108                loginHostList=[]
109                for key in hostInfo:
110                    loginHostList.append((key,hostInfo[key]['loginURI']))
111                trustedHostDict=AA.getTrustedHostInfo(role=parsedSimpleCondition[0])
112                for key in trustedHostDict:
113                    loginHostList.append((key,trustedHostDict[key]['loginURI']))
114               
115                return self.__showSiteList(loginHostList)
116               
117        def __reEstablish(self):
118                ''' bind to local session manager which acts as a proxy '''
119               
120                self.__loadKeys()
121                smWSDL=self.config.get('security','localSM',None)
122                try:
123                        #set up session client
124                        # (all these keys to do message level encryption while talking to server,
125                        # see __loadKeys for more details)
126                        self.smClient = SessionClient(smWSDL=smWSDL,
127                                    smPubKeyFilePath=self.__localSessionManagerPublicKey,
128                                    clntPubKeyFilePath=self.__thisCGIpublicKey,
129                                    clntPriKeyFilePath=self.__thisCGIprivateKey)
130                        self.connected=1
131                except Exception, e:
132                        # Socket error returns tuple - reformat to just give msg
133                        #raise SecurityCGIError("Session client: " + str(e))
134                        pass # for now we don't have the libraries or code attached
135       
136        def __loadKeys(self):
137                ''' Load security keys '''
138               
139                # We (potentially) need the public and private keys of this cgi script
140                # and the public key of the session client if our communication goes
141                # out over the public network and we want to deploy message
142                # level encryption.
143                 
144                #However, for the first installation, we will assume both the CGI and
145                #the session manager are running behind the same firewall.
146               
147                self.__thisCGIpublicKey=None
148                self.__thisCGIprivateKey=None
149               
150                #these are the things I need to talk to my local session manager
151                self.__localSessionManagerPublicKey=None
152                self.__localSessionManagerProxyWSDL=self.config.get('Security','localSM',None)
153               
154                #we need to call out to smWSDL to get their public key as a first step?
155                #self.__remoteSessionManagerPublicKey=self.__getKey(smWSDL)
156               
157                return
158       
159        def __getPublicKey(self,smWSDL):
160                ''' Given the WSDL address of a session manager object, get the public key associated
161                with it '''
162                return None
163       
164        def __showSiteList(self,loginList,heading=''):
165            '''Show the user a list of trusted hosts, and redirect to one of them '''
166            html='''<p> Access to resource [<b>%s</b>] requires credentials, please login ...'
167                    <hr>
168                    <form action="https://glue.badc.rl.ac.uk/cgi-bin/security.py" method="POST">
169                    <table bgcolor=#ADD8E6 cellspacing=0 border=0 cellpadding=5>
170                    <tbody><tr>
171                    <td><select name="requestURI">
172                    <option value="">Select your home site...'''%self.url
173            for i,j in loginList:
174                html+='<option value="%s">%s'%(j,i)
175            html+='''</select></td>
176                    <td align="right"><input type=submit value="Login"></td>
177                    </tr></tbody>
178                    </table>
179                    <input type="hidden" name="returnURI" value="%s">
180                    </form>
181                    </body>
182                    </html>'''%self.url
183            return html
184
185   
186   
Note: See TracBrowser for help on using the repository browser.