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 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
271 edward_config
.sign_with_key
)
273 email_bytes
= sys
.stdin
.buffer.read()
275 # do this twice so sigs can be verified with newly imported keys
276 parse_pgp_mime(email_bytes
, gpgme_ctx
)
277 email_struct
= parse_pgp_mime(email_bytes
, gpgme_ctx
)
279 email_to
, email_reply_to
, email_subject
= email_to_reply_to_subject(email_bytes
)
280 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
282 replyinfo_obj
= ReplyInfo()
283 replyinfo_obj
.replies
= lang
.replies
285 prepare_for_reply(email_struct
, replyinfo_obj
)
286 get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
287 reply_plaintext
= write_reply(replyinfo_obj
)
289 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_reply_to
, reply_from
, \
290 email_subject
, replyinfo_obj
.encrypt_to_key
,
293 if print_reply_only
== True:
296 send_reply(reply_mime
, email_reply_to
, reply_from
)
299 def get_gpg_context (gnupghome
, sign_with_key_fp
):
301 This function returns the GPG context needed for encryption and signing.
303 The context is needed by other functions which use GPG functionality.
306 gnupghome: The path to "~/.gnupg/" or its alternative.
307 sign_with_key: The fingerprint of the key to sign with
310 A gpgme context to be used for GPG functions.
313 the 'armor' flag is set to True and the list of signing keys contains
314 the single specified key
317 os
.environ
['GNUPGHOME'] = gnupghome
319 gpgme_ctx
= gpgme
.Context()
320 gpgme_ctx
.armor
= True
323 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
324 except gpgme
.GpgmeError
:
325 error("unable to load signing key. is the gnupghome "
326 + "and signing key properly set in the edward_config.py?")
329 gpgme_ctx
.signers
= [sign_with_key
]
334 def parse_pgp_mime (email_bytes
, gpgme_ctx
):
335 """Parses the email for mime payloads and decrypts/verfies signatures.
337 This function creates a representation of a mime or plaintext email with
338 the EddyMsg class. It then splits each mime payload into one or more pieces
339 which may be plain text or GPG data. It then decrypts encrypted parts and
340 does some very basic signature verification on those parts.
343 email_bytes: an email message in byte string format
344 gpgme_ctx: a gpgme context
347 A message as an instance of EddyMsg
350 the returned EddyMsg instance has split, decrypted, verified and pubkey
354 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
356 eddymsg_obj
= parse_mime(email_struct
)
357 split_payloads(eddymsg_obj
)
358 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
363 def parse_mime(msg_struct
):
364 """Translates python's email.parser format into an EddyMsg format
366 If the message is multi-part, then a recursive object is created, where
367 each sub-part is also a EddyMsg instance.
370 msg_struct: an email parsed with email.parser.BytesParser(), which can be
374 an instance of EddyMsg, potentially a recursive one.
377 eddymsg_obj
= get_subpart_data(msg_struct
)
379 if msg_struct
.is_multipart() == True:
380 payloads
= msg_struct
.get_payload()
382 eddymsg_obj
.multipart
= True
383 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
388 def scan_and_split (payload_piece
, match_name
, pattern
):
389 """This splits the payloads of an EddyMsg object into GPG and text parts.
391 An EddyMsg object's payload_pieces starts off as a list containing a single
392 PayloadPiece object. This function returns a list of these objects which
393 have been split into GPG data and regular text, if such splits need to be/
397 payload_piece: a single payload or a split part of a payload
398 match_name: the type of data to try to spit out from the payload piece
399 pattern: the search pattern to be used for finding that type of data
402 a list of objects of the PayloadPiece class, in the order that the
403 string part of payload_piece originally was, broken up according to
404 matches specified by 'pattern'.
407 # don't try to re-split pieces containing gpg data
408 if payload_piece
.piece_type
!= TxtType
.text
:
409 return [payload_piece
]
411 flags
= re
.DOTALL | re
.MULTILINE
412 matches
= re
.search(pattern
, payload_piece
.string
, flags
=flags
)
415 pieces
= [payload_piece
]
419 beginning
= PayloadPiece()
420 beginning
.string
= payload_piece
.string
[:matches
.start()]
421 beginning
.piece_type
= payload_piece
.piece_type
423 match
= PayloadPiece()
424 match
.string
= payload_piece
.string
[matches
.start():matches
.end()]
425 match
.piece_type
= match_name
427 rest
= PayloadPiece()
428 rest
.string
= payload_piece
.string
[matches
.end():]
429 rest
.piece_type
= payload_piece
.piece_type
431 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
432 pieces
= [beginning
, match
] + more_pieces
437 def get_subpart_data (part
):
438 """This function grabs information from a mime part.
440 It copies needed data from an email.parser.BytesParser() object over to an
444 part: an email.parser.BytesParser() object
452 mime_decoded_bytes
= part
.get_payload(decode
=True)
453 charset
= part
.get_content_charset()
455 # your guess is as good as a-myy-ee-ine...
459 payload_string
= part
.as_string()
460 if payload_string
!= None:
461 # convert each isolated carriage return or line feed to carriage return + line feed
462 payload_string_crlf
= re
.sub(r
'\n', '\r\n', re
.sub(r
'\r', '\n', re
.sub(r
'\r\n', '\n', payload_string
)))
463 obj
.payload_bytes
= payload_string_crlf
.encode(charset
)
465 obj
.filename
= part
.get_filename()
466 obj
.content_type
= part
.get_content_type()
467 obj
.content_disposition
= part
['content-disposition']
468 obj
.description_list
= part
['content-description']
470 if mime_decoded_bytes
!= None:
472 payload
= PayloadPiece()
473 payload
.string
= mime_decoded_bytes
.decode(charset
)
474 payload
.piece_type
= TxtType
.text
476 obj
.payload_pieces
= [payload
]
477 except UnicodeDecodeError:
483 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
484 """A function which maps another function onto a message's subparts.
486 This is a higer-order function which recursively performs a specified
487 function on each subpart of a multi-part message. Each single-part sub-part
488 has the function applied to it. This function also works if the part passed
492 function_to_do: function to perform on sub-parts
493 eddymsg_obj: a single part or multi-part EddyMsg object
494 data: a second argument to pass to 'function_to_do'
500 The passed-in EddyMsg object is transformed recursively on its
501 sub-parts according to 'function_to_do'.
504 if eddymsg_obj
.multipart
== True:
505 for sub
in eddymsg_obj
.subparts
:
506 do_to_eddys_pieces(function_to_do
, sub
, data
)
508 function_to_do(eddymsg_obj
, data
)
511 def split_payloads (eddymsg_obj
):
512 """Splits all (sub-)payloads of a message into GPG data and regular text.
514 Recursively performs payload splitting on all sub-parts of an EddyMsg
515 object into the various GPG data types, such as GPG messages, public key
516 blocks and signed text.
519 eddymsg_obj: an instance of EddyMsg
525 The EddyMsg object has payloads that are unsplit (by may be split)..
528 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
531 for match_pair
in match_pairs
:
532 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
535 def split_payload_pieces (eddymsg_obj
, match_pair
):
536 """A helper function for split_payloads(); works on PayloadPiece objects.
538 This function splits up PayloadPiece objects into multipe PayloadPiece
539 objects and replaces the EddyMsg object's previous list of payload pieces
540 with the new split up one.
543 eddymsg_obj: a single-part EddyMsg object.
544 match_pair: a tuple from the match_pairs list, which specifies a match
545 name and a match pattern.
551 The payload piece(s) of an EddyMsg object may be already split or
555 The EddyMsg object's payload piece(s) are split into a list of pieces
556 if matches of the match_pair are found.
559 (match_name
, pattern
) = match_pair
562 for piece
in eddymsg_obj
.payload_pieces
:
563 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
565 eddymsg_obj
.payload_pieces
= new_pieces_list
568 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
569 """Performs GPG operations on the GPG parts of the message
571 This function decrypts text, verifies signatures, and imports public keys
572 included in an email.
575 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
576 and non-GPG sections by split_payloads()
577 gpgme_ctx: a gpgme context
579 prev_parts: a list of mime parts that occur before the eddymsg_obj
580 part, under the same multi-part mime part. This is used for
581 verifying detached signatures. For the root mime part, this should
582 be an empty list, which is the default value if this paramater is
589 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
592 Decryption, verification and key imports occur. the gpg_data members of
593 PayloadPiece objects get filled in with GPGData objects with some of
594 their attributes set.
597 if eddymsg_obj
.multipart
== True:
599 for sub
in eddymsg_obj
.subparts
:
600 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
605 for piece
in eddymsg_obj
.payload_pieces
:
607 if piece
.piece_type
== TxtType
.text
:
608 # don't transform the plaintext.
611 elif piece
.piece_type
== TxtType
.message
:
612 piece
.gpg_data
= GPGData()
614 (plaintext_b
, sigs
, sigkey_missing
, key_cannot_encrypt
) = decrypt_block(piece
.string
, gpgme_ctx
)
616 piece
.gpg_data
.sigkey_missing
= sigkey_missing
617 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
620 piece
.gpg_data
.decrypted
= True
621 piece
.gpg_data
.sigs
= sigs
623 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
626 # if not encrypted, check to see if this is an armored signature.
627 (plaintext_b
, sigs
, sigkey_missing
, key_cannot_encrypt
) = verify_sig_message(piece
.string
, gpgme_ctx
)
629 piece
.gpg_data
.sigkey_missing
= sigkey_missing
630 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
633 piece
.piece_type
= TxtType
.signature
634 piece
.gpg_data
.sigs
= sigs
636 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
638 elif piece
.piece_type
== TxtType
.pubkey
:
639 piece
.gpg_data
= GPGData()
641 (key_fps
, key_cannot_encrypt
) = add_gpg_key(piece
.string
, gpgme_ctx
)
643 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
646 piece
.gpg_data
.keys
= key_fps
648 elif piece
.piece_type
== TxtType
.detachedsig
:
649 piece
.gpg_data
= GPGData()
651 for prev
in prev_parts
:
652 (sig_fps
, sigkey_missing
, key_cannot_encrypt
) = verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
654 piece
.gpg_data
.sigkey_missing
= sigkey_missing
655 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
658 piece
.gpg_data
.sigs
= sig_fps
659 piece
.gpg_data
.plainobj
= prev
666 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
667 """Updates replyinfo_obj with info on the message's GPG success/failures
669 This function marks replyinfo_obj with information about whether encrypted
670 text in eddymsg_obj was successfully decrypted, signatures were verified
671 and whether a public key was found or not.
674 eddymsg_obj: a message in the EddyMsg format
675 replyinfo_obj: an instance of ReplyInfo
681 eddymsg_obj has had its gpg_data created by gpg_on_payloads
684 replyinfo_obj has been updated with info about decryption/sig
685 verififcation status, etc. However the desired key isn't imported until
686 later, so the success or failure of that updates the values set here.
689 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
691 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
692 """A helper function for prepare_for_reply
694 It updates replyinfo_obj with GPG success/failure information, when
695 supplied a single-part EddyMsg object.
698 eddymsg_obj: a single-part message in the EddyMsg format
699 replyinfo_obj: an object which holds information about the message's
706 eddymsg_obj is a single-part message. (it may be a part of a multi-part
707 message.) It has had its gpg_data created by gpg_on_payloads if it has
711 replyinfo_obj has been updated with gpg success/failure information
714 for piece
in eddymsg_obj
.payload_pieces
:
715 if piece
.piece_type
== TxtType
.text
:
716 # don't quote the plaintext part.
719 elif piece
.piece_type
== TxtType
.message
:
720 prepare_for_reply_message(piece
, replyinfo_obj
)
722 elif piece
.piece_type
== TxtType
.pubkey
:
723 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
725 elif (piece
.piece_type
== TxtType
.detachedsig
) \
726 or (piece
.piece_type
== TxtType
.signature
):
727 prepare_for_reply_sig(piece
, replyinfo_obj
)
730 def prepare_for_reply_message (piece
, replyinfo_obj
):
731 """Helper function for prepare_for_reply()
733 This function is called when the piece_type of a payload piece is
734 TxtType.message, or GPG Message block. This should be encrypted text. If
735 the encryted block is correclty signed, a sig will be attached to
736 .target_key unless there is already one there.
739 piece: a PayloadPiece object.
740 replyinfo_obj: object which gets updated with decryption status, etc.
746 the piece.payload_piece value should be TxtType.message.
749 replyinfo_obj gets updated with decryption status, signing status, a
750 potential signing key, posession status of the public key for the
751 signature and encryption capability status if that key is missing.
754 if piece
.gpg_data
.plainobj
== None:
755 replyinfo_obj
.decrypt_failure
= True
758 replyinfo_obj
.decrypt_success
= True
760 # we already have a key (and a message)
761 if replyinfo_obj
.target_key
!= None:
764 if piece
.gpg_data
.sigs
== []:
765 if piece
.gpg_data
.sigkey_missing
== True:
766 replyinfo_obj
.sigkey_missing
= True
768 if piece
.gpg_data
.key_cannot_encrypt
== True:
769 replyinfo_obj
.key_cannot_encrypt
= True
771 # only include a signed message in the reply.
772 get_signed_part
= True
775 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
776 replyinfo_obj
.sig_success
= True
777 get_signed_part
= False
779 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
781 # to catch public keys in encrypted blocks
782 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
785 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
786 """Helper function for prepare_for_reply(). Marks pubkey import status.
788 Marks replyinfo_obj with pub key import status.
791 piece: a PayloadPiece object
792 replyinfo_obj: a ReplyInfo object
795 piece.piece_type should be set to TxtType.pubkey .
798 replyinfo_obj has its fields updated.
801 if piece
.gpg_data
.keys
== []:
802 if piece
.gpg_data
.key_cannot_encrypt
== True:
803 replyinfo_obj
.key_cannot_encrypt
= True
805 replyinfo_obj
.pubkey_success
= True
807 # prefer public key as a fallback for the encrypted reply
808 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
811 def prepare_for_reply_sig (piece
, replyinfo_obj
):
812 """Helper function for prepare_for_reply(). Marks sig verification status.
814 Marks replyinfo_obj with signature verification status.
817 piece: a PayloadPiece object
818 replyinfo_obj: a ReplyInfo object
821 piece.piece_type should be set to TxtType.signature, or
822 TxtType.detachedsig .
825 replyinfo_obj has its fields updated.
828 if piece
.gpg_data
.sigs
== []:
829 replyinfo_obj
.sig_failure
= True
831 if piece
.gpg_data
.sigkey_missing
== True:
832 replyinfo_obj
.sigkey_missing
= True
834 if piece
.gpg_data
.key_cannot_encrypt
== True:
835 replyinfo_obj
.key_cannot_encrypt
= True
838 replyinfo_obj
.sig_success
= True
840 if replyinfo_obj
.fallback_target_key
== None:
841 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
843 if (piece
.piece_type
== TxtType
.signature
):
844 # to catch public keys in signature blocks
845 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
848 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
849 """For creating a string representation of a signed, encrypted part.
851 When given a decrypted payload, it will add either the plaintext or signed
852 plaintext to the reply message, depeding on 'get_signed_part'. This is
853 useful for ensuring that the reply message only comes from a signed and
854 ecrypted GPG message. It also sets the target_key for encrypting the reply
855 if it's told to get signed text only.
858 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
860 replyinfo_obj: a ReplyInfo object for holding the message to quote and
861 the target_key to encrypt to.
862 get_signed_part: True if we should only include text that contains a
863 further signature. If False, then include plain text.
869 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
870 which represents decrypted text. It may or may not be signed on that
874 the ReplyInfo instance may have a new 'target_key' set and its
875 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
879 if eddymsg_obj
== None:
882 # recurse on multi-part mime
883 if eddymsg_obj
.multipart
== True:
884 for sub
in eddymsg_obj
.subparts
:
885 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
887 for piece
in eddymsg_obj
.payload_pieces
:
888 if (get_signed_part
):
889 if ((piece
.piece_type
== TxtType
.detachedsig
) \
890 or (piece
.piece_type
== TxtType
.signature
)) \
891 and (piece
.gpg_data
!= None) \
892 and (piece
.gpg_data
.plainobj
!= None):
893 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
894 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
897 if (eddymsg_obj
.content_disposition
== None \
898 or not eddymsg_obj
.content_disposition
.startswith("attachment")) \
899 and piece
.piece_type
== TxtType
.text
:
900 replyinfo_obj
.msg_to_quote
+= piece
.string
903 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
904 """Obtains a public key object from a key fingerprint
906 If the .target_key is not set, then we use .fallback_target_key, if
910 replyinfo_obj: ReplyInfo instance
911 gpgme_ctx: the gpgme context
917 Loading a key requires that we have the public key imported. This
918 requires that they email contains the pub key block, or that it was
919 previously sent to edward.
922 If the key can be loaded, then replyinfo_obj.reply_to_key points to the
923 public key object. If the key cannot be loaded, then the replyinfo_obj
924 is marked as having no public key available. If the key is not capable
925 of encryption, it will not be used, and replyinfo_obj will be marked
929 for key
in (replyinfo_obj
.target_key
, replyinfo_obj
.fallback_target_key
):
932 encrypt_to_key
= gpgme_ctx
.get_key(key
)
934 except gpgme
.GpgmeError
:
937 if is_key_usable(encrypt_to_key
):
938 replyinfo_obj
.encrypt_to_key
= encrypt_to_key
939 replyinfo_obj
.have_reply_key
= True
940 replyinfo_obj
.key_can_encrypt
= True
944 replyinfo_obj
.key_cannot_encrypt
= True
948 def write_reply (replyinfo_obj
):
949 """Write the reply email body about the GPG successes/failures.
951 The reply is about whether decryption, sig verification and key
952 import/loading was successful or failed. If text was successfully decrypted
953 and verified, then the first instance of such text will be included in
957 replyinfo_obj: contains details of GPG processing status
960 the plaintext message to be sent to the user
963 replyinfo_obj should be populated with info about GPG processing status.
968 if (replyinfo_obj
.pubkey_success
== True):
969 reply_plain
+= replyinfo_obj
.replies
['greeting']
970 reply_plain
+= "\n\n"
973 if replyinfo_obj
.decrypt_success
== True:
974 debug('decrypt success')
975 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
976 reply_plain
+= "\n\n"
978 elif replyinfo_obj
.decrypt_failure
== True:
979 debug('decrypt failure')
980 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
981 reply_plain
+= "\n\n"
984 if replyinfo_obj
.sig_success
== True:
985 debug('signature success')
986 reply_plain
+= replyinfo_obj
.replies
['sig_success']
987 reply_plain
+= "\n\n"
989 elif replyinfo_obj
.sig_failure
== True:
990 debug('signature failure')
991 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
992 reply_plain
+= "\n\n"
995 if (replyinfo_obj
.pubkey_success
== True):
996 debug('public key received')
997 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
998 reply_plain
+= "\n\n"
1000 elif (replyinfo_obj
.sigkey_missing
== True):
1001 debug('no public key')
1002 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
1003 reply_plain
+= "\n\n"
1005 elif (replyinfo_obj
.key_can_encrypt
== False) \
1006 and (replyinfo_obj
.key_cannot_encrypt
== True):
1007 debug('bad public key')
1008 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
1009 reply_plain
+= "\n\n"
1012 if (replyinfo_obj
.decrypt_success
== True) \
1013 and (replyinfo_obj
.sig_success
== True) \
1014 and (replyinfo_obj
.have_reply_key
== True):
1015 debug('message quoted')
1016 reply_plain
+= replyinfo_obj
.replies
['quote_follows']
1017 reply_plain
+= "\n\n"
1018 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
1019 reply_plain
+= quoted_text
1020 reply_plain
+= "\n\n"
1023 if (reply_plain
== ""):
1024 debug('plaintext message')
1025 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
1026 reply_plain
+= "\n\n"
1029 reply_plain
+= replyinfo_obj
.replies
['signature']
1030 reply_plain
+= "\n\n"
1035 def add_gpg_key (key_block
, gpgme_ctx
):
1036 """Adds a GPG pubkey to the local keystore
1038 This adds keys received through email into the key store so they can be
1042 key_block: the string form of the ascii-armored public key block
1043 gpgme_ctx: the gpgme context
1046 the fingerprint(s) of the imported key(s) which can be used for
1047 encryption, and a boolean marking whether none of the keys are capable
1051 fp
= io
.BytesIO(key_block
.encode('ascii'))
1054 result
= gpgme_ctx
.import_(fp
)
1055 imports
= result
.imports
1056 except gpgme
.GpgmeError
:
1059 key_fingerprints
= []
1060 key_cannot_encrypt
= False
1062 for import_res
in imports
:
1063 fingerprint
= import_res
[0]
1066 key_obj
= gpgme_ctx
.get_key(fingerprint
)
1070 if key_obj
!= None and is_key_usable(key_obj
):
1071 key_fingerprints
+= [fingerprint
]
1072 key_cannot_encrypt
= False
1074 debug("added gpg key: " + fingerprint
)
1076 elif key_fingerprints
== []:
1077 key_cannot_encrypt
= True
1079 return (key_fingerprints
, key_cannot_encrypt
)
1082 def verify_sig_message (msg_block
, gpgme_ctx
):
1083 """Verifies the signature of a signed, ascii-armored block of text.
1085 It encodes the string into ascii, since binary GPG files are currently
1086 unsupported, and alternative, the ascii-armored format is encodable into
1090 msg_block: a GPG Message block in string form. It may be encrypted or
1091 not. If it is encrypted, it will return empty results.
1092 gpgme_ctx: the gpgme context
1095 A tuple containing the plaintext bytes of the signed part, the list of
1096 fingerprints of encryption-capable keys signing the data, a boolean
1097 marking whether edward is missing all public keys for validating any of
1098 the signatures, and a boolean marking whether all sigs' keys are
1099 incapable of encryption. If verification failed, perhaps because the
1100 message was also encrypted, sensible default values are returned.
1103 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1104 plain_b
= io
.BytesIO()
1107 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
1108 except gpgme
.GpgmeError
:
1109 return ("",[],False,False)
1111 plaintext_b
= plain_b
.getvalue()
1113 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1115 return (plaintext_b
, fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1118 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1119 """Verifies the signature of a detached signature.
1121 This requires the signature part and the signed part as separate arguments.
1124 detached_sig: the signature part of the detached signature
1125 plaintext_bytes: the byte form of the message being signed.
1126 gpgme_ctx: the gpgme context
1129 A tuple containging a list of encryption capable signing fingerprints
1130 if the signature verification was sucessful, a boolean marking whether
1131 edward is missing all public keys for validating any of the signatures,
1132 and a boolean marking whether all signing keys are incapable of
1133 encryption. Otherwise, a tuple containing an empty list and True are
1137 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1138 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1141 sigs
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1142 except gpgme
.GpgmeError
:
1143 return ([],False,False)
1145 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1147 return (fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1150 def decrypt_block (msg_block
, gpgme_ctx
):
1151 """Decrypts a block of GPG text and verifies any included sigatures.
1153 Some encypted messages have embeded signatures, so those are verified too.
1156 msg_block: the encrypted(/signed) text
1157 gpgme_ctx: the gpgme context
1160 A tuple containing plaintext bytes, encryption-capable signatures (if
1161 decryption and signature verification were successful, respectively), a
1162 boolean marking whether edward is missing all public keys for
1163 validating any of the signatures, and a boolean marking whether all
1164 signature keys are incapable of encryption.
1167 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1168 plain_b
= io
.BytesIO()
1171 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1172 except gpgme
.GpgmeError
:
1173 return ("",[],False,False)
1175 plaintext_b
= plain_b
.getvalue()
1177 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1179 return (plaintext_b
, fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1182 def get_signature_fp (sigs
, gpgme_ctx
):
1183 """Selects valid signatures from output of gpgme signature verifying functions
1185 get_signature_fp returns a list of valid signature fingerprints if those
1186 fingerprints are associated with available keys capable of encryption.
1189 sigs: a signature verification result object list
1190 gpgme_ctx: a gpgme context
1193 fingerprints: a list of fingerprints
1194 sigkey_missing: a boolean marking whether public keys are missing for
1195 all available signatures.
1196 key_cannot_encrypt: a boolearn marking whether available public keys are
1197 incapable of encryption.
1200 sigkey_missing
= False
1201 key_cannot_encrypt
= False
1205 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1207 key_obj
= gpgme_ctx
.get_key(sig
.fpr
)
1209 if fingerprints
== []:
1210 sigkey_missing
= True
1213 if is_key_usable(key_obj
):
1214 fingerprints
+= [sig
.fpr
]
1215 key_cannot_encrypt
= False
1216 sigkey_missing
= False
1218 elif fingerprints
== []:
1219 key_cannot_encrypt
= True
1221 elif fingerprints
== []:
1222 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1223 sigkey_missing
= True
1225 return (fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1228 def is_key_usable (key_obj
):
1229 """Returns boolean representing key usability regarding encryption
1231 Tests various feature of key and returns usability
1234 key_obj: a gpgme key object
1237 A boolean representing key usability
1239 if key_obj
.can_encrypt
and not key_obj
.invalid
and not key_obj
.expired \
1240 and not key_obj
.revoked
and not key_obj
.disabled
:
1246 def email_to_reply_to_subject (email_bytes
):
1247 """Returns the email's To:, Reply-To: (or From:), and Subject: fields
1249 Returns this information from an email.
1252 email_bytes: the byte string form of the email
1255 the email To:, Reply-To: (or From:), and Subject: fields as strings
1258 email_struct
= email
.parser
.BytesHeaderParser().parsebytes(email_bytes
)
1260 email_to
= email_struct
['To']
1261 email_from
= email_struct
['From']
1262 email_reply_to
= email_struct
['Reply-To']
1264 email_subject
= email_struct
['Subject']
1266 if email_reply_to
== None:
1267 email_reply_to
= email_from
1269 return email_to
, email_reply_to
, email_subject
1272 def import_lang_pick_address(email_to
, hostname
):
1273 """Imports language file for i18n support; makes reply from address
1275 The language imported depends on the To: address of the email received by
1276 edward. an -en ending implies the English language, whereas a -ja ending
1277 implies Japanese. The list of supported languages is listed in the 'langs'
1278 list at the beginning of the program. This function also chooses the
1279 language-dependent address which can be used as the From address in the
1283 email_to: the string containing the email address that the mail was
1285 hostname: the hostname part of the reply email's from address
1288 the reference to the imported language module. The only variable in
1289 this file is the 'replies' dictionary.
1295 if email_to
!= None:
1297 if "edward-" + lang
in email_to
:
1301 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1302 lang_module
= importlib
.import_module(lang_mod_name
)
1304 reply_from
= "edward-" + use_lang
+ "@" + hostname
1306 return lang_module
, reply_from
1309 def generate_encrypted_mime (plaintext
, email_to
, email_from
, email_subject
,
1310 encrypt_to_key
, gpgme_ctx
):
1311 """This function creates the mime email reply. It can encrypt the email.
1313 If the encrypt_key is included, then the email is encrypted and signed.
1314 Otherwise it is unencrypted.
1317 plaintext: the plaintext body of the message to create.
1318 email_to: the email address to reply to
1319 email_subject: the subject to use in reply
1320 encrypt_to_key: the key object to use for encrypting the email. (or
1322 gpgme_ctx: the gpgme context
1325 A string version of the mime message, possibly encrypted and signed.
1328 plaintext_mime
= MIMEText(plaintext
)
1329 plaintext_mime
.set_charset('utf-8')
1331 if (encrypt_to_key
!= None):
1333 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1337 control_mime
= MIMEApplication("Version: 1",
1338 _subtype
='pgp-encrypted',
1339 _encoder
=email
.encoders
.encode_7or8bit
)
1340 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1341 control_mime
.set_charset('us-ascii')
1343 encoded_mime
= MIMEApplication(encrypted_text
,
1344 _subtype
='octet-stream; name="encrypted.asc"',
1345 _encoder
=email
.encoders
.encode_7or8bit
)
1346 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1347 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1348 encoded_mime
.set_charset('us-ascii')
1350 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1351 message_mime
.attach(control_mime
)
1352 message_mime
.attach(encoded_mime
)
1353 message_mime
['Content-Disposition'] = 'inline'
1356 message_mime
= plaintext_mime
1358 message_mime
['To'] = email_to
1359 message_mime
['From'] = email_from
1360 message_mime
['Subject'] = email_subject
1362 reply
= message_mime
.as_string()
1367 def send_reply(email_txt
, reply_to
, reply_from
):
1368 """Sends reply email
1370 Sent to original sender
1373 email_txt: message as a string
1374 reply_to: recipient of reply
1375 reply_from: edward's specific email address
1381 if reply_to
== None:
1382 error("*** ERROR: No one to send email to.")
1385 s
= smtplib
.SMTP('localhost')
1386 s
.sendmail(reply_from
, reply_to
, email_txt
)
1390 def email_quote_text (text
):
1391 """Quotes input text by inserting "> "s
1393 This is useful for quoting a text for the reply message. It inserts "> "
1394 strings at the beginning of lines.
1397 text: plain text to quote
1403 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1405 return quoted_message
1408 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1409 """Encrypts and signs plaintext
1411 This encrypts and signs a message.
1414 plaintext: text to sign and ecrypt
1415 encrypt_to_key: the key object to encrypt to
1416 gpgme_ctx: the gpgme context
1419 An encrypted and signed string of text
1422 # the plaintext should be mime encoded in an ascii-compatible form
1423 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1424 encrypted_bytes
= io
.BytesIO()
1426 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1427 plaintext_bytes
, encrypted_bytes
)
1429 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1430 return encrypted_txt
1433 def error (error_msg
):
1434 """Write an error message to stdout
1436 The error message includes the program name.
1439 error_msg: the message to print
1445 An error message is printed to stdout
1448 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1451 def debug (debug_msg
):
1452 """Writes a debug message to stdout if debug == True
1454 If the debug option is set in edward_config.py, then the passed message
1455 gets printed to stdout.
1458 debug_msg: the message to print to stdout
1464 A debug message is printed to stdout
1467 if edward_config
.debug
== True:
1472 """Sets the progname variable and processes optional argument
1474 If there are more than two arguments then edward complains and quits. An
1475 single "-p" argument sets the print_reply_only option, which makes edward
1476 print email replies instead of mailing them.
1482 True if edward should print arguments instead of mailing them,
1483 otherwise it returns False.
1486 Exits with error 1 if there are more than two arguments, otherwise
1487 returns the print_reply_only option.
1491 progname
= sys
.argv
[0]
1493 print_reply_only
= False
1495 if len(sys
.argv
) > 2:
1496 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1497 + " -p print reply message to stdout, do not mail it\n", \
1501 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1502 print_reply_only
= True
1504 return print_reply_only
1507 if __name__
== "__main__":
1508 """Executes main if this file is not loaded interactively"""