ud-mailgate: remove exception for m√ľnchen.debian.net
[mirror/userdir-ldap.git] / ud-mailgate
1 #!/usr/bin/env python
2 # -*- mode: python -*-
3
4 #   Prior copyright probably rmurray, troup, joey, jgg -- weasel 2008
5 #   Copyright (c) 2009 Stephen Gran <steve@lobefin.net>
6 #   Copyright (c) 2008,2009,2010 Peter Palfrader <peter@palfrader.org>
7 #   Copyright (c) 2008 Joerg Jaspert <joerg@debian.org>
8 #   Copyright (c) 2010 Helmut Grohne <helmut@subdivi.de>
9
10 import userdir_gpg
11 import userdir_ldap
12 import sys
13 import traceback
14 import time
15 import ldap
16 import os
17 import commands
18 import pwd
19 import tempfile
20 import subprocess
21 import email
22 import email.parser
23 import binascii
24
25 from userdir_gpg import *
26 from userdir_ldap import *
27 from userdir_exceptions import *
28
29 # Error codes from /usr/include/sysexits.h
30 ReplyTo = ConfModule.replyto
31 PingFrom = ConfModule.pingfrom
32 ChPassFrom = ConfModule.chpassfrom
33 ChangeFrom = ConfModule.changefrom
34 ReplayCacheFile = ConfModule.replaycachefile
35 SSHFingerprintFile = ConfModule.fingerprintfile
36 TOTPTicketDirectory = ConfModule.totpticketdirectory
37 WebUILocation = ConfModule.webuilocation
38
39 UUID_FORMAT = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
40 machine_regex = re.compile("^[0-9a-zA-Z.-]+$")
41
42 EX_TEMPFAIL = 75
43 EX_PERMFAIL = 65      # EX_DATAERR
44 Error = 'Message Error'
45 SeenKey = 0
46 SeenDNS = 0
47 mailRBL = {}
48 mailRHSBL = {}
49 mailWhitelist = {}
50 SeenList = {}
51 DNS = {}
52 ValidHostNames = []  # will be initialized in later
53
54 SSHFingerprint = re.compile(r'^(\d+) ([0-9a-f\:]{47}|SHA256:[0-9A-Za-z/+]{43}) (.+)$')
55 SSHRSA1Match = re.compile(r'^^(.* )?\d+ \d+ \d+')
56
57 ArbChanges = {"c": "..",
58               "l": ".*",
59               "facsimileTelephoneNumber": ".*",
60               "telephoneNumber": ".*",
61               "postalAddress": ".*",
62               "bATVToken": ".*",
63               "postalCode": ".*",
64               "loginShell": ".*",
65               "emailForward": "^([^<>@]+@.+)?$",
66               "jabberJID": "^([^<>@]+@.+)?$",
67               "ircNick": ".*",
68               "icqUin": "^[0-9]*$",
69               "onVacation": ".*",
70               "labeledURI": ".*",
71               "birthDate": "^([0-9]{4})([01][0-9])([0-3][0-9])$",
72               "mailDisableMessage": ".*",
73               "mailGreylisting": "^(TRUE|FALSE)$",
74               "mailCallout": "^(TRUE|FALSE)$",
75               "mailDefaultOptions": "^(TRUE|FALSE)$",
76               "VoIP": ".*",
77               "mailContentInspectionAction": "^(reject|blackhole|markup)$", }
78
79 DelItems = {"c": None,
80             "l": None,
81             "facsimileTelephoneNumber": None,
82             "telephoneNumber": None,
83             "postalAddress": None,
84             "bATVToken": None,
85             "postalCode": None,
86             "emailForward": None,
87             "ircNick": None,
88             "onVacation": None,
89             "labeledURI": None,
90             "latitude": None,
91             "longitude": None,
92             "icqUin": None,
93             "jabberJID": None,
94             "jpegPhoto": None,
95             "dnsZoneEntry": None,
96             "sshRSAAuthKey": None,
97             "birthDate": None,
98             "mailGreylisting": None,
99             "mailCallout": None,
100             "mailRBL": None,
101             "mailRHSBL": None,
102             "mailWhitelist": None,
103             "mailDisableMessage": None,
104             "mailDefaultOptions": None,
105             "VoIP": None,
106             "mailContentInspectionAction": None,
107             }
108
109
110 # Decode a GPS location from some common forms
111 def LocDecode(Str, Dir):
112     # Check for Decimal degrees, DGM, or DGMS
113     if re.match(r"^[+-]?[\d.]+$", Str) is not None:
114         return Str
115
116     Deg = '0'
117     Min = None
118     Sec = None
119     Dr = Dir[0]
120
121     # Check for DDDxMM.MMMM where x = [nsew]
122     Match = re.match(r"^(\d+)([" + Dir + r"])([\d.]+)$", Str)
123     if Match:
124         G = Match.groups()
125         Deg = G[0]
126         Min = G[2]
127         Dr = G[1]
128
129     # Check for DD.DD x
130     Match = re.match(r"^([\d.]+) ?([" + Dir + r"])$", Str)
131     if Match:
132         G = Match.groups()
133         Deg = G[0]
134         Dr = G[1]
135
136     # Check for DD:MM.MM x
137     Match = re.match(r"^(\d+):([\d.]+) ?([" + Dir + "])$", Str)
138     if Match:
139         G = Match.groups()
140         Deg = G[0]
141         Min = G[1]
142         Dr = G[2]
143
144     # Check for DD:MM:SS.SS x
145     Match = re.match(r"^(\d+):(\d+):([\d.]+) ?([" + Dir + "])$", Str)
146     if Match:
147         G = Match.groups()
148         Deg = G[0]
149         Min = G[1]
150         Sec = G[2]
151         Dr = G[3]
152
153     # Some simple checks
154     if float(Deg) > 180:
155         raise UDFormatError("Bad degrees")
156     if Min is not None and float(Min) > 60:
157         raise UDFormatError("Bad minutes")
158     if Sec is not None and float(Sec) > 60:
159         raise UDFormatError("Bad seconds")
160
161     # Pad on an extra leading 0 to disambiguate small numbers
162     if len(Deg) <= 1 or Deg[1] == '.':
163         Deg = '0' + Deg
164     if Min is not None and (len(Min) <= 1 or Min[1] == '.'):
165         Min = '0' + Min
166     if Sec is not None and (len(Sec) <= 1 or Sec[1] == '.'):
167         Sec = '0' + Sec
168
169     # Construct a DGM/DGMS type value from the components.
170     Res = "+"
171     if Dr == Dir[1]:
172         Res = "-"
173     Res = Res + Deg
174     if Min is not None:
175         Res = Res + Min
176     if Sec is not None:
177         Res = Res + Sec
178     return Res
179
180
181 # Handle changing a set of arbitary fields
182 #  <field>: value
183 def DoArbChange(Str, Attrs):
184     Match = re.match("^([^ :]+): (.*)$", Str)
185     if Match is None:
186         return None
187     G = Match.groups()
188
189     attrName = G[0].lower()
190     for i in ArbChanges.keys():
191         if i.lower() == attrName:
192             attrName = i
193             break
194     if attrName not in ArbChanges:
195         return None
196
197     value = G[1]
198     if re.match(ArbChanges[attrName], value) is None:
199         raise UDFormatError("Item does not match the required format" + ArbChanges[attrName])
200
201     Attrs.append((ldap.MOD_REPLACE, attrName, value))
202     return "Changed entry %s to %s" % (attrName, value)
203
204
205 # Handle changing a set of arbitary fields
206 #  <field>: value
207 def DoDel(Str, Attrs):
208     Match = re.match("^del (.*)$", Str)
209     if Match is None:
210         return None
211     G = Match.groups()
212
213     attrName = G[0].lower()
214     for i in DelItems.keys():
215         if i.lower() == attrName:
216             attrName = i
217             break
218     if attrName not in DelItems:
219         return "Cannot erase entry %s" % (attrName,)
220
221     Attrs.append((ldap.MOD_DELETE, attrName, None))
222     return "Removed entry %s" % (attrName)
223
224
225 # Handle a position change message, the line format is:
226 #  Lat: -12412.23 Long: +12341.2342
227 def DoPosition(Str, Attrs):
228     Match = re.match(r"^lat: ([+\-]?[\d:.ns]+(?: ?[ns])?) long: ([+\-]?[\d:.ew]+(?: ?[ew])?)$", Str.lower())
229     if Match is None:
230         return None
231
232     G = Match.groups()
233     try:
234         sLat = LocDecode(G[0], "ns")
235         sLong = LocDecode(G[1], "ew")
236         Lat = DecDegree(sLat, 1)
237         Long = DecDegree(sLong, 1)
238     except Exception:
239         raise UDFormatError("Positions were found, but they are not correctly formed")
240
241     Attrs.append((ldap.MOD_REPLACE, "latitude", sLat))
242     Attrs.append((ldap.MOD_REPLACE, "longitude", sLong))
243     return "Position set to %s/%s (%s/%s decimal degrees)" % (sLat, sLong, Lat, Long)
244
245
246 # Load bad ssh fingerprints
247 def LoadBadSSH():
248     f = open(SSHFingerprintFile, "r")
249     bad = []
250     FingerprintLine = re.compile(r'^([0-9a-f:]{47}).*$')
251     for line in f.readlines():
252         Match = FingerprintLine.match(line)
253         if Match is not None:
254             g = Match.groups()
255             bad.append(g[0])
256     return bad
257
258
259 # Handle an SSH authentication key, the line format is:
260 #  [options] 1024 35 13188913666680[..] [comment]
261 # maybe it really should be:
262 # [allowed_hosts=machine1,machine2 ][options ]ssh-rsa keybytes [comment]
263 def DoSSH(Str, Attrs, badkeys, uid):
264     Match = SSH2AuthSplit.match(Str)
265     if Match is None:
266         return None
267     g = Match.groups()
268     typekey = g[1]
269     if Match is None:
270         Match = SSHRSA1Match.match(Str)
271         if Match is not None:
272             return "RSA1 keys not supported anymore"
273         return None
274
275     # lines can now be prepended with "allowed_hosts=machine1,machine2 "
276     machines = []
277     if Str.startswith("allowed_hosts="):
278         Str = Str.split("=", 1)[1]
279         if ' ' not in Str:
280             return "invalid ssh key syntax with machine specification"
281         machines, Str = Str.split(' ', 1)
282         machines = machines.split(",")
283         for m in machines:
284             if not m:
285                 return "empty machine specification for ssh key"
286             if not machine_regex.match(m):
287                 return "machine specification for ssh key contains invalid characters"
288             if m not in ValidHostNames:
289                 return "unknown machine {} used in allowed_hosts stanza for ssh keys".format(m)
290
291     (fd, path) = tempfile.mkstemp(".pub", "sshkeytry", "/tmp")
292     f = open(path, "w")
293     f.write("%s\n" % (Str))
294     f.close()
295     cmd = "/usr/bin/ssh-keygen -l -f %s < /dev/null" % (path)
296     (result, output) = commands.getstatusoutput(cmd)
297     os.remove(path)
298     if (result != 0):
299         raise UDExecuteError("ssh-keygen -l invocation failed!\n%s\n" % (output))
300
301     # format the string again for ldap:
302     if machines:
303         Str = "allowed_hosts=%s %s" % (",".join(machines), Str)
304
305     # Head
306     Date = time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime(time.time()))
307     ErrReplyHead = "From: %s\nCc: %s\nReply-To: %s\nDate: %s\n" % (os.environ['SENDER'], os.environ['SENDER'], ReplyTo, Date)
308     Subst = {}
309     Subst["__ADMIN__"] = ReplyTo
310     Subst["__USER__"] = uid
311
312     Match = SSHFingerprint.match(output)
313     if Match is None:
314         return "Failed to match SSH fingerprint, has the output of ssh-keygen changed?"
315     g = Match.groups()
316     key_size = g[0]
317     fingerprint = g[1]
318
319     if typekey == "rsa":
320         key_size_ok = (int(key_size) >= 2048)
321     elif typekey == "ed25519":
322         key_size_ok = True
323     else:
324         key_size_ok = False
325
326     if not key_size_ok:
327         return "SSH key fails formal criteria, not added.  We only accept RSA keys (>= 2048 bits) or ed25519 keys."
328     elif fingerprint in badkeys:
329         try:
330             # Body
331             Subst["__ERROR__"] = "SSH key with fingerprint %s known as bad key" % (g[1])
332             ErrReply = TemplateSubst(Subst, open(TemplatesDir + "admin-info", "r").read())
333
334             Child = os.popen("/usr/sbin/sendmail -t", "w")
335             Child.write(ErrReplyHead)
336             Child.write(ErrReply)
337             if Child.close() is not None:
338                 raise UDExecuteError("Sendmail gave a non-zero return code")
339         except Exception:
340             sys.exit(EX_TEMPFAIL)
341
342         # And now break and stop processing input, which sends a reply to the user.
343         raise UDFormatError("Submitted SSH key known to be bad and insecure, processing halted, NOTHING MODIFIED AT ALL")
344
345     global SeenKey
346     if SeenKey:
347         Attrs.append((ldap.MOD_ADD, "sshRSAAuthKey", Str))
348         return "SSH Key added: %s %s [%s]" % (key_size, fingerprint, FormatSSHAuth(Str))
349
350     Attrs.append((ldap.MOD_REPLACE, "sshRSAAuthKey", Str))
351     SeenKey = 1
352     return "SSH Keys replaced with: %s %s [%s]" % (key_size, fingerprint, FormatSSHAuth(Str))
353
354
355 # Handle changing a dns entry
356 #  host IN A     12.12.12.12
357 #  host IN AAAA  1234::5678
358 #  host IN CNAME foo.bar.    <- Trailing dot is required
359 #  host IN MX    foo.bar.    <- Trailing dot is required
360 def DoDNS(Str, Attrs, DnRecord):
361     cnamerecord = re.match(r"^[-\w]+\s+IN\s+CNAME\s+([-\w.]+\.)$", Str, re.IGNORECASE)
362     arecord = re.match(r'^[-\w]+\s+IN\s+A\s+(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$', Str, re.IGNORECASE)
363     mxrecord = re.match(r"^[-\w]+\s+IN\s+MX\s+(\d{1,3})\s+([-\w.]+\.)$", Str, re.IGNORECASE)
364     txtrecord = re.match(r"^[-\w]+\s+IN\s+TXT\s+([-\d. a-z\t<>@:]+)", Str, re.IGNORECASE)
365     aaaarecord = re.match(r'^[-\w]+\s+IN\s+AAAA\s+([A-F0-9:]{2,39})$', Str, re.IGNORECASE)
366
367     if cnamerecord is None and\
368        arecord is None and\
369        mxrecord is None and\
370        txtrecord is None and\
371        aaaarecord is None:
372         return None
373
374     # Check for punycode.  We ought to validate it before we allow it in our zone.
375     if Str.lower().startswith('xn--'):
376         return "Punycode not allowed: " + Str
377
378     # Check if the name is already taken
379     G = re.match(r'^([-\w+]+)\s', Str)
380     if G is None:
381         raise UDFormatError("Hostname not found although we already passed record syntax checks")
382     hostname = G.group(1)
383
384     # Check for collisions
385     global lc
386     # [JT 20070409 - search for both tab and space suffixed hostnames
387     #  since we accept either.  It'd probably be better to parse the
388     #  incoming string in order to construct what we feed LDAP rather
389     #  than just passing it through as is.]
390     filter = "(|(dnsZoneEntry=%s        *)(dnsZoneEntry=%s *))" % (hostname, hostname)
391     Rec = lc.search_s(BaseDn, ldap.SCOPE_ONELEVEL, filter, ["uid"])
392     for x in Rec:
393         if GetAttr(x, "uid") != GetAttr(DnRecord, "uid"):
394             return "DNS entry is already owned by " + GetAttr(x, "uid")
395
396     global SeenDNS
397     global DNS
398
399     if cnamerecord:
400         if hostname in DNS:
401             return "CNAME and other RR types not allowed: " + Str
402         else:
403             DNS[hostname] = 2
404     else:
405         if DNS.get(hostname) == 2:
406             return "CNAME and other RR types not allowed: " + Str
407         else:
408             DNS[hostname] = 1
409
410     if cnamerecord is not None:
411         sanitized = "%s IN CNAME %s" % (hostname, cnamerecord.group(1))
412     elif txtrecord is not None:
413         sanitized = "%s IN TXT %s" % (hostname, txtrecord.group(1))
414     elif arecord is not None:
415         ipaddress = arecord.group(1)
416         for quad in ipaddress.split('.'):
417             if not (int(quad) >= 0 and int(quad) <= 255):
418                 return "Invalid quad %s in IP address %s in line %s" % (quad, ipaddress, Str)
419         sanitized = "%s IN A %s" % (hostname, ipaddress)
420     elif mxrecord is not None:
421         priority = mxrecord.group(1)
422         mx = mxrecord.group(2)
423         sanitized = "%s IN MX %s %s" % (hostname, priority, mx)
424     elif aaaarecord is not None:
425         ipv6address = aaaarecord.group(1)
426         parts = ipv6address.split(':')
427         if len(parts) > 8:
428             return "Invalid IPv6 address (%s): too many parts" % (ipv6address)
429         if len(parts) <= 2:
430             return "Invalid IPv6 address (%s): too few parts" % (ipv6address)
431         if parts[0] == "":
432             parts.pop(0)
433         if parts[-1] == "":
434             parts.pop(-1)
435         seenEmptypart = False
436         for p in parts:
437             if len(p) > 4:
438                 return "Invalid IPv6 address (%s): part %s is longer than 4 characters" % (ipv6address, p)
439             if p == "":
440                 if seenEmptypart:
441                     return "Invalid IPv6 address (%s): more than one :: (nothing in between colons) is not allowed" % (ipv6address)
442                 seenEmptypart = True
443             sanitized = "%s IN AAAA %s" % (hostname, ipv6address)
444     else:
445         raise UDFormatError("None of the types I recognize was it.  I shouldn't be here.  confused.")
446
447     if SeenDNS:
448         Attrs.append((ldap.MOD_ADD, "dnsZoneEntry", sanitized))
449         return "DNS Entry added " + sanitized
450
451     Attrs.append((ldap.MOD_REPLACE, "dnsZoneEntry", sanitized))
452     SeenDNS = 1
453     return "DNS Entry replaced with " + sanitized
454
455
456 # Handle an RBL list (mailRBL, mailRHSBL, mailWhitelist)
457 def DoRBL(Str, Attrs):
458     Match = re.compile('^mail(rbl|rhsbl|whitelist) ([-a-z0-9.]+)$').match(Str.lower())
459     if Match is None:
460         return None
461
462     if Match.group(1) == "rbl":
463         Key = "mailRBL"
464     if Match.group(1) == "rhsbl":
465         Key = "mailRHSBL"
466     if Match.group(1) == "whitelist":
467         Key = "mailWhitelist"
468     Host = Match.group(2)
469
470     global SeenList
471     if Key in SeenList:
472         Attrs.append((ldap.MOD_ADD, Key, Host))
473         return "%s added %s" % (Key, Host)
474
475     Attrs.append((ldap.MOD_REPLACE, Key, Host))
476     SeenList[Key] = 1
477     return "%s replaced with %s" % (Key, Host)
478
479
480 # Handle a ConfirmSudoPassword request
481 def DoConfirmSudopassword(Str, SudoPasswd):
482     Match = re.compile('^confirm sudopassword (' + UUID_FORMAT + ') ([a-z0-9.,*-]+) ([0-9a-f]{40})$').match(Str)
483     if Match is None:
484         return None
485
486     uuid = Match.group(1)
487     hosts = Match.group(2)
488     hmac = Match.group(3)
489
490     SudoPasswd[uuid] = (hosts, hmac)
491     return "got confirm for sudo password %s on host(s) %s, auth code %s" % (uuid, hosts, hmac)
492
493
494 def FinishConfirmSudopassword(lc, uid, Attrs, SudoPasswd):
495     result = "\n"
496
497     if len(SudoPasswd) == 0:
498         return None
499
500     res = lc.search_s(BaseDn, ldap.SCOPE_ONELEVEL, "uid=" + uid, ['sudoPassword'])
501     if len(res) != 1:
502         raise UDFormatError("Not exactly one hit when searching for user")
503     if 'sudoPassword' in res[0][1]:
504         inldap = res[0][1]['sudoPassword']
505     else:
506         inldap = []
507
508     newldap = []
509     for entry in inldap:
510         Match = re.compile('^(' + UUID_FORMAT + ') (confirmed:[0-9a-f]{40}|unconfirmed) ([a-z0-9.,*-]+) ([^ ]+)$').match(entry)
511         if Match is None:
512             raise UDFormatError("Could not parse existing sudopasswd entry")
513         uuid = Match.group(1)
514         status = Match.group(2)
515         hosts = Match.group(3)
516         cryptedpass = Match.group(4)
517
518         if uuid in SudoPasswd:
519             confirmedHosts = SudoPasswd[uuid][0]
520             confirmedHmac = SudoPasswd[uuid][1]
521             if status.startswith('confirmed:'):
522                 if status == 'confirmed:' + make_passwd_hmac('password-is-confirmed', 'sudo', uid, uuid, hosts, cryptedpass):
523                     result += "Entry %s for sudo password on hosts %s already confirmed.\n" % (uuid, hosts)
524                 else:
525                     result += "Entry %s for sudo password on hosts %s is listed as confirmed, but HMAC does not verify.\n" % (uuid, hosts)
526             elif confirmedHosts != hosts:
527                 result += "Entry %s hostlist mismatch (%s vs. %s).\n" % (uuid, hosts, confirmedHosts)
528             elif make_passwd_hmac('confirm-new-password', 'sudo', uid, uuid, hosts, cryptedpass) == confirmedHmac:
529                 result += "Entry %s for sudo password on hosts %s now confirmed.\n" % (uuid, hosts)
530                 status = 'confirmed:' + make_passwd_hmac('password-is-confirmed', 'sudo', uid, uuid, hosts, cryptedpass)
531             else:
532                 result += "Entry %s for sudo password on hosts %s HMAC verify failed.\n" % (uuid, hosts)
533             del SudoPasswd[uuid]
534
535         newentry = " ".join([uuid, status, hosts, cryptedpass])
536         if len(newldap) == 0:
537             newldap.append((ldap.MOD_REPLACE, "sudoPassword", newentry))
538         else:
539             newldap.append((ldap.MOD_ADD, "sudoPassword", newentry))
540
541     for entry in SudoPasswd:
542         result += "Entry %s that you confirm is not listed in ldap." % (entry,)
543
544     for entry in newldap:
545         Attrs.append(entry)
546
547     return result
548
549
550 def connect_to_ldap_and_check_if_locked(DnRecord):
551     # Connect to the ldap server
552     lc = connectLDAP()
553     F = open(PassDir + "/pass-" + pwd.getpwuid(os.getuid())[0], "r")
554     AccessPass = F.readline().strip().split(" ")
555     F.close()
556     lc.simple_bind_s("uid={},{}".format(AccessPass[0], BaseDn), AccessPass[1])
557
558     # Check for a locked account
559     Attrs = lc.search_s(BaseDn, ldap.SCOPE_ONELEVEL, "uid=" + GetAttr(DnRecord, "uid"))
560     if (GetAttr(Attrs[0], "userPassword").find("*LK*") != -1) \
561        or GetAttr(Attrs[0], "userPassword").startswith("!"):
562         raise UDNotAllowedError("This account is locked")
563     return lc
564
565
566 # Handle an [almost] arbitary change
567 def HandleChange(Reply, DnRecord, Key):
568     global PlainText
569     Lines = re.split("\n *\r?", PlainText)
570
571     Result = ""
572     Attrs = []
573     SudoPasswd = {}
574     Show = 0
575     CommitChanges = 1
576     for Line in Lines:
577         Line = Line.strip()
578         if Line == "":
579             continue
580
581         # Try to process a command line
582         Result += "> " + Line + "\n"
583         try:
584             if Line == "show":
585                 Show = 1
586                 Res = "OK"
587             else:
588                 badkeys = LoadBadSSH()
589                 Res = DoPosition(Line, Attrs) or DoDNS(Line, Attrs, DnRecord) or \
590                     DoArbChange(Line, Attrs) or DoSSH(Line, Attrs, badkeys, GetAttr(DnRecord, "uid")) or \
591                     DoDel(Line, Attrs) or DoRBL(Line, Attrs) or DoConfirmSudopassword(Line, SudoPasswd)
592         except Exception:
593             Res = None
594             Result += "==> %s: %s\n" % (sys.exc_type, sys.exc_value)
595
596         # Fail, if someone tries to send someone elses signed email to the
597         # daemon then we want to abort ASAP.
598         if Res is None:
599             CommitChanges = 0
600             Result = Result + "Command is not understood. Halted - no changes committed\n"
601             break
602         Result += Res + "\n"
603
604     # Connect to the ldap server
605     lc = connect_to_ldap_and_check_if_locked(DnRecord)
606
607     if CommitChanges == 1 and len(SudoPasswd) > 0:  # only if we are still good to go
608         try:
609             Res = FinishConfirmSudopassword(lc, GetAttr(DnRecord, "uid"), Attrs, SudoPasswd)
610             if Res is not None:
611                 Result += Res + "\n"
612         except Error, e:
613             CommitChanges = 0
614             Result = Result + "FinishConfirmSudopassword raised an error (%s) - no changes committed\n" % (e)
615
616     if CommitChanges == 1 and len(Attrs) > 0:
617         Dn = "uid=" + GetAttr(DnRecord, "uid") + "," + BaseDn
618         lc.modify_s(Dn, Attrs)
619
620     Attribs = ""
621     if Show == 1:
622         Attrs = lc.search_s(BaseDn, ldap.SCOPE_ONELEVEL, "uid=" + GetAttr(DnRecord, "uid"))
623         if len(Attrs) == 0:
624             raise UDNotAllowedError("User not found")
625         Attribs = GPGEncrypt(PrettyShow(Attrs[0]) + "\n", "0x" + Key[1], Key[4])
626
627     Subst = {}
628     Subst["__FROM__"] = ChangeFrom
629     Subst["__EMAIL__"] = EmailAddress(DnRecord)
630     Subst["__ADMIN__"] = ReplyTo
631     Subst["__RESULT__"] = Result
632     Subst["__ATTR__"] = Attribs
633
634     return Reply + TemplateSubst(Subst, open(TemplatesDir + "change-reply", "r").read())
635
636
637 # Handle ping handles an email sent to the 'ping' address (ie this program
638 # called with a ping argument) It replies with a dump of the public records.
639 def HandlePing(Reply, DnRecord, Key):
640     Subst = {}
641     Subst["__FROM__"] = PingFrom
642     Subst["__EMAIL__"] = EmailAddress(DnRecord)
643     Subst["__LDAPFIELDS__"] = PrettyShow(DnRecord)
644     Subst["__ADMIN__"] = ReplyTo
645
646     return Reply + TemplateSubst(Subst, open(TemplatesDir + "ping-reply", "r").read())
647
648
649 def get_crypttype_preamble(key):
650     if (key[4] == 1):
651         type = "Your message was encrypted using PGP 2.x\ncompatibility mode."
652     else:
653         type = "Your message was encrypted using GPG (OpenPGP)\ncompatibility "\
654                "mode, without IDEA. This message cannot be decoded using PGP 2.x"
655     return type
656
657
658 # Handle a change password email sent to the change password address
659 # (this program called with the chpass argument)
660 def HandleChPass(Reply, DnRecord, Key):
661     # Generate a random password
662     Password = GenPass()
663     Pass = HashPass(Password)
664
665     # Use GPG to encrypt it
666     Message = GPGEncrypt("Your new password is '" + Password + "'\n", "0x" + Key[1], Key[4])
667     Password = None
668
669     if Message is None:
670         raise UDFormatError("Unable to generate the encrypted reply, gpg failed.")
671
672     Subst = {}
673     Subst["__FROM__"] = ChPassFrom
674     Subst["__EMAIL__"] = EmailAddress(DnRecord)
675     Subst["__CRYPTTYPE__"] = get_crypttype_preamble(Key)
676     Subst["__PASSWORD__"] = Message
677     Subst["__ADMIN__"] = ReplyTo
678     Reply = Reply + TemplateSubst(Subst, open(TemplatesDir + "passwd-changed", "r").read())
679
680     lc = connect_to_ldap_and_check_if_locked(DnRecord)
681     # Modify the password
682     Rec = [(ldap.MOD_REPLACE, "userPassword", "{crypt}" + Pass),
683            (ldap.MOD_REPLACE, "shadowLastChange", str(int(time.time() / (24 * 60 * 60))))]
684     Dn = "uid=" + GetAttr(DnRecord, "uid") + "," + BaseDn
685     lc.modify_s(Dn, Rec)
686
687     return Reply
688
689
690 def HandleChTOTPSeed(Reply, DnRecord, Key):
691     # Generate a random seed
692     seed = binascii.hexlify(open("/dev/urandom", "r").read(32))
693     random_id = binascii.hexlify(open("/dev/urandom", "r").read(32))
694     totp_file_name = "%d-%s" % (time.time(), random_id,)
695
696     msg = GPGEncrypt("Please go to %s/fetch-totp-seed.cgi?id=%s\n to fetch your TOTP seed" % (WebUILocation, totp_file_name), "0x" + Key[1], Key[4])
697
698     if msg is None:
699         raise UDFormatError("Unable to generate the encrypted reply, gpg failed.")
700
701     Subst = {}
702     Subst["__FROM__"] = ChPassFrom
703     Subst["__EMAIL__"] = EmailAddress(DnRecord)
704     Subst["__PASSWORD__"] = msg
705     Subst["__ADMIN__"] = ReplyTo
706     Reply += TemplateSubst(Subst, open(TemplatesDir + "totp-seed-changed", "r").read())
707
708     lc = connect_to_ldap_and_check_if_locked(DnRecord)
709     # Save the seed so the user can pick it up.
710     f = open(os.path.join(TOTPTicketDirectory, totp_file_name), os.O_WRONLY | os.O_CREAT)
711     print >> f, seed
712     print >> f, GetAttr(DnRecord, "uid")
713     f.close()
714
715     # Modify the password
716     Rec = [(ldap.MOD_REPLACE, "totpSeed", seed)]
717     Dn = "uid=" + GetAttr(DnRecord, "uid") + "," + BaseDn
718     lc.modify_s(Dn, Rec)
719     return Reply
720
721
722 def HandleChKrbPass(Reply, DnRecord, Key):
723     # Connect to the ldap server, will throw an exception if account locked.
724     lc = connect_to_ldap_and_check_if_locked(DnRecord)
725
726     user = GetAttr(DnRecord, "uid")
727     krb_proc = subprocess.Popen(('ud-krb-reset', user), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
728     krb_proc.stdin.close()
729     out = krb_proc.stdout.readlines()
730     krb_proc.wait()
731     exitcode = krb_proc.returncode
732
733     # Use GPG to encrypt it
734     m = "Tried to reset your kerberos principal's password.\n"
735     if exitcode == 0:
736         m += "The exitcode of the reset script was zero, indicating that everything\n"
737         m += "worked.  However, this being software who knows.  Script's output below."
738     else:
739         m += "The exitcode of the reset script was %d, indicating that something\n" % (exitcode,)
740         m += "went terribly, terribly wrong.  Please consult the script's output below\n"
741         m += "for more information.  Contact the admins if you have any questions or\n"
742         m += "require assitance."
743
744     m += "\n" + ''.join(map(lambda x: "| " + x, out))
745
746     Message = GPGEncrypt(m, "0x" + Key[1], Key[4])
747     if Message is None:
748         raise UDFormatError("Unable to generate the encrypted reply, gpg failed.")
749
750     Subst = {}
751     Subst["__FROM__"] = ChPassFrom
752     Subst["__EMAIL__"] = EmailAddress(DnRecord)
753     Subst["__CRYPTTYPE__"] = get_crypttype_preamble(Key)
754     Subst["__PASSWORD__"] = Message
755     Subst["__ADMIN__"] = ReplyTo
756     Reply += TemplateSubst(Subst, open(TemplatesDir + "passwd-changed", "r").read())
757
758     return Reply
759
760 # Start of main program
761
762
763 # Drop messages from a mailer daemon.
764 if not os.environ.get('SENDER'):
765     sys.exit(0)
766
767 ErrMsg = "Indeterminate Error"
768 ErrType = EX_TEMPFAIL
769 try:
770     # Startup the replay cache
771     ErrType = EX_TEMPFAIL
772     ErrMsg = "Failed to initialize the replay cache:"
773
774     # Get the email
775     ErrType = EX_PERMFAIL
776     ErrMsg = "Failed to understand the email or find a signature:"
777     mail = email.parser.Parser().parse(sys.stdin)
778     Msg = GetClearSig(mail)
779
780     ErrMsg = "Message is not PGP signed:"
781     if Msg[0].find("-----BEGIN PGP SIGNED MESSAGE-----") == -1 and \
782        Msg[0].find("-----BEGIN PGP MESSAGE-----") == -1:
783         raise UDFormatError("No PGP signature")
784
785     # Check the signature
786     ErrMsg = "Unable to check the signature or the signature was invalid:"
787     pgp = GPGCheckSig2(Msg[0])
788
789     if not pgp.ok:
790         raise UDFormatError(pgp.why)
791
792     if pgp.text is None:
793         raise UDFormatError("Null signature text")
794
795     # Extract the plain message text in the event of mime encoding
796     global PlainText
797     ErrMsg = "Problem stripping MIME headers from the decoded message"
798     if Msg[1] == 1:
799         e = email.parser.Parser().parsestr(pgp.text)
800         PlainText = e.get_payload(decode=True)
801     else:
802         PlainText = pgp.text
803
804     # Connect to the ldap server
805     ErrType = EX_TEMPFAIL
806     ErrMsg = "An error occured while performing the LDAP lookup"
807     global lc
808     lc = connectLDAP()
809     lc.simple_bind_s("", "")
810
811     # Search for the matching key fingerprint
812     Attrs = lc.search_s(BaseDn, ldap.SCOPE_ONELEVEL, "keyFingerPrint={}".format(pgp.key_fpr))
813
814     ErrType = EX_PERMFAIL
815     if len(Attrs) == 0:
816         raise UDFormatError("Key not found")
817     if len(Attrs) != 1:
818         raise UDFormatError("Oddly your key fingerprint is assigned to more than one account..")
819
820     # Check the signature against the replay cache
821     RC = ReplayCache(ReplayCacheFile)
822     RC.process(pgp.sig_info)
823
824     # Determine the sender address
825     ErrMsg = "A problem occured while trying to formulate the reply"
826     Sender = mail.get('Reply-To', mail.get('From'))
827     if not Sender:
828         raise UDFormatError("Unable to determine the sender's address")
829
830     # Formulate a reply
831     Date = time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime(time.time()))
832     Reply = "To: %s\nReply-To: %s\nDate: %s\n" % (Sender, ReplyTo, Date)
833
834     Res = lc.search_s(HostBaseDn, ldap.SCOPE_SUBTREE, '(objectClass=debianServer)', ['hostname'])
835     # Res is a list of tuples.
836     # The tuples contain a dn (str) and a dictionary.
837     # The dictionaries map the key "hostname" to a list.
838     # These lists contain a single hostname (str).
839     ValidHostNames = reduce(lambda a, b: a + b, [value.get("hostname", []) for (dn, value) in Res], [])
840
841     # Dispatch
842     if sys.argv[1] == "ping":
843         Reply = HandlePing(Reply, Attrs[0], pgp.key_info)
844     elif sys.argv[1] == "chpass":
845         if PlainText.strip().find("Please change my Debian password") >= 0:
846             Reply = HandleChPass(Reply, Attrs[0], pgp.key_info)
847         elif PlainText.strip().find("Please change my Kerberos password") >= 0:
848             Reply = HandleChKrbPass(Reply, Attrs[0], pgp.key_info)
849         elif PlainText.strip().find("Please change my TOTP seed") >= 0:
850             Reply = HandleChTOTPSeed(Reply, Attrs[0], pgp.key_info)
851         else:
852             raise UDFormatError("Please send a signed message where the first line of text is the string 'Please change my Debian password' or some other string we accept here.")
853     elif sys.argv[1] == "change":
854         Reply = HandleChange(Reply, Attrs[0], pgp.key_info)
855     else:
856         print sys.argv
857         raise UDFormatError("Incorrect Invokation")
858
859     # Send the message through sendmail
860     ErrMsg = "A problem occured while trying to send the reply"
861     Child = os.popen("/usr/sbin/sendmail -t", "w")
862     #   Child = os.popen("cat","w")
863     Child.write(Reply)
864     if Child.close() is not None:
865         raise UDExecuteError("Sendmail gave a non-zero return code")
866
867 except Exception:
868     # Error Reply Header
869     Date = time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime(time.time()))
870     ErrReplyHead = "To: %s\nReply-To: %s\nDate: %s\n" % (os.environ['SENDER'], ReplyTo, Date)
871
872     # Error Body
873     Subst = {}
874     Subst["__ERROR__"] = ErrMsg
875     Subst["__ADMIN__"] = ReplyTo
876
877     Trace = "==> %s: %s\n" % (sys.exc_type, sys.exc_value)
878     List = traceback.extract_tb(sys.exc_traceback)
879     if len(List) > 1:
880         Trace = Trace + "Python Stack Trace:\n"
881         for x in List:
882             Trace = Trace + "   %s %s:%u: %s\n" % (x[2], x[0], x[1], x[3])
883
884     Subst["__TRACE__"] = Trace
885
886     # Try to send the bounce
887     try:
888         ErrReply = TemplateSubst(Subst, open(TemplatesDir + "error-reply", "r").read())
889
890         Child = os.popen("/usr/sbin/sendmail -t -oi -f ''", "w")
891         Child.write(ErrReplyHead)
892         Child.write(ErrReply)
893         if Child.close() is not None:
894             raise UDExecuteError("Sendmail gave a non-zero return code")
895     except Exception:
896         sys.exit(EX_TEMPFAIL)
897
898     if ErrType != EX_PERMFAIL:
899         sys.exit(ErrType)
900     sys.exit(0)
901
902 # vim:set et:
903 # vim:set ts=4:
904 # vim:set shiftwidth=4: