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.tgz
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' and 'description_list' come from the mime
107 description_list
= None
110 class PayloadPiece (object):
112 PayloadPiece represents a complte or sub-section of a mime part.
114 Instances of this class are often strung together within one or more arrays
115 pointed to by each instance of the EddyMsg class.
117 'piece_type' refers to an enum whose value describes the content of
118 'string'. Examples include TxtType.pubkey, for public keys, and
119 TxtType.message, for encrypted data (or armored signatures until they are
120 known to be such.) Some of the names derive from the header and footer of
121 each of these ascii-encoded gpg blocks.
123 'string' contains some string of text, such as non-GPG text, an encrypted
124 block of text, a signature, or a public key.
126 'gpg_data' points to any instances of GPGData that have been created based
127 on the contents of 'string'.
135 class GPGData (object):
137 GPGData holds info from decryption, sig. verification, and/or pub. keys.
139 Instances of this class contain decrypted information, signature
140 fingerprints and/or fingerprints of processed and imported public keys.
142 'decrypted' is set to True if 'plainobj' was created from encrypted data.
144 'plainobj' points to any decrypted, or signed part of, a GPG signature. It
145 is intended to be an instance of the EddyMsg class.
147 'sigs' is a list of fingerprints of keys used to sign the data in plainobj.
149 'sigkey_missing' is set to True if edward doesn't have the key it needs to
150 verify the signature on a block of text.
152 'key_cannot_encrypt' is set to True if pubkeys or sigs' keys in the payload
153 piece are not capable of encryption, are revoked or expired, for instance.
155 'keys' is a list of fingerprints of keys obtained in public key blocks.
162 sigkey_missing
= False
163 key_cannot_encrypt
= False
167 class ReplyInfo (object):
169 ReplyInfo contains details that edward uses in generating its reply.
171 Instances of this class contain information about whether a message was
172 successfully encrypted or signed, and whether a public key was attached, or
173 retrievable, from the local GPG store. It stores the fingerprints of
174 potential encryption key candidates and the message (if any at all) to
175 quote in edward's reply.
177 'replies' points one of the dictionaries of translated replies.
179 'target_key' refers to the fingerprint of a key used to sign encrypted
180 data. This is the preferred key, if it is set, and if is available.
182 'fallback_target_key' referst to the fingerprint of a key used to sign
183 unencrypted data; alternatively it may be a public key attached to the
186 'encrypt_to_key' the key object to use when encrypting edward's reply
188 'msg_to_quote' refers to the part of a message which edward should quote in
189 his reply. This should remain as None if there was no encrypted and singed
190 part. This is to avoid making edward a service for decrypting other
191 people's messages to edward.
193 'decrypt_success' is set to True if edward could decrypt part of the
196 'sig_success' is set to True if edward could to some extent verify the
197 signature of a signed part of the message to edward.
199 'key_can_encrypt' is set to True if a key which can be encrypted to has
202 'sig_failure' is set to True if edward could not verify a siganture.
204 'pubkey_success' is set to True if edward successfully imported a public
207 'sigkey_missing' is set to True if edward doesn't have the public key
208 needed for signature verification.
210 'key_cannot_encrypt' is set to True if pubkeys or sig's keys in a payload
211 piece of the message are not capable of encryption.
213 'have_repy_key' is set to True if edward has a public key to encrypt its
220 fallback_target_key
= None
221 encrypt_to_key
= None
224 decrypt_success
= False
226 pubkey_success
= False
227 key_can_encrypt
= False
229 decrypt_failure
= False
231 sigkey_missing
= False
232 key_cannot_encrypt
= False
234 have_reply_key
= False
240 This is the main function for edward, a GPG reply bot.
242 Edward responds to GPG-encrypted and signed mail, encrypting and signing
243 the response if the user's public key is, or was, included in the message.
252 Mime or plaintext email passing in through standard input. Portions of
253 the email may be encrypted. If the To: address contains the text
254 "edward-ja", then the reply will contain a reply written in the
255 Japanese language. There are other languages as well. The default
259 A reply email will be printed to standard output. The contents of the
260 reply email depends on whether the original email was encrypted or not,
261 has or doesn't have a signature, whether a public key used in the
262 original message is provided or locally stored, and the language
263 implied by the To: address in the original email.
266 print_reply_only
= handle_args()
268 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
269 edward_config
.sign_with_key
)
271 email_bytes
= sys
.stdin
.buffer.read()
272 email_struct
= parse_pgp_mime(email_bytes
, gpgme_ctx
)
274 email_to
, email_from
, email_subject
= email_to_from_subject(email_bytes
)
275 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
277 replyinfo_obj
= ReplyInfo()
278 replyinfo_obj
.replies
= lang
.replies
280 prepare_for_reply(email_struct
, replyinfo_obj
)
281 get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
282 reply_plaintext
= write_reply(replyinfo_obj
)
284 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_from
, \
285 email_subject
, replyinfo_obj
.encrypt_to_key
,
288 if print_reply_only
== True:
291 send_reply(reply_mime
, email_subject
, email_from
, reply_from
)
294 def get_gpg_context (gnupghome
, sign_with_key_fp
):
296 This function returns the GPG context needed for encryption and signing.
298 The context is needed by other functions which use GPG functionality.
301 gnupghome: The path to "~/.gnupg/" or its alternative.
302 sign_with_key: The fingerprint of the key to sign with
305 A gpgme context to be used for GPG functions.
308 the 'armor' flag is set to True and the list of signing keys contains
309 the single specified key
312 os
.environ
['GNUPGHOME'] = gnupghome
314 gpgme_ctx
= gpgme
.Context()
315 gpgme_ctx
.armor
= True
318 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
319 except gpgme
.GpgmeError
:
320 error("unable to load signing key. is the gnupghome "
321 + "and signing key properly set in the edward_config.py?")
324 gpgme_ctx
.signers
= [sign_with_key
]
329 def parse_pgp_mime (email_bytes
, gpgme_ctx
):
330 """Parses the email for mime payloads and decrypts/verfies signatures.
332 This function creates a representation of a mime or plaintext email with
333 the EddyMsg class. It then splits each mime payload into one or more pieces
334 which may be plain text or GPG data. It then decrypts encrypted parts and
335 does some very basic signature verification on those parts.
338 email_bytes: an email message in byte string format
339 gpgme_ctx: a gpgme context
342 A message as an instance of EddyMsg
345 the returned EddyMsg instance has split, decrypted, verified and pubkey
349 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
351 eddymsg_obj
= parse_mime(email_struct
)
352 split_payloads(eddymsg_obj
)
353 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
358 def parse_mime(msg_struct
):
359 """Translates python's email.parser format into an EddyMsg format
361 If the message is multi-part, then a recursive object is created, where
362 each sub-part is also a EddyMsg instance.
365 msg_struct: an email parsed with email.parser.Parser(), which can be
369 an instance of EddyMsg, potentially a recursive one.
372 eddymsg_obj
= EddyMsg()
374 if msg_struct
.is_multipart() == True:
375 payloads
= msg_struct
.get_payload()
377 eddymsg_obj
.multipart
= True
378 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
381 eddymsg_obj
= get_subpart_data(msg_struct
)
386 def scan_and_split (payload_piece
, match_name
, pattern
):
387 """This splits the payloads of an EddyMsg object into GPG and text parts.
389 An EddyMsg object's payload_pieces starts off as a list containing a single
390 PayloadPiece object. This function returns a list of these objects which
391 have been split into GPG data and regular text, if such splits need to be/
395 payload_piece: a single payload or a split part of a payload
396 match_name: the type of data to try to spit out from the payload piece
397 pattern: the search pattern to be used for finding that type of data
400 a list of objects of the PayloadPiece class, in the order that the
401 string part of payload_piece originally was, broken up according to
402 matches specified by 'pattern'.
405 # don't try to re-split pieces containing gpg data
406 if payload_piece
.piece_type
!= TxtType
.text
:
407 return [payload_piece
]
409 flags
= re
.DOTALL | re
.MULTILINE
410 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
411 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
414 pieces
= [payload_piece
]
418 beginning
= PayloadPiece()
419 beginning
.string
= matches
.group('beginning')
420 beginning
.piece_type
= payload_piece
.piece_type
422 match
= PayloadPiece()
423 match
.string
= matches
.group('match')
424 match
.piece_type
= match_name
426 rest
= PayloadPiece()
427 rest
.string
= matches
.group('rest')
428 rest
.piece_type
= payload_piece
.piece_type
430 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
431 pieces
= [beginning
, match
] + more_pieces
436 def get_subpart_data (part
):
437 """This function grabs information from a single part mime object.
439 It copies needed data from a single part email.parser.Parser() object over
440 to an EddyMsg object.
443 part: a non-multi-part mime.parser.Parser() object
446 a single-part EddyMsg() object
451 mime_decoded_bytes
= part
.get_payload(decode
=True)
452 charset
= part
.get_content_charset()
454 # your guess is as good as a-myy-ee-ine...
458 payload_string
= part
.as_string()
459 if payload_string
!= None:
460 obj
.payload_bytes
= payload_string
.encode(charset
)
462 obj
.filename
= part
.get_filename()
463 obj
.content_type
= part
.get_content_type()
464 obj
.description_list
= part
['content-description']
466 if mime_decoded_bytes
!= None:
468 payload
= PayloadPiece()
469 payload
.string
= mime_decoded_bytes
.decode(charset
)
470 payload
.piece_type
= TxtType
.text
472 obj
.payload_pieces
= [payload
]
473 except UnicodeDecodeError:
479 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
480 """A function which maps another function onto a message's subparts.
482 This is a higer-order function which recursively performs a specified
483 function on each subpart of a multi-part message. Each single-part sub-part
484 has the function applied to it. This function also works if the part passed
488 function_to_do: function to perform on sub-parts
489 eddymsg_obj: a single part or multi-part EddyMsg object
490 data: a second argument to pass to 'function_to_do'
496 The passed-in EddyMsg object is transformed recursively on its
497 sub-parts according to 'function_to_do'.
500 if eddymsg_obj
.multipart
== True:
501 for sub
in eddymsg_obj
.subparts
:
502 do_to_eddys_pieces(function_to_do
, sub
, data
)
504 function_to_do(eddymsg_obj
, data
)
507 def split_payloads (eddymsg_obj
):
508 """Splits all (sub-)payloads of a message into GPG data and regular text.
510 Recursively performs payload splitting on all sub-parts of an EddyMsg
511 object into the various GPG data types, such as GPG messages, public key
512 blocks and signed text.
515 eddymsg_obj: an instance of EddyMsg
521 The EddyMsg object has payloads that are unsplit (by may be split)..
524 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
527 for match_pair
in match_pairs
:
528 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
531 def split_payload_pieces (eddymsg_obj
, match_pair
):
532 """A helper function for split_payloads(); works on PayloadPiece objects.
534 This function splits up PayloadPiece objects into multipe PayloadPiece
535 objects and replaces the EddyMsg object's previous list of payload pieces
536 with the new split up one.
539 eddymsg_obj: a single-part EddyMsg object.
540 match_pair: a tuple from the match_pairs list, which specifies a match
541 name and a match pattern.
547 The payload piece(s) of an EddyMsg object may be already split or
551 The EddyMsg object's payload piece(s) are split into a list of pieces
552 if matches of the match_pair are found.
555 (match_name
, pattern
) = match_pair
558 for piece
in eddymsg_obj
.payload_pieces
:
559 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
561 eddymsg_obj
.payload_pieces
= new_pieces_list
564 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
565 """Performs GPG operations on the GPG parts of the message
567 This function decrypts text, verifies signatures, and imports public keys
568 included in an email.
571 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
572 and non-GPG sections by split_payloads()
573 gpgme_ctx: a gpgme context
575 prev_parts: a list of mime parts that occur before the eddymsg_obj
576 part, under the same multi-part mime part. This is used for
577 verifying detached signatures. For the root mime part, this should
578 be an empty list, which is the default value if this paramater is
585 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
588 Decryption, verification and key imports occur. the gpg_data members of
589 PayloadPiece objects get filled in with GPGData objects with some of
590 their attributes set.
593 if eddymsg_obj
.multipart
== True:
595 for sub
in eddymsg_obj
.subparts
:
596 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
601 for piece
in eddymsg_obj
.payload_pieces
:
603 if piece
.piece_type
== TxtType
.text
:
604 # don't transform the plaintext.
607 elif piece
.piece_type
== TxtType
.message
:
608 piece
.gpg_data
= GPGData()
610 (plaintext_b
, sigs
, sigkey_missing
, key_cannot_encrypt
) = decrypt_block(piece
.string
, gpgme_ctx
)
612 piece
.gpg_data
.sigkey_missing
= sigkey_missing
613 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
616 piece
.gpg_data
.decrypted
= True
617 piece
.gpg_data
.sigs
= sigs
619 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
622 # if not encrypted, check to see if this is an armored signature.
623 (plaintext_b
, sigs
, sigkey_missing
, key_cannot_encrypt
) = verify_sig_message(piece
.string
, gpgme_ctx
)
625 piece
.gpg_data
.sigkey_missing
= sigkey_missing
626 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
629 piece
.piece_type
= TxtType
.signature
630 piece
.gpg_data
.sigs
= sigs
632 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
634 elif piece
.piece_type
== TxtType
.pubkey
:
635 piece
.gpg_data
= GPGData()
637 (key_fps
, key_cannot_encrypt
) = add_gpg_key(piece
.string
, gpgme_ctx
)
639 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
642 piece
.gpg_data
.keys
= key_fps
644 elif piece
.piece_type
== TxtType
.detachedsig
:
645 piece
.gpg_data
= GPGData()
647 for prev
in prev_parts
:
648 (sig_fps
, sigkey_missing
, key_cannot_encrypt
) = verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
650 piece
.gpg_data
.sigkey_missing
= sigkey_missing
651 piece
.gpg_data
.key_cannot_encrypt
= key_cannot_encrypt
654 piece
.gpg_data
.sigs
= sig_fps
655 piece
.gpg_data
.plainobj
= prev
662 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
663 """Updates replyinfo_obj with info on the message's GPG success/failures
665 This function marks replyinfo_obj with information about whether encrypted
666 text in eddymsg_obj was successfully decrypted, signatures were verified
667 and whether a public key was found or not.
670 eddymsg_obj: a message in the EddyMsg format
671 replyinfo_obj: an instance of ReplyInfo
677 eddymsg_obj has had its gpg_data created by gpg_on_payloads
680 replyinfo_obj has been updated with info about decryption/sig
681 verififcation status, etc. However the desired key isn't imported until
682 later, so the success or failure of that updates the values set here.
685 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
687 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
688 """A helper function for prepare_for_reply
690 It updates replyinfo_obj with GPG success/failure information, when
691 supplied a single-part EddyMsg object.
694 eddymsg_obj: a single-part message in the EddyMsg format
695 replyinfo_obj: an object which holds information about the message's
702 eddymsg_obj is a single-part message. (it may be a part of a multi-part
703 message.) It has had its gpg_data created by gpg_on_payloads if it has
707 replyinfo_obj has been updated with gpg success/failure information
710 for piece
in eddymsg_obj
.payload_pieces
:
711 if piece
.piece_type
== TxtType
.text
:
712 # don't quote the plaintext part.
715 elif piece
.piece_type
== TxtType
.message
:
716 prepare_for_reply_message(piece
, replyinfo_obj
)
718 elif piece
.piece_type
== TxtType
.pubkey
:
719 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
721 elif (piece
.piece_type
== TxtType
.detachedsig
) \
722 or (piece
.piece_type
== TxtType
.signature
):
723 prepare_for_reply_sig(piece
, replyinfo_obj
)
726 def prepare_for_reply_message (piece
, replyinfo_obj
):
727 """Helper function for prepare_for_reply()
729 This function is called when the piece_type of a payload piece is
730 TxtType.message, or GPG Message block. This should be encrypted text. If
731 the encryted block is correclty signed, a sig will be attached to
732 .target_key unless there is already one there.
735 piece: a PayloadPiece object.
736 replyinfo_obj: object which gets updated with decryption status, etc.
742 the piece.payload_piece value should be TxtType.message.
745 replyinfo_obj gets updated with decryption status, signing status, a
746 potential signing key, posession status of the public key for the
747 signature and encryption capability status if that key is missing.
750 if piece
.gpg_data
.plainobj
== None:
751 replyinfo_obj
.decrypt_failure
= True
754 replyinfo_obj
.decrypt_success
= True
756 # we already have a key (and a message)
757 if replyinfo_obj
.target_key
!= None:
760 if piece
.gpg_data
.sigs
== []:
761 if piece
.gpg_data
.sigkey_missing
== True:
762 replyinfo_obj
.sigkey_missing
= True
764 if piece
.gpg_data
.key_cannot_encrypt
== True:
765 replyinfo_obj
.key_cannot_encrypt
= True
767 # only include a signed message in the reply.
768 get_signed_part
= True
771 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
772 replyinfo_obj
.sig_success
= True
773 get_signed_part
= False
775 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
777 # to catch public keys in encrypted blocks
778 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
781 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
782 """Helper function for prepare_for_reply(). Marks pubkey import status.
784 Marks replyinfo_obj with pub key import status.
787 piece: a PayloadPiece object
788 replyinfo_obj: a ReplyInfo object
791 piece.piece_type should be set to TxtType.pubkey .
794 replyinfo_obj has its fields updated.
797 if piece
.gpg_data
.keys
== []:
798 if piece
.gpg_data
.key_cannot_encrypt
== True:
799 replyinfo_obj
.key_cannot_encrypt
= True
801 replyinfo_obj
.pubkey_success
= True
803 # prefer public key as a fallback for the encrypted reply
804 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
807 def prepare_for_reply_sig (piece
, replyinfo_obj
):
808 """Helper function for prepare_for_reply(). Marks sig verification status.
810 Marks replyinfo_obj with signature verification status.
813 piece: a PayloadPiece object
814 replyinfo_obj: a ReplyInfo object
817 piece.piece_type should be set to TxtType.signature, or
818 TxtType.detachedsig .
821 replyinfo_obj has its fields updated.
824 if piece
.gpg_data
.sigs
== []:
825 replyinfo_obj
.sig_failure
= True
827 if piece
.gpg_data
.sigkey_missing
== True:
828 replyinfo_obj
.sigkey_missing
= True
830 if piece
.gpg_data
.key_cannot_encrypt
== True:
831 replyinfo_obj
.key_cannot_encrypt
= True
834 replyinfo_obj
.sig_success
= True
836 if replyinfo_obj
.fallback_target_key
== None:
837 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
839 if (piece
.piece_type
== TxtType
.signature
):
840 # to catch public keys in signature blocks
841 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
844 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
845 """For creating a string representation of a signed, encrypted part.
847 When given a decrypted payload, it will add either the plaintext or signed
848 plaintext to the reply message, depeding on 'get_signed_part'. This is
849 useful for ensuring that the reply message only comes from a signed and
850 ecrypted GPG message. It also sets the target_key for encrypting the reply
851 if it's told to get signed text only.
854 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
856 replyinfo_obj: a ReplyInfo object for holding the message to quote and
857 the target_key to encrypt to.
858 get_signed_part: True if we should only include text that contains a
859 further signature. If False, then include plain text.
865 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
866 which represents decrypted text. It may or may not be signed on that
870 the ReplyInfo instance may have a new 'target_key' set and its
871 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
875 if eddymsg_obj
== None:
878 # recurse on multi-part mime
879 if eddymsg_obj
.multipart
== True:
880 for sub
in eddymsg_obj
.subparts
:
881 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
883 for piece
in eddymsg_obj
.payload_pieces
:
884 if (get_signed_part
):
885 if ((piece
.piece_type
== TxtType
.detachedsig
) \
886 or (piece
.piece_type
== TxtType
.signature
)) \
887 and (piece
.gpg_data
!= None) \
888 and (piece
.gpg_data
.plainobj
!= None):
889 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
890 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
893 if piece
.piece_type
== TxtType
.text
:
894 replyinfo_obj
.msg_to_quote
+= piece
.string
897 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
898 """Obtains a public key object from a key fingerprint
900 If the .target_key is not set, then we use .fallback_target_key, if
904 replyinfo_obj: ReplyInfo instance
905 gpgme_ctx: the gpgme context
911 Loading a key requires that we have the public key imported. This
912 requires that they email contains the pub key block, or that it was
913 previously sent to edward.
916 If the key can be loaded, then replyinfo_obj.reply_to_key points to the
917 public key object. If the key cannot be loaded, then the replyinfo_obj
918 is marked as having no public key available. If the key is not capable
919 of encryption, it will not be used, and replyinfo_obj will be marked
923 for key
in (replyinfo_obj
.target_key
, replyinfo_obj
.fallback_target_key
):
926 encrypt_to_key
= gpgme_ctx
.get_key(key
)
928 except gpgme
.GpgmeError
:
931 if is_key_usable(encrypt_to_key
):
932 replyinfo_obj
.encrypt_to_key
= encrypt_to_key
933 replyinfo_obj
.have_reply_key
= True
934 replyinfo_obj
.key_can_encrypt
= True
938 replyinfo_obj
.key_cannot_encrypt
= True
942 def write_reply (replyinfo_obj
):
943 """Write the reply email body about the GPG successes/failures.
945 The reply is about whether decryption, sig verification and key
946 import/loading was successful or failed. If text was successfully decrypted
947 and verified, then the first instance of such text will be included in
951 replyinfo_obj: contains details of GPG processing status
954 the plaintext message to be sent to the user
957 replyinfo_obj should be populated with info about GPG processing status.
962 if (replyinfo_obj
.pubkey_success
== True):
963 reply_plain
+= replyinfo_obj
.replies
['greeting']
964 reply_plain
+= "\n\n"
967 if replyinfo_obj
.decrypt_success
== True:
968 debug('decrypt success')
969 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
971 if (replyinfo_obj
.sig_success
== True) and (replyinfo_obj
.have_reply_key
== True):
972 debug('message quoted')
973 reply_plain
+= replyinfo_obj
.replies
['space']
974 reply_plain
+= replyinfo_obj
.replies
['quote_follows']
975 reply_plain
+= "\n\n"
976 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
977 reply_plain
+= quoted_text
979 reply_plain
+= "\n\n"
981 elif replyinfo_obj
.decrypt_failure
== True:
982 debug('decrypt failure')
983 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
984 reply_plain
+= "\n\n"
987 if replyinfo_obj
.sig_success
== True:
988 debug('signature success')
989 reply_plain
+= replyinfo_obj
.replies
['sig_success']
990 reply_plain
+= "\n\n"
992 elif replyinfo_obj
.sig_failure
== True:
993 debug('signature failure')
994 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
995 reply_plain
+= "\n\n"
998 if (replyinfo_obj
.pubkey_success
== True):
999 debug('public key received')
1000 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
1001 reply_plain
+= "\n\n"
1003 elif (replyinfo_obj
.sigkey_missing
== True):
1004 debug('no public key')
1005 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
1006 reply_plain
+= "\n\n"
1008 elif (replyinfo_obj
.key_can_encrypt
== False) \
1009 and (replyinfo_obj
.key_cannot_encrypt
== True):
1010 debug('bad public key')
1011 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
1012 reply_plain
+= "\n\n"
1015 if (reply_plain
== ""):
1016 debug('plaintext message')
1017 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
1018 reply_plain
+= "\n\n"
1021 reply_plain
+= replyinfo_obj
.replies
['signature']
1022 reply_plain
+= "\n\n"
1027 def add_gpg_key (key_block
, gpgme_ctx
):
1028 """Adds a GPG pubkey to the local keystore
1030 This adds keys received through email into the key store so they can be
1034 key_block: the string form of the ascii-armored public key block
1035 gpgme_ctx: the gpgme context
1038 the fingerprint(s) of the imported key(s) which can be used for
1039 encryption, and a boolean marking whether none of the keys are capable
1043 fp
= io
.BytesIO(key_block
.encode('ascii'))
1046 result
= gpgme_ctx
.import_(fp
)
1047 imports
= result
.imports
1048 except gpgme
.GpgmeError
:
1051 key_fingerprints
= []
1052 key_cannot_encrypt
= False
1054 for import_res
in imports
:
1055 fingerprint
= import_res
[0]
1058 key_obj
= gpgme_ctx
.get_key(fingerprint
)
1062 if is_key_usable(key_obj
):
1063 key_fingerprints
+= [fingerprint
]
1064 key_cannot_encrypt
= False
1066 debug("added gpg key: " + fingerprint
)
1068 elif key_fingerprints
== []:
1069 key_cannot_encrypt
= True
1071 return (key_fingerprints
, key_cannot_encrypt
)
1074 def verify_sig_message (msg_block
, gpgme_ctx
):
1075 """Verifies the signature of a signed, ascii-armored block of text.
1077 It encodes the string into ascii, since binary GPG files are currently
1078 unsupported, and alternative, the ascii-armored format is encodable into
1082 msg_block: a GPG Message block in string form. It may be encrypted or
1083 not. If it is encrypted, it will return empty results.
1084 gpgme_ctx: the gpgme context
1087 A tuple containing the plaintext bytes of the signed part, the list of
1088 fingerprints of encryption-capable keys signing the data, a boolean
1089 marking whether edward is missing all public keys for validating any of
1090 the signatures, and a boolean marking whether all sigs' keys are
1091 incapable of encryption. If verification failed, perhaps because the
1092 message was also encrypted, sensible default values are returned.
1095 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1096 plain_b
= io
.BytesIO()
1099 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
1100 except gpgme
.GpgmeError
:
1101 return ("",[],False,False)
1103 plaintext_b
= plain_b
.getvalue()
1105 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1107 return (plaintext_b
, fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1110 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1111 """Verifies the signature of a detached signature.
1113 This requires the signature part and the signed part as separate arguments.
1116 detached_sig: the signature part of the detached signature
1117 plaintext_bytes: the byte form of the message being signed.
1118 gpgme_ctx: the gpgme context
1121 A tuple containging a list of encryption capable signing fingerprints
1122 if the signature verification was sucessful, a boolean marking whether
1123 edward is missing all public keys for validating any of the signatures,
1124 and a boolean marking whether all signing keys are incapable of
1125 encryption. Otherwise, a tuple containing an empty list and True are
1129 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1130 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1133 sigs
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1134 except gpgme
.GpgmeError
:
1135 return ([],False,False)
1137 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1139 return (fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1142 def decrypt_block (msg_block
, gpgme_ctx
):
1143 """Decrypts a block of GPG text and verifies any included sigatures.
1145 Some encypted messages have embeded signatures, so those are verified too.
1148 msg_block: the encrypted(/signed) text
1149 gpgme_ctx: the gpgme context
1152 A tuple containing plaintext bytes, encryption-capable signatures (if
1153 decryption and signature verification were successful, respectively), a
1154 boolean marking whether edward is missing all public keys for
1155 validating any of the signatures, and a boolean marking whether all
1156 signature keys are incapable of encryption.
1159 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1160 plain_b
= io
.BytesIO()
1163 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1164 except gpgme
.GpgmeError
:
1165 return ("",[],False,False)
1167 plaintext_b
= plain_b
.getvalue()
1169 (fingerprints
, sigkey_missing
, key_cannot_encrypt
) = get_signature_fp(sigs
, gpgme_ctx
)
1171 return (plaintext_b
, fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1174 def get_signature_fp (sigs
, gpgme_ctx
):
1175 """Selects valid signatures from output of gpgme signature verifying functions
1177 get_signature_fp returns a list of valid signature fingerprints if those
1178 fingerprints are associated with available keys capable of encryption.
1181 sigs: a signature verification result object list
1182 gpgme_ctx: a gpgme context
1185 fingerprints: a list of fingerprints
1186 sigkey_missing: a boolean marking whether public keys are missing for
1187 all available signatures.
1188 key_cannot_encrypt: a boolearn marking whether available public keys are
1189 incapable of encryption.
1192 sigkey_missing
= False
1193 key_cannot_encrypt
= False
1197 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1199 key_obj
= gpgme_ctx
.get_key(sig
.fpr
)
1201 if fingerprints
== []:
1202 sigkey_missing
= True
1205 if is_key_usable(key_obj
):
1206 fingerprints
+= [sig
.fpr
]
1207 key_cannot_encrypt
= False
1208 sigkey_missing
= False
1210 elif fingerprints
== []:
1211 key_cannot_encrypt
= True
1213 elif fingerprints
== []:
1214 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1215 sigkey_missing
= True
1217 return (fingerprints
, sigkey_missing
, key_cannot_encrypt
)
1220 def is_key_usable (key_obj
):
1221 """Returns boolean representing key usability regarding encryption
1223 Tests various feature of key and returns usability
1226 key_obj: a gpgme key object
1229 A boolean representing key usability
1231 if key_obj
.can_encrypt
and not key_obj
.invalid
and not key_obj
.expired \
1232 and not key_obj
.revoked
and not key_obj
.disabled
:
1238 def email_to_from_subject (email_bytes
):
1239 """Returns the values of the email's To:, From: and Subject: fields
1241 Returns this information from an email.
1244 email_bytes: the byte string form of the email
1247 the email To:, From:, and Subject: fields as strings
1250 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
1252 email_to
= email_struct
['To']
1253 email_from
= email_struct
['From']
1254 email_subject
= email_struct
['Subject']
1256 return email_to
, email_from
, email_subject
1259 def import_lang_pick_address(email_to
, hostname
):
1260 """Imports language file for i18n support; makes reply from address
1262 The language imported depends on the To: address of the email received by
1263 edward. an -en ending implies the English language, whereas a -ja ending
1264 implies Japanese. The list of supported languages is listed in the 'langs'
1265 list at the beginning of the program. This function also chooses the
1266 language-dependent address which can be used as the From address in the
1270 email_to: the string containing the email address that the mail was
1272 hostname: the hostname part of the reply email's from address
1275 the reference to the imported language module. The only variable in
1276 this file is the 'replies' dictionary.
1282 if email_to
!= None:
1284 if "edward-" + lang
in email_to
:
1288 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1289 lang_module
= importlib
.import_module(lang_mod_name
)
1291 reply_from
= "edward-" + use_lang
+ "@" + hostname
1293 return lang_module
, reply_from
1296 def generate_encrypted_mime (plaintext
, email_to
, email_subject
, encrypt_to_key
,
1298 """This function creates the mime email reply. It can encrypt the email.
1300 If the encrypt_key is included, then the email is encrypted and signed.
1301 Otherwise it is unencrypted.
1304 plaintext: the plaintext body of the message to create.
1305 email_to: the email address to reply to
1306 email_subject: the subject to use in reply
1307 encrypt_to_key: the key object to use for encrypting the email. (or
1309 gpgme_ctx: the gpgme context
1312 A string version of the mime message, possibly encrypted and signed.
1315 plaintext_mime
= MIMEText(plaintext
)
1316 plaintext_mime
.set_charset('utf-8')
1318 if (encrypt_to_key
!= None):
1320 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1324 control_mime
= MIMEApplication("Version: 1",
1325 _subtype
='pgp-encrypted',
1326 _encoder
=email
.encoders
.encode_7or8bit
)
1327 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1328 control_mime
.set_charset('us-ascii')
1330 encoded_mime
= MIMEApplication(encrypted_text
,
1331 _subtype
='octet-stream; name="encrypted.asc"',
1332 _encoder
=email
.encoders
.encode_7or8bit
)
1333 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1334 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1335 encoded_mime
.set_charset('us-ascii')
1337 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1338 message_mime
.attach(control_mime
)
1339 message_mime
.attach(encoded_mime
)
1340 message_mime
['Content-Disposition'] = 'inline'
1343 message_mime
= plaintext_mime
1345 message_mime
['To'] = email_to
1346 message_mime
['Subject'] = email_subject
1348 reply
= message_mime
.as_string()
1353 def send_reply(email_txt
, subject
, reply_to
, reply_from
):
1355 email_bytes
= email_txt
.encode('ascii')
1357 p
= subprocess
.Popen(["/usr/sbin/sendmail", "-f", reply_from
, "-F", "Edward, GPG Bot", "-i", reply_to
], stdin
=subprocess
.PIPE
)
1359 (stdout
, stderr
) = p
.communicate(email_bytes
)
1362 debug("sendmail stdout: " + str(stdout
))
1364 error("sendmail stderr: " + str(stderr
))
1367 def email_quote_text (text
):
1368 """Quotes input text by inserting "> "s
1370 This is useful for quoting a text for the reply message. It inserts "> "
1371 strings at the beginning of lines.
1374 text: plain text to quote
1380 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1382 return quoted_message
1385 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1386 """Encrypts and signs plaintext
1388 This encrypts and signs a message.
1391 plaintext: text to sign and ecrypt
1392 encrypt_to_key: the key object to encrypt to
1393 gpgme_ctx: the gpgme context
1396 An encrypted and signed string of text
1399 # the plaintext should be mime encoded in an ascii-compatible form
1400 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1401 encrypted_bytes
= io
.BytesIO()
1403 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1404 plaintext_bytes
, encrypted_bytes
)
1406 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1407 return encrypted_txt
1410 def error (error_msg
):
1411 """Write an error message to stdout
1413 The error message includes the program name.
1416 error_msg: the message to print
1422 An error message is printed to stdout
1425 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1428 def debug (debug_msg
):
1429 """Writes a debug message to stdout if debug == True
1431 If the debug option is set in edward_config.py, then the passed message
1432 gets printed to stdout.
1435 debug_msg: the message to print to stdout
1441 A debug message is printed to stdout
1444 if edward_config
.debug
== True:
1449 """Sets the progname variable and processes optional argument
1451 If there are more than two arguments then edward complains and quits. An
1452 single "-p" argument sets the print_reply_only option, which makes edward
1453 print email replies instead of mailing them.
1459 True if edward should print arguments instead of mailing them,
1460 otherwise it returns False.
1463 Exits with error 1 if there are more than two arguments, otherwise
1464 returns the print_reply_only option.
1468 progname
= sys
.argv
[0]
1470 print_reply_only
= False
1472 if len(sys
.argv
) > 2:
1473 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1474 + " -p print reply message to stdout, do not mail it\n", \
1478 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1479 print_reply_only
= True
1481 return print_reply_only
1484 if __name__
== "__main__":
1485 """Executes main if this file is not loaded interactively"""