source: fedd/access_to_abac.py @ 2e46f35

axis_examplecompt_changesinfo-ops
Last change on this file since 2e46f35 was 2e46f35, checked in by mikeryan <mikeryan@…>, 8 years ago

switch to /usr/bin/env python to run python

  • Property mode set to 100755
File size: 14.5 KB
Line 
1#!/usr/bin/env python
2
3import sys, os
4import re
5import subprocess
6import os.path
7
8from string import join
9from optparse import OptionParser, OptionValueError
10from tempfile import mkdtemp
11
12from federation.fedid import fedid
13from federation.authorizer import abac_authorizer
14from federation.util import abac_split_cert, abac_pem_type, file_expanding_opts
15
16
17class attribute:
18    '''
19    Encapculate a principal/attribute/link tuple.
20    '''
21    bad_attr = re.compile('[^a-zA-Z0-9_]+')
22    def __init__(self, p, a, l=None):
23        self.principal = p
24        self.attr = attribute.bad_attr.sub('_', a)
25        if l: self.link = attribute.bad_attr.sub('_', l)
26        else: self.link = None
27
28    def __str__(self):
29        if self.link:
30            return "%s.%s.%s" % (self.principal, self.attr, self.link)
31        elif self.attr:
32            return "%s.%s" % (self.principal, self.attr)
33        else:
34            return "%s" % self.principal
35
36class credential:
37    '''
38    A Credential, that is the requisites (as attributes) and the assigned
39    attribute (as principal, attr).   If req is iterable, the requirements are
40    an intersection/conjunction.
41    '''
42    bad_attr = re.compile('[^a-zA-Z0-9_]+')
43    def __init__(self, p, a, req):
44        self.principal = p
45        if isinstance(a, (tuple, list, set)) and len(a) == 1:
46            self.attr = credential.bad_attr.sub('_', a[0])
47        else:
48            self.attr = credential.bad_attr.sub('_', a)
49        self.req = req
50
51    def __str__(self):
52        if isinstance(self.req, (tuple, list, set)):
53            return "%s.%s <- %s" % (self.principal, self.attr, 
54                    join(["%s" % r for r in self.req], ' & '))
55        else:
56            return "%s.%s <- %s" % (self.principal, self.attr, self.req)
57
58# Mappinng generation function and the access parser throw these when there is
59# a parsing problem.
60class parse_error(RuntimeError): pass
61
62# Error creating a credential
63class credential_error(RuntimeError): pass
64
65# Functions to parse the individual access maps as well as an overall function
66# to parse generic ones.  The specific ones create a credential to local
67# attributes mapping and the global one creates the access policy credentials.
68
69#  All the local parsing functions get the unparsed remainder of the line
70#  (after the three-name and the attribute it maps to), the credential list to
71#  add the new ABAC credential(s) that will be mapped into the loacl
72#  credentials, the fedid of this entity, a dict mapping the local credentials
73#  to ABAC credentials that are required to exercise those local rights and the
74#  three-name (p, gp, gu) that is being mapped.
75def parse_emulab(l, creds, me, to_id, p, gp, gu, lr):
76    '''
77    Parse the emulab (project, allocation_user, access_user) format.  Access
78    users are deprecates and allocation users used for both.  This fuction
79    collapses them.
80    '''
81    right_side_str = '\s*,\s*\(\s*%s\s*,\s*%s\s*,\s*%s\s*\)' % \
82            (id_same_str, id_same_str,id_same_str)
83
84    m = re.match(right_side_str, l)
85    if m:
86        project, user = m.group(1,2)
87        # Resolve "<same>"s in project and user
88        if project == '<same>':
89            if gp  is not None:
90                project = gp
91            else:
92                raise parse_error("Project cannot be decisively mapped: %s" % l)
93        if user == '<same>':
94            if gu is not None:
95                user = gu
96            else:
97                raise parse_error("User cannot be decisively mapped: %s" % l)
98
99        # Create a semi-mnemonic name for the destination credential (the one
100        # that will be mapped to the local attributes
101        if gp and gu:
102            a = 'project_%s_user_%s' % (gp, gu)
103        elif gp:
104            a = 'project_%s' % gp
105        elif gu:
106            a = 'user_%s' % gu
107        else:
108            raise parse_error("No mapping for %s/%s!?" % (gp, gu))
109
110        # Store the creds and map entries
111        c = credential(me, a, 
112                [attribute(p, x, lr) for x in (gp, gu) if x is not None])
113        creds.add(c)
114        if (project, user) in to_id: to_id[(project,user)].append(c)
115        else: to_id[(project,user)] = [ c ]
116    else:
117        raise parse_error("Badly formatted local mapping: %s" % l)
118
119
120def parse_protogeni(l, creds, me, to_id, p, gp, gu, lr):
121    '''
122    Parse the protoGENI (cert, user, user_key, cert_pw) format.
123    '''
124    right_side_str = '\s*,\s*\(\s*(%s)\s*,\s*(%s)\s*,\s*(%s)\s*,\s*(%s)\s*\)' \
125            % (path_str, id_str, path_str, id_str)
126
127    m = re.match(right_side_str, l)
128    if m:
129        cert, user, key, pw = m.group(1,2,3,4)
130        # The credential is formed from just the path (with / mapped to _) and
131        # the username.
132        acert = re.sub('/', '_', cert)
133
134        a = "cert_%s_user_%s" % (acert, user)
135
136        # Store em
137        c = credential(me, a, 
138                [attribute(p, x, lr) for x in (gp, gu) if x is not None])
139        creds.add(c)
140        if (cert, user, key, pw) in to_id: 
141            to_id[(cert, user, key, pw)].append(c)
142        else: 
143            to_id[(cert, user, key, pw)] = [ c ]
144    else:
145        raise parse_error("Badly formatted local mapping: %s" % l)
146
147def parse_dragon(l, creds, me, to_id, p, gp, gu, lr):
148    '''
149    Parse the dragon (repository_name) version.
150    '''
151    right_side_str = '\s*,\s*\(\s*(%s)\s*\)' % \
152            (id_str)
153
154    m = re.match(right_side_str, l)
155    if m:
156        repo= m.group(1)
157        c = credential(me, 'repo_%s' % repo, 
158                [attribute(p, x, lr) for x in (gp, gu) if x is not None])
159        creds.add(c)
160        if repo in to_id: to_id[repo].append(c)
161        else: to_id[repo] = [ c ]
162    else:
163        raise parse_error("Badly formatted local mapping: %s" % l)
164
165def parse_skel(l, creds, me, to_id, p, gp, gu, lr):
166    '''
167    Parse the skeleton (local_attr) version.
168    '''
169    right_side_str = '\s*,\s*\(\s*(%s)\s*\)' % \
170            (id_str)
171
172    m = re.match(right_side_str, l)
173    if m:
174        lattr = m.group(1)
175        c = credential(me, 'lattr_%s' % lattr, 
176                [attribute(p, x, lr) for x in (gp, gu) if x is not None])
177        creds.add(c)
178        if lattr in to_id: to_id[lattr].append(c)
179        else: to_id[lattr] = [ c ]
180    else:
181        raise parse_error("Badly formatted local mapping: %s" % l)
182
183# internal plug-ins have no local attributes.
184def parse_internal(l, creds, me, to_id, p, gp, gu, lr): pass
185
186
187def parse_access(fn, mapper, delegation_link):
188    """
189    Parse the access file, calling out to the mapper to parse specific
190    credential types.  Mappers are above this code.
191    """
192    creds = set()
193    to_id = { }
194    f = open(fn, "r")
195    for i, l in enumerate(f):
196        try:
197            if comment_re.match(l):
198                continue
199            else:
200                m =  line_re.match(l)
201                if m:
202                    p, da = m.group(1, 4)
203                    gp, gu = m.group(2, 3)
204                    if gp == '<any>': gp = None
205                    if gu == '<any>': gu = None
206
207                    creds.add(credential(me, da, 
208                            [attribute(p, x, delegation_link) \
209                                    for x in (gp, gu) \
210                                        if x is not None]))
211                    if m.group(5) and mapper:
212                        mapper(m.group(5), creds, me, to_id, p, gp, gu,
213                                delegation_link)
214                else:
215                    raise parse_error('Syntax error')
216        except parse_error, e:
217            f.close()
218            raise parse_error('Error on line %d of %s: %s' % \
219                    (i, fn, e.message))
220    f.close()
221
222    return creds, to_id
223
224
225
226class access_opts(file_expanding_opts):
227    '''
228    Parse the options for this program.  Most are straightforward, but the
229    mapper uses a callback to convert from a string to a local mapper function.
230    '''
231    # Valid mappers
232    mappers = { 
233            'emulab': parse_emulab, 
234            'dragon': parse_dragon,
235            'internal': parse_internal,
236            'skel': parse_skel,
237            'protogeni': parse_protogeni,
238            }
239
240    @staticmethod
241    def parse_mapper(opt, s, val, parser, dest):
242        if val in access_opts.mappers:
243            setattr(parser.values, dest, access_opts.mappers[val])
244        else:
245            raise OptionValueError('%s must be one of %s' % \
246                    (s, join(access_opts.mappers.keys(), ', ')))
247
248    def __init__(self):
249        file_expanding_opts.__init__(self, usage='%prog [opts] file [...]')
250        self.add_option('--cert', dest='cert', default=None,
251                type='str', action='callback', callback=self.expand_file,
252                help='my fedid as an X.509 certificate')
253        self.add_option('--key', dest='key', default=None,
254                type='str', action='callback', callback=self.expand_file,
255                help='key for the certificate')
256        self.add_option('--dir', dest='dir', default=None,
257                type='str', action='callback', callback=self.expand_file,
258                help='Output directory for credentials')
259        self.add_option('--type', action='callback', nargs=1, type='str',
260                callback=access_opts.parse_mapper, 
261                callback_kwargs = { 'dest': 'mapper'}, 
262                help='Type of access file to parse.  One of %s. ' %\
263                        join(access_opts.mappers.keys(), ', ') + \
264                        'Omit for generic parsing.')
265        self.add_option('--quiet', dest='quiet', action='store_true', 
266                default=False,
267                help='Do not print credential to local attribute map')
268        self.add_option('--no_create_creds', action='store_false', 
269                dest='create_creds', default=True,
270                help='Do not create credentials for rules.')
271        self.add_option('--file', dest='file', default=None,
272                type='str', action='callback', callback=self.expand_file,
273                help='Access DB to parse.  If this is present, ' + \
274                        'omit the positional filename')
275        self.add_option('--mapfile', dest='map', default=None,
276                type='str', action='callback', callback=self.expand_file,
277                help='File for the attribute to local authorization data')
278        self.add_option('--no-delegate', action='store_false', dest='delegate',
279                default=True,
280                help='do not accept delegated attributes with the ' +\
281                        'acting_for linking role')
282        self.add_option('--no_auth', action='store_false', dest='create_auth', 
283                default=True, help='do not create a full ABAC authorizer')
284        self.add_option('--debug', action='store_true', dest='debug', 
285                default=False, help='Just print actions')
286        self.set_defaults(mapper=None)
287
288def create_creds(creds, cert, key, dir, debug=False, 
289        creddy='/usr/local/bin/creddy'):
290    '''
291    Make the creddy calls to create the attributes from the list of credential
292    objects in the creds parameter.
293    '''
294    def attrs(r):
295        '''
296        Convert an attribute into creddy --subject-id and --subject-role
297        parameters
298        '''
299        if r.principal and r.link and r.attr:
300            return ['--subject-id=%s' % r.principal, 
301                    '--subject-role=%s.%s' % (r.attr, r.link),
302                    ]
303        elif r.principal and r.attr:
304            return ['--subject-id=%s' % r.principal, 
305                    '--subject-role=%s' %r.attr]
306        elif r.principal:
307            return ['--subject-id=%s' % r.prinicpal]
308        else:
309            raise parse_error('Attribute without a principal?')
310
311    # main line of create_creds
312    for i, c in enumerate(creds):
313        cmd = [creddy, '--attribute', '--issuer=%s' % cert, '--key=%s' % key,
314                '--role=%s' % c.attr, '--out=%s/cred%d_attr.der' % (dir, i)]
315        for r in c.req:
316            cmd.extend(attrs(r))
317        if debug:
318            print join(cmd)
319        else:
320            rv = subprocess.call(cmd)
321            if rv != 0:
322                raise credential_error("%s: %d" % (join(cmd), rv))
323
324def clear_dir(dir):
325    for path, dirs, files in os.walk(dir, topdown=False):
326        for f in files: os.unlink(os.path.join(path, f))
327        for d in dirs: os.rmdir(os.path.join(path, d))
328
329# Regular expressions and parts thereof for parsing
330comment_re = re.compile('^\s*#|^$')
331fedid_str = 'fedid:([0-9a-fA-F]{40})'
332id_str = '[a-zA-Z][\w_-]*'
333path_str = '[a-zA-Z_/\.-]+'
334id_any_str = '(%s|<any>)' % id_str
335id_same_str = '(%s|<same>)' % id_str
336left_side_str = '\(\s*%s\s*,\s*%s\s*,\s*%s\s*\)' % \
337        (fedid_str, id_any_str, id_any_str)
338right_side_str = '(%s)(\s*,\s*\(.*\))?' % (id_str)
339line_re = re.compile('%s\s*->\s*%s' % (left_side_str, right_side_str))
340
341p = access_opts()
342opts, args = p.parse_args()
343
344cert, key = None, None
345delete_certs = False
346delete_creds = False
347
348if opts.file:
349    args.append(opts.file)
350
351# Validate arguments
352if len(args) < 1:
353    sys.exit('No filenames given to parse')
354
355if opts.key:
356    if not os.access(opts.key, os.R_OK):
357        key = opts.key
358    else:
359        sys.exit('Cannot read key (%s)' % opts.key)
360
361if opts.dir:
362    if not os.access(opts.dir, os.F_OK):
363        try:
364            os.mkdir(opts.dir, 0700)
365        except EnvironmentError, e:
366            sys.exit("Cannot create %s: %s" % (e.filename, e.strerror))
367    if not os.path.isdir(opts.dir):
368        sys.exit('%s is not a directory' % opts.dir)
369    elif not os.access(opts.dir, os.W_OK):
370        sys.exit('%s is not writable' % opts.dir)
371
372if opts.create_auth:
373    creds_dir = mkdtemp()
374    delete_creds = True
375    auth_dir = opts.dir
376else:
377    creds_dir = opts.dir
378    auth_dir = None
379
380if opts.delegate: delegation_link = 'acting_for'
381else: delegation_link = None
382
383if not opts.mapper and (opts.map or opts.debug):
384    print >>sys.stderr, "No --type specified, mapping file will be empty."
385
386if opts.cert: 
387    try:
388        me = fedid(file=opts.cert) 
389    except EnvironmentError, e:
390        sys.exit('Bad --cert: %s (%s)' % (e.strerror, e.filename or '?!'))
391
392    if not opts.key:
393        if abac_pem_type(opts.cert) == 'both':
394            key, cert = abac_split_cert(opts.cert)
395            delete_certs = True
396    else:
397        cert = opts.cert
398else: 
399    print >>sys.stderr, 'No --cert, using dummy fedid'
400    me = fedid(hexstr='0123456789012345678901234567890123456789')
401    cert = None
402
403# The try block makes sure that credentials split into tmp files are deleted
404try:
405    # Do the parsing
406    for fn in args:
407        try:
408            creds, to_id = parse_access(fn, opts.mapper, delegation_link)
409        except parse_error, e:
410            print >> sys.stderr, "%s" % e
411            continue
412
413        except EnvironmentError, e:
414            print >>sys.stderr, "File error %s: %s" % \
415                    (e.filename or '!?', e.strerror) 
416            continue
417
418        # Credential output
419        if opts.create_creds:
420            if all([cert, key, opts.dir]):
421                try:
422                    create_creds([c for c in creds if c.principal == me],
423                            cert, key, creds_dir, opts.debug)
424                except credential_error, e:
425                    sys.exit('Credential creation failed: %s' % e)
426            else:
427                print >>sys.stderr, 'Cannot create credentials.  ' + \
428                        'Missing parameter'
429
430        # Local map output
431        if opts.map or opts.debug:
432            try:
433                if opts.map and opts.map != '-' and not opts.debug:
434                    f = open(opts.map, 'w')
435                else:
436                    f = sys.stdout
437                for k, c in to_id.items():
438                    # Keys are either a single string or a tuple of them; join
439                    # the tuples into a comma-separated string.
440                    if isinstance(k, basestring): rhs = k
441                    else: rhs = join(k, ', ')
442
443                    for a in set(["%s.%s" % (x.principal, x.attr) for x in c]):
444                        print >>f, "%s -> (%s)" % (a, rhs)
445            except EnvironmentError, e:
446                sys.exit("Cannot open %s: %s" % (e.filename or '!?', 
447                    e.strerror))
448
449        # Create an authorizer if requested.
450        if opts.create_auth:
451            clear_dir(auth_dir)
452            try:
453                # Pass in the options rather than the potentially split key
454                # because abac_authorizer will split it and store it
455                # internally.  The opts.cert may get split twice, but we won't
456                # lose one.
457                a = abac_authorizer(key=opts.key, me=opts.cert, 
458                        certs=creds_dir, save=auth_dir)
459                a.save(auth_dir)
460            except EnvironmentError, e:
461                sys.exit("Can't create or write %s: %s" % \
462                        (e.filename, e.strerror))
463            except abac_authorizer.bad_cert_error, e:
464                sys.exit("Error creating authorizer: %s" % e)
465
466finally:
467    try:
468        if delete_certs:
469            if cert: os.unlink(cert)
470            if key: os.unlink(key)
471        if delete_creds and creds_dir:
472            clear_dir(creds_dir)
473            os.rmdir(creds_dir)
474    except EnvironmentError, e:
475        sys.exit("Can't remove %s: %s" % ( e.filename, e.strerror))
Note: See TracBrowser for help on using the repository browser.