edward

   1 #! /usr/bin/env python3
   2 # -*- coding: utf-8 -*-
   3 """*********************************************************************
   4 * Edward is free software: you can redistribute it and/or modify       *
   5 * it under the terms of the GNU Affero Public License as published by  *
   6 * the Free Software Foundation, either version 3 of the License, or    *
   7 * (at your option) any later version.                                  *
   8 *                                                                      *
   9 * Edward 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 Affero Public License for more details.                          *
  13 *                                                                      *
  14 * You should have received a copy of the GNU Affero Public License     *
  15 * along with Edward.  If not, see <http://www.gnu.org/licenses/>.      *
  16 *                                                                      *
  17 * Copyright (C) 2014-2015 Andrew Engelbrecht                (AGPLv3+)  *
  18 * Copyright (C) 2014      Josh Drake                        (AGPLv3+)  *
  19 * Copyright (C) 2014      Lisa Marie Maginnis               (AGPLv3+)  *
  20 * Copyright (C) 2009-2015 Tails developers <tails@boum.org> ( GPLv3+)  *
  21 * Copyright (C) 2009      W. Trevor King <wking@drexel.edu> ( GPLv2+)  *
  22 *                                                                      *
  23 * Special thanks to Josh Drake for writing the original edward bot! :) *
  24 *                                                                      *
  25 ************************************************************************
  26
  27 Code sourced from these projects:
  28
  29   * http://agpl.fsf.org/emailselfdefense.fsf.org/edward/CURRENT/edward.tar.gz
  30   * https://git-tails.immerda.ch/whisperback/tree/whisperBack/encryption.py?h=feature/python3
  31   * http://www.physics.drexel.edu/~wking/code/python/send_pgp_mime
  32 """
  33
  34 import sys
  35 import gpgme
  36 import re
  37 import io
  38 import os
  39 import importlib
  40
  41 import email.parser
  42 import email.message
  43 import email.encoders
  44
  45 from email.mime.multipart       import MIMEMultipart
  46 from email.mime.application     import MIMEApplication
  47 from email.mime.nonmultipart    import MIMENonMultipart
  48
  49 import edward_config
  50
  51 langs = ["de", "el", "en", "fr", "ja", "pt-br", "ro", "ru", "tr"]
  52
  53 """This list contains the abbreviated names of reply languages available to
  54 edward."""
  55
  56
  57 match_types =  [('clearsign',
  58                 '-----BEGIN PGP SIGNED MESSAGE-----.*?-----BEGIN PGP SIGNATURE-----.*?-----END PGP SIGNATURE-----'),
  59                 ('message',
  60                 '-----BEGIN PGP MESSAGE-----.*?-----END PGP MESSAGE-----'),
  61                 ('pubkey',
  62                 '-----BEGIN PGP PUBLIC KEY BLOCK-----.*?-----END PGP PUBLIC KEY BLOCK-----'),
  63                 ('detachedsig',
  64                 '-----BEGIN PGP SIGNATURE-----.*?-----END PGP SIGNATURE-----')]
  65
  66 """This list of tuples matches query names with re.search() queries used
  67 to find GPG data for edward to process."""
  68
  69
  70 class EddyMsg (object):
  71     """
  72     The EddyMsg class represents relevant parts of a mime message.
  73
  74     The represented message can be single-part or multi-part.
  75
  76     'multipart' is set to True if there are multiple mime parts.
  77
  78     'subparts' points to a list of mime sub-parts if it is a multi-part
  79     message. Otherwise it points to an empty list.
  80
  81     'payload_bytes' contains the raw mime-decoded bytes that haven't been
  82     encoded into a character set.
  83
  84     'payload_pieces' is a list of objects containing strings that when strung
  85     together form the fully-decoded string representation of the mime part.
  86
  87     The 'charset' describes the character set of payload_bytes.
  88
  89     The 'filename', 'content_type' and 'description_list' come from the mime
  90     part parameters.
  91     """
  92
  93     multipart               = False
  94     subparts                = []
  95
  96     payload_bytes           = None
  97     payload_pieces          = []
  98
  99     charset                 = None
 100     filename                = None
 101     content_type            = None
 102     description_list        = None
 103
 104
 105 class PayloadPiece (object):
 106     """
 107     PayloadPiece represents a complte or sub-section of a mime part.
 108
 109     Instances of this class are often strung together within one or more arrays
 110     pointed to by each instance of the EddyMsg class.
 111
 112     'piece_type' refers to a string whose value describes the content of
 113     'string'.  Examples include "pubkey", for public keys, and "message", for
 114     encrypted data (or armored signatures until they are known to be such.) The
 115     names derive from the header and footer of each of these ascii-encoded gpg
 116     blocks.
 117
 118     'string' contains some string of text, such as non-GPG text, an encrypted
 119     block of text, a signature, or a public key.
 120
 121     'gpg_data' points to any instances of GPGData that have been created based
 122     on the contents of 'string'.
 123     """
 124
 125     piece_type              = None
 126     string                  = None
 127     gpg_data                = None
 128
 129
 130 class GPGData (object):
 131     """
 132     GPGData holds info from decryption, sig. verification, and/or pub. keys.
 133
 134     Instances of this class contain decrypted information, signature
 135     fingerprints and/or fingerprints of processed and imported public keys.
 136
 137     'decrypted' is set to True if 'plainobj' was created from encrypted data.
 138
 139     'plainobj' points to any decrypted, or signed part of, a GPG signature. It
 140     is intended to be an instance of the EddyMsg class.
 141
 142     'sigs' is a list of fingerprints of keys used to sign the data in plainobj.
 143
 144     'keys' is a list of fingerprints of keys obtained in public key blocks.
 145     """
 146
 147     decrypted               = False
 148
 149     plainobj                = None
 150     sigs                    = []
 151     keys                    = []
 152
 153
 154 class ReplyInfo (object):
 155     """
 156     ReplyInfo contains details that edward uses in generating its reply.
 157
 158     Instances of this class contain information about whether a message was
 159     successfully encrypted or signed, and whether a public key was attached, or
 160     retrievable, from the local GPG store. It stores the fingerprints of
 161     potential encryption key candidates and the message (if any at all) to
 162     quote in edward's reply.
 163
 164     'replies' points one of the dictionaries of translated replies.
 165
 166     'target_key' refers to the fingerprint of a key used to sign encrypted
 167     data. This is the preferred key, if it is set, and if is available.
 168
 169     'fallback_target_key' referst to the fingerprint of a key used to sign
 170     unencrypted data; alternatively it may be a public key attached to the
 171     message.
 172
 173     'msg_to_quote' refers to the part of a message which edward should quote in
 174     his reply. This should remain as None if there was no encrypted and singed
 175     part. This is to avoid making edward a service for decrypting other
 176     people's messages to edward.
 177
 178     'success_decrypt' is set to True if edward could decrypt part of the
 179     message.
 180
 181     'failed_decrypt' is set to True if edward failed to decrypt part of the
 182     message.
 183
 184     'publick_key_received' is set to True if edward successfully imported a
 185     public key.
 186
 187     'no_public_key' is set to True if edward doesn't have a key to encrypt to
 188     when replying to the user.
 189
 190     'sig_success' is set to True if edward could to some extent verify the
 191     signature of a signed part of the message to edward.
 192
 193     'sig_failure' is set to True if edward failed to some extent verify the
 194     signature of a signed part of the message to edward.
 195     """
 196
 197     replies                 = None
 198
 199     target_key              = None
 200     fallback_target_key     = None
 201     msg_to_quote            = ""
 202
 203     success_decrypt         = False
 204     failed_decrypt          = False
 205     public_key_received     = False
 206     no_public_key           = False
 207     sig_success             = False
 208     sig_failure             = False
 209
 210
 211 def main ():
 212
 213     """
 214     This is the main function for edward, a GPG reply bot.
 215
 216     Edward responds to GPG-encrypted and signed mail, encrypting and signing
 217     the response if the user's public key is, or was, included in the message.
 218
 219     Args:
 220         None
 221
 222     Returns:
 223         Nothing
 224
 225     Pre:
 226         Mime or plaintext email passing in through standard input.  Portions of
 227         the email may be encrypted. If the To: address contains the text
 228         "edward-ja", then the reply will contain a reply written in the
 229         Japanese language.  There are other languages as well. The default
 230         language is English.
 231
 232     Post:
 233         A reply email will be printed to standard output. The contents of the
 234         reply email depends on whether the original email was encrypted or not,
 235         has or doesn't have a signature, whether a public key used in the
 236         original message is provided or locally stored, and the language
 237         implied by the To: address in the original email.
 238     """
 239
 240     handle_args()
 241
 242     gpgme_ctx = get_gpg_context(edward_config.gnupghome,
 243                               edward_config.sign_with_key)
 244
 245     email_text = sys.stdin.read()
 246     email_struct = parse_pgp_mime(email_text, gpgme_ctx)
 247
 248     email_to, email_from, email_subject = email_to_from_subject(email_text)
 249     lang = import_lang(email_to)
 250
 251     replyinfo_obj = ReplyInfo()
 252     replyinfo_obj.replies = lang.replies
 253
 254     prepare_for_reply(email_struct, replyinfo_obj)
 255     encrypt_to_key = get_key_from_fp(replyinfo_obj, gpgme_ctx)
 256     reply_plaintext = write_reply(replyinfo_obj)
 257
 258     reply_mime = generate_encrypted_mime(reply_plaintext, email_from, \
 259                                          email_subject, encrypt_to_key,
 260                                          gpgme_ctx)
 261
 262     print(reply_mime)
 263
 264
 265 def get_gpg_context (gnupghome, sign_with_key_fp):
 266     """
 267     This function returns the GPG context needed for encryption and signing.
 268
 269     The context is needed by other functions which use GPG functionality.
 270
 271     Args:
 272         gnupghome: The path to "~/.gnupg/" or its alternative.
 273         sign_with_key: The fingerprint of the key to sign with
 274
 275     Returns:
 276         A gpgme context to be used for GPG functions.
 277
 278     Post:
 279         the 'armor' flag is set to True and the list of signing keys contains
 280         the single specified key
 281     """
 282
 283     os.environ['GNUPGHOME'] = gnupghome
 284
 285     gpgme_ctx = gpgme.Context()
 286     gpgme_ctx.armor = True
 287
 288     try:
 289         sign_with_key = gpgme_ctx.get_key(sign_with_key_fp)
 290     except:
 291         error("unable to load signing key. is the gnupghome "
 292                 + "and signing key properly set in the edward_config.py?")
 293         exit(1)
 294
 295     gpgme_ctx.signers = [sign_with_key]
 296
 297     return gpgme_ctx
 298
 299
 300 def parse_pgp_mime (email_text, gpgme_ctx):
 301     """Parses the email for mime payloads and decrypts/verfies signatures.
 302
 303     This function creates a representation of a mime or plaintext email with
 304     the EddyMsg class. It then splits each mime payload into one or more pieces
 305     which may be plain text or GPG data. It then decrypts encrypted parts and
 306     does some very basic signature verification on those parts.
 307
 308     Args:
 309         email_text: an email message in string format
 310         gpgme_ctx:  a gpgme context
 311
 312     Returns:
 313         A message as an instance of EddyMsg
 314
 315     Post:
 316         the returned EddyMsg instance has split, decrypted, verified and pubkey
 317         imported payloads
 318     """
 319
 320     email_struct = email.parser.Parser().parsestr(email_text)
 321
 322     eddymsg_obj = parse_mime(email_struct)
 323     split_payloads(eddymsg_obj)
 324     gpg_on_payloads(eddymsg_obj, gpgme_ctx)
 325
 326     return eddymsg_obj
 327
 328
 329 def parse_mime(msg_struct):
 330     """Translates python's email.parser format into an EddyMsg format
 331
 332     If the message is multi-part, then a recursive object is created, where
 333     each sub-part is also a EddyMsg instance.
 334
 335     Args:
 336         msg_struct: an email parsed with email.parser.Parser(), which can be
 337             multi-part
 338
 339     Returns:
 340         an instance of EddyMsg, potentially a recursive one.
 341     """
 342
 343     eddymsg_obj = EddyMsg()
 344
 345     if msg_struct.is_multipart() == True:
 346         payloads = msg_struct.get_payload()
 347
 348         eddymsg_obj.multipart = True
 349         eddymsg_obj.subparts = list(map(parse_mime, payloads))
 350
 351     else:
 352         eddymsg_obj = get_subpart_data(msg_struct)
 353
 354     return eddymsg_obj
 355
 356
 357 def scan_and_split (payload_piece, match_type, pattern):
 358     """This splits the payloads of an EddyMsg object into GPG and text parts.
 359
 360     An EddyMsg object's payload_pieces starts off as a list containing a single
 361     PayloadPiece object. This function returns a list of these objects which
 362     have been split into GPG data and regular text, if such splits need to be/
 363     can be made.
 364
 365     Args:
 366         payload_piece: a single payload or a split part of a payload
 367         match_type: the type of data to try to spit out from the payload piece
 368         pattern: the search pattern to be used for finding that type of data
 369
 370     Returns:
 371         a list of objects of the PayloadPiece class, in the order that the
 372         string part of payload_piece originally was, broken up according to
 373         matches specified by 'pattern'.
 374     """
 375
 376     # don't try to re-split pieces containing gpg data
 377     if payload_piece.piece_type != "text":
 378         return [payload_piece]
 379
 380     flags = re.DOTALL | re.MULTILINE
 381     matches = re.search("(?P<beginning>.*?)(?P<match>" + pattern +
 382                         ")(?P<rest>.*)", payload_piece.string, flags=flags)
 383
 384     if matches == None:
 385         pieces = [payload_piece]
 386
 387     else:
 388
 389         beginning               = PayloadPiece()
 390         beginning.string        = matches.group('beginning')
 391         beginning.piece_type    = payload_piece.piece_type
 392
 393         match                   = PayloadPiece()
 394         match.string            = matches.group('match')
 395         match.piece_type        = match_type
 396
 397         rest                    = PayloadPiece()
 398         rest.string             = matches.group('rest')
 399         rest.piece_type         = payload_piece.piece_type
 400
 401         more_pieces = scan_and_split(rest, match_type, pattern)
 402         pieces = [beginning, match ] + more_pieces
 403
 404     return pieces
 405
 406
 407 def get_subpart_data (part):
 408     """This function grabs information from a single part mime object.
 409
 410     It copies needed data from a single part email.parser.Parser() object over
 411     to an EddyMsg object.
 412
 413     Args:
 414         part: a non-multi-part mime.parser.Parser() object
 415
 416     Returns:
 417         a single-part EddyMsg() object
 418     """
 419
 420     obj = EddyMsg()
 421
 422     obj.charset             = part.get_content_charset()
 423     obj.payload_bytes       = part.get_payload(decode=True)
 424
 425     obj.filename            = part.get_filename()
 426     obj.content_type        = part.get_content_type()
 427     obj.description_list    = part['content-description']
 428
 429     # your guess is as good as a-myy-ee-ine...
 430     if obj.charset == None:
 431         obj.charset = 'utf-8'
 432
 433     if obj.payload_bytes != None:
 434         try:
 435             payload = PayloadPiece()
 436             payload.string = obj.payload_bytes.decode(obj.charset)
 437             payload.piece_type = 'text'
 438
 439             obj.payload_pieces = [payload]
 440         except UnicodeDecodeError:
 441             pass
 442
 443     return obj
 444
 445
 446 def do_to_eddys_pieces (function_to_do, eddymsg_obj, data):
 447     """A function which maps another function onto a message's subparts.
 448
 449     This is a higer-order function which recursively performs a specified
 450     function on each subpart of a multi-part message. Each single-part sub-part
 451     has the function applied to it. This function also works if the part passed
 452     in is single-part.
 453
 454     Args:
 455         function_to_do: function to perform on sub-parts
 456         eddymsg_obj: a single part or multi-part EddyMsg object
 457         data: a second argument to pass to 'function_to_do'
 458
 459     Returns:
 460         Nothing
 461
 462     Post:
 463         The passed-in EddyMsg object is transformed recursively on its
 464         sub-parts according to 'function_to_do'.
 465     """
 466
 467     if eddymsg_obj.multipart == True:
 468         for sub in eddymsg_obj.subparts:
 469             do_to_eddys_pieces(function_to_do, sub, data)
 470     else:
 471         function_to_do(eddymsg_obj, data)
 472
 473
 474 def split_payloads (eddymsg_obj):
 475     """Splits all (sub-)payloads of a message into GPG data and regular text.
 476
 477     Recursively performs payload splitting on all sub-parts of an EddyMsg
 478     object into the various GPG data types, such as GPG messages, public key
 479     blocks and signed text.
 480
 481     Args:
 482         eddymsg_obj: an instance of EddyMsg
 483
 484     Returns:
 485         Nothing
 486
 487     Pre:
 488         The EddyMsg object has payloads that are unsplit (by may be split)..
 489
 490     Post:
 491         The EddyMsg object's payloads are all split into GPG and non-GPG parts.
 492     """
 493
 494     for match_type in match_types:
 495         do_to_eddys_pieces(split_payload_pieces, eddymsg_obj, match_type)
 496
 497
 498 def split_payload_pieces (eddymsg_obj, match_type):
 499     """A helper function for split_payloads(); works on PayloadPiece objects.
 500
 501     This function splits up PayloadPiece objects into multipe PayloadPiece
 502     objects and replaces the EddyMsg object's previous list of payload pieces
 503     with the new split up one.
 504
 505     Args:
 506         eddymsg_obj: a single-part EddyMsg object.
 507         match_type: a tuple from the match_types list, which specifies a match
 508             name and a match pattern.
 509
 510     Returns:
 511         Nothing
 512
 513     Pre:
 514         The payload piece(s) of an EddyMsg object may be already split or
 515         unsplit.
 516
 517     Post:
 518         The EddyMsg object's payload piece(s) are split into a list of pieces
 519         if matches of the match_type are found.
 520     """
 521
 522     (match_name, pattern) = match_type
 523
 524     new_pieces_list = []
 525     for piece in eddymsg_obj.payload_pieces:
 526         new_pieces_list += scan_and_split(piece, match_name, pattern)
 527
 528     eddymsg_obj.payload_pieces = new_pieces_list
 529
 530
 531 def gpg_on_payloads (eddymsg_obj, gpgme_ctx, prev_parts=[]):
 532     """Performs GPG operations on the GPG parts of the message
 533
 534     This function decrypts text, verifies signatures, and imports public keys
 535     included in an email.
 536
 537     Args:
 538         eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
 539             and non-GPG sections by split_payloads()
 540         gpgme_ctx: a gpgme context
 541
 542         prev_parts: a list of mime parts that occur before the eddymsg_obj
 543             part, under the same multi-part mime part. This is used for
 544             verifying detached signatures. For the root mime part, this should
 545             be an empty list, which is the default value if this paramater is
 546             omitted.
 547
 548     Return:
 549         Nothing
 550
 551     Pre:
 552         eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
 553
 554     Post:
 555         Decryption, verification and key imports occur. the gpg_data member of
 556         PayloadPiece objects get filled in with GPGData objects.
 557     """
 558
 559     if eddymsg_obj.multipart == True:
 560         prev_parts=[]
 561         for sub in eddymsg_obj.subparts:
 562             gpg_on_payloads (sub, gpgme_ctx, prev_parts)
 563             prev_parts += [sub]
 564
 565         return
 566
 567     for piece in eddymsg_obj.payload_pieces:
 568
 569         if piece.piece_type == "text":
 570             # don't transform the plaintext.
 571             pass
 572
 573         elif piece.piece_type == "message":
 574             (plaintext, sigs) = decrypt_block(piece.string, gpgme_ctx)
 575
 576             if plaintext:
 577                 piece.gpg_data = GPGData()
 578                 piece.gpg_data.decrypted = True
 579                 piece.gpg_data.sigs = sigs
 580                 # recurse!
 581                 piece.gpg_data.plainobj = parse_pgp_mime(plaintext, gpgme_ctx)
 582                 continue
 583
 584             # if not encrypted, check to see if this is an armored signature.
 585             (plaintext, sigs) = verify_sig_message(piece.string, gpgme_ctx)
 586
 587             if plaintext:
 588                 piece.piece_type = "signature"
 589                 piece.gpg_data = GPGData()
 590                 piece.gpg_data.sigs = sigs
 591                 # recurse!
 592                 piece.gpg_data.plainobj = parse_pgp_mime(plaintext, gpgme_ctx)
 593
 594         elif piece.piece_type == "pubkey":
 595             key_fps = add_gpg_key(piece.string, gpgme_ctx)
 596
 597             if key_fps != []:
 598                 piece.gpg_data = GPGData()
 599                 piece.gpg_data.keys = key_fps
 600
 601         elif piece.piece_type == "clearsign":
 602             (plaintext, sig_fps) = verify_clear_signature(piece.string, gpgme_ctx)
 603
 604             if sig_fps != []:
 605                 piece.gpg_data = GPGData()
 606                 piece.gpg_data.sigs = sig_fps
 607                 piece.gpg_data.plainobj = parse_pgp_mime(plaintext, gpgme_ctx)
 608
 609         elif piece.piece_type == "detachedsig":
 610             for prev in prev_parts:
 611                 payload_bytes = prev.payload_bytes
 612                 sig_fps = verify_detached_signature(piece.string, payload_bytes, gpgme_ctx)
 613
 614                 if sig_fps != []:
 615                     piece.gpg_data = GPGData()
 616                     piece.gpg_data.sigs = sig_fps
 617                     piece.gpg_data.plainobj = prev
 618                     break
 619
 620         else:
 621             pass
 622
 623
 624 def prepare_for_reply (eddymsg_obj, replyinfo_obj):
 625
 626     do_to_eddys_pieces(prepare_for_reply_pieces, eddymsg_obj, replyinfo_obj)
 627
 628 def prepare_for_reply_pieces (eddymsg_obj, replyinfo_obj):
 629
 630     for piece in eddymsg_obj.payload_pieces:
 631         if piece.piece_type == "text":
 632             # don't quote the plaintext part.
 633             pass
 634
 635         elif piece.piece_type == "message":
 636             prepare_for_reply_message(piece, replyinfo_obj)
 637
 638         elif piece.piece_type == "pubkey":
 639             prepare_for_reply_pubkey(piece, replyinfo_obj)
 640
 641         elif (piece.piece_type == "clearsign") \
 642             or (piece.piece_type == "detachedsig") \
 643             or (piece.piece_type == "signature"):
 644                     prepare_for_reply_sig(piece, replyinfo_obj)
 645
 646
 647 def prepare_for_reply_message (piece, replyinfo_obj):
 648
 649     if piece.gpg_data == None:
 650         replyinfo_obj.failed_decrypt = True
 651         return
 652
 653     replyinfo_obj.success_decrypt = True
 654
 655     # we already have a key (and a message)
 656     if replyinfo_obj.target_key != None:
 657         return
 658
 659     if piece.gpg_data.sigs != []:
 660         replyinfo_obj.target_key = piece.gpg_data.sigs[0]
 661         get_signed_part = False
 662     else:
 663         # only include a signed message in the reply.
 664         get_signed_part = True
 665
 666     replyinfo_obj.msg_to_quote = flatten_decrypted_payloads(piece.gpg_data.plainobj, get_signed_part)
 667
 668     # to catch public keys in encrypted blocks
 669     prepare_for_reply(piece.gpg_data.plainobj, replyinfo_obj)
 670
 671
 672 def prepare_for_reply_pubkey (piece, replyinfo_obj):
 673
 674     if piece.gpg_data == None or piece.gpg_data.keys == []:
 675         replyinfo_obj.no_public_key = True
 676     else:
 677         replyinfo_obj.public_key_received = True
 678
 679         if replyinfo_obj.fallback_target_key == None:
 680             replyinfo_obj.fallback_target_key = piece.gpg_data.keys[0]
 681
 682
 683 def prepare_for_reply_sig (piece, replyinfo_obj):
 684
 685     if piece.gpg_data == None or piece.gpg_data.sigs == []:
 686         replyinfo_obj.sig_failure = True
 687     else:
 688         replyinfo_obj.sig_success = True
 689
 690         if replyinfo_obj.fallback_target_key == None:
 691             replyinfo_obj.fallback_target_key = piece.gpg_data.sigs[0]
 692
 693
 694
 695 def flatten_decrypted_payloads (eddymsg_obj, get_signed_part):
 696
 697     flat_string = ""
 698
 699     if eddymsg_obj == None:
 700         return ""
 701
 702     # recurse on multi-part mime
 703     if eddymsg_obj.multipart == True:
 704         for sub in eddymsg_obj.subparts:
 705             flat_string += flatten_decrypted_payloads (sub, get_signed_part)
 706
 707         return flat_string
 708
 709     for piece in eddymsg_obj.payload_pieces:
 710         if piece.piece_type == "text":
 711             flat_string += piece.string
 712
 713         if (get_signed_part):
 714             # don't include nested encryption
 715             if (piece.piece_type == "message") \
 716                     and (piece.gpg_data != None) \
 717                     and (piece.gpg_data.decrypted == False):
 718                         flat_string += flatten_decrypted_payloads(piece.gpg_data.plainobj, get_signed_part)
 719
 720             elif ((piece.piece_type == "clearsign") \
 721                     or (piece.piece_type == "detachedsig") \
 722                     or (piece.piece_type == "signature")) \
 723                     and (piece.gpg_data != None):
 724                         # FIXME: the key used to sign this message needs to be the one that is used for the encrypted reply.
 725                         flat_string += flatten_decrypted_payloads (piece.gpg_data.plainobj, get_signed_part)
 726
 727     return flat_string
 728
 729
 730 def get_key_from_fp (replyinfo_obj, gpgme_ctx):
 731
 732     if replyinfo_obj.target_key == None:
 733         replyinfo_obj.target_key = replyinfo_obj.fallback_target_key
 734
 735     if replyinfo_obj.target_key != None:
 736         try:
 737             encrypt_to_key = gpgme_ctx.get_key(replyinfo_obj.target_key)
 738             return encrypt_to_key
 739
 740         except:
 741             pass
 742
 743     # no available key to use
 744     replyinfo_obj.target_key = None
 745     replyinfo_obj.fallback_target_key = None
 746
 747     replyinfo_obj.no_public_key = True
 748     replyinfo_obj.public_key_received = False
 749
 750     return None
 751
 752
 753 def write_reply (replyinfo_obj):
 754
 755     reply_plain = ""
 756
 757     if replyinfo_obj.success_decrypt == True:
 758         reply_plain += replyinfo_obj.replies['success_decrypt']
 759
 760         if replyinfo_obj.no_public_key == False:
 761             quoted_text = email_quote_text(replyinfo_obj.msg_to_quote)
 762             reply_plain += quoted_text
 763
 764     elif replyinfo_obj.failed_decrypt == True:
 765         reply_plain += replyinfo_obj.replies['failed_decrypt']
 766
 767
 768     if replyinfo_obj.sig_success == True:
 769         reply_plain += "\n\n"
 770         reply_plain += replyinfo_obj.replies['sig_success']
 771
 772     elif replyinfo_obj.sig_failure == True:
 773         reply_plain += "\n\n"
 774         reply_plain += replyinfo_obj.replies['sig_failure']
 775
 776
 777     if replyinfo_obj.public_key_received == True:
 778         reply_plain += "\n\n"
 779         reply_plain += replyinfo_obj.replies['public_key_received']
 780
 781     elif replyinfo_obj.no_public_key == True:
 782         reply_plain += "\n\n"
 783         reply_plain += replyinfo_obj.replies['no_public_key']
 784
 785
 786     reply_plain += "\n\n"
 787     reply_plain += replyinfo_obj.replies['signature']
 788
 789     return reply_plain
 790
 791
 792 def add_gpg_key (key_block, gpgme_ctx):
 793
 794     fp = io.BytesIO(key_block.encode('ascii'))
 795
 796     result = gpgme_ctx.import_(fp)
 797     imports = result.imports
 798
 799     key_fingerprints = []
 800
 801     if imports != []:
 802         for import_ in imports:
 803             fingerprint = import_[0]
 804             key_fingerprints += [fingerprint]
 805
 806             debug("added gpg key: " + fingerprint)
 807
 808     return key_fingerprints
 809
 810
 811 def verify_sig_message (msg_block, gpgme_ctx):
 812
 813     block_b = io.BytesIO(msg_block.encode('ascii'))
 814     plain_b = io.BytesIO()
 815
 816     try:
 817         sigs = gpgme_ctx.verify(block_b, None, plain_b)
 818     except:
 819         return ("",[])
 820
 821     plaintext = plain_b.getvalue().decode('utf-8')
 822
 823     fingerprints = []
 824     for sig in sigs:
 825         fingerprints += [sig.fpr]
 826     return (plaintext, fingerprints)
 827
 828
 829 def verify_clear_signature (sig_block, gpgme_ctx):
 830
 831     # FIXME: this might require the un-decoded bytes
 832     # or the correct re-encoding with the carset of the mime part.
 833     msg_fp = io.BytesIO(sig_block.encode('utf-8'))
 834     ptxt_fp = io.BytesIO()
 835
 836     result = gpgme_ctx.verify(msg_fp, None, ptxt_fp)
 837
 838     # FIXME: this might require using the charset of the mime part.
 839     plaintext = ptxt_fp.getvalue().decode('utf-8')
 840
 841     sig_fingerprints = []
 842     for res_ in result:
 843         sig_fingerprints += [res_.fpr]
 844
 845     return plaintext, sig_fingerprints
 846
 847
 848 def verify_detached_signature (detached_sig, plaintext_bytes, gpgme_ctx):
 849
 850     detached_sig_fp = io.BytesIO(detached_sig.encode('ascii'))
 851     plaintext_fp = io.BytesIO(plaintext_bytes)
 852     ptxt_fp = io.BytesIO()
 853
 854     result = gpgme_ctx.verify(detached_sig_fp, plaintext_fp, None)
 855
 856     sig_fingerprints = []
 857     for res_ in result:
 858         sig_fingerprints += [res_.fpr]
 859
 860     return sig_fingerprints
 861
 862
 863 def decrypt_block (msg_block, gpgme_ctx):
 864
 865     block_b = io.BytesIO(msg_block.encode('ascii'))
 866     plain_b = io.BytesIO()
 867
 868     try:
 869         sigs = gpgme_ctx.decrypt_verify(block_b, plain_b)
 870     except:
 871         return ("",[])
 872
 873     plaintext = plain_b.getvalue().decode('utf-8')
 874
 875     fingerprints = []
 876     for sig in sigs:
 877         fingerprints += [sig.fpr]
 878     return (plaintext, fingerprints)
 879
 880
 881 def choose_reply_encryption_key (gpgme_ctx, fingerprints):
 882
 883     reply_key = None
 884     for fp in fingerprints:
 885         try:
 886             key = gpgme_ctx.get_key(fp)
 887
 888             if (key.can_encrypt == True):
 889                 reply_key = key
 890                 break
 891         except:
 892             continue
 893
 894
 895     return reply_key
 896
 897
 898 def email_to_from_subject (email_text):
 899
 900     email_struct = email.parser.Parser().parsestr(email_text)
 901
 902     email_to        = email_struct['To']
 903     email_from      = email_struct['From']
 904     email_subject   = email_struct['Subject']
 905
 906     return email_to, email_from, email_subject
 907
 908
 909 def import_lang(email_to):
 910
 911     if email_to != None:
 912         for lang in langs:
 913             if "edward-" + lang in email_to:
 914                 lang = "lang." + re.sub('-', '_', lang)
 915                 language = importlib.import_module(lang)
 916
 917                 return language
 918
 919     return importlib.import_module("lang.en")
 920
 921
 922 def generate_encrypted_mime (plaintext, email_from, email_subject, encrypt_to_key,
 923                     gpgme_ctx):
 924
 925     # quoted printable encoding lets most ascii characters look normal
 926     # before the mime message is decoded.
 927     char_set = email.charset.Charset("utf-8")
 928     char_set.body_encoding = email.charset.QP
 929
 930     # MIMEText doesn't allow setting the text encoding
 931     # so we use MIMENonMultipart.
 932     plaintext_mime = MIMENonMultipart('text', 'plain')
 933     plaintext_mime.set_payload(plaintext, charset=char_set)
 934
 935     if (encrypt_to_key != None):
 936
 937         encrypted_text = encrypt_sign_message(plaintext_mime.as_string(),
 938                                               encrypt_to_key,
 939                                               gpgme_ctx)
 940
 941         control_mime = MIMEApplication("Version: 1",
 942                                        _subtype='pgp-encrypted',
 943                                        _encoder=email.encoders.encode_7or8bit)
 944         control_mime['Content-Description'] = 'PGP/MIME version identification'
 945         control_mime.set_charset('us-ascii')
 946
 947         encoded_mime = MIMEApplication(encrypted_text,
 948                                        _subtype='octet-stream; name="encrypted.asc"',
 949                                        _encoder=email.encoders.encode_7or8bit)
 950         encoded_mime['Content-Description'] = 'OpenPGP encrypted message'
 951         encoded_mime['Content-Disposition'] = 'inline; filename="encrypted.asc"'
 952         encoded_mime.set_charset('us-ascii')
 953
 954         message_mime = MIMEMultipart(_subtype="encrypted", protocol="application/pgp-encrypted")
 955         message_mime.attach(control_mime)
 956         message_mime.attach(encoded_mime)
 957         message_mime['Content-Disposition'] = 'inline'
 958
 959     else:
 960         message_mime = plaintext_mime
 961
 962     message_mime['To'] = email_from
 963     message_mime['Subject'] = email_subject
 964
 965     reply = message_mime.as_string()
 966
 967     return reply
 968
 969
 970 def email_quote_text (text):
 971
 972     quoted_message = re.sub(r'^', r'> ', text, flags=re.MULTILINE)
 973
 974     return quoted_message
 975
 976
 977 def encrypt_sign_message (plaintext, encrypt_to_key, gpgme_ctx):
 978
 979     plaintext_bytes = io.BytesIO(plaintext.encode('ascii'))
 980     encrypted_bytes = io.BytesIO()
 981
 982     gpgme_ctx.encrypt_sign([encrypt_to_key], gpgme.ENCRYPT_ALWAYS_TRUST,
 983             plaintext_bytes, encrypted_bytes)
 984
 985     encrypted_txt = encrypted_bytes.getvalue().decode('ascii')
 986     return encrypted_txt
 987
 988
 989 def error (error_msg):
 990
 991     sys.stderr.write(progname + ": " + str(error_msg) + "\n")
 992
 993
 994 def debug (debug_msg):
 995
 996     if edward_config.debug == True:
 997         error(debug_msg)
 998
 999
1000 def handle_args ():
1001
1002     global progname
1003     progname = sys.argv[0]
1004
1005     if len(sys.argv) > 1:
1006         print(progname + ": error, this program doesn't " \
1007                 "need any arguments.", file=sys.stderr)
1008         exit(1)
1009
1010
1011 if __name__ == "__main__":
1012
1013     main()
1014