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/PREVIOUS-20150530/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
47 from email
.mime
.text
import MIMEText
48 from email
.mime
.multipart
import MIMEMultipart
49 from email
.mime
.application
import MIMEApplication
50 from email
.mime
.nonmultipart
import MIMENonMultipart
54 langs
= ["de", "el", "en", "es", "fr", "it", "ja", "pt-br", "ro", "ru", "tr"]
56 """This list contains the abbreviated names of reply languages available to
59 class TxtType (enum
.Enum
):
67 match_pairs
= [(TxtType
.message
,
68 '-----BEGIN PGP MESSAGE-----.*?-----END PGP MESSAGE-----'),
70 '-----BEGIN PGP PUBLIC KEY BLOCK-----.*?-----END PGP PUBLIC KEY BLOCK-----'),
72 '-----BEGIN PGP SIGNATURE-----.*?-----END PGP SIGNATURE-----')]
74 """This list of tuples matches query names with re.search() queries used
75 to find GPG data for edward to process."""
78 class EddyMsg (object):
80 The EddyMsg class represents relevant parts of a mime message.
82 The represented message can be single-part or multi-part.
84 'multipart' is set to True if there are multiple mime parts.
86 'subparts' points to a list of mime sub-parts if it is a multi-part
87 message. Otherwise it points to an empty list.
89 'payload_bytes' is a binary representation of the mime part before header
90 removal and message decoding.
92 'payload_pieces' is a list of objects containing strings that when strung
93 together form the fully-decoded string representation of the mime part.
95 The 'filename', 'content_type', 'content_disposition' and
96 'description_list' come from the mime part parameters.
108 content_disposition
= None
109 description_list
= None
112 class PayloadPiece (object):
114 PayloadPiece represents a complte or sub-section of a mime part.
116 Instances of this class are often strung together within one or more arrays
117 pointed to by each instance of the EddyMsg class.
119 'piece_type' refers to an enum whose value describes the content of
120 'string'. Examples include TxtType.pubkey, for public keys, and
121 TxtType.message, for encrypted data (or armored signatures until they are
122 known to be such.) Some of the names derive from the header and footer of
123 each of these ascii-encoded gpg blocks.
125 'string' contains some string of text, such as non-GPG text, an encrypted
126 block of text, a signature, or a public key.
128 'gpg_data' points to any instances of GPGData that have been created based
129 on the contents of 'string'.
137 class GPGData (object):
139 GPGData holds info from decryption, sig. verification, and/or pub. keys.
141 Instances of this class contain decrypted information, signature
142 fingerprints and/or fingerprints of processed and imported public keys.
144 'decrypted' is set to True if 'plainobj' was created from encrypted data.
146 'plainobj' points to any decrypted, or signed part of, a GPG signature. It
147 is intended to be an instance of the EddyMsg class.
149 'sigs' is a list of fingerprints of keys used to sign the data in plainobj.
151 'sigkey_missing' is set to True if edward doesn't have the key it needs to
152 verify the signature on a block of text.
154 'key_cannot_encrypt' is set to True if pubkeys or sigs' keys in the payload
155 piece are not capable of encryption, are revoked or expired, for instance.
157 'keys' is a list of fingerprints of keys obtained in public key blocks.
164 sigkey_missing
= False
165 key_cannot_encrypt
= False
169 class ReplyInfo (object):
171 ReplyInfo contains details that edward uses in generating its reply.
173 Instances of this class contain information about whether a message was
174 successfully encrypted or signed, and whether a public key was attached, or
175 retrievable, from the local GPG store. It stores the fingerprints of
176 potential encryption key candidates and the message (if any at all) to
177 quote in edward's reply.
179 'replies' points one of the dictionaries of translated replies.
181 'target_key' refers to the fingerprint of a key used to sign encrypted
182 data. This is the preferred key, if it is set, and if is available.
184 'fallback_target_key' referst to the fingerprint of a key used to sign
185 unencrypted data; alternatively it may be a public key attached to the
188 'encrypt_to_key' the key object to use when encrypting edward's reply
190 'msg_to_quote' refers to the part of a message which edward should quote in
191 his reply. This should remain as None if there was no encrypted and singed
192 part. This is to avoid making edward a service for decrypting other
193 people's messages to edward.
195 'decrypt_success' is set to True if edward could decrypt part of the
198 'sig_success' is set to True if edward could to some extent verify the
199 signature of a signed part of the message to edward.
201 'key_can_encrypt' is set to True if a key which can be encrypted to has
204 'sig_failure' is set to True if edward could not verify a siganture.
206 'pubkey_success' is set to True if edward successfully imported a public
209 'sigkey_missing' is set to True if edward doesn't have the public key
210 needed for signature verification.
212 'key_cannot_encrypt' is set to True if pubkeys or sig's keys in a payload
213 piece of the message are not capable of encryption.
215 'have_repy_key' is set to True if edward has a public key to encrypt its
222 fallback_target_key
= None
223 encrypt_to_key
= None
226 decrypt_success
= False
228 pubkey_success
= False
229 key_can_encrypt
= False
231 decrypt_failure
= False
233 sigkey_missing
= False
234 key_cannot_encrypt
= False
236 have_reply_key
= False
242 This is the main function for edward, a GPG reply bot.
244 Edward responds to GPG-encrypted and signed mail, encrypting and signing
245 the response if the user's public key is, or was, included in the message.
254 Mime or plaintext email passing in through standard input. Portions of
255 the email may be encrypted. If the To: address contains the text
256 "edward-ja", then the reply will contain a reply written in the
257 Japanese language. There are other languages as well. The default
261 A reply email will be printed to standard output. The contents of the
262 reply email depends on whether the original email was encrypted or not,
263 has or doesn't have a signature, whether a public key used in the
264 original message is provided or locally stored, and the language
265 implied by the To: address in the original email.
268 print_reply_only
= handle_args()
270 email_bytes
= sys
.stdin
.buffer.read()
272 test_auto_reply(email_bytes
)
274 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
275 edward_config
.sign_with_key
)
277 # do this twice so sigs can be verified with newly imported keys
278 parse_pgp_mime(email_bytes
, gpgme_ctx
)
279 email_struct
= parse_pgp_mime(email_bytes
, gpgme_ctx
)
281 email_to
, email_reply_to
, email_subject
= email_to_reply_to_subject(email_bytes
)
282 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
284 replyinfo_obj
= ReplyInfo()
285 replyinfo_obj
.replies
= lang
.replies
287 prepare_for_reply(email_struct
, replyinfo_obj
)
288 get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
289 reply_plaintext
= write_reply(replyinfo_obj
)
291 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_reply_to
, reply_from
, \
292 email_subject
, replyinfo_obj
.encrypt_to_key
,
295 if print_reply_only
== True:
298 send_reply(reply_mime
, email_reply_to
, reply_from
)
301 def get_gpg_context (gnupghome
, sign_with_key_fp
):
303 This function returns the GPG context needed for encryption and signing.
305 The context is needed by other functions which use GPG functionality.
308 gnupghome: The path to "~/.gnupg/" or its alternative.
309 sign_with_key: The fingerprint of the key to sign with
312 A gpgme context to be used for GPG functions.
315 the 'armor' flag is set to True and the list of signing keys contains
316 the single specified key
319 os
.environ
['GNUPGHOME'] = gnupghome
321 gpgme_ctx
= gpgme
.Context()
322 gpgme_ctx
.armor
= True
325 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
326 except gpgme
.GpgmeError
:
327 error("unable to load signing key. is the gnupghome "
328 + "and signing key properly set in the edward_config.py?")
331 gpgme_ctx
.signers
= [sign_with_key
]
336 def parse_pgp_mime (email_bytes
, gpgme_ctx
):
337 """Parses the email for mime payloads and decrypts/verfies signatures.
339 This function creates a representation of a mime or plaintext email with
340 the EddyMsg class. It then splits each mime payload into one or more pieces
341 which may be plain text or GPG data. It then decrypts encrypted parts and
342 does some very basic signature verification on those parts.
345 email_bytes: an email message in byte string format
346 gpgme_ctx: a gpgme context
349 A message as an instance of EddyMsg
352 the returned EddyMsg instance has split, decrypted, verified and pubkey
356 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
358 eddymsg_obj
= parse_mime(email_struct
)
359 split_payloads(eddymsg_obj
)
360 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
365 def parse_mime(msg_struct
):
366 """Translates python's email.parser format into an EddyMsg format
368 If the message is multi-part, then a recursive object is created, where
369 each sub-part is also a EddyMsg instance.
372 msg_struct: an email parsed with email.parser.BytesParser(), which can be
376 an instance of EddyMsg, potentially a recursive one.
379 eddymsg_obj
= get_subpart_data(msg_struct
)
381 if msg_struct
.is_multipart() == True:
382 payloads
= msg_struct
.get_payload()
384 eddymsg_obj
.multipart
= True
385 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
390 def scan_and_split (payload_piece
, match_name
, pattern
):
391 """This splits the payloads of an EddyMsg object into GPG and text parts.
393 An EddyMsg object's payload_pieces starts off as a list containing a single
394 PayloadPiece object. This function returns a list of these objects which
395 have been split into GPG data and regular text, if such splits need to be/
399 payload_piece: a single payload or a split part of a payload
400 match_name: the type of data to try to spit out from the payload piece
401 pattern: the search pattern to be used for finding that type of data
404 a list of objects of the PayloadPiece class, in the order that the
405 string part of payload_piece originally was, broken up according to
406 matches specified by 'pattern'.
409 # don't try to re-split pieces containing gpg data
410 if payload_piece
.piece_type
!= TxtType
.text
:
411 return [payload_piece
]
413 flags
= re
.DOTALL | re
.MULTILINE
414 matches
= re
.search(pattern
, payload_piece
.string
, flags
=flags
)
417 pieces
= [payload_piece
]
421 beginning
= PayloadPiece()
422 beginning
.string
= payload_piece
.string
[:matches
.start()]
423 beginning
.piece_type
= payload_piece
.piece_type
425 match
= PayloadPiece()
426 match
.string
= payload_piece
.string
[matches
.start():matches
.end()]
427 match
.piece_type
= match_name
429 rest
= PayloadPiece()
430 rest
.string
= payload_piece
.string
[matches
.end():]
431 rest
.piece_type
= payload_piece
.piece_type
433 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
434 pieces
= [beginning
, match
] + more_pieces
439 def get_subpart_data (part
):
440 """This function grabs information from a mime part.
442 It copies needed data from an email.parser.BytesParser() object over to an
446 part: an email.parser.BytesParser() object
454 mime_decoded_bytes
= part
.get_payload(decode
=True)
455 charset
= part
.get_content_charset()
457 # your guess is as good as a-myy-ee-ine...
461 payload_string
= part
.as_string()
462 if payload_string
!= None:
463 # convert each isolated carriage return or line feed to carriage return + line feed
464 payload_string_crlf
= re
.sub(r
'\n', '\r\n', re
.sub(r
'\r', '\n', re
.sub(r
'\r\n', '\n', payload_string
)))
465 obj
.payload_bytes
= payload_string_crlf
.encode(charset
)
467 obj
.filename
= part
.get_filename()
468 obj
.content_type
= part
.get_content_type()
469 obj
.content_disposition
= part
['content-disposition']
470 obj
.description_list
= part
['content-description']
472 if mime_decoded_bytes
!= None:
474 payload
= PayloadPiece()
475 payload
.string
= mime_decoded_bytes
.decode(charset
)
476 payload
.piece_type
= TxtType
.text
478 obj
.payload_pieces
= [payload
]
479 except UnicodeDecodeError:
485 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
486 """A function which maps another function onto a message's subparts.
488 This is a higer-order function which recursively performs a specified
489 function on each subpart of a multi-part message. Each single-part sub-part
490 has the function applied to it. This function also works if the part passed
494 function_to_do: function to perform on sub-parts
495 eddymsg_obj: a single part or multi-part EddyMsg object
496 data: a second argument to pass to 'function_to_do'
502 The passed-in EddyMsg object is transformed recursively on its
503 sub-parts according to 'function_to_do'.
506 if eddymsg_obj
.multipart
== True:
507 for sub
in eddymsg_obj
.subparts
:
508 do_to_eddys_pieces(function_to_do
, sub
, data
)
510 function_to_do(eddymsg_obj
, data
)
513 def split_payloads (eddymsg_obj
):
514 """Splits all (sub-)payloads of a message into GPG data and regular text.
516 Recursively performs payload splitting on all sub-parts of an EddyMsg
517 object into the various GPG data types, such as GPG messages, public key
518 blocks and signed text.
521 eddymsg_obj: an instance of EddyMsg
527 The EddyMsg object has payloads that are unsplit (by may be split)..
530 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
533 for match_pair
in match_pairs
:
534 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
537 def split_payload_pieces (eddymsg_obj
, match_pair
):
538 """A helper function for split_payloads(); works on PayloadPiece objects.
540 This function splits up PayloadPiece objects into multipe PayloadPiece
541 objects and replaces the EddyMsg object's previous list of payload pieces
542 with the new split up one.
545 eddymsg_obj: a single-part EddyMsg object.
546 match_pair: a tuple from the match_pairs list, which specifies a match
547 name and a match pattern.
553 The payload piece(s) of an EddyMsg object may be already split or
557 The EddyMsg object's payload piece(s) are split into a list of pieces
558 if matches of the match_pair are found.
561 (match_name
, pattern
) = match_pair
564 for piece
in eddymsg_obj
.payload_pieces
:
565 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
567 eddymsg_obj
.payload_pieces
= new_pieces_list
570 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
571 """Performs GPG operations on the GPG parts of the message
573 This function decrypts text, verifies signatures, and imports public keys
574 included in an email.
577 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
578 and non-GPG sections by split_payloads()
579 gpgme_ctx: a gpgme context
581 prev_parts: a list of mime parts that occur before the eddymsg_obj
582 part, under the same multi-part mime part. This is used for
583 verifying detached signatures. For the root mime part, this should
584 be an empty list, which is the default value if this paramater is
591 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
594 Decryption, verification and key imports occur. the gpg_data members of
595 PayloadPiece objects get filled in with GPGData objects with some of
596 their attributes set.
599 if eddymsg_obj
.multipart
== True:
601 for sub
in eddymsg_obj
.subparts
:
602 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
607 for piece
in eddymsg_obj
.payload_pieces
:
609 if piece
.piece_type
== TxtType
.text
:
610 # don't transform the plaintext.
613 elif piece
.piece_type
== TxtType
.message
:
614 piece
.gpg_data
= GPGData()
616 (plaintext_b
, sigs
, sigkey_missing
, key_cannot_encrypt
) = decrypt_block(piece
.string
, gpgme_ctx
)
618 piece
.gpg_data
.sigkey_missing
= sigkey_missing
619 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
622 piece
.gpg_data
.decrypted
= True
623 piece
.gpg_data
.sigs
= sigs
625 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
628 # if not encrypted, check to see if this is an armored signature.
629 (plaintext_b
, sigs
, sigkey_missing
, key_cannot_encrypt
) = verify_sig_message(piece
.string
, gpgme_ctx
)
631 piece
.gpg_data
.sigkey_missing
= sigkey_missing
632 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
635 piece
.piece_type
= TxtType
.signature
636 piece
.gpg_data
.sigs
= sigs
638 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
640 elif piece
.piece_type
== TxtType
.pubkey
:
641 piece
.gpg_data
= GPGData()
643 (key_fps
, key_cannot_encrypt
) = add_gpg_key(piece
.string
, gpgme_ctx
)
645 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
648 piece
.gpg_data
.keys
= key_fps
650 elif piece
.piece_type
== TxtType
.detachedsig
:
651 piece
.gpg_data
= GPGData()
653 for prev
in prev_parts
:
654 (sig_fps
, sigkey_missing
, key_cannot_encrypt
) = verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
656 piece
.gpg_data
.sigkey_missing
= sigkey_missing
657 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
660 piece
.gpg_data
.sigs
= sig_fps
661 piece
.gpg_data
.plainobj
= prev
668 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
669 """Updates replyinfo_obj with info on the message's GPG success/failures
671 This function marks replyinfo_obj with information about whether encrypted
672 text in eddymsg_obj was successfully decrypted, signatures were verified
673 and whether a public key was found or not.
676 eddymsg_obj: a message in the EddyMsg format
677 replyinfo_obj: an instance of ReplyInfo
683 eddymsg_obj has had its gpg_data created by gpg_on_payloads
686 replyinfo_obj has been updated with info about decryption/sig
687 verififcation status, etc. However the desired key isn't imported until
688 later, so the success or failure of that updates the values set here.
691 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
693 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
694 """A helper function for prepare_for_reply
696 It updates replyinfo_obj with GPG success/failure information, when
697 supplied a single-part EddyMsg object.
700 eddymsg_obj: a single-part message in the EddyMsg format
701 replyinfo_obj: an object which holds information about the message's
708 eddymsg_obj is a single-part message. (it may be a part of a multi-part
709 message.) It has had its gpg_data created by gpg_on_payloads if it has
713 replyinfo_obj has been updated with gpg success/failure information
716 for piece
in eddymsg_obj
.payload_pieces
:
717 if piece
.piece_type
== TxtType
.text
:
718 # don't quote the plaintext part.
721 elif piece
.piece_type
== TxtType
.message
:
722 prepare_for_reply_message(piece
, replyinfo_obj
)
724 elif piece
.piece_type
== TxtType
.pubkey
:
725 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
727 elif (piece
.piece_type
== TxtType
.detachedsig
) \
728 or (piece
.piece_type
== TxtType
.signature
):
729 prepare_for_reply_sig(piece
, replyinfo_obj
)
732 def prepare_for_reply_message (piece
, replyinfo_obj
):
733 """Helper function for prepare_for_reply()
735 This function is called when the piece_type of a payload piece is
736 TxtType.message, or GPG Message block. This should be encrypted text. If
737 the encryted block is correclty signed, a sig will be attached to
738 .target_key unless there is already one there.
741 piece: a PayloadPiece object.
742 replyinfo_obj: object which gets updated with decryption status, etc.
748 the piece.payload_piece value should be TxtType.message.
751 replyinfo_obj gets updated with decryption status, signing status, a
752 potential signing key, posession status of the public key for the
753 signature and encryption capability status if that key is missing.
756 if piece
.gpg_data
.plainobj
== None:
757 replyinfo_obj
.decrypt_failure
= True
760 replyinfo_obj
.decrypt_success
= True
762 # we already have a key (and a message)
763 if replyinfo_obj
.target_key
!= None:
766 if piece
.gpg_data
.sigs
== []:
767 if piece
.gpg_data
.sigkey_missing
== True:
768 replyinfo_obj
.sigkey_missing
= True
770 if piece
.gpg_data
.key_cannot_encrypt
== True:
771 replyinfo_obj
.key_cannot_encrypt
= True
773 # only include a signed message in the reply.
774 get_signed_part
= True
777 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
778 replyinfo_obj
.sig_success
= True
779 get_signed_part
= False
781 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
783 # to catch public keys in encrypted blocks
784 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
787 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
788 """Helper function for prepare_for_reply(). Marks pubkey import status.
790 Marks replyinfo_obj with pub key import status.
793 piece: a PayloadPiece object
794 replyinfo_obj: a ReplyInfo object
797 piece.piece_type should be set to TxtType.pubkey .
800 replyinfo_obj has its fields updated.
803 if piece
.gpg_data
.keys
== []:
804 if piece
.gpg_data
.key_cannot_encrypt
== True:
805 replyinfo_obj
.key_cannot_encrypt
= True
807 replyinfo_obj
.pubkey_success
= True
809 # prefer public key as a fallback for the encrypted reply
810 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
813 def prepare_for_reply_sig (piece
, replyinfo_obj
):
814 """Helper function for prepare_for_reply(). Marks sig verification status.
816 Marks replyinfo_obj with signature verification status.
819 piece: a PayloadPiece object
820 replyinfo_obj: a ReplyInfo object
823 piece.piece_type should be set to TxtType.signature, or
824 TxtType.detachedsig .
827 replyinfo_obj has its fields updated.
830 if piece
.gpg_data
.sigs
== []:
831 replyinfo_obj
.sig_failure
= True
833 if piece
.gpg_data
.sigkey_missing
== True:
834 replyinfo_obj
.sigkey_missing
= True
836 if piece
.gpg_data
.key_cannot_encrypt
== True:
837 replyinfo_obj
.key_cannot_encrypt
= True
840 replyinfo_obj
.sig_success
= True
842 if replyinfo_obj
.fallback_target_key
== None:
843 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
845 if (piece
.piece_type
== TxtType
.signature
):
846 # to catch public keys in signature blocks
847 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
850 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
851 """For creating a string representation of a signed, encrypted part.
853 When given a decrypted payload, it will add either the plaintext or signed
854 plaintext to the reply message, depeding on 'get_signed_part'. This is
855 useful for ensuring that the reply message only comes from a signed and
856 ecrypted GPG message. It also sets the target_key for encrypting the reply
857 if it's told to get signed text only.
860 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
862 replyinfo_obj: a ReplyInfo object for holding the message to quote and
863 the target_key to encrypt to.
864 get_signed_part: True if we should only include text that contains a
865 further signature. If False, then include plain text.
871 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
872 which represents decrypted text. It may or may not be signed on that
876 the ReplyInfo instance may have a new 'target_key' set and its
877 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
881 if eddymsg_obj
== None:
884 # recurse on multi-part mime
885 if eddymsg_obj
.multipart
== True:
886 for sub
in eddymsg_obj
.subparts
:
887 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
889 for piece
in eddymsg_obj
.payload_pieces
:
890 if (get_signed_part
):
891 if ((piece
.piece_type
== TxtType
.detachedsig
) \
892 or (piece
.piece_type
== TxtType
.signature
)) \
893 and (piece
.gpg_data
!= None) \
894 and (piece
.gpg_data
.plainobj
!= None):
895 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
896 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
899 if (eddymsg_obj
.content_disposition
== None \
900 or not eddymsg_obj
.content_disposition
.startswith("attachment")) \
901 and piece
.piece_type
== TxtType
.text
:
902 replyinfo_obj
.msg_to_quote
+= piece
.string
905 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
906 """Obtains a public key object from a key fingerprint
908 If the .target_key is not set, then we use .fallback_target_key, if
912 replyinfo_obj: ReplyInfo instance
913 gpgme_ctx: the gpgme context
919 Loading a key requires that we have the public key imported. This
920 requires that they email contains the pub key block, or that it was
921 previously sent to edward.
924 If the key can be loaded, then replyinfo_obj.reply_to_key points to the
925 public key object. If the key cannot be loaded, then the replyinfo_obj
926 is marked as having no public key available. If the key is not capable
927 of encryption, it will not be used, and replyinfo_obj will be marked
931 for key
in (replyinfo_obj
.target_key
, replyinfo_obj
.fallback_target_key
):
934 encrypt_to_key
= gpgme_ctx
.get_key(key
)
936 except gpgme
.GpgmeError
:
939 if is_key_usable(encrypt_to_key
):
940 replyinfo_obj
.encrypt_to_key
= encrypt_to_key
941 replyinfo_obj
.have_reply_key
= True
942 replyinfo_obj
.key_can_encrypt
= True
946 replyinfo_obj
.key_cannot_encrypt
= True
950 def write_reply (replyinfo_obj
):
951 """Write the reply email body about the GPG successes/failures.
953 The reply is about whether decryption, sig verification and key
954 import/loading was successful or failed. If text was successfully decrypted
955 and verified, then the first instance of such text will be included in
959 replyinfo_obj: contains details of GPG processing status
962 the plaintext message to be sent to the user
965 replyinfo_obj should be populated with info about GPG processing status.
970 if (replyinfo_obj
.pubkey_success
== True):
971 reply_plain
+= replyinfo_obj
.replies
['greeting']
972 reply_plain
+= "\n\n"
975 if replyinfo_obj
.decrypt_success
== True:
976 debug('decrypt success')
977 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
978 reply_plain
+= "\n\n"
980 elif replyinfo_obj
.decrypt_failure
== True:
981 debug('decrypt failure')
982 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
983 reply_plain
+= "\n\n"
986 if replyinfo_obj
.sig_success
== True:
987 debug('signature success')
988 reply_plain
+= replyinfo_obj
.replies
['sig_success']
989 reply_plain
+= "\n\n"
991 elif replyinfo_obj
.sig_failure
== True:
992 debug('signature failure')
993 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
994 reply_plain
+= "\n\n"
997 if (replyinfo_obj
.pubkey_success
== True):
998 debug('public key received')
999 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
1000 reply_plain
+= "\n\n"
1002 elif (replyinfo_obj
.sigkey_missing
== True):
1003 debug('no public key')
1004 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
1005 reply_plain
+= "\n\n"
1007 elif (replyinfo_obj
.key_can_encrypt
== False) \
1008 and (replyinfo_obj
.key_cannot_encrypt
== True):
1009 debug('bad public key')
1010 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
1011 reply_plain
+= "\n\n"
1014 if (replyinfo_obj
.decrypt_success
== True) \
1015 and (replyinfo_obj
.sig_success
== True) \
1016 and (replyinfo_obj
.have_reply_key
== True):
1017 debug('message quoted')
1018 reply_plain
+= replyinfo_obj
.replies
['quote_follows']
1019 reply_plain
+= "\n\n"
1020 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
1021 reply_plain
+= quoted_text
1022 reply_plain
+= "\n\n"
1025 if (reply_plain
== ""):
1026 debug('plaintext message')
1027 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
1028 reply_plain
+= "\n\n"
1031 reply_plain
+= replyinfo_obj
.replies
['signature']
1032 reply_plain
+= "\n\n"
1037 def add_gpg_key (key_block
, gpgme_ctx
):
1038 """Adds a GPG pubkey to the local keystore
1040 This adds keys received through email into the key store so they can be
1044 key_block: the string form of the ascii-armored public key block
1045 gpgme_ctx: the gpgme context
1048 the fingerprint(s) of the imported key(s) which can be used for
1049 encryption, and a boolean marking whether none of the keys are capable
1053 fp
= io
.BytesIO(key_block
.encode('ascii'))
1056 result
= gpgme_ctx
.import_(fp
)
1057 imports
= result
.imports
1058 except gpgme
.GpgmeError
:
1061 key_fingerprints
= []
1062 key_cannot_encrypt
= False
1064 for import_res
in imports
:
1065 fingerprint
= import_res
[0]
1068 key_obj
= gpgme_ctx
.get_key(fingerprint
)
1072 if key_obj
!= None and is_key_usable(key_obj
):
1073 key_fingerprints
+= [fingerprint
]
1074 key_cannot_encrypt
= False
1076 debug("added gpg key: " + fingerprint
)
1078 elif key_fingerprints
== []:
1079 key_cannot_encrypt
= True
1081 return (key_fingerprints
, key_cannot_encrypt
)
1084 def verify_sig_message (msg_block
, gpgme_ctx
):
1085 """Verifies the signature of a signed, ascii-armored block of text.
1087 It encodes the string into ascii, since binary GPG files are currently
1088 unsupported, and alternative, the ascii-armored format is encodable into
1092 msg_block: a GPG Message block in string form. It may be encrypted or
1093 not. If it is encrypted, it will return empty results.
1094 gpgme_ctx: the gpgme context
1097 A tuple containing the plaintext bytes of the signed part, the list of
1098 fingerprints of encryption-capable keys signing the data, a boolean
1099 marking whether edward is missing all public keys for validating any of
1100 the signatures, and a boolean marking whether all sigs' keys are
1101 incapable of encryption. If verification failed, perhaps because the
1102 message was also encrypted, sensible default values are returned.
1105 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1106 plain_b
= io
.BytesIO()
1109 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
1110 except gpgme
.GpgmeError
:
1111 return ("",[],False,False)
1113 plaintext_b
= plain_b
.getvalue()
1115 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1117 return (plaintext_b
, fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1120 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1121 """Verifies the signature of a detached signature.
1123 This requires the signature part and the signed part as separate arguments.
1126 detached_sig: the signature part of the detached signature
1127 plaintext_bytes: the byte form of the message being signed.
1128 gpgme_ctx: the gpgme context
1131 A tuple containging a list of encryption capable signing fingerprints
1132 if the signature verification was sucessful, a boolean marking whether
1133 edward is missing all public keys for validating any of the signatures,
1134 and a boolean marking whether all signing keys are incapable of
1135 encryption. Otherwise, a tuple containing an empty list and True are
1139 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1140 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1143 sigs
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1144 except gpgme
.GpgmeError
:
1145 return ([],False,False)
1147 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1149 return (fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1152 def decrypt_block (msg_block
, gpgme_ctx
):
1153 """Decrypts a block of GPG text and verifies any included sigatures.
1155 Some encypted messages have embeded signatures, so those are verified too.
1158 msg_block: the encrypted(/signed) text
1159 gpgme_ctx: the gpgme context
1162 A tuple containing plaintext bytes, encryption-capable signatures (if
1163 decryption and signature verification were successful, respectively), a
1164 boolean marking whether edward is missing all public keys for
1165 validating any of the signatures, and a boolean marking whether all
1166 signature keys are incapable of encryption.
1169 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1170 plain_b
= io
.BytesIO()
1173 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1174 except gpgme
.GpgmeError
:
1175 return ("",[],False,False)
1177 plaintext_b
= plain_b
.getvalue()
1179 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1181 return (plaintext_b
, fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1184 def get_signature_fp (sigs
, gpgme_ctx
):
1185 """Selects valid signatures from output of gpgme signature verifying functions
1187 get_signature_fp returns a list of valid signature fingerprints if those
1188 fingerprints are associated with available keys capable of encryption.
1191 sigs: a signature verification result object list
1192 gpgme_ctx: a gpgme context
1195 fingerprints: a list of fingerprints
1196 sigkey_missing: a boolean marking whether public keys are missing for
1197 all available signatures.
1198 key_cannot_encrypt: a boolearn marking whether available public keys are
1199 incapable of encryption.
1202 sigkey_missing
= False
1203 key_cannot_encrypt
= False
1207 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1209 key_obj
= gpgme_ctx
.get_key(sig
.fpr
)
1211 if fingerprints
== []:
1212 sigkey_missing
= True
1215 if is_key_usable(key_obj
):
1216 fingerprints
+= [sig
.fpr
]
1217 key_cannot_encrypt
= False
1218 sigkey_missing
= False
1220 elif fingerprints
== []:
1221 key_cannot_encrypt
= True
1223 elif fingerprints
== []:
1224 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1225 sigkey_missing
= True
1227 return (fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1230 def is_key_usable (key_obj
):
1231 """Returns boolean representing key usability regarding encryption
1233 Tests various feature of key and returns usability
1236 key_obj: a gpgme key object
1239 A boolean representing key usability
1241 if key_obj
.can_encrypt
and not key_obj
.invalid
and not key_obj
.expired \
1242 and not key_obj
.revoked
and not key_obj
.disabled
:
1248 def test_auto_reply (email_bytes
):
1249 """Test whether email is auto-generated
1251 If the email is autogenerated, edward quits without sending a response.
1252 This is not a perfect test. Some auto-responses will go undetected.
1255 email_bytes: the byte string from of the email
1258 Nothing, or exits the program
1261 email_struct
= email
.parser
.BytesHeaderParser().parsebytes(email_bytes
)
1263 auto_submitted
= email_struct
['Auto-Submitted']
1265 if auto_submitted
== None or auto_submitted
== "no" \
1266 or auto_submitted
== "No":
1274 def email_to_reply_to_subject (email_bytes
):
1275 """Returns the email's To:, Reply-To: (or From:), and Subject: fields
1277 Returns this information from an email.
1280 email_bytes: the byte string form of the email
1283 the email To:, Reply-To: (or From:), and Subject: fields as strings
1286 email_struct
= email
.parser
.BytesHeaderParser().parsebytes(email_bytes
)
1288 email_to
= email_struct
['To']
1289 email_from
= email_struct
['From']
1290 email_reply_to
= email_struct
['Reply-To']
1292 email_subject
= email_struct
['Subject']
1294 if email_reply_to
== None:
1295 email_reply_to
= email_from
1297 return email_to
, email_reply_to
, email_subject
1300 def import_lang_pick_address(email_to
, hostname
):
1301 """Imports language file for i18n support; makes reply from address
1303 The language imported depends on the To: address of the email received by
1304 edward. an -en ending implies the English language, whereas a -ja ending
1305 implies Japanese. The list of supported languages is listed in the 'langs'
1306 list at the beginning of the program. This function also chooses the
1307 language-dependent address which can be used as the From address in the
1311 email_to: the string containing the email address that the mail was
1313 hostname: the hostname part of the reply email's from address
1316 the reference to the imported language module. The only variable in
1317 this file is the 'replies' dictionary.
1323 if email_to
!= None:
1325 if "edward-" + lang
in email_to
:
1329 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1330 lang_module
= importlib
.import_module(lang_mod_name
)
1332 reply_from
= "edward-" + use_lang
+ "@" + hostname
1334 return lang_module
, reply_from
1337 def generate_encrypted_mime (plaintext
, email_to
, email_from
, email_subject
,
1338 encrypt_to_key
, gpgme_ctx
):
1339 """This function creates the mime email reply. It can encrypt the email.
1341 If the encrypt_key is included, then the email is encrypted and signed.
1342 Otherwise it is unencrypted.
1345 plaintext: the plaintext body of the message to create.
1346 email_to: the email address to reply to
1347 email_subject: the subject to use in reply
1348 encrypt_to_key: the key object to use for encrypting the email. (or
1350 gpgme_ctx: the gpgme context
1353 A string version of the mime message, possibly encrypted and signed.
1356 plaintext_mime
= MIMEText(plaintext
)
1357 plaintext_mime
.set_charset('utf-8')
1359 if (encrypt_to_key
!= None):
1361 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1365 control_mime
= MIMEApplication("Version: 1",
1366 _subtype
='pgp-encrypted',
1367 _encoder
=email
.encoders
.encode_7or8bit
)
1368 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1369 control_mime
.set_charset('us-ascii')
1371 encoded_mime
= MIMEApplication(encrypted_text
,
1372 _subtype
='octet-stream; name="encrypted.asc"',
1373 _encoder
=email
.encoders
.encode_7or8bit
)
1374 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1375 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1376 encoded_mime
.set_charset('us-ascii')
1378 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1379 message_mime
.attach(control_mime
)
1380 message_mime
.attach(encoded_mime
)
1381 message_mime
['Content-Disposition'] = 'inline'
1384 message_mime
= plaintext_mime
1386 message_mime
['Auto-Submitted'] = 'auto-replied'
1388 message_mime
['To'] = email_to
1389 message_mime
['From'] = email_from
1390 message_mime
['Subject'] = email_subject
1392 reply
= message_mime
.as_string()
1397 def send_reply(email_txt
, reply_to
, reply_from
):
1398 """Sends reply email
1400 Sent to original sender
1403 email_txt: message as a string
1404 reply_to: recipient of reply
1405 reply_from: edward's specific email address
1411 if reply_to
== None:
1412 error("*** ERROR: No one to send email to.")
1415 s
= smtplib
.SMTP('localhost')
1416 s
.sendmail(reply_from
, reply_to
, email_txt
)
1420 def email_quote_text (text
):
1421 """Quotes input text by inserting "> "s
1423 This is useful for quoting a text for the reply message. It inserts "> "
1424 strings at the beginning of lines.
1427 text: plain text to quote
1433 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1435 return quoted_message
1438 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1439 """Encrypts and signs plaintext
1441 This encrypts and signs a message.
1444 plaintext: text to sign and ecrypt
1445 encrypt_to_key: the key object to encrypt to
1446 gpgme_ctx: the gpgme context
1449 An encrypted and signed string of text
1452 # the plaintext should be mime encoded in an ascii-compatible form
1453 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1454 encrypted_bytes
= io
.BytesIO()
1456 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1457 plaintext_bytes
, encrypted_bytes
)
1459 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1460 return encrypted_txt
1463 def error (error_msg
):
1464 """Write an error message to stdout
1466 The error message includes the program name.
1469 error_msg: the message to print
1475 An error message is printed to stdout
1478 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1481 def debug (debug_msg
):
1482 """Writes a debug message to stdout if debug == True
1484 If the debug option is set in edward_config.py, then the passed message
1485 gets printed to stdout.
1488 debug_msg: the message to print to stdout
1494 A debug message is printed to stdout
1497 if edward_config
.debug
== True:
1502 """Sets the progname variable and processes optional argument
1504 If there are more than two arguments then edward complains and quits. An
1505 single "-p" argument sets the print_reply_only option, which makes edward
1506 print email replies instead of mailing them.
1512 True if edward should print arguments instead of mailing them,
1513 otherwise it returns False.
1516 Exits with error 1 if there are more than two arguments, otherwise
1517 returns the print_reply_only option.
1521 progname
= sys
.argv
[0]
1523 print_reply_only
= False
1525 if len(sys
.argv
) > 2:
1526 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1527 + " -p print reply message to stdout, do not mail it\n", \
1531 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1532 print_reply_only
= True
1534 return print_reply_only
1537 if __name__
== "__main__":
1538 """Executes main if this file is not loaded interactively"""