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. *
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. *
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/>. *
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+) *
23 * Special thanks to Josh Drake for writing the original edward bot! :) *
25 ************************************************************************
27 Code sourced from these projects:
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
45 from email
.mime
.multipart
import MIMEMultipart
46 from email
.mime
.application
import MIMEApplication
47 from email
.mime
.nonmultipart
import MIMENonMultipart
51 langs
= ["de", "el", "en", "fr", "ja", "pt-br", "ro", "ru", "tr"]
53 """This list contains the abbreviated names of reply languages available to
57 match_types
= [('clearsign',
58 '-----BEGIN PGP SIGNED MESSAGE-----.*?-----BEGIN PGP SIGNATURE-----.*?-----END PGP SIGNATURE-----'),
60 '-----BEGIN PGP MESSAGE-----.*?-----END PGP MESSAGE-----'),
62 '-----BEGIN PGP PUBLIC KEY BLOCK-----.*?-----END PGP PUBLIC KEY BLOCK-----'),
64 '-----BEGIN PGP SIGNATURE-----.*?-----END PGP SIGNATURE-----')]
66 """This list of tuples matches query names with re.search() queries used
67 to find GPG data for edward to process."""
70 class EddyMsg (object):
72 The EddyMsg class represents relevant parts of a mime message.
74 The represented message can be single-part or multi-part.
76 'multipart' is set to True if there are multiple mime parts.
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.
81 'payload_bytes' contains the raw mime-decoded bytes that haven't been
82 encoded into a character set.
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.
87 The 'charset' describes the character set of payload_bytes.
89 The 'filename', 'content_type' and 'description_list' come from the mime
102 description_list
= None
105 class PayloadPiece (object):
107 PayloadPiece represents a complte or sub-section of a mime part.
109 Instances of this class are often strung together within one or more arrays
110 pointed to by each instance of the EddyMsg class.
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
118 'string' contains some string of text, such as non-GPG text, an encrypted
119 block of text, a signature, or a public key.
121 'gpg_data' points to any instances of GPGData that have been created based
122 on the contents of 'string'.
130 class GPGData (object):
132 GPGData holds info from decryption, sig. verification, and/or pub. keys.
134 Instances of this class contain decrypted information, signature
135 fingerprints and/or fingerprints of processed and imported public keys.
137 'decrypted' is set to True if 'plainobj' was created from encrypted data.
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.
142 'sigs' is a list of fingerprints of keys used to sign the data in plainobj.
144 'keys' is a list of fingerprints of keys obtained in public key blocks.
154 class ReplyInfo (object):
156 ReplyInfo contains details that edward uses in generating its reply.
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.
164 'replies' points one of the dictionaries of translated replies.
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.
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
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.
178 'success_decrypt' is set to True if edward could decrypt part of the
181 'failed_decrypt' is set to True if edward failed to decrypt part of the
184 'publick_key_received' is set to True if edward successfully imported a
187 'no_public_key' is set to True if edward doesn't have a key to encrypt to
188 when replying to the user.
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.
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.
200 fallback_target_key
= None
203 success_decrypt
= False
204 failed_decrypt
= False
205 public_key_received
= False
206 no_public_key
= False
214 This is the main function for edward, a GPG reply bot.
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.
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
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.
242 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
243 edward_config
.sign_with_key
)
245 email_text
= sys
.stdin
.read()
246 email_struct
= parse_pgp_mime(email_text
, gpgme_ctx
)
248 email_to
, email_from
, email_subject
= email_to_from_subject(email_text
)
249 lang
= import_lang(email_to
)
251 replyinfo_obj
= ReplyInfo()
252 replyinfo_obj
.replies
= lang
.replies
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
)
258 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_from
, \
259 email_subject
, encrypt_to_key
,
265 def get_gpg_context (gnupghome
, sign_with_key_fp
):
267 This function returns the GPG context needed for encryption and signing.
269 The context is needed by other functions which use GPG functionality.
272 gnupghome: The path to "~/.gnupg/" or its alternative.
273 sign_with_key: The fingerprint of the key to sign with
276 A gpgme context to be used for GPG functions.
279 the 'armor' flag is set to True and the list of signing keys contains
280 the single specified key
283 os
.environ
['GNUPGHOME'] = gnupghome
285 gpgme_ctx
= gpgme
.Context()
286 gpgme_ctx
.armor
= True
289 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
291 error("unable to load signing key. is the gnupghome "
292 + "and signing key properly set in the edward_config.py?")
295 gpgme_ctx
.signers
= [sign_with_key
]
300 def parse_pgp_mime (email_text
, gpgme_ctx
):
301 """Parses the email for mime payloads and decrypts/verfies signatures.
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.
309 email_text: an email message in string format
310 gpgme_ctx: a gpgme context
313 A message as an instance of EddyMsg
316 the returned EddyMsg instance has split, decrypted, verified and pubkey
320 email_struct
= email
.parser
.Parser().parsestr(email_text
)
322 eddymsg_obj
= parse_mime(email_struct
)
323 split_payloads(eddymsg_obj
)
324 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
329 def parse_mime(msg_struct
):
330 """Translates python's email.parser format into an EddyMsg format
332 If the message is multi-part, then a recursive object is created, where
333 each sub-part is also a EddyMsg instance.
336 msg_struct: an email parsed with email.parser.Parser(), which can be
340 an instance of EddyMsg, potentially a recursive one.
343 eddymsg_obj
= EddyMsg()
345 if msg_struct
.is_multipart() == True:
346 payloads
= msg_struct
.get_payload()
348 eddymsg_obj
.multipart
= True
349 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
352 eddymsg_obj
= get_subpart_data(msg_struct
)
357 def scan_and_split (payload_piece
, match_type
, pattern
):
358 """This splits the payloads of an EddyMsg object into GPG and text parts.
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/
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
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'.
376 # don't try to re-split pieces containing gpg data
377 if payload_piece
.piece_type
!= "text":
378 return [payload_piece
]
380 flags
= re
.DOTALL | re
.MULTILINE
381 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
382 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
385 pieces
= [payload_piece
]
389 beginning
= PayloadPiece()
390 beginning
.string
= matches
.group('beginning')
391 beginning
.piece_type
= payload_piece
.piece_type
393 match
= PayloadPiece()
394 match
.string
= matches
.group('match')
395 match
.piece_type
= match_type
397 rest
= PayloadPiece()
398 rest
.string
= matches
.group('rest')
399 rest
.piece_type
= payload_piece
.piece_type
401 more_pieces
= scan_and_split(rest
, match_type
, pattern
)
402 pieces
= [beginning
, match
] + more_pieces
407 def get_subpart_data (part
):
408 """This function grabs information from a single part mime object.
410 It copies needed data from a single part email.parser.Parser() object over
411 to an EddyMsg object.
414 part: a non-multi-part mime.parser.Parser() object
417 a single-part EddyMsg() object
422 obj
.charset
= part
.get_content_charset()
423 obj
.payload_bytes
= part
.get_payload(decode
=True)
425 obj
.filename
= part
.get_filename()
426 obj
.content_type
= part
.get_content_type()
427 obj
.description_list
= part
['content-description']
429 # your guess is as good as a-myy-ee-ine...
430 if obj
.charset
== None:
431 obj
.charset
= 'utf-8'
433 if obj
.payload_bytes
!= None:
435 payload
= PayloadPiece()
436 payload
.string
= obj
.payload_bytes
.decode(obj
.charset
)
437 payload
.piece_type
= 'text'
439 obj
.payload_pieces
= [payload
]
440 except UnicodeDecodeError:
446 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
447 """A function which maps another function onto a message's subparts.
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
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'
463 The passed-in EddyMsg object is transformed recursively on its
464 sub-parts according to 'function_to_do'.
467 if eddymsg_obj
.multipart
== True:
468 for sub
in eddymsg_obj
.subparts
:
469 do_to_eddys_pieces(function_to_do
, sub
, data
)
471 function_to_do(eddymsg_obj
, data
)
474 def split_payloads (eddymsg_obj
):
475 """Splits all (sub-)payloads of a message into GPG data and regular text.
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.
482 eddymsg_obj: an instance of EddyMsg
488 The EddyMsg object has payloads that are unsplit (by may be split)..
491 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
494 for match_type
in match_types
:
495 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_type
)
498 def split_payload_pieces (eddymsg_obj
, match_type
):
499 """A helper function for split_payloads(); works on PayloadPiece objects.
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.
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.
514 The payload piece(s) of an EddyMsg object may be already split or
518 The EddyMsg object's payload piece(s) are split into a list of pieces
519 if matches of the match_type are found.
522 (match_name
, pattern
) = match_type
525 for piece
in eddymsg_obj
.payload_pieces
:
526 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
528 eddymsg_obj
.payload_pieces
= new_pieces_list
531 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
532 """Performs GPG operations on the GPG parts of the message
534 This function decrypts text, verifies signatures, and imports public keys
535 included in an email.
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
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
552 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
555 Decryption, verification and key imports occur. the gpg_data member of
556 PayloadPiece objects get filled in with GPGData objects.
559 if eddymsg_obj
.multipart
== True:
561 for sub
in eddymsg_obj
.subparts
:
562 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
567 for piece
in eddymsg_obj
.payload_pieces
:
569 if piece
.piece_type
== "text":
570 # don't transform the plaintext.
573 elif piece
.piece_type
== "message":
574 (plaintext
, sigs
) = decrypt_block(piece
.string
, gpgme_ctx
)
577 piece
.gpg_data
= GPGData()
578 piece
.gpg_data
.decrypted
= True
579 piece
.gpg_data
.sigs
= sigs
581 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
584 # if not encrypted, check to see if this is an armored signature.
585 (plaintext
, sigs
) = verify_sig_message(piece
.string
, gpgme_ctx
)
588 piece
.piece_type
= "signature"
589 piece
.gpg_data
= GPGData()
590 piece
.gpg_data
.sigs
= sigs
592 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
594 # FIXME: handle pubkeys first, so that signatures can be validated
595 # on freshly imported keys
596 elif piece
.piece_type
== "pubkey":
597 key_fps
= add_gpg_key(piece
.string
, gpgme_ctx
)
600 piece
.gpg_data
= GPGData()
601 piece
.gpg_data
.keys
= key_fps
603 elif piece
.piece_type
== "clearsign":
604 (plaintext
, sig_fps
) = verify_clear_signature(piece
.string
, gpgme_ctx
)
607 piece
.gpg_data
= GPGData()
608 piece
.gpg_data
.sigs
= sig_fps
609 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
611 elif piece
.piece_type
== "detachedsig":
612 for prev
in prev_parts
:
613 payload_bytes
= prev
.payload_bytes
614 sig_fps
= verify_detached_signature(piece
.string
, payload_bytes
, gpgme_ctx
)
617 piece
.gpg_data
= GPGData()
618 piece
.gpg_data
.sigs
= sig_fps
619 piece
.gpg_data
.plainobj
= prev
626 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
627 """Updates replyinfo_obj with info on the message's GPG success/failures
629 This function marks replyinfo_obj with information about whether encrypted
630 text in eddymsg_obj was successfully decrypted, signatures were verified
631 and whether a public key was found or not.
634 eddymsg_obj: a message in the EddyMsg format
635 replyinfo_obj: an instance of ReplyInfo
641 eddymsg_obj has had its gpg_data created by gpg_on_payloads
644 replyinfo_obj has been updated with info about decryption/sig
645 verififcation status, etc. However the desired key isn't imported until
646 later, so the success or failure of that updates the values set here.
649 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
651 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
652 """A helper function for prepare_for_reply
654 It updates replyinfo_obj with GPG success/failure information, when
655 supplied a single-part EddyMsg object.
658 eddymsg_obj: a single-part message in the EddyMsg format
659 replyinfo_obj: an object which holds information about the message's
666 eddymsg_obj is a single-part message. (it may be a part of a multi-part
667 message.) It has had its gpg_data created by gpg_on_payloads if it has
671 replyinfo_obj has been updated with gpg success/failure information
674 for piece
in eddymsg_obj
.payload_pieces
:
675 if piece
.piece_type
== "text":
676 # don't quote the plaintext part.
679 elif piece
.piece_type
== "message":
680 prepare_for_reply_message(piece
, replyinfo_obj
)
682 elif piece
.piece_type
== "pubkey":
683 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
685 elif (piece
.piece_type
== "clearsign") \
686 or (piece
.piece_type
== "detachedsig") \
687 or (piece
.piece_type
== "signature"):
688 prepare_for_reply_sig(piece
, replyinfo_obj
)
691 def prepare_for_reply_message (piece
, replyinfo_obj
):
692 """Helper function for prepare_for_reply()
694 This function is called when the piece_type of a payload piece is
695 "message", or GPG Message block. This should be encrypted text. If the
696 encryted block is signed, a sig will be attached to .target_key unless
697 there is already one there.
700 piece: a PayloadPiece object.
701 replyinfo_obj: object which gets updated with decryption status, etc.
708 the piece.payload_piece value should be "message".
711 replyinfo_obj gets updated with decryption status, signing status and a
712 potential signing key.
715 if piece
.gpg_data
== None:
716 replyinfo_obj
.failed_decrypt
= True
719 replyinfo_obj
.success_decrypt
= True
721 # we already have a key (and a message)
722 if replyinfo_obj
.target_key
!= None:
725 if piece
.gpg_data
.sigs
!= []:
726 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
727 get_signed_part
= False
729 # only include a signed message in the reply.
730 get_signed_part
= True
732 replyinfo_obj
.msg_to_quote
= flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, get_signed_part
)
734 # to catch public keys in encrypted blocks
735 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
738 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
739 """Helper function for prepare_for_reply(). Marks pubkey import status.
741 Marks replyinfo_obj with pub key import status.
744 piece: a PayloadPiece object
745 replyinfo_obj: a ReplyInfo object
748 piece.piece_type should be set to "pubkey".
751 replyinfo_obj has its fields updated.
754 if piece
.gpg_data
== None or piece
.gpg_data
.keys
== []:
755 replyinfo_obj
.no_public_key
= True
757 replyinfo_obj
.public_key_received
= True
759 if replyinfo_obj
.fallback_target_key
== None:
760 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
763 def prepare_for_reply_sig (piece
, replyinfo_obj
):
764 """Helper function for prepare_for_reply(). Marks sig verification status.
766 Marks replyinfo_obj with signature verification status.
769 piece: a PayloadPiece object
770 replyinfo_obj: a ReplyInfo object
773 piece.piece_type should be set to "clearsign", "signature", or
777 replyinfo_obj has its fields updated.
780 if piece
.gpg_data
== None or piece
.gpg_data
.sigs
== []:
781 replyinfo_obj
.sig_failure
= True
783 replyinfo_obj
.sig_success
= True
785 if replyinfo_obj
.fallback_target_key
== None:
786 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
790 def flatten_decrypted_payloads (eddymsg_obj
, get_signed_part
):
791 """Returns a string representation of a signed, encrypted part.
793 Returns the string representation of the first signed/encrypted or signed
794 then encrypted block of text. (Signature inside of Encryption)
797 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
799 get_signed_part: True if we should only include text that contains a
800 further signature. If False, then include plain text.
803 A string representation of encrypted and signed text.
806 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
807 which represents decrypted text. It may or may not be signed on that
813 if eddymsg_obj
== None:
816 # recurse on multi-part mime
817 if eddymsg_obj
.multipart
== True:
818 for sub
in eddymsg_obj
.subparts
:
819 flat_string
+= flatten_decrypted_payloads (sub
, get_signed_part
)
823 for piece
in eddymsg_obj
.payload_pieces
:
824 if (get_signed_part
):
825 if ((piece
.piece_type
== "clearsign") \
826 or (piece
.piece_type
== "detachedsig") \
827 or (piece
.piece_type
== "signature")) \
828 and (piece
.gpg_data
!= None):
829 # FIXME: the key used to sign this message needs to be the one that is used for the encrypted reply.
830 flat_string
+= flatten_decrypted_payloads (piece
.gpg_data
.plainobj
, False)
833 if piece
.piece_type
== "text":
834 flat_string
+= piece
.string
839 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
840 """Obtains a public key object from a key fingerprint
842 If the .target_key is not set, then we use .fallback_target_key.
845 replyinfo_obj: ReplyInfo instance
846 gpgme_ctx: the gpgme context
849 The key object of the key of either the target_key or the fallback one
850 if .target_key is not set. If the key cannot be loaded, then return
854 Loading a key requires that we have the public key imported. This
855 requires that they email contains the pub key block, or that it was
856 previously sent to edward.
859 If the key cannot be loaded, then the replyinfo_obj is marked for
860 having no public key available.
863 if replyinfo_obj
.target_key
== None:
864 replyinfo_obj
.target_key
= replyinfo_obj
.fallback_target_key
866 if replyinfo_obj
.target_key
!= None:
868 encrypt_to_key
= gpgme_ctx
.get_key(replyinfo_obj
.target_key
)
869 return encrypt_to_key
874 # no available key to use
875 replyinfo_obj
.target_key
= None
876 replyinfo_obj
.fallback_target_key
= None
878 replyinfo_obj
.no_public_key
= True
879 replyinfo_obj
.public_key_received
= False
884 def write_reply (replyinfo_obj
):
885 """Write the reply email body about the GPG successes/failures.
887 The reply is about whether decryption, sig verification and key
888 import/loading was successful or failed. If text was successfully decrypted
889 and verified, then the first instance of such text will be included in
893 replyinfo_obj: contains details of GPG processing status
896 the plaintext message to be sent to the user
899 replyinfo_obj should be populated with info about GPG processing status.
904 if replyinfo_obj
.success_decrypt
== True:
905 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
907 if replyinfo_obj
.no_public_key
== False:
908 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
909 reply_plain
+= quoted_text
911 elif replyinfo_obj
.failed_decrypt
== True:
912 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
915 if replyinfo_obj
.sig_success
== True:
916 reply_plain
+= "\n\n"
917 reply_plain
+= replyinfo_obj
.replies
['sig_success']
919 elif replyinfo_obj
.sig_failure
== True:
920 reply_plain
+= "\n\n"
921 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
924 if replyinfo_obj
.public_key_received
== True:
925 reply_plain
+= "\n\n"
926 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
928 elif replyinfo_obj
.no_public_key
== True:
929 reply_plain
+= "\n\n"
930 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
933 reply_plain
+= "\n\n"
934 reply_plain
+= replyinfo_obj
.replies
['signature']
939 def add_gpg_key (key_block
, gpgme_ctx
):
940 """Adds a GPG pubkey to the local keystore
942 This adds keys received through email into the key store so they can be
946 key_block: the string form of the ascii-armored public key block
947 gpgme_ctx: the gpgme context
950 the fingerprint(s) of the imported key(s)
953 fp
= io
.BytesIO(key_block
.encode('ascii'))
955 result
= gpgme_ctx
.import_(fp
)
956 imports
= result
.imports
958 key_fingerprints
= []
961 for import_
in imports
:
962 fingerprint
= import_
[0]
963 key_fingerprints
+= [fingerprint
]
965 debug("added gpg key: " + fingerprint
)
967 return key_fingerprints
970 def verify_sig_message (msg_block
, gpgme_ctx
):
971 """Verifies the signature of a signed, ascii-armored block of text.
973 It encodes the string into ascii, since binary GPG files are currently
974 unsupported, and alternative, the ascii-armored format is encodable into
978 msg_block: a GPG Message block in string form. It may be encrypted or
979 not. If it is encrypted, it will return empty results.
980 gpgme_ctx: the gpgme context
983 A tuple of the plaintext of the signed part and the list of
984 fingerprints of keys signing the data. If verification failed, perhaps
985 because the message was also encrypted, then empty results are
989 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
990 plain_b
= io
.BytesIO()
993 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
997 plaintext
= plain_b
.getvalue().decode('utf-8')
1001 fingerprints
+= [sig
.fpr
]
1002 return (plaintext
, fingerprints
)
1005 def verify_clear_signature (sig_block
, gpgme_ctx
):
1006 """Verifies the signature of a clear signature.
1008 It first encodes the string into utf-8, but this will need to be fixed in
1009 order to support other character encodings.
1012 sig_block: a string of clear-signed text.
1013 gpgme_ctx: the gpgme context
1016 A tuple of the plaintext of the signed part and the list of
1017 fingerprints of keys signing the data. If verification failed, then
1018 empty results are returned.
1021 # FIXME: this might require the un-decoded bytes
1022 # or the correct re-encoding with the carset of the mime part.
1023 msg_fp
= io
.BytesIO(sig_block
.encode('utf-8'))
1024 ptxt_fp
= io
.BytesIO()
1026 result
= gpgme_ctx
.verify(msg_fp
, None, ptxt_fp
)
1028 # FIXME: this might require using the charset of the mime part.
1029 plaintext
= ptxt_fp
.getvalue().decode('utf-8')
1031 sig_fingerprints
= []
1033 sig_fingerprints
+= [res_
.fpr
]
1035 return plaintext
, sig_fingerprints
1038 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1039 """Verifies the signature of a detached signature.
1041 This requires the signature part and the signed part as separate arguments.
1044 detached_sig: the signature part of the detached signature
1045 plaintext_bytes: the byte form of the message being signed.
1046 gpgme_ctx: the gpgme context
1049 A list of signing fingerprints if the signature verification was
1050 sucessful. Otherwise, an empty list is returned.
1053 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1054 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1055 ptxt_fp
= io
.BytesIO()
1057 result
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1059 sig_fingerprints
= []
1061 sig_fingerprints
+= [res_
.fpr
]
1063 return sig_fingerprints
1066 def decrypt_block (msg_block
, gpgme_ctx
):
1067 """Decrypts a block of GPG text, and verifies any included sigatures.
1069 Some encypted messages have embeded signatures, so those are verified too.
1072 msg_block: the encrypted(/signed) text
1073 gpgme_ctx: the gpgme context
1076 A tuple of plaintext and signatures, if the decryption and signature
1077 verification were successful, respectively.
1080 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1081 plain_b
= io
.BytesIO()
1084 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1088 plaintext
= plain_b
.getvalue().decode('utf-8')
1092 fingerprints
+= [sig
.fpr
]
1093 return (plaintext
, fingerprints
)
1096 def email_to_from_subject (email_text
):
1097 """Returns the values of the email's To:, From: and Subject: fields
1099 Returns this information from an email.
1102 email_text: the string form of the email
1105 the email To:, From:, and Subject: fields as strings
1108 email_struct
= email
.parser
.Parser().parsestr(email_text
)
1110 email_to
= email_struct
['To']
1111 email_from
= email_struct
['From']
1112 email_subject
= email_struct
['Subject']
1114 return email_to
, email_from
, email_subject
1117 def import_lang(email_to
):
1118 """Imports appropriate language file for basic i18n support
1120 The language imported depends on the To: address of the email received by
1121 edward. an -en ending implies the English language, whereas a -ja ending
1122 implies Japanese. The list of supported languages is listed in the 'langs'
1123 list at the beginning of the program.
1126 email_to: the string containing the email address that the mail was
1130 the reference to the imported language module. The only variable in
1131 this file is the 'replies' dictionary.
1134 if email_to
!= None:
1136 if "edward-" + lang
in email_to
:
1137 lang
= "lang." + re
.sub('-', '_', lang
)
1138 language
= importlib
.import_module(lang
)
1142 return importlib
.import_module("lang.en")
1145 def generate_encrypted_mime (plaintext
, email_from
, email_subject
, encrypt_to_key
,
1147 """This function creates the mime email reply. It can encrypt the email.
1149 If the encrypt_key is included, then the email is encrypted and signed.
1150 Otherwise it is unencrypted.
1153 plaintext: the plaintext body of the message to create.
1154 email_from: the email address to reply to
1155 email_subject: the subject to use in reply
1156 encrypt_to_key: the key object to use for encrypting the email. (or
1158 gpgme_ctx: the gpgme context
1161 A string version of the mime message, possibly encrypted and signed.
1164 # quoted printable encoding lets most ascii characters look normal
1165 # before the mime message is decoded.
1166 char_set
= email
.charset
.Charset("utf-8")
1167 char_set
.body_encoding
= email
.charset
.QP
1169 # MIMEText doesn't allow setting the text encoding
1170 # so we use MIMENonMultipart.
1171 plaintext_mime
= MIMENonMultipart('text', 'plain')
1172 plaintext_mime
.set_payload(plaintext
, charset
=char_set
)
1174 if (encrypt_to_key
!= None):
1176 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1180 control_mime
= MIMEApplication("Version: 1",
1181 _subtype
='pgp-encrypted',
1182 _encoder
=email
.encoders
.encode_7or8bit
)
1183 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1184 control_mime
.set_charset('us-ascii')
1186 encoded_mime
= MIMEApplication(encrypted_text
,
1187 _subtype
='octet-stream; name="encrypted.asc"',
1188 _encoder
=email
.encoders
.encode_7or8bit
)
1189 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1190 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1191 encoded_mime
.set_charset('us-ascii')
1193 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1194 message_mime
.attach(control_mime
)
1195 message_mime
.attach(encoded_mime
)
1196 message_mime
['Content-Disposition'] = 'inline'
1199 message_mime
= plaintext_mime
1201 message_mime
['To'] = email_from
1202 message_mime
['Subject'] = email_subject
1204 reply
= message_mime
.as_string()
1209 def email_quote_text (text
):
1210 """Quotes input text by inserting "> "s
1212 This is useful for quoting a text for the reply message. It inserts "> "
1213 strings at the beginning of lines.
1216 text: plain text to quote
1222 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1224 return quoted_message
1227 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1228 """Encrypts and signs plaintext
1230 This encrypts and signs a message.
1233 plaintext: text to sign and ecrypt
1234 encrypt_to_key: the key object to encrypt to
1235 gpgme_ctx: the gpgme context
1238 An encrypted and signed string of text
1241 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1242 encrypted_bytes
= io
.BytesIO()
1244 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1245 plaintext_bytes
, encrypted_bytes
)
1247 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1248 return encrypted_txt
1251 def error (error_msg
):
1252 """Write an error message to stdout
1254 The error message includes the program name.
1257 error_msg: the message to print
1263 An error message is printed to stdout
1266 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1269 def debug (debug_msg
):
1270 """Writes a debug message to stdout if debug == True
1272 If the debug option is set in edward_config.py, then the passed message
1273 gets printed to stdout.
1276 debug_msg: the message to print to stdout
1282 A debug message is printed to stdout
1285 if edward_config
.debug
== True:
1290 """Sets the progname variable and complains about any arguments
1292 If there are any arguments, then edward complains and quits, because input
1302 Exits with error 1 if there are arguments, otherwise returns to the
1303 calling function, such as main().
1307 progname
= sys
.argv
[0]
1309 if len(sys
.argv
) > 1:
1310 print(progname
+ ": error, this program doesn't " \
1311 "need any arguments.", file=sys
.stderr
)
1315 if __name__
== "__main__":
1316 """Executes main if this file is not loaded interactively"""