userdir_gpg.py

   1 #   Copyright (c) 1999-2001  Jason Gunthorpe <jgg@debian.org>
   2 #   Copyright (c) 2005       Joey Schulze <joey@infodrom.org>
   3 #
   4 #   This program is free software; you can redistribute it and/or modify
   5 #   it under the terms of the GNU General Public License as published by
   6 #   the Free Software Foundation; either version 2 of the License, or
   7 #   (at your option) any later version.
   8 #
   9 #   This program is distributed in the hope that it will be useful,
  10 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 #   GNU General Public License for more details.
  13 #
  14 #   You should have received a copy of the GNU General Public License
  15 #   along with this program; if not, write to the Free Software
  16 #   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 # GPG issues -
  19 #  - gpgm with a status FD being fed keymaterial and other interesting
  20 #    things does nothing.. If it could ID the keys and stuff over the
  21 #    status-fd I could decide what to do with them. I would also like it
  22 #    to report which key it selected for encryption (also if there
  23 #    were multi-matches..) Being able to detect a key-revoke cert would be
  24 #    good too.
  25 #  - I would like to be able to fetch the comment and version fields from the
  26 #    packets so I can tell if a signature is made by pgp2 to enable the
  27 #    pgp2 encrypting mode.
  28
  29 import sys
  30 import StringIO
  31 import os
  32 import tempfile
  33 import re
  34 import time
  35 import fcntl
  36 import anydbm
  37 import email
  38 import email.message
  39
  40 from userdir_exceptions import *
  41
  42 # General GPG options
  43 GPGPath = "gpg"
  44 # "--load-extension", "rsa",
  45 GPGBasicOptions = ["--no-options",
  46                    "--batch",
  47                    "--no-default-keyring",
  48                    "--secret-keyring", "/dev/null",
  49                    "--always-trust"]
  50 GPGKeyRings = []
  51 GPGSigOptions = ["--output", "-"]
  52 GPGSearchOptions = ["--dry-run", "--with-colons", "--fingerprint",
  53                     "--fingerprint", "--fixed-list-mode"]
  54 GPGEncryptOptions = ["--output", "-", "--quiet", "--always-trust",
  55                      "--armor", "--encrypt"]
  56 GPGEncryptPGP2Options = ["--set-filename", "", "--rfc1991",
  57                          "--load-extension", "idea",
  58                          "--cipher-algo", "idea"] + GPGEncryptOptions
  59
  60 # Replay cutoff times in seconds
  61 CleanCutOff = 7 * 24 * 60 * 60
  62 AgeCutOff = 4 * 24 * 60 * 60
  63 FutureCutOff = 3 * 24 * 60 * 60
  64
  65
  66 def ClearKeyrings():
  67    del GPGKeyRings[:]
  68
  69
  70 # Set the keyrings, the input is a list of keyrings
  71 def SetKeyrings(Rings):
  72    for x in Rings:
  73       GPGKeyRings.append("--keyring")
  74       GPGKeyRings.append(x)
  75
  76
  77 # GetClearSig takes an un-seekable email message stream (mimetools.Message)
  78 # and returns a standard PGP '---BEGIN PGP SIGNED MESSAGE---' bounded
  79 # clear signed text.
  80 # If this is fed to gpg/pgp it will verify the signature and spit out the
  81 # signed text component. Email headers and PGP mime (RFC 2015) is understood
  82 # but no effort is made to cull any information outside the PGP boundaries
  83 # Please note that in the event of a mime decode the mime headers will be
  84 # present in the signature text! The return result is a tuple, the first
  85 # element is the text itself the second is a mime flag indicating if the
  86 # result should be mime processed after sig checking.
  87 #
  88 # Paranoid will check the message text to make sure that all the plaintext is
  89 # in fact signed (bounded by a PGP packet)
  90 #
  91 # lax_multipart: treat multipart bodies other than multipart/signed
  92 # as one big plain text body
  93 def GetClearSig(Msg, Paranoid=0, lax_multipart=False):
  94    if not Msg.__class__ == email.message.Message:
  95       raise RuntimeError, "GetClearSign() not called with a email.message.Message"
  96
  97    if Paranoid and lax_multipart:
  98       raise RuntimeError, "Paranoid and lax_multipart don't mix well"
  99
 100    # See if this is a MIME encoded multipart signed message
 101    if Msg.is_multipart():
 102       if not Msg.get_content_type() == "multipart/signed":
 103          if lax_multipart:
 104             payloads = Msg.get_payload()
 105             msg = "\n".join(map( lambda p: p.get_payload(decode=True), payloads))
 106             return (msg, 0)
 107          raise UDFormatError, "Cannot handle multipart messages not of type multipart/signed";
 108
 109       if Paranoid:
 110          if Msg.preamble is not None and Msg.preamble.strip() != "":
 111             raise UDFormatError,"Unsigned text in message (at start)";
 112          if Msg.epilogue is not None and Msg.epilogue.strip() != "":
 113             raise UDFormatError,"Unsigned text in message (at end)";
 114
 115       payloads = Msg.get_payload()
 116       if len(payloads) != 2:
 117          raise UDFormatError, "multipart/signed message with number of payloads != 2";
 118
 119       (Signed, Signature) = payloads
 120
 121       if Signed.get_content_type() != "text/plain" and not lax_multipart:
 122          raise UDFormatError, "Invalid pgp/mime encoding for first part[wrong plaintext type]";
 123       if Signature.get_content_type() != "application/pgp-signature":
 124          raise UDFormatError, "Invalid pgp/mime encoding for second part [wrong signature type]";
 125
 126       # Append the PGP boundary header and the signature text to re-form the
 127       # original signed block [needs to convert to \r\n]
 128       Output = "-----BEGIN PGP SIGNED MESSAGE-----\r\n";
 129       # Semi-evil hack to get the proper hash type inserted in the message
 130       if Msg.get_param('micalg') != None:
 131           Output = Output + "Hash: SHA1,%s\r\n"%(Msg.get_param('micalg')[4:].upper())
 132       Output = Output + "\r\n";
 133       Output = Output + Signed.as_string().replace("\n-","\n- -") + "\n" + Signature.get_payload(decode=True)
 134       return (Output,1);
 135    else:
 136       if Paranoid == 0:
 137          # Just return the message body
 138          return (Msg.get_payload(decode=True), 0);
 139
 140       Body = [];
 141       State = 1;
 142       for x in Msg.get_payload(decode=True).split('\n'):
 143           Body.append(x)
 144
 145           if x == "":
 146              continue;
 147
 148           # Leading up to the signature
 149           if State == 1:
 150              if x == "-----BEGIN PGP SIGNED MESSAGE-----":
 151                 State = 2;
 152              else:
 153                 raise UDFormatError,"Unsigned text in message (at start)";
 154              continue;
 155
 156           # In the signature plain text
 157           if State == 2:
 158              if x == "-----BEGIN PGP SIGNATURE-----":
 159                 State = 3;
 160              continue;
 161
 162           # In the signature
 163           if State == 3:
 164              if x == "-----END PGP SIGNATURE-----":
 165                 State = 4;
 166              continue;
 167
 168           # Past the end
 169           if State == 4:
 170              raise UDFormatError,"Unsigned text in message (at end)";
 171
 172       return ("\n".join(Body), 0);
 173
 174 # This opens GPG in 'write filter' mode. It takes Message and sends it
 175 # to GPGs standard input, pipes the standard output to a temp file along
 176 # with the status FD. The two tempfiles are passed to GPG by fd and are
 177 # accessible from the filesystem for only a short period. Message may be
 178 # None in which case GPGs stdin is closed directly after forking. This
 179 # is best used for sig checking and encryption.
 180 # The return result is a tuple (Exit,StatusFD,OutputFD), both fds are
 181 # fully rewound and readable.
 182 def GPGWriteFilter(Program,Options,Message):
 183    # Make sure the tmp files we open are unreadable, there is a short race
 184    # between when the temp file is opened and unlinked that some one else
 185    # could open it or hard link it. This is not important however as no
 186    # Secure data is fed through the temp files.
 187    OldMask = os.umask(0777);
 188    try:
 189       Output = tempfile.TemporaryFile("w+b");
 190       GPGText = tempfile.TemporaryFile("w+b");
 191       InPipe = os.pipe();
 192       InPipe = [InPipe[0],InPipe[1]];
 193    finally:
 194       os.umask(OldMask);
 195
 196    try:
 197       # Fork off GPG in a horrible way, we redirect most of its FDs
 198       # Input comes from a pipe and its two outputs are spooled to unlinked
 199       # temp files (ie private)
 200       Child = os.fork();
 201       if Child == 0:
 202          try:
 203             os.dup2(InPipe[0],0);
 204             os.close(InPipe[1]);
 205             os.dup2(Output.fileno(),1);
 206             os.dup2(os.open("/dev/null",os.O_WRONLY),2);
 207             os.dup2(GPGText.fileno(),3);
 208
 209             Args = [Program,"--status-fd","3"] + GPGBasicOptions + GPGKeyRings + Options
 210             os.execvp(Program,Args);
 211          finally:
 212             os._exit(100);
 213
 214       # Get rid of the other end of the pipe
 215       os.close(InPipe[0])
 216       InPipe[0] = -1;
 217
 218       # Send the message
 219       if Message != None:
 220          try:
 221             os.write(InPipe[1],Message);
 222          except:
 223            pass;
 224       os.close(InPipe[1]);
 225       InPipe[1] = -1;
 226
 227       # Wait for GPG to finish
 228       Exit = os.waitpid(Child,0);
 229
 230       # Create the result including the new readable file descriptors
 231       Result = (Exit,os.fdopen(os.dup(GPGText.fileno()),"r"), \
 232                 os.fdopen(os.dup(Output.fileno()),"r"));
 233       Result[1].seek(0);
 234       Result[2].seek(0);
 235
 236       Output.close();
 237       GPGText.close();
 238       return Result;
 239    finally:
 240       if InPipe[0] != -1:
 241          os.close(InPipe[0]);
 242       if InPipe[1] != -1:
 243          os.close(InPipe[1]);
 244       Output.close();
 245       GPGText.close();
 246
 247 # This takes a text passage, a destination and a flag indicating the
 248 # compatibility to use and returns an encrypted message to the recipient.
 249 # It is best if the recipient is specified using the hex key fingerprint
 250 # of the target, ie 0x64BE1319CCF6D393BF87FF9358A6D4EE
 251 def GPGEncrypt(Message,To,PGP2):
 252    Error = "KeyringError"
 253    # Encrypt using the PGP5 block encoding and with the PGP5 option set.
 254    # This will handle either RSA or DSA/DH asymetric keys.
 255    # In PGP2 compatible mode IDEA and rfc1991 encoding are used so that
 256    # PGP2 can read the result. RSA keys do not need PGP2 to be set, as GPG
 257    # can read a message encrypted with blowfish and RSA.
 258    searchkey = GPGKeySearch(To);
 259    if len(searchkey) == 0:
 260       raise Error, "No key found matching %s"%(To);
 261    elif len(searchkey) > 1:
 262       raise Error, "Multiple keys found matching %s"%(To);
 263    if searchkey[0][4].find("E") < 0:
 264       raise Error, "Key %s has no encryption capability - are all encryption subkeys expired or revoked?  Are there any encryption subkeys?"%(To);
 265
 266    if PGP2 == 0:
 267       try:
 268          Res = None;
 269          Res = GPGWriteFilter(GPGPath,["-r",To]+GPGEncryptOptions,Message);
 270          if Res[0][1] != 0:
 271             return None;
 272          Text = Res[2].read();
 273          return Text;
 274       finally:
 275          if Res != None:
 276             Res[1].close();
 277             Res[2].close();
 278    else:
 279       # We have to call gpg with a filename or it will create a packet that
 280       # PGP2 cannot understand.
 281       TmpName = tempfile.mktemp();
 282       try:
 283          Res = None;
 284          MsgFile = open(TmpName,"wc");
 285          MsgFile.write(Message);
 286          MsgFile.close();
 287          Res = GPGWriteFilter(GPGPath,["-r",To]+GPGEncryptPGP2Options+[TmpName],None);
 288          if Res[0][1] != 0:
 289             return None;
 290          Text = Res[2].read();
 291          return Text;
 292       finally:
 293          try:
 294             os.unlink(TmpName);
 295          except:
 296             pass;
 297          if Res != None:
 298             Res[1].close();
 299             Res[2].close();
 300
 301 # Checks the signature of a standard PGP message, like that returned by
 302 # GetClearSig. It returns a large tuple of the form:
 303 #   (Why,(SigId,Date,KeyFinger),(KeyID,KeyFinger,Owner,Length,PGP2),Text);
 304 # Where,
 305 #  Why = None if checking was OK otherwise an error string.
 306 #  SigID+Date represent something suitable for use in a replay cache. The
 307 #             date is returned as the number of seconds since the UTC epoch.
 308 #             The keyID is also in this tuple for easy use of the replay
 309 #             cache
 310 #  KeyID, KeyFinger and Owner represent the Key used to sign this message
 311 #         PGP2 indicates if the message was created using PGP 2.x
 312 #  Text is the full byte-for-byte signed text in a string
 313 def GPGCheckSig(Message):
 314    Res = None;
 315    try:
 316       Res = GPGWriteFilter(GPGPath,GPGSigOptions,Message);
 317       Exit = Res[0];
 318
 319       # Parse the GPG answer
 320       Strm = Res[1];
 321       GoodSig = 0;
 322       SigId = None;
 323       KeyFinger = None;
 324       KeyID = None;
 325       Owner = None;
 326       Date = None;
 327       Why = None;
 328       TagMap = {};
 329       while(1):
 330          # Grab and split up line
 331          Line = Strm.readline();
 332          if Line == "":
 333             break;
 334          Split = re.split("[ \n]",Line);
 335          if Split[0] != "[GNUPG:]":
 336             continue;
 337
 338          # We only process the first occurance of any tag.
 339          if TagMap.has_key(Split[1]):
 340             continue;
 341          TagMap[Split[1]] = None;
 342
 343          # Good signature response
 344          if Split[1] == "GOODSIG":
 345             # Just in case GPG returned a bad signal before this (bug?)
 346             if Why == None:
 347                GoodSig = 1;
 348             KeyID = Split[2];
 349             Owner = ' '.join(Split[3:])
 350             # If this message is signed with a subkey which has not yet
 351             # expired, GnuPG will say GOODSIG here, even if the primary
 352             # key already has expired.  This came up in discussion of
 353             # bug #489225.  GPGKeySearch only returns non-expired keys.
 354             Verify = GPGKeySearch(KeyID);
 355             if len(Verify) == 0:
 356                GoodSig = 0
 357                Why = "Key has expired (no unexpired key found in keyring matching %s)"%(KeyId);
 358
 359          # Bad signature response
 360          if Split[1] == "BADSIG":
 361             GoodSig = 0;
 362             KeyID = Split[2];
 363             Why = "Verification of signature failed";
 364
 365          # Bad signature response
 366          if Split[1] == "ERRSIG":
 367             GoodSig = 0;
 368             KeyID = Split[2];
 369             if len(Split) <= 7:
 370                Why = "GPG error, ERRSIG status tag is invalid";
 371             elif Split[7] == '9':
 372                Why = "Unable to verify signature, signing key missing.";
 373             elif Split[7] == '4':
 374                Why = "Unable to verify signature, unknown packet format/key type";
 375             else:
 376                Why = "Unable to verify signature, unknown reason";
 377
 378          if Split[1] == "NO_PUBKEY":
 379             GoodSig = 0;
 380             Why = "Unable to verify signature, signing key missing.";
 381
 382          # Expired signature
 383          if Split[1] == "EXPSIG":
 384             GoodSig = 0;
 385             Why = "Signature has expired";
 386
 387          # Expired signature
 388          if Split[1] == "EXPKEYSIG":
 389             GoodSig = 0;
 390             Why = "Signing key (%s, %s) has expired"%(Split[2], Split[3]);
 391
 392          # Revoked key
 393          if Split[1] == "KEYREVOKED" or Split[1] == "REVKEYSIG":
 394             GoodSig = 0;
 395             Why = "Signing key has been revoked";
 396
 397          # Corrupted packet
 398          if Split[1] == "NODATA" or Split[1] == "BADARMOR":
 399             GoodSig = 0;
 400             Why = "The packet was corrupted or contained no data";
 401
 402          # Signature ID
 403          if Split[1] == "SIG_ID":
 404             SigId = Split[2];
 405             Date = long(Split[4]);
 406
 407          # ValidSig has the key finger print
 408          if Split[1] == "VALIDSIG":
 409             # Use the fingerprint of the primary key when available
 410             if len(Split) >= 12:
 411                KeyFinger = Split[11];
 412             else:
 413                KeyFinger = Split[2];
 414
 415       # Reopen the stream as a readable stream
 416       Text = Res[2].read();
 417
 418       # A gpg failure is an automatic bad signature
 419       if Exit[1] != 0 and Why == None:
 420          GoodSig = 0;
 421          Why = "GPG execution returned non-zero exit status: " + str(Exit[1]);
 422
 423       if GoodSig == 0 and (Why == None or len(Why) == 0):
 424          Why = "Checking Failed";
 425
 426       # Try to decide if this message was sent using PGP2
 427       PGP2Message = 0;
 428       if (re.search("-----[\n\r][\n\r]?Version: 2\\.",Message) != None):
 429          PGP2Message = 1;
 430
 431       return (Why,(SigId,Date,KeyFinger),(KeyID,KeyFinger,Owner,0,PGP2Message),Text);
 432    finally:
 433       if Res != None:
 434          Res[1].close();
 435          Res[2].close();
 436
 437 class GPGCheckSig2:
 438         def __init__(self, msg):
 439                 res = GPGCheckSig(msg)
 440                 self.why = res[0]
 441                 self.sig_info = res[1]
 442                 self.key_info = res[2]
 443                 self.text = res[3]
 444
 445                 self.ok = self.why is None
 446
 447                 self.sig_id = self.sig_info[0]
 448                 self.sig_date = self.sig_info[1]
 449                 self.sig_fpr = self.sig_info[2]
 450
 451                 self.key_id = self.key_info[0]
 452                 self.key_fpr = self.key_info[1]
 453                 self.key_owner = self.key_info[2]
 454
 455                 self.is_pgp2 = self.key_info[4]
 456
 457 # Search for keys given a search pattern. The pattern is passed directly
 458 # to GPG for processing. The result is a list of tuples of the form:
 459 #   (KeyID,KeyFinger,Owner,Length)
 460 # Which is similar to the key identification tuple output by GPGChecksig
 461 #
 462 # Do not return keys where the primary key has expired
 463 def GPGKeySearch(SearchCriteria):
 464    Args = [GPGPath] + GPGBasicOptions + GPGKeyRings + GPGSearchOptions + \
 465           [SearchCriteria," 2> /dev/null"]
 466    Strm = None
 467    Result = []
 468    Validity = None
 469    Length = 0
 470    KeyID = ""
 471    Capabilities = ""
 472    Fingerprint = ""
 473    Owner = ""
 474    Hits = {}
 475
 476    dir = os.path.expanduser("~/.gnupg")
 477    if not os.path.isdir(dir):
 478       os.mkdir(dir, 0700)
 479
 480    try:
 481       # The GPG output will contain zero or more stanza, one stanza per match found.
 482       # Each stanza consists of the following records, in order:
 483       #   tru : trust database information
 484       #   pub : primary key from which we extract
 485       #         field  1 - Validity
 486       #         field  2 - Length
 487       #         field  4 - KeyID
 488       #         field 11 - Capabilities
 489       #   fpr : fingerprint of primary key from which we extract
 490       #         field  9 - Fingerprint
 491       #   uid : first User ID attached to primary key from which we extract
 492       #         Field  9 - Owner
 493       #   uid : (optional) additional multiple User IDs attached to primary key
 494       #   sub : (optional) secondary key
 495       #   fpr : (opitonal) fingerprint of secondary key if sub is present
 496       Strm = os.popen(" ".join(Args),"r")
 497       Want = "pub"
 498       while(1):
 499          Line = Strm.readline()
 500          if Line == "":
 501             break
 502          Split = Line.split(":")
 503
 504          if Split[0] != Want:
 505             continue
 506
 507          if Want == 'pub':
 508             Validity = Split[1]
 509             Length = int(Split[2])
 510             KeyID = Split[4]
 511             Capabilities = Split[11]
 512             Want = 'fpr'
 513             continue
 514
 515          if Want == 'fpr':
 516             Fingerprint = Split[9]
 517             if Hits.has_key(Fingerprint):
 518                Want = 'pub' # already seen, skip to next stanza
 519             else:
 520                Hits[Fingerprint] = None
 521                Want = 'uid'
 522             continue
 523
 524          if Want == 'uid':
 525             Owner = Split[9]
 526             if Validity != 'e': # if not expired
 527                Result.append( (KeyID,Fingerprint,Owner,Length,Capabilities) )
 528             Want = 'pub' # finished, skip to next stanza
 529             continue
 530
 531    finally:
 532       if Strm != None:
 533          Strm.close()
 534    return Result
 535
 536 # Print the available key information in a format similar to GPG's output
 537 # We do not know the values of all the feilds so they are just replaced
 538 # with ?'s
 539 def GPGPrintKeyInfo(Ident):
 540    print "pub  %u?/%s ??-??-?? %s" % (Ident[3],Ident[0][-8:],Ident[2]);
 541    print "     key fingerprint = 0x%s" % (Ident[1]);
 542
 543 # Perform a substition of template
 544 def TemplateSubst(Map,Template):
 545    for x in Map.keys():
 546       Template = Template.replace(x, Map[x])
 547    return Template;
 548
 549 # The replay class uses a python DB (BSD db if avail) to implement
 550 # protection against replay. Replay is an attacker capturing the
 551 # plain text signed message and sending it back to the victim at some
 552 # later date. Each signature has a unique signature ID (and signing
 553 # Key Fingerprint) as well as a timestamp. The first stage of replay
 554 # protection is to ensure that the timestamp is reasonable, in particular
 555 # not to far ahead or too far behind the current system time. The next
 556 # step is to look up the signature + key fingerprint in the replay database
 557 # and determine if it has been recived. The database is cleaned out
 558 # periodically and old signatures are discarded. By using a timestamp the
 559 # database size is bounded to being within the range of the allowed times
 560 # plus a little fuzz. The cache is serialized with a flocked lock file
 561 class ReplayCache:
 562    def __init__(self,Database):
 563       self.Lock = open(Database + ".lock","w",0600);
 564       fcntl.flock(self.Lock.fileno(),fcntl.LOCK_EX);
 565       self.DB = anydbm.open(Database,"c",0600);
 566       self.CleanCutOff = CleanCutOff;
 567       self.AgeCutOff = AgeCutOff;
 568       self.FutureCutOff = FutureCutOff;
 569       self.Clean()
 570
 571    # Close the cache and lock
 572    def __del__(self):
 573       self.close();
 574    def close(self):
 575       self.DB.close();
 576       self.Lock.close();
 577
 578    # Clean out any old signatures
 579    def Clean(self):
 580       CutOff = time.time() - self.CleanCutOff;
 581       for x in self.DB.keys():
 582          if int(self.DB[x]) <= CutOff:
 583             del self.DB[x];
 584
 585    # Check a signature. 'sig' is a 3 tuple that has the sigId, date and
 586    # key ID
 587    def Check(self,Sig):
 588       if Sig[0] == None or Sig[1] == None or Sig[2] == None:
 589          return "Invalid signature";
 590       if int(Sig[1]) > time.time() + self.FutureCutOff:
 591          return "Signature has a time too far in the future";
 592       if self.DB.has_key(Sig[0] + '-' + Sig[2]):
 593          return "Signature has already been received";
 594       if int(Sig[1]) < time.time() - self.AgeCutOff:
 595          return "Signature has passed the age cut off ";
 596       # + str(int(Sig[1])) + ',' + str(time.time()) + "," + str(Sig);
 597       return None;
 598
 599    # Add a signature, the sig is the same as is given to Check
 600    def Add(self,Sig):
 601       if Sig[0] == None or Sig[1] == None:
 602          raise RuntimeError,"Invalid signature";
 603       if Sig[1] < time.time() - self.CleanCutOff:
 604          return;
 605       Key = Sig[0] + '-' + Sig[2]
 606       if self.DB.has_key(Key):
 607          if int(self.DB[Key]) < Sig[1]:
 608             self.DB[Key] = str(int(Sig[1]));
 609       else:
 610          self.DB[Key] = str(int(Sig[1]));
 611
 612    def process(self, sig_info):
 613       r = self.Check(sig_info);
 614       if r is not None:
 615          raise RuntimeError, "The replay cache rejected your message: %s." % (r,)
 616       self.Add(sig_info)
 617       self.close()
 618
 619 # vim:set et:
 620 # vim:set ts=3:
 621 # vim:set shiftwidth=3: