Some additional indexing
[mirror/userdir-ldap.git] / ud-generate
1 #!/usr/bin/env python
2 # -*- mode: python -*-
3 # Generates passwd, shadow and group files from the ldap directory.
4
5 #   Copyright (c) 2000-2001  Jason Gunthorpe <jgg@debian.org>
6 #   Copyright (c) 2003-2004  James Troup <troup@debian.org>
7 #   Copyright (c) 2004-2005,7  Joey Schulze <joey@infodrom.org>
8 #   Copyright (c) 2001-2007  Ryan Murray <rmurray@debian.org>
9 #   Copyright (c) 2008 Peter Palfrader <peter@palfrader.org>
10 #   Copyright (c) 2008 Andreas Barth <aba@not.so.argh.org>
11 #   Copyright (c) 2008 Mark Hymers <mhy@debian.org>
12 #   Copyright (c) 2008 Luk Claes <luk@debian.org>
13 #   Copyright (c) 2008 Thomas Viehmann <tv@beamnet.de>
14 #   Copyright (c) 2009 Stephen Gran <steve@lobefin.net>
15 #
16 #   This program is free software; you can redistribute it and/or modify
17 #   it under the terms of the GNU General Public License as published by
18 #   the Free Software Foundation; either version 2 of the License, or
19 #   (at your option) any later version.
20 #
21 #   This program is distributed in the hope that it will be useful,
22 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
23 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24 #   GNU General Public License for more details.
25 #
26 #   You should have received a copy of the GNU General Public License
27 #   along with this program; if not, write to the Free Software
28 #   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29
30 import string, re, time, ldap, getopt, sys, os, pwd, posix, socket, base64, sha, shutil, errno, tarfile, grp
31 from userdir_ldap import *
32 from userdir_exceptions import *
33
34 global Allowed
35 global CurrentHost
36
37 PasswdAttrs = None
38 DebianUsers = None
39 DisabledUsers = []
40 GroupIDMap = {}
41 SubGroupMap = {}
42 Allowed = None
43 CurrentHost = ""
44
45 UUID_FORMAT = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
46
47 EmailCheck = re.compile("^([^ <>@]+@[^ ,<>@]+)?$")
48 BSMTPCheck = re.compile(".*mx 0 (gluck)\.debian\.org\..*",re.DOTALL)
49 PurposeHostField = re.compile(r".*\[\[([\*\-]?[a-z0-9.\-]*)(?:\|.*)?\]\]")
50 DNSZone = ".debian.net"
51 Keyrings = ConfModule.sync_keyrings.split(":")
52
53 def safe_makedirs(dir):
54    try:
55       os.makedirs(dir)
56    except OSError, e:
57       if e.errno == errno.EEXIST:
58          pass
59       else:
60          raise e
61
62 def safe_rmtree(dir):
63    try:
64       shutil.rmtree(dir)
65    except OSError, e:
66       if e.errno == errno.ENOENT:
67          pass
68       else:
69          raise e
70
71 def Sanitize(Str):
72    return Str.translate(string.maketrans("\n\r\t", "$$$"))
73
74 def DoLink(From, To, File):
75    try: 
76       posix.remove(To + File)
77    except: 
78       pass
79    posix.link(From + File, To + File)
80
81 def IsRetired(DnRecord):
82    """
83    Looks for accountStatus in the LDAP record and tries to
84    match it against one of the known retired statuses
85    """
86
87    status = GetAttr(DnRecord, "accountStatus", None)
88    if status is None:
89       return False
90
91    line = status.split()
92    status = line[0]
93    
94    if status == "inactive":
95       return True
96
97    elif status == "memorial":
98       return True
99
100    elif status == "retiring":
101       # We'll give them a few extra days over what we said
102       age = 6 * 31 * 24 * 60 * 60
103       try:
104          return (time.time() - time.mktime(time.strptime(line[1], "%Y-%m-%d"))) > age
105       except IndexError:
106          return False
107       except ValueError:
108          return False
109
110    return False
111
112 def IsGidDebian(x):
113    try:
114       return int(GetAttr(x, "gidNumber", 0)) == 800
115    except ValueError:
116       return False
117
118 # See if this user is in the group list
119 def IsInGroup(DnRecord):
120   if Allowed is None:
121      return True
122
123   # See if the primary group is in the list
124   if Allowed.has_key(GetAttr(DnRecord, "gidNumber")) != 0:
125      return True
126
127   # Check the host based ACL
128   if DnRecord[1].has_key("allowedHost") != 0:
129      if CurrentHost in DnRecord[1]["allowedHost"]:
130         return True
131
132   # See if there are supplementary groups
133   if DnRecord[1].has_key("supplementaryGid") == 0:
134      return False
135
136   supgroups=[]
137   addGroups(supgroups, DnRecord[1]["supplementaryGid"], GetAttr(DnRecord, "uid"))
138   for g in supgroups:
139      if Allowed.has_key(g):
140         return True
141   return False
142
143 def Die(File, F, Fdb):
144    if F != None:
145       F.close()
146    if Fdb != None:
147       Fdb.close()
148    try: 
149       os.remove(File + ".tmp")
150    except:
151       pass
152    try: 
153       os.remove(File + ".tdb.tmp")
154    except: 
155       pass
156
157 def Done(File, F, Fdb):
158    if F != None:
159       F.close()
160       os.rename(File + ".tmp", File)
161    if Fdb != None:
162       Fdb.close()
163       os.rename(File + ".tdb.tmp", File + ".tdb")
164
165 # Generate the password list
166 def GenPasswd(File, HomePrefix, PwdMarker):
167    F = None
168    try:
169       F = open(File + ".tdb.tmp", "w")
170      
171       userlist = {}
172       # Fetch all the users
173       global PasswdAttrs
174      
175       I = 0
176       for x in PasswdAttrs:
177          if x[1].has_key("uidNumber") == 0 or not IsInGroup(x):
178             continue
179      
180          # Do not let people try to buffer overflow some busted passwd parser.
181          if len(GetAttr(x, "gecos")) > 100 or len(GetAttr(x, "loginShell")) > 50:
182             continue
183      
184          userlist[GetAttr(x, "uid")] = int(GetAttr(x, "gidNumber"))
185          Line = "%s:%s:%s:%s:%s:%s%s:%s" % (GetAttr(x, "uid"),\
186                  PwdMarker,\
187                  GetAttr(x, "uidNumber"), GetAttr(x, "gidNumber"),\
188                  GetAttr(x, "gecos"), HomePrefix, GetAttr(x, "uid"),\
189                  GetAttr(x, "loginShell"))
190      
191          Line = Sanitize(Line) + "\n"
192          F.write("0%u %s" % (I, Line))
193          F.write(".%s %s" % (GetAttr(x, "uid"), Line))
194          F.write("=%s %s" % (GetAttr(x, "uidNumber"), Line))
195          I = I + 1
196   
197    # Oops, something unspeakable happened.
198    except:
199       Die(File, None, F)
200       raise
201    Done(File, None, F)
202
203    # Return the list of users so we know which keys to export
204    return userlist
205
206 # Generate the shadow list
207 def GenShadow(File):
208    F = None
209    try:
210       OldMask = os.umask(0077)
211       F = open(File + ".tdb.tmp", "w", 0600)
212       os.umask(OldMask)
213      
214       # Fetch all the users
215       global PasswdAttrs
216      
217       I = 0
218       for x in PasswdAttrs:
219          if x[1].has_key("uidNumber") == 0 or not IsInGroup(x):
220             continue
221      
222          Pass = GetAttr(x, "userPassword")
223          if Pass[0:7] != "{crypt}" or len(Pass) > 50:
224             Pass = '*'
225          else:
226             Pass = Pass[7:]
227      
228          # If the account is locked, mark it as such in shadow
229          # See Debian Bug #308229 for why we set it to 1 instead of 0
230          if (GetAttr(x, "userPassword").find("*LK*") != -1) \
231              or GetAttr(x, "userPassword").startswith("!"):
232             ShadowExpire = '1'
233          else:
234             ShadowExpire = GetAttr(x, "shadowExpire")
235      
236          Line = "%s:%s:%s:%s:%s:%s:%s:%s:" % (GetAttr(x, "uid"),\
237                  Pass, GetAttr(x, "shadowLastChange"),\
238                  GetAttr(x, "shadowMin"), GetAttr(x, "shadowMax"),\
239                  GetAttr(x, "shadowWarning"), GetAttr(x, "shadowInactive"),\
240                  ShadowExpire)
241          Line = Sanitize(Line) + "\n"
242          F.write("0%u %s" % (I, Line))
243          F.write(".%s %s" % (GetAttr(x, "uid"), Line))
244          I = I + 1
245   
246    # Oops, something unspeakable happened.
247    except:
248       Die(File, None, F)
249       raise
250    Done(File, None, F)
251
252 # Generate the sudo passwd file
253 def GenShadowSudo(File, untrusted):
254    F = None
255    try:
256       OldMask = os.umask(0077)
257       F = open(File + ".tmp", "w", 0600)
258       os.umask(OldMask)
259      
260       # Fetch all the users
261       global PasswdAttrs
262      
263       for x in PasswdAttrs:
264          Pass = '*'
265          if x[1].has_key("uidNumber") == 0 or not IsInGroup(x):
266             continue
267      
268          if x[1].has_key('sudoPassword'):
269             for entry in x[1]['sudoPassword']:
270                Match = re.compile('^('+UUID_FORMAT+') (confirmed:[0-9a-f]{40}|unconfirmed) ([a-z0-9.,*]+) ([^ ]+)$').match(entry)
271                if Match == None:
272                   continue
273                uuid = Match.group(1)
274                status = Match.group(2)
275                hosts = Match.group(3)
276                cryptedpass = Match.group(4)
277      
278                if status != 'confirmed:'+make_passwd_hmac('password-is-confirmed', 'sudo', x[1]['uid'][0], uuid, hosts, cryptedpass):
279                   continue
280                for_all = hosts == "*"
281                for_this_host = CurrentHost in hosts.split(',')
282                if not (for_all or for_this_host):
283                   continue
284                # ignore * passwords for untrusted hosts, but copy host specific passwords
285                if for_all and untrusted:
286                   continue
287                Pass = cryptedpass
288                if for_this_host: # this makes sure we take a per-host entry over the for-all entry
289                   break
290             if len(Pass) > 50:
291                Pass = '*'
292      
293          Line = "%s:%s" % (GetAttr(x, "uid"), Pass)
294          Line = Sanitize(Line) + "\n"
295          F.write("%s" % (Line))
296   
297    # Oops, something unspeakable happened.
298    except:
299       Die(File, F, None)
300       raise
301    Done(File, F, None)
302
303 # Generate the shadow list
304 def GenSSHShadow():
305    # Fetch all the users
306    userfiles = []
307
308    global PasswdAttrs
309
310    safe_rmtree(os.path.join(GlobalDir, 'userkeys'))
311    safe_makedirs(os.path.join(GlobalDir, 'userkeys'))
312
313    for x in PasswdAttrs:
314
315       if x[1].has_key("uidNumber") == 0 or \
316          x[1].has_key("sshRSAAuthKey") == 0:
317          continue
318
319       User = GetAttr(x, "uid")
320       F = None
321
322       try:
323          OldMask = os.umask(0077)
324          File = os.path.join(GlobalDir, 'userkeys', User)
325          F = open(File + ".tmp", "w", 0600)
326          os.umask(OldMask)
327
328          for I in x[1]["sshRSAAuthKey"]:
329             MultipleLine = "%s" % I
330             MultipleLine = Sanitize(MultipleLine) + "\n"
331             F.write(MultipleLine)
332
333          Done(File, F, None)
334          userfiles.append(os.path.basename(File))
335
336       # Oops, something unspeakable happened.
337       except IOError:
338          Die(File, F, None)
339          Die(masterFileName, masterFile, None)
340          raise
341
342    return userfiles
343
344 def GenSSHtarballs(userlist, SSHFiles, grouprevmap, target):
345    OldMask = os.umask(0077)
346    tf = tarfile.open(name=os.path.join(GlobalDir, 'ssh-keys-%s.tar.gz' % CurrentHost), mode='w:gz')
347    os.umask(OldMask)
348    for f in userlist.keys():
349       if f not in SSHFiles:
350          continue
351       # If we're not exporting their primary group, don't export
352       # the key and warn
353       grname = None
354       if userlist[f] in grouprevmap.keys():
355          grname = grouprevmap[userlist[f]]
356       else:
357          try:
358             if int(userlist[f]) <= 100:
359                # In these cases, look it up in the normal way so we
360                # deal with cases where, for instance, users are in group
361                # users as their primary group.
362                grname = grp.getgrgid(userlist[f])[0]
363          except Exception, e:
364             pass
365
366       if grname is None:
367          print "User %s is supposed to have their key exported to host %s but their primary group (gid: %d) isn't in LDAP" % (f, CurrentHost, userlist[f])
368          continue
369
370       to = tf.gettarinfo(os.path.join(GlobalDir, 'userkeys', f), f)
371       # These will only be used where the username doesn't
372       # exist on the target system for some reason; hence,
373       # in those cases, the safest thing is for the file to
374       # be owned by root but group nobody.  This deals with
375       # the bloody obscure case where the group fails to exist
376       # whilst the user does (in which case we want to avoid
377       # ending up with a file which is owned user:root to avoid
378       # a fairly obvious attack vector)
379       to.uid = 0
380       to.gid = 65534
381       # Using the username / groupname fields avoids any need
382       # to give a shit^W^W^Wcare about the UIDoffset stuff.
383       to.uname = f
384       to.gname = grname
385       to.mode  = 0400
386       tf.addfile(to, file(os.path.join(GlobalDir, 'userkeys', f)))
387
388    tf.close()
389    os.rename(os.path.join(GlobalDir, 'ssh-keys-%s.tar.gz' % CurrentHost), target)
390
391 # add a list of groups to existing groups,
392 # including all subgroups thereof, recursively.
393 # basically this proceduces the transitive hull of the groups in
394 # addgroups.
395 def addGroups(existingGroups, newGroups, uid):
396    for group in newGroups:
397       # if it's a <group>@host, split it and verify it's on the current host.
398       s = group.split('@', 1)
399       if len(s) == 2 and s[1] != CurrentHost:
400          continue
401       group = s[0]
402
403       # let's see if we handled this group already
404       if group in existingGroups:
405          continue
406
407       if not GroupIDMap.has_key(group):
408          print "Group", group, "does not exist but", uid, "is in it"
409          continue
410
411       existingGroups.append(group)
412
413       if SubGroupMap.has_key(group):
414          addGroups(existingGroups, SubGroupMap[group], uid)
415
416 # Generate the group list
417 def GenGroup(File):
418    grouprevmap = {}
419    F = None
420    try:
421       F = open(File + ".tdb.tmp", "w")
422      
423       # Generate the GroupMap
424       GroupMap = {}
425       for x in GroupIDMap.keys():
426          GroupMap[x] = []
427      
428       # Fetch all the users
429       global PasswdAttrs
430      
431       # Sort them into a list of groups having a set of users
432       for x in PasswdAttrs:
433          uid = GetAttr(x, "uid")
434          if x[1].has_key("uidNumber") == 0 or not IsInGroup(x):
435             continue
436          if x[1].has_key("supplementaryGid") == 0:
437             continue
438      
439          supgroups=[]
440          addGroups(supgroups, x[1]["supplementaryGid"], uid)
441          for g in supgroups:
442             GroupMap[g].append(uid)
443      
444       # Output the group file.
445       J = 0
446       for x in GroupMap.keys():
447          grouprevmap[GroupIDMap[x]] = x
448          if GroupIDMap.has_key(x) == 0:
449             continue
450          Line = "%s:x:%u:" % (x, GroupIDMap[x])
451          Comma = ''
452          for I in GroupMap[x]:
453             Line = Line + ("%s%s" % (Comma, I))
454             Comma = ','
455          Line = Sanitize(Line) + "\n"
456          F.write("0%u %s" % (J, Line))
457          F.write(".%s %s" % (x, Line))
458          F.write("=%u %s" % (GroupIDMap[x], Line))
459          J = J + 1
460   
461    # Oops, something unspeakable happened.
462    except:
463       Die(File, None, F)
464       raise
465    Done(File, None, F)
466   
467    return grouprevmap
468
469 def CheckForward():
470    global DebianUsers
471    for x in DebianUsers:
472       if x[1].has_key("emailForward") == 0:
473          continue
474    
475       if not IsInGroup(x):
476          x[1].pop("emailForward")
477          continue
478
479       # Do not allow people to try to buffer overflow busted parsers
480       if len(GetAttr(x, "emailForward")) > 200:
481          x[1].pop("emailForward")
482          continue
483
484       # Check the forwarding address
485       if EmailCheck.match(GetAttr(x, "emailForward")) == None:
486          x[1].pop("emailForward")
487
488 # Generate the email forwarding list
489 def GenForward(File):
490    F = None
491    try:
492       OldMask = os.umask(0022)
493       F = open(File + ".tmp", "w", 0644)
494       os.umask(OldMask)
495      
496       # Fetch all the users
497       global DebianUsers
498      
499       # Write out the email address for each user
500       for x in DebianUsers:
501          if x[1].has_key("emailForward") == 0:
502             continue
503      
504          Line = "%s: %s" % (GetAttr(x, "uid"), GetAttr(x, "emailForward"))
505          Line = Sanitize(Line) + "\n"
506          F.write(Line)
507   
508    # Oops, something unspeakable happened.
509    except:
510       Die(File, F, None)
511       raise
512    Done(File, F, None)
513
514 def GenAllForward(File):
515    Fdb = None
516    try:
517       OldMask = os.umask(0022)
518       Fdb = os.popen("cdbmake %s %s.tmp"%(File, File), "w")
519       os.umask(OldMask)
520      
521       # Fetch all the users
522       global DebianUsers
523      
524       # Write out the email address for each user
525       for x in DebianUsers:
526          if x[1].has_key("emailForward") == 0:
527             continue
528      
529          # Do not allow people to try to buffer overflow busted parsers
530          Forward = GetAttr(x, "emailForward")
531      
532          User = GetAttr(x, "uid")
533          Fdb.write("+%d,%d:%s->%s\n" % (len(User), len(Forward), User, Forward))
534   
535       Fdb.write("\n")
536    # Oops, something unspeakable happened.
537    except:
538       Fdb.close()
539       raise
540    if Fdb.close() != None:
541       raise "cdbmake gave an error"
542
543 # Generate the anon XEarth marker file
544 def GenMarkers(File):
545    F = None
546    try:
547       F = open(File + ".tmp", "w")
548      
549       # Fetch all the users
550       global DebianUsers
551      
552       # Write out the position for each user
553       for x in DebianUsers:
554          if x[1].has_key("latitude") == 0 or x[1].has_key("longitude") == 0:
555             continue
556          try:
557             Line = "%8s %8s \"\""%(DecDegree(GetAttr(x, "latitude"), 1), DecDegree(GetAttr(x, "longitude"), 1))
558             Line = Sanitize(Line) + "\n"
559             F.write(Line)
560          except:
561             pass
562   
563    # Oops, something unspeakable happened.
564    except:
565       Die(File, F, None)
566       raise
567    Done(File, F, None)
568
569 # Generate the debian-private subscription list
570 def GenPrivate(File):
571    F = None
572    try:
573       F = open(File + ".tmp", "w")
574      
575       # Fetch all the users
576       global DebianUsers
577      
578       # Write out the position for each user
579       for x in DebianUsers:
580          if x[1].has_key("privateSub") == 0:
581             continue
582      
583          # If the account has no PGP key, do not write it
584          if x[1].has_key("keyFingerPrint") == 0:
585             continue
586      
587          try:
588             Line = "%s"%(GetAttr(x, "privateSub"))
589             Line = Sanitize(Line) + "\n"
590             F.write(Line)
591          except:
592             pass
593   
594    # Oops, something unspeakable happened.
595    except:
596       Die(File, F, None)
597       raise
598    Done(File, F, None)
599
600 # Generate a list of locked accounts
601 def GenDisabledAccounts(File):
602    F = None
603    try:
604       F = open(File + ".tmp", "w")
605      
606       # Fetch all the users
607       global PasswdAttrs
608       global DisabledUsers
609      
610       I = 0
611       for x in PasswdAttrs:
612          if x[1].has_key("uidNumber") == 0:
613             continue
614      
615          Pass = GetAttr(x, "userPassword")
616          Line = ""
617          # *LK* is the reference value for a locked account
618          # password starting with ! is also a locked account
619          if Pass.find("*LK*") != -1 or Pass.startswith("!"):
620             # Format is <login>:<reason>
621             Line = "%s:%s" % (GetAttr(x, "uid"), "Account is locked")
622             DisabledUsers.append(x)
623      
624          if Line != "":
625             F.write(Sanitize(Line) + "\n")
626      
627    
628    # Oops, something unspeakable happened.
629    except:
630       Die(File, F, None)
631       raise
632    Done(File, F, None)
633
634 # Generate the list of local addresses that refuse all mail
635 def GenMailDisable(File):
636    F = None
637    try:
638       F = open(File + ".tmp", "w")
639      
640       # Fetch all the users
641       global DebianUsers
642      
643       for x in DebianUsers:
644          Reason = None
645      
646          if x[1].has_key("mailDisableMessage"):
647             Reason = GetAttr(x, "mailDisableMessage")
648          else:
649             continue
650      
651          try:
652             Line = "%s: %s"%(GetAttr(x, "uid"), Reason)
653             Line = Sanitize(Line) + "\n"
654             F.write(Line)
655          except:
656             pass
657   
658    # Oops, something unspeakable happened.
659    except:
660       Die(File, F, None)
661       raise
662    Done(File, F, None)
663
664 # Generate a list of uids that should have boolean affects applied
665 def GenMailBool(File, Key):
666    F = None
667    try:
668       F = open(File + ".tmp", "w")
669      
670       # Fetch all the users
671       global DebianUsers
672      
673       for x in DebianUsers:
674          Reason = None
675      
676          if x[1].has_key(Key) == 0:
677             continue
678      
679          if GetAttr(x, Key) != "TRUE":
680             continue
681      
682          try:
683             Line = "%s"%(GetAttr(x, "uid"))
684             Line = Sanitize(Line) + "\n"
685             F.write(Line)
686          except:
687             pass
688   
689    # Oops, something unspeakable happened.
690    except:
691       Die(File, F, None)
692       raise
693    Done(File, F, None)
694
695 # Generate a list of hosts for RBL or whitelist purposes.
696 def GenMailList(File, Key):
697    F = None
698    try:
699       F = open(File + ".tmp", "w")
700      
701       # Fetch all the users
702       global DebianUsers
703      
704       for x in DebianUsers:
705          Reason = None
706      
707          if x[1].has_key(Key) == 0:
708             continue
709      
710          try:
711             found = 0
712             Line = None
713             for z in x[1][Key]:
714                 if Key == "mailWhitelist":
715                    if re.match('^[-\w.]+(/[\d]+)?$', z) == None:
716                       continue
717                 else:
718                    if re.match('^[-\w.]+$', z) == None:
719                       continue
720                 if found == 0:
721                    found = 1
722                    Line = GetAttr(x, "uid")
723                 else:
724                     Line += " "
725                 Line += ": " + z
726                 if Key == "mailRHSBL":
727                    Line += "/$sender_address_domain"
728      
729             if Line != None:
730                Line = Sanitize(Line) + "\n"
731                F.write(Line)
732          except:
733             pass
734   
735    # Oops, something unspeakable happened.
736    except:
737       Die(File, F, None)
738       raise
739    Done(File, F, None)
740
741 def isRoleAccount(pwEntry):
742    if not pwEntry.has_key("objectClass"):
743       raise "pwEntry has no objectClass"
744    oc =  pwEntry['objectClass']
745    try:
746       i = oc.index('debianRoleAccount')
747       return True
748    except ValueError:
749       return False
750
751 # Generate the DNS Zone file
752 def GenDNS(File, HomePrefix):
753    F = None
754    try:
755       F = open(File + ".tmp", "w")
756      
757       # Fetch all the users
758       global PasswdAttrs
759      
760       # Write out the zone file entry for each user
761       for x in PasswdAttrs:
762          if x[1].has_key("dnsZoneEntry") == 0:
763             continue
764      
765          # If the account has no PGP key, do not write it
766          if x[1].has_key("keyFingerPrint") == 0 and not isRoleAccount(x[1]):
767             continue
768          try:
769             F.write("; %s\n"%(EmailAddress(x)))
770             for z in x[1]["dnsZoneEntry"]:
771                Split = z.lower().split()
772                if Split[1].lower() == 'in':
773                   for y in range(0, len(Split)):
774                      if Split[y] == "$":
775                         Split[y] = "\n\t"
776                   Line = " ".join(Split) + "\n"
777                   F.write(Line)
778      
779                   Host = Split[0] + DNSZone
780                   if BSMTPCheck.match(Line) != None:
781                      F.write("; Has BSMTP\n")
782      
783                   # Write some identification information
784                   if Split[2].lower() == "a":
785                      Line = "%s IN TXT \"%s\"\n"%(Split[0], EmailAddress(x))
786                      for y in x[1]["keyFingerPrint"]:
787                         Line = Line + "%s IN TXT \"PGP %s\"\n"%(Split[0], FormatPGPKey(y))
788                      F.write(Line)
789                else:
790                   Line = "; Err %s"%(str(Split))
791                   F.write(Line)
792      
793             F.write("\n")
794          except:
795             F.write("; Errors\n")
796             pass
797   
798    # Oops, something unspeakable happened.
799    except:
800       Die(File, F, None)
801       raise
802    Done(File, F, None)
803
804 # Generate the DNS SSHFP records
805 def GenSSHFP(File, HomePrefix):
806    F = None
807    try:
808       F = open(File + ".tmp", "w")
809      
810       # Fetch all the hosts
811       global HostAttrs
812       if HostAttrs == None:
813          raise UDEmptyList, "No Hosts"
814      
815       for x in HostAttrs:
816          if x[1].has_key("hostname") == 0 or \
817             x[1].has_key("sshRSAHostKey") == 0:
818             continue
819          Host = GetAttr(x, "hostname")
820          Algorithm = None
821          for I in x[1]["sshRSAHostKey"]:
822             Split = I.split()
823             if Split[0] == 'ssh-rsa':
824                Algorithm = 1
825             if Split[0] == 'ssh-dss':
826                Algorithm = 2
827             if Algorithm == None:
828                continue
829             Fingerprint = sha.new(base64.decodestring(Split[1])).hexdigest()
830             Line = "%s. IN SSHFP %u 1 %s" % (Host, Algorithm, Fingerprint)
831             Line = Sanitize(Line) + "\n"
832             F.write(Line)
833    # Oops, something unspeakable happened.
834    except:
835       Die(File, F, None)
836       raise
837    Done(File, F, None)
838
839 # Generate the BSMTP file
840 def GenBSMTP(File, HomePrefix):
841    F = None
842    try:
843       F = open(File + ".tmp", "w")
844      
845       # Fetch all the users
846       global DebianUsers
847      
848       # Write out the zone file entry for each user
849       for x in DebianUsers:
850          if x[1].has_key("dnsZoneEntry") == 0:
851             continue
852      
853          # If the account has no PGP key, do not write it
854          if x[1].has_key("keyFingerPrint") == 0:
855             continue
856          try:
857             for z in x[1]["dnsZoneEntry"]:
858                Split = z.lower().split()
859                if Split[1].lower() == 'in':
860                   for y in range(0, len(Split)):
861                      if Split[y] == "$":
862                         Split[y] = "\n\t"
863                   Line = " ".join(Split) + "\n"
864      
865                   Host = Split[0] + DNSZone
866                   if BSMTPCheck.match(Line) != None:
867                       F.write("%s: user=%s group=Debian file=%s%s/bsmtp/%s\n"%(Host,
868                                   GetAttr(x, "uid"), HomePrefix, GetAttr(x, "uid"), Host))
869      
870          except:
871             F.write("; Errors\n")
872             pass
873   
874    # Oops, something unspeakable happened.
875    except:
876       Die(File, F, None)
877       raise
878    Done(File, F, None)
879   
880 #  cache IP adresses
881 HostToIPCache = {}
882 def HostToIP(Host):
883    global HostToIPCache
884    if not Host in HostToIPCache:
885       IPAdressesT = None
886       try:
887          IPAdressesT = list(set([ (a[0], a[4][0]) for a in socket.getaddrinfo(Host, None)]))
888       except socket.gaierror, (code):
889          if code[0] != -2:
890             raise
891       IPAdresses = []
892       if not IPAdressesT is None:
893          for addr in IPAdressesT:
894             if addr[0] == socket.AF_INET:
895                IPAdresses += [addr[1], "::ffff:"+addr[1]]
896             else:
897                IPAdresses += [addr[1]]
898       HostToIPCache[Host] = IPAdresses
899    return HostToIPCache[Host]
900
901 # Generate the ssh known hosts file
902 def GenSSHKnown(File, mode=None):
903    F = None
904    try:
905       OldMask = os.umask(0022)
906       F = open(File + ".tmp", "w", 0644)
907       os.umask(OldMask)
908      
909       global HostAttrs
910       if HostAttrs is None:
911          raise UDEmptyList, "No Hosts"
912      
913       for x in HostAttrs:
914          if x[1].has_key("hostname") == 0 or \
915             x[1].has_key("sshRSAHostKey") == 0:
916             continue
917          Host = GetAttr(x, "hostname")
918          HostNames = [ Host ]
919          if Host.endswith(HostDomain):
920             HostNames.append(Host[:-(len(HostDomain) + 1)])
921      
922          # in the purpose field [[host|some other text]] (where some other text is optional)
923          # makes a hyperlink on the web thing. we now also add these hosts to the ssh known_hosts
924          # file.  But so that we don't have to add everything we link we can add an asterisk
925          # and say [[*... to ignore it.  In order to be able to add stuff to ssh without
926          # http linking it we also support [[-hostname]] entries.
927          for i in x[1].get("purpose", []):
928             m = PurposeHostField.match(i)
929             if m:
930                m = m.group(1)
931                # we ignore [[*..]] entries
932                if m.startswith('*'):
933                   continue
934                if m.startswith('-'):
935                   m = m[1:]
936                if m:
937                   HostNames.append(m)
938                   if m.endswith(HostDomain):
939                      HostNames.append(m[:-(len(HostDomain) + 1)])
940      
941          for I in x[1]["sshRSAHostKey"]:
942             if mode and mode == 'authorized_keys':
943                #Line = 'command="rsync --server --sender -pr . /var/cache/userdir-ldap/hosts/%s",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,from="%s" %s' % (Host, ",".join(HNames + HostToIP(Host)), I)
944                Line = 'command="rsync --server --sender -pr . /var/cache/userdir-ldap/hosts/%s",no-port-forwarding,no-X11-forwarding,no-agent-forwarding %s' % (Host,I)
945             else:
946                Line = "%s %s" %(",".join(HostNames + HostToIP(Host)), I)
947             Line = Sanitize(Line) + "\n"
948             F.write(Line)
949    # Oops, something unspeakable happened.
950    except:
951       Die(File, F, None)
952       raise
953    Done(File, F, None)
954
955 # Generate the debianhosts file (list of all IP addresses)
956 def GenHosts(l, File):
957    F = None
958    try:
959       OldMask = os.umask(0022)
960       F = open(File + ".tmp", "w", 0644)
961       os.umask(OldMask)
962      
963       # Fetch all the hosts
964       hostnames = l.search_s(HostBaseDn, ldap.SCOPE_ONELEVEL, "hostname=*",
965                              ["hostname"])
966      
967       if hostnames is None:
968          raise UDEmptyList, "No Hosts"
969      
970       seen = set()
971       for x in hostnames:
972          host = GetAttr(x, "hostname", None)
973          if host:
974             addrs = []
975             try:
976                addrs += socket.getaddrinfo(host, None, socket.AF_INET)
977             except socket.error:
978                pass
979             try:
980                addrs += socket.getaddrinfo(host, None, socket.AF_INET6)
981             except socket.error:
982                pass
983            
984             for addrinfo in addrs:
985                if addrinfo[0] in (socket.AF_INET, socket.AF_INET6):
986                   addr = addrinfo[4][0]
987                   if addr not in seen:
988                      print >> F, addrinfo[4][0]
989                      seen.add(addr)
990    # Oops, something unspeakable happened.
991    except:
992       Die(File, F, None)
993       raise
994    Done(File, F, None)
995
996 def GenKeyrings(OutDir):
997    for k in Keyrings:
998       shutil.copy(k, OutDir)
999
1000 # Connect to the ldap server
1001 l = connectLDAP()
1002 F = open(PassDir + "/pass-" + pwd.getpwuid(os.getuid())[0], "r")
1003 Pass = F.readline().strip().split(" ")
1004 F.close()
1005 l.simple_bind_s("uid=" + Pass[0] + "," + BaseDn, Pass[1])
1006
1007 # Fetch all the groups
1008 GroupIDMap = {}
1009 Attrs = l.search_s(BaseDn, ldap.SCOPE_ONELEVEL, "gid=*",\
1010                   ["gid", "gidNumber", "subGroup"])
1011
1012 # Generate the SubGroupMap and GroupIDMap
1013 for x in Attrs:
1014    if x[1].has_key("gidNumber") == 0:
1015       continue
1016    GroupIDMap[x[1]["gid"][0]] = int(x[1]["gidNumber"][0])
1017    if x[1].has_key("subGroup") != 0:
1018       SubGroupMap.setdefault(x[1]["gid"][0], []).extend(x[1]["subGroup"])
1019
1020 # Fetch all the users
1021 PasswdAttrs = l.search_s(BaseDn, ldap.SCOPE_ONELEVEL, "uid=*",\
1022                 ["uid", "uidNumber", "gidNumber", "supplementaryGid",\
1023                  "gecos", "loginShell", "userPassword", "shadowLastChange",\
1024                  "shadowMin", "shadowMax", "shadowWarning", "shadowInactive",
1025                  "shadowExpire", "emailForward", "latitude", "longitude",\
1026                  "allowedHost", "sshRSAAuthKey", "dnsZoneEntry", "cn", "sn",\
1027                  "keyFingerPrint", "privateSub", "mailDisableMessage",\
1028                  "mailGreylisting", "mailCallout", "mailRBL", "mailRHSBL",\
1029                  "mailWhitelist", "sudoPassword", "objectClass", "accountStatus"])
1030
1031 if PasswdAttrs is None:
1032    raise UDEmptyList, "No Users"
1033
1034 # Fetch all the hosts
1035 HostAttrs    = l.search_s(HostBaseDn, ldap.SCOPE_ONELEVEL, "sshRSAHostKey=*",\
1036                 ["hostname", "sshRSAHostKey", "purpose"])
1037
1038 # Open the control file
1039 if len(sys.argv) == 1:
1040    F = open(GenerateConf, "r")
1041 else:
1042    F = open(sys.argv[1], "r")
1043
1044 # Generate global things
1045 GlobalDir = GenerateDir + "/"
1046 GenDisabledAccounts(GlobalDir + "disabled-accounts")
1047
1048 PasswdAttrs = filter(lambda x: not IsRetired(x), PasswdAttrs)
1049 #DebianUsers = filter(lambda x: IsGidDebian(x), PasswdAttrs)
1050 DebianUsers = PasswdAttrs
1051
1052 CheckForward()
1053
1054 GenMailDisable(GlobalDir + "mail-disable")
1055 GenAllForward(GlobalDir + "mail-forward.cdb")
1056 GenPrivate(GlobalDir + "debian-private")
1057 #GenSSHKnown(l,GlobalDir+"authorized_keys", 'authorized_keys')
1058 GenMailBool(GlobalDir + "mail-greylist", "mailGreylisting")
1059 GenMailBool(GlobalDir + "mail-callout", "mailCallout")
1060 GenMailList(GlobalDir + "mail-rbl", "mailRBL")
1061 GenMailList(GlobalDir + "mail-rhsbl", "mailRHSBL")
1062 GenMailList(GlobalDir + "mail-whitelist", "mailWhitelist")
1063 GenKeyrings(GlobalDir)
1064
1065 # Compatibility.
1066 GenForward(GlobalDir + "forward-alias")
1067
1068 PasswdAttrs = filter(lambda x: not x in DisabledUsers, PasswdAttrs)
1069
1070 SSHFiles = GenSSHShadow()
1071 GenMarkers(GlobalDir + "markers")
1072 GenSSHKnown(GlobalDir + "ssh_known_hosts")
1073 GenHosts(l, GlobalDir + "debianhosts")
1074
1075 while(1):
1076    Line = F.readline()
1077    if Line == "":
1078       break
1079    Line = Line.strip()
1080    if Line == "":
1081       continue
1082    if Line[0] == '#':
1083       continue
1084
1085    Split = Line.split(" ")
1086    OutDir = GenerateDir + '/' + Split[0] + '/'
1087    try:
1088       os.mkdir(OutDir)
1089    except: 
1090       pass
1091
1092    # Get the group list and convert any named groups to numerics
1093    GroupList = {}
1094    ExtraList = {}
1095    for I in Split[2:]:
1096       if I[0] == '[':
1097          ExtraList[I] = None
1098          continue
1099       GroupList[I] = None
1100       if GroupIDMap.has_key(I):
1101          GroupList[str(GroupIDMap[I])] = None
1102
1103    Allowed = GroupList
1104    if Allowed == {}:
1105       Allowed = None
1106    CurrentHost = Split[0]
1107
1108    DoLink(GlobalDir, OutDir, "debianhosts")
1109    DoLink(GlobalDir, OutDir, "ssh_known_hosts")
1110    DoLink(GlobalDir, OutDir, "disabled-accounts")
1111
1112    sys.stdout.flush()
1113    if ExtraList.has_key("[NOPASSWD]"):
1114       userlist = GenPasswd(OutDir + "passwd", Split[1], "*")
1115    else:
1116       userlist = GenPasswd(OutDir + "passwd", Split[1], "x")
1117    sys.stdout.flush()
1118    grouprevmap = GenGroup(OutDir + "group")
1119    GenShadowSudo(OutDir + "sudo-passwd", ExtraList.has_key("[UNTRUSTED]") or ExtraList.has_key("[NOPASSWD]"))
1120
1121    # Now we know who we're allowing on the machine, export
1122    # the relevant ssh keys
1123    GenSSHtarballs(userlist, SSHFiles, grouprevmap, os.path.join(OutDir, 'ssh-keys.tar.gz'))
1124
1125    if ExtraList.has_key("[UNTRUSTED]"):
1126       print "[UNTRUSTED] tag is obsolete and may be removed in the future."
1127       continue
1128    if not ExtraList.has_key("[NOPASSWD]"):
1129       GenShadow(OutDir + "shadow")
1130
1131    # Link in global things
1132    if not ExtraList.has_key("[NOMARKERS]"):
1133       DoLink(GlobalDir, OutDir, "markers")
1134    DoLink(GlobalDir, OutDir, "mail-forward.cdb")
1135    DoLink(GlobalDir, OutDir, "mail-disable")
1136    DoLink(GlobalDir, OutDir, "mail-greylist")
1137    DoLink(GlobalDir, OutDir, "mail-callout")
1138    DoLink(GlobalDir, OutDir, "mail-rbl")
1139    DoLink(GlobalDir, OutDir, "mail-rhsbl")
1140    DoLink(GlobalDir, OutDir, "mail-whitelist")
1141
1142    # Compatibility.
1143    DoLink(GlobalDir, OutDir, "forward-alias")
1144
1145    if ExtraList.has_key("[DNS]"):
1146       GenDNS(OutDir + "dns-zone", Split[1])
1147       GenSSHFP(OutDir + "dns-sshfp", Split[1])
1148
1149    if ExtraList.has_key("[BSMTP]"):
1150       GenBSMTP(OutDir + "bsmtp", Split[1])
1151
1152    if ExtraList.has_key("[PRIVATE]"):
1153       DoLink(GlobalDir, OutDir, "debian-private")
1154
1155    if ExtraList.has_key("[KEYRING]"):
1156       for k in Keyrings:
1157         DoLink(GlobalDir, OutDir, os.path.basename(k))
1158    else:
1159       for k in Keyrings:
1160          try: 
1161             posix.remove(OutDir + os.path.basename(k))
1162          except:
1163             pass
1164
1165 # vim:set et:
1166 # vim:set ts=3:
1167 # vim:set shiftwidth=3: