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()
274 email_struct
= parse_pgp_mime(email_bytes
, gpgme_ctx
)
276 email_to
, email_reply_to
, email_subject
= email_to_reply_to_subject(email_bytes
)
277 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
279 replyinfo_obj
= ReplyInfo()
280 replyinfo_obj
.replies
= lang
.replies
282 prepare_for_reply(email_struct
, replyinfo_obj
)
283 get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
284 reply_plaintext
= write_reply(replyinfo_obj
)
286 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_reply_to
, \
287 email_subject
, replyinfo_obj
.encrypt_to_key
,
290 if print_reply_only
== True:
293 send_reply(reply_mime
, email_reply_to
, reply_from
)
296 def get_gpg_context (gnupghome
, sign_with_key_fp
):
298 This function returns the GPG context needed for encryption and signing.
300 The context is needed by other functions which use GPG functionality.
303 gnupghome: The path to "~/.gnupg/" or its alternative.
304 sign_with_key: The fingerprint of the key to sign with
307 A gpgme context to be used for GPG functions.
310 the 'armor' flag is set to True and the list of signing keys contains
311 the single specified key
314 os
.environ
['GNUPGHOME'] = gnupghome
316 gpgme_ctx
= gpgme
.Context()
317 gpgme_ctx
.armor
= True
320 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
321 except gpgme
.GpgmeError
:
322 error("unable to load signing key. is the gnupghome "
323 + "and signing key properly set in the edward_config.py?")
326 gpgme_ctx
.signers
= [sign_with_key
]
331 def parse_pgp_mime (email_bytes
, gpgme_ctx
):
332 """Parses the email for mime payloads and decrypts/verfies signatures.
334 This function creates a representation of a mime or plaintext email with
335 the EddyMsg class. It then splits each mime payload into one or more pieces
336 which may be plain text or GPG data. It then decrypts encrypted parts and
337 does some very basic signature verification on those parts.
340 email_bytes: an email message in byte string format
341 gpgme_ctx: a gpgme context
344 A message as an instance of EddyMsg
347 the returned EddyMsg instance has split, decrypted, verified and pubkey
351 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
353 eddymsg_obj
= parse_mime(email_struct
)
354 split_payloads(eddymsg_obj
)
355 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
360 def parse_mime(msg_struct
):
361 """Translates python's email.parser format into an EddyMsg format
363 If the message is multi-part, then a recursive object is created, where
364 each sub-part is also a EddyMsg instance.
367 msg_struct: an email parsed with email.parser.BytesParser(), which can be
371 an instance of EddyMsg, potentially a recursive one.
374 eddymsg_obj
= get_subpart_data(msg_struct
)
376 if msg_struct
.is_multipart() == True:
377 payloads
= msg_struct
.get_payload()
379 eddymsg_obj
.multipart
= True
380 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
385 def scan_and_split (payload_piece
, match_name
, pattern
):
386 """This splits the payloads of an EddyMsg object into GPG and text parts.
388 An EddyMsg object's payload_pieces starts off as a list containing a single
389 PayloadPiece object. This function returns a list of these objects which
390 have been split into GPG data and regular text, if such splits need to be/
394 payload_piece: a single payload or a split part of a payload
395 match_name: the type of data to try to spit out from the payload piece
396 pattern: the search pattern to be used for finding that type of data
399 a list of objects of the PayloadPiece class, in the order that the
400 string part of payload_piece originally was, broken up according to
401 matches specified by 'pattern'.
404 # don't try to re-split pieces containing gpg data
405 if payload_piece
.piece_type
!= TxtType
.text
:
406 return [payload_piece
]
408 flags
= re
.DOTALL | re
.MULTILINE
409 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
410 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
413 pieces
= [payload_piece
]
417 beginning
= PayloadPiece()
418 beginning
.string
= matches
.group('beginning')
419 beginning
.piece_type
= payload_piece
.piece_type
421 match
= PayloadPiece()
422 match
.string
= matches
.group('match')
423 match
.piece_type
= match_name
425 rest
= PayloadPiece()
426 rest
.string
= matches
.group('rest')
427 rest
.piece_type
= payload_piece
.piece_type
429 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
430 pieces
= [beginning
, match
] + more_pieces
435 def get_subpart_data (part
):
436 """This function grabs information from a mime part.
438 It copies needed data from an email.parser.BytesParser() object over to an
442 part: an email.parser.BytesParser() object
450 mime_decoded_bytes
= part
.get_payload(decode
=True)
451 charset
= part
.get_content_charset()
453 # your guess is as good as a-myy-ee-ine...
457 payload_string
= part
.as_string()
458 if payload_string
!= None:
459 # convert each isolated carriage return or line feed to carriage return + line feed
460 payload_string_crlf
= re
.sub(r
'\n', '\r\n', re
.sub(r
'\r', '\n', re
.sub(r
'\r\n', '\n', payload_string
)))
461 obj
.payload_bytes
= payload_string_crlf
.encode(charset
)
463 obj
.filename
= part
.get_filename()
464 obj
.content_type
= part
.get_content_type()
465 obj
.content_disposition
= part
['content-disposition']
466 obj
.description_list
= part
['content-description']
468 if mime_decoded_bytes
!= None:
470 payload
= PayloadPiece()
471 payload
.string
= mime_decoded_bytes
.decode(charset
)
472 payload
.piece_type
= TxtType
.text
474 obj
.payload_pieces
= [payload
]
475 except UnicodeDecodeError:
481 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
482 """A function which maps another function onto a message's subparts.
484 This is a higer-order function which recursively performs a specified
485 function on each subpart of a multi-part message. Each single-part sub-part
486 has the function applied to it. This function also works if the part passed
490 function_to_do: function to perform on sub-parts
491 eddymsg_obj: a single part or multi-part EddyMsg object
492 data: a second argument to pass to 'function_to_do'
498 The passed-in EddyMsg object is transformed recursively on its
499 sub-parts according to 'function_to_do'.
502 if eddymsg_obj
.multipart
== True:
503 for sub
in eddymsg_obj
.subparts
:
504 do_to_eddys_pieces(function_to_do
, sub
, data
)
506 function_to_do(eddymsg_obj
, data
)
509 def split_payloads (eddymsg_obj
):
510 """Splits all (sub-)payloads of a message into GPG data and regular text.
512 Recursively performs payload splitting on all sub-parts of an EddyMsg
513 object into the various GPG data types, such as GPG messages, public key
514 blocks and signed text.
517 eddymsg_obj: an instance of EddyMsg
523 The EddyMsg object has payloads that are unsplit (by may be split)..
526 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
529 for match_pair
in match_pairs
:
530 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
533 def split_payload_pieces (eddymsg_obj
, match_pair
):
534 """A helper function for split_payloads(); works on PayloadPiece objects.
536 This function splits up PayloadPiece objects into multipe PayloadPiece
537 objects and replaces the EddyMsg object's previous list of payload pieces
538 with the new split up one.
541 eddymsg_obj: a single-part EddyMsg object.
542 match_pair: a tuple from the match_pairs list, which specifies a match
543 name and a match pattern.
549 The payload piece(s) of an EddyMsg object may be already split or
553 The EddyMsg object's payload piece(s) are split into a list of pieces
554 if matches of the match_pair are found.
557 (match_name
, pattern
) = match_pair
560 for piece
in eddymsg_obj
.payload_pieces
:
561 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
563 eddymsg_obj
.payload_pieces
= new_pieces_list
566 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
567 """Performs GPG operations on the GPG parts of the message
569 This function decrypts text, verifies signatures, and imports public keys
570 included in an email.
573 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
574 and non-GPG sections by split_payloads()
575 gpgme_ctx: a gpgme context
577 prev_parts: a list of mime parts that occur before the eddymsg_obj
578 part, under the same multi-part mime part. This is used for
579 verifying detached signatures. For the root mime part, this should
580 be an empty list, which is the default value if this paramater is
587 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
590 Decryption, verification and key imports occur. the gpg_data members of
591 PayloadPiece objects get filled in with GPGData objects with some of
592 their attributes set.
595 if eddymsg_obj
.multipart
== True:
597 for sub
in eddymsg_obj
.subparts
:
598 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
603 for piece
in eddymsg_obj
.payload_pieces
:
605 if piece
.piece_type
== TxtType
.text
:
606 # don't transform the plaintext.
609 elif piece
.piece_type
== TxtType
.message
:
610 piece
.gpg_data
= GPGData()
612 (plaintext_b
, sigs
, sigkey_missing
, key_cannot_encrypt
) = decrypt_block(piece
.string
, gpgme_ctx
)
614 piece
.gpg_data
.sigkey_missing
= sigkey_missing
615 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
618 piece
.gpg_data
.decrypted
= True
619 piece
.gpg_data
.sigs
= sigs
621 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
624 # if not encrypted, check to see if this is an armored signature.
625 (plaintext_b
, sigs
, sigkey_missing
, key_cannot_encrypt
) = verify_sig_message(piece
.string
, gpgme_ctx
)
627 piece
.gpg_data
.sigkey_missing
= sigkey_missing
628 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
631 piece
.piece_type
= TxtType
.signature
632 piece
.gpg_data
.sigs
= sigs
634 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
636 elif piece
.piece_type
== TxtType
.pubkey
:
637 piece
.gpg_data
= GPGData()
639 (key_fps
, key_cannot_encrypt
) = add_gpg_key(piece
.string
, gpgme_ctx
)
641 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
644 piece
.gpg_data
.keys
= key_fps
646 elif piece
.piece_type
== TxtType
.detachedsig
:
647 piece
.gpg_data
= GPGData()
649 for prev
in prev_parts
:
650 (sig_fps
, sigkey_missing
, key_cannot_encrypt
) = verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
652 piece
.gpg_data
.sigkey_missing
= sigkey_missing
653 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
656 piece
.gpg_data
.sigs
= sig_fps
657 piece
.gpg_data
.plainobj
= prev
664 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
665 """Updates replyinfo_obj with info on the message's GPG success/failures
667 This function marks replyinfo_obj with information about whether encrypted
668 text in eddymsg_obj was successfully decrypted, signatures were verified
669 and whether a public key was found or not.
672 eddymsg_obj: a message in the EddyMsg format
673 replyinfo_obj: an instance of ReplyInfo
679 eddymsg_obj has had its gpg_data created by gpg_on_payloads
682 replyinfo_obj has been updated with info about decryption/sig
683 verififcation status, etc. However the desired key isn't imported until
684 later, so the success or failure of that updates the values set here.
687 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
689 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
690 """A helper function for prepare_for_reply
692 It updates replyinfo_obj with GPG success/failure information, when
693 supplied a single-part EddyMsg object.
696 eddymsg_obj: a single-part message in the EddyMsg format
697 replyinfo_obj: an object which holds information about the message's
704 eddymsg_obj is a single-part message. (it may be a part of a multi-part
705 message.) It has had its gpg_data created by gpg_on_payloads if it has
709 replyinfo_obj has been updated with gpg success/failure information
712 for piece
in eddymsg_obj
.payload_pieces
:
713 if piece
.piece_type
== TxtType
.text
:
714 # don't quote the plaintext part.
717 elif piece
.piece_type
== TxtType
.message
:
718 prepare_for_reply_message(piece
, replyinfo_obj
)
720 elif piece
.piece_type
== TxtType
.pubkey
:
721 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
723 elif (piece
.piece_type
== TxtType
.detachedsig
) \
724 or (piece
.piece_type
== TxtType
.signature
):
725 prepare_for_reply_sig(piece
, replyinfo_obj
)
728 def prepare_for_reply_message (piece
, replyinfo_obj
):
729 """Helper function for prepare_for_reply()
731 This function is called when the piece_type of a payload piece is
732 TxtType.message, or GPG Message block. This should be encrypted text. If
733 the encryted block is correclty signed, a sig will be attached to
734 .target_key unless there is already one there.
737 piece: a PayloadPiece object.
738 replyinfo_obj: object which gets updated with decryption status, etc.
744 the piece.payload_piece value should be TxtType.message.
747 replyinfo_obj gets updated with decryption status, signing status, a
748 potential signing key, posession status of the public key for the
749 signature and encryption capability status if that key is missing.
752 if piece
.gpg_data
.plainobj
== None:
753 replyinfo_obj
.decrypt_failure
= True
756 replyinfo_obj
.decrypt_success
= True
758 # we already have a key (and a message)
759 if replyinfo_obj
.target_key
!= None:
762 if piece
.gpg_data
.sigs
== []:
763 if piece
.gpg_data
.sigkey_missing
== True:
764 replyinfo_obj
.sigkey_missing
= True
766 if piece
.gpg_data
.key_cannot_encrypt
== True:
767 replyinfo_obj
.key_cannot_encrypt
= True
769 # only include a signed message in the reply.
770 get_signed_part
= True
773 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
774 replyinfo_obj
.sig_success
= True
775 get_signed_part
= False
777 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
779 # to catch public keys in encrypted blocks
780 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
783 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
784 """Helper function for prepare_for_reply(). Marks pubkey import status.
786 Marks replyinfo_obj with pub key import status.
789 piece: a PayloadPiece object
790 replyinfo_obj: a ReplyInfo object
793 piece.piece_type should be set to TxtType.pubkey .
796 replyinfo_obj has its fields updated.
799 if piece
.gpg_data
.keys
== []:
800 if piece
.gpg_data
.key_cannot_encrypt
== True:
801 replyinfo_obj
.key_cannot_encrypt
= True
803 replyinfo_obj
.pubkey_success
= True
805 # prefer public key as a fallback for the encrypted reply
806 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
809 def prepare_for_reply_sig (piece
, replyinfo_obj
):
810 """Helper function for prepare_for_reply(). Marks sig verification status.
812 Marks replyinfo_obj with signature verification status.
815 piece: a PayloadPiece object
816 replyinfo_obj: a ReplyInfo object
819 piece.piece_type should be set to TxtType.signature, or
820 TxtType.detachedsig .
823 replyinfo_obj has its fields updated.
826 if piece
.gpg_data
.sigs
== []:
827 replyinfo_obj
.sig_failure
= True
829 if piece
.gpg_data
.sigkey_missing
== True:
830 replyinfo_obj
.sigkey_missing
= True
832 if piece
.gpg_data
.key_cannot_encrypt
== True:
833 replyinfo_obj
.key_cannot_encrypt
= True
836 replyinfo_obj
.sig_success
= True
838 if replyinfo_obj
.fallback_target_key
== None:
839 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
841 if (piece
.piece_type
== TxtType
.signature
):
842 # to catch public keys in signature blocks
843 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
846 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
847 """For creating a string representation of a signed, encrypted part.
849 When given a decrypted payload, it will add either the plaintext or signed
850 plaintext to the reply message, depeding on 'get_signed_part'. This is
851 useful for ensuring that the reply message only comes from a signed and
852 ecrypted GPG message. It also sets the target_key for encrypting the reply
853 if it's told to get signed text only.
856 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
858 replyinfo_obj: a ReplyInfo object for holding the message to quote and
859 the target_key to encrypt to.
860 get_signed_part: True if we should only include text that contains a
861 further signature. If False, then include plain text.
867 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
868 which represents decrypted text. It may or may not be signed on that
872 the ReplyInfo instance may have a new 'target_key' set and its
873 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
877 if eddymsg_obj
== None:
880 # recurse on multi-part mime
881 if eddymsg_obj
.multipart
== True:
882 for sub
in eddymsg_obj
.subparts
:
883 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
885 for piece
in eddymsg_obj
.payload_pieces
:
886 if (get_signed_part
):
887 if ((piece
.piece_type
== TxtType
.detachedsig
) \
888 or (piece
.piece_type
== TxtType
.signature
)) \
889 and (piece
.gpg_data
!= None) \
890 and (piece
.gpg_data
.plainobj
!= None):
891 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
892 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
895 if (eddymsg_obj
.content_disposition
== None \
896 or not eddymsg_obj
.content_disposition
.startswith("attachment")) \
897 and piece
.piece_type
== TxtType
.text
:
898 replyinfo_obj
.msg_to_quote
+= piece
.string
901 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
902 """Obtains a public key object from a key fingerprint
904 If the .target_key is not set, then we use .fallback_target_key, if
908 replyinfo_obj: ReplyInfo instance
909 gpgme_ctx: the gpgme context
915 Loading a key requires that we have the public key imported. This
916 requires that they email contains the pub key block, or that it was
917 previously sent to edward.
920 If the key can be loaded, then replyinfo_obj.reply_to_key points to the
921 public key object. If the key cannot be loaded, then the replyinfo_obj
922 is marked as having no public key available. If the key is not capable
923 of encryption, it will not be used, and replyinfo_obj will be marked
927 for key
in (replyinfo_obj
.target_key
, replyinfo_obj
.fallback_target_key
):
930 encrypt_to_key
= gpgme_ctx
.get_key(key
)
932 except gpgme
.GpgmeError
:
935 if is_key_usable(encrypt_to_key
):
936 replyinfo_obj
.encrypt_to_key
= encrypt_to_key
937 replyinfo_obj
.have_reply_key
= True
938 replyinfo_obj
.key_can_encrypt
= True
942 replyinfo_obj
.key_cannot_encrypt
= True
946 def write_reply (replyinfo_obj
):
947 """Write the reply email body about the GPG successes/failures.
949 The reply is about whether decryption, sig verification and key
950 import/loading was successful or failed. If text was successfully decrypted
951 and verified, then the first instance of such text will be included in
955 replyinfo_obj: contains details of GPG processing status
958 the plaintext message to be sent to the user
961 replyinfo_obj should be populated with info about GPG processing status.
966 if (replyinfo_obj
.pubkey_success
== True):
967 reply_plain
+= replyinfo_obj
.replies
['greeting']
968 reply_plain
+= "\n\n"
971 if replyinfo_obj
.decrypt_success
== True:
972 debug('decrypt success')
973 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
975 if (replyinfo_obj
.sig_success
== True) and (replyinfo_obj
.have_reply_key
== True):
976 debug('message quoted')
977 reply_plain
+= replyinfo_obj
.replies
['space']
978 reply_plain
+= replyinfo_obj
.replies
['quote_follows']
979 reply_plain
+= "\n\n"
980 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
981 reply_plain
+= quoted_text
983 reply_plain
+= "\n\n"
985 elif replyinfo_obj
.decrypt_failure
== True:
986 debug('decrypt failure')
987 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
988 reply_plain
+= "\n\n"
991 if replyinfo_obj
.sig_success
== True:
992 debug('signature success')
993 reply_plain
+= replyinfo_obj
.replies
['sig_success']
994 reply_plain
+= "\n\n"
996 elif replyinfo_obj
.sig_failure
== True:
997 debug('signature failure')
998 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
999 reply_plain
+= "\n\n"
1002 if (replyinfo_obj
.pubkey_success
== True):
1003 debug('public key received')
1004 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
1005 reply_plain
+= "\n\n"
1007 elif (replyinfo_obj
.sigkey_missing
== True):
1008 debug('no public key')
1009 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
1010 reply_plain
+= "\n\n"
1012 elif (replyinfo_obj
.key_can_encrypt
== False) \
1013 and (replyinfo_obj
.key_cannot_encrypt
== True):
1014 debug('bad public key')
1015 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
1016 reply_plain
+= "\n\n"
1019 if (reply_plain
== ""):
1020 debug('plaintext message')
1021 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
1022 reply_plain
+= "\n\n"
1025 reply_plain
+= replyinfo_obj
.replies
['signature']
1026 reply_plain
+= "\n\n"
1031 def add_gpg_key (key_block
, gpgme_ctx
):
1032 """Adds a GPG pubkey to the local keystore
1034 This adds keys received through email into the key store so they can be
1038 key_block: the string form of the ascii-armored public key block
1039 gpgme_ctx: the gpgme context
1042 the fingerprint(s) of the imported key(s) which can be used for
1043 encryption, and a boolean marking whether none of the keys are capable
1047 fp
= io
.BytesIO(key_block
.encode('ascii'))
1050 result
= gpgme_ctx
.import_(fp
)
1051 imports
= result
.imports
1052 except gpgme
.GpgmeError
:
1055 key_fingerprints
= []
1056 key_cannot_encrypt
= False
1058 for import_res
in imports
:
1059 fingerprint
= import_res
[0]
1062 key_obj
= gpgme_ctx
.get_key(fingerprint
)
1066 if key_obj
!= None and is_key_usable(key_obj
):
1067 key_fingerprints
+= [fingerprint
]
1068 key_cannot_encrypt
= False
1070 debug("added gpg key: " + fingerprint
)
1072 elif key_fingerprints
== []:
1073 key_cannot_encrypt
= True
1075 return (key_fingerprints
, key_cannot_encrypt
)
1078 def verify_sig_message (msg_block
, gpgme_ctx
):
1079 """Verifies the signature of a signed, ascii-armored block of text.
1081 It encodes the string into ascii, since binary GPG files are currently
1082 unsupported, and alternative, the ascii-armored format is encodable into
1086 msg_block: a GPG Message block in string form. It may be encrypted or
1087 not. If it is encrypted, it will return empty results.
1088 gpgme_ctx: the gpgme context
1091 A tuple containing the plaintext bytes of the signed part, the list of
1092 fingerprints of encryption-capable keys signing the data, a boolean
1093 marking whether edward is missing all public keys for validating any of
1094 the signatures, and a boolean marking whether all sigs' keys are
1095 incapable of encryption. If verification failed, perhaps because the
1096 message was also encrypted, sensible default values are returned.
1099 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1100 plain_b
= io
.BytesIO()
1103 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
1104 except gpgme
.GpgmeError
:
1105 return ("",[],False,False)
1107 plaintext_b
= plain_b
.getvalue()
1109 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1111 return (plaintext_b
, fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1114 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1115 """Verifies the signature of a detached signature.
1117 This requires the signature part and the signed part as separate arguments.
1120 detached_sig: the signature part of the detached signature
1121 plaintext_bytes: the byte form of the message being signed.
1122 gpgme_ctx: the gpgme context
1125 A tuple containging a list of encryption capable signing fingerprints
1126 if the signature verification was sucessful, a boolean marking whether
1127 edward is missing all public keys for validating any of the signatures,
1128 and a boolean marking whether all signing keys are incapable of
1129 encryption. Otherwise, a tuple containing an empty list and True are
1133 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1134 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1137 sigs
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1138 except gpgme
.GpgmeError
:
1139 return ([],False,False)
1141 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1143 return (fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1146 def decrypt_block (msg_block
, gpgme_ctx
):
1147 """Decrypts a block of GPG text and verifies any included sigatures.
1149 Some encypted messages have embeded signatures, so those are verified too.
1152 msg_block: the encrypted(/signed) text
1153 gpgme_ctx: the gpgme context
1156 A tuple containing plaintext bytes, encryption-capable signatures (if
1157 decryption and signature verification were successful, respectively), a
1158 boolean marking whether edward is missing all public keys for
1159 validating any of the signatures, and a boolean marking whether all
1160 signature keys are incapable of encryption.
1163 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1164 plain_b
= io
.BytesIO()
1167 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1168 except gpgme
.GpgmeError
:
1169 return ("",[],False,False)
1171 plaintext_b
= plain_b
.getvalue()
1173 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1175 return (plaintext_b
, fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1178 def get_signature_fp (sigs
, gpgme_ctx
):
1179 """Selects valid signatures from output of gpgme signature verifying functions
1181 get_signature_fp returns a list of valid signature fingerprints if those
1182 fingerprints are associated with available keys capable of encryption.
1185 sigs: a signature verification result object list
1186 gpgme_ctx: a gpgme context
1189 fingerprints: a list of fingerprints
1190 sigkey_missing: a boolean marking whether public keys are missing for
1191 all available signatures.
1192 key_cannot_encrypt: a boolearn marking whether available public keys are
1193 incapable of encryption.
1196 sigkey_missing
= False
1197 key_cannot_encrypt
= False
1201 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1203 key_obj
= gpgme_ctx
.get_key(sig
.fpr
)
1205 if fingerprints
== []:
1206 sigkey_missing
= True
1209 if is_key_usable(key_obj
):
1210 fingerprints
+= [sig
.fpr
]
1211 key_cannot_encrypt
= False
1212 sigkey_missing
= False
1214 elif fingerprints
== []:
1215 key_cannot_encrypt
= True
1217 elif fingerprints
== []:
1218 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1219 sigkey_missing
= True
1221 return (fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1224 def is_key_usable (key_obj
):
1225 """Returns boolean representing key usability regarding encryption
1227 Tests various feature of key and returns usability
1230 key_obj: a gpgme key object
1233 A boolean representing key usability
1235 if key_obj
.can_encrypt
and not key_obj
.invalid
and not key_obj
.expired \
1236 and not key_obj
.revoked
and not key_obj
.disabled
:
1242 def email_to_reply_to_subject (email_bytes
):
1243 """Returns the email's To:, Reply-To: (or From:), and Subject: fields
1245 Returns this information from an email.
1248 email_bytes: the byte string form of the email
1251 the email To:, Reply-To: (or From:), and Subject: fields as strings
1254 email_struct
= email
.parser
.BytesHeaderParser().parsebytes(email_bytes
)
1256 email_to
= email_struct
['To']
1257 email_from
= email_struct
['From']
1258 email_reply_to
= email_struct
['Reply-To']
1260 email_subject
= email_struct
['Subject']
1262 if email_reply_to
== None:
1263 email_reply_to
= email_from
1265 return email_to
, email_reply_to
, email_subject
1268 def import_lang_pick_address(email_to
, hostname
):
1269 """Imports language file for i18n support; makes reply from address
1271 The language imported depends on the To: address of the email received by
1272 edward. an -en ending implies the English language, whereas a -ja ending
1273 implies Japanese. The list of supported languages is listed in the 'langs'
1274 list at the beginning of the program. This function also chooses the
1275 language-dependent address which can be used as the From address in the
1279 email_to: the string containing the email address that the mail was
1281 hostname: the hostname part of the reply email's from address
1284 the reference to the imported language module. The only variable in
1285 this file is the 'replies' dictionary.
1291 if email_to
!= None:
1293 if "edward-" + lang
in email_to
:
1297 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1298 lang_module
= importlib
.import_module(lang_mod_name
)
1300 reply_from
= "edward-" + use_lang
+ "@" + hostname
1302 return lang_module
, reply_from
1305 def generate_encrypted_mime (plaintext
, email_to
, email_subject
, encrypt_to_key
,
1307 """This function creates the mime email reply. It can encrypt the email.
1309 If the encrypt_key is included, then the email is encrypted and signed.
1310 Otherwise it is unencrypted.
1313 plaintext: the plaintext body of the message to create.
1314 email_to: the email address to reply to
1315 email_subject: the subject to use in reply
1316 encrypt_to_key: the key object to use for encrypting the email. (or
1318 gpgme_ctx: the gpgme context
1321 A string version of the mime message, possibly encrypted and signed.
1324 plaintext_mime
= MIMEText(plaintext
)
1325 plaintext_mime
.set_charset('utf-8')
1327 if (encrypt_to_key
!= None):
1329 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1333 control_mime
= MIMEApplication("Version: 1",
1334 _subtype
='pgp-encrypted',
1335 _encoder
=email
.encoders
.encode_7or8bit
)
1336 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1337 control_mime
.set_charset('us-ascii')
1339 encoded_mime
= MIMEApplication(encrypted_text
,
1340 _subtype
='octet-stream; name="encrypted.asc"',
1341 _encoder
=email
.encoders
.encode_7or8bit
)
1342 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1343 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1344 encoded_mime
.set_charset('us-ascii')
1346 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1347 message_mime
.attach(control_mime
)
1348 message_mime
.attach(encoded_mime
)
1349 message_mime
['Content-Disposition'] = 'inline'
1352 message_mime
= plaintext_mime
1354 message_mime
['To'] = email_to
1355 message_mime
['Subject'] = email_subject
1357 reply
= message_mime
.as_string()
1362 def send_reply(email_txt
, reply_to
, reply_from
):
1363 """Sends reply email
1365 Sent to original sender
1368 email_txt: message as a string
1369 reply_to: recipient of reply
1370 reply_from: edward's specific email address
1376 if reply_to
== None:
1377 error("*** ERROR: No one to send email to.")
1380 s
= smtplib
.SMTP('localhost')
1381 s
.sendmail(reply_from
, reply_to
, email_txt
)
1385 def email_quote_text (text
):
1386 """Quotes input text by inserting "> "s
1388 This is useful for quoting a text for the reply message. It inserts "> "
1389 strings at the beginning of lines.
1392 text: plain text to quote
1398 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1400 return quoted_message
1403 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1404 """Encrypts and signs plaintext
1406 This encrypts and signs a message.
1409 plaintext: text to sign and ecrypt
1410 encrypt_to_key: the key object to encrypt to
1411 gpgme_ctx: the gpgme context
1414 An encrypted and signed string of text
1417 # the plaintext should be mime encoded in an ascii-compatible form
1418 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1419 encrypted_bytes
= io
.BytesIO()
1421 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1422 plaintext_bytes
, encrypted_bytes
)
1424 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1425 return encrypted_txt
1428 def error (error_msg
):
1429 """Write an error message to stdout
1431 The error message includes the program name.
1434 error_msg: the message to print
1440 An error message is printed to stdout
1443 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1446 def debug (debug_msg
):
1447 """Writes a debug message to stdout if debug == True
1449 If the debug option is set in edward_config.py, then the passed message
1450 gets printed to stdout.
1453 debug_msg: the message to print to stdout
1459 A debug message is printed to stdout
1462 if edward_config
.debug
== True:
1467 """Sets the progname variable and processes optional argument
1469 If there are more than two arguments then edward complains and quits. An
1470 single "-p" argument sets the print_reply_only option, which makes edward
1471 print email replies instead of mailing them.
1477 True if edward should print arguments instead of mailing them,
1478 otherwise it returns False.
1481 Exits with error 1 if there are more than two arguments, otherwise
1482 returns the print_reply_only option.
1486 progname
= sys
.argv
[0]
1488 print_reply_only
= False
1490 if len(sys
.argv
) > 2:
1491 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1492 + " -p print reply message to stdout, do not mail it\n", \
1496 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1497 print_reply_only
= True
1499 return print_reply_only
1502 if __name__
== "__main__":
1503 """Executes main if this file is not loaded interactively"""