1 #! /usr/bin/env python3
2 # -*- coding: utf-8 -*-
3 """*********************************************************************
4 * Edward is free software: you can redistribute it and/or modify *
5 * it under the terms of the GNU Affero Public License as published by *
6 * the Free Software Foundation, either version 3 of the License, or *
7 * (at your option) any later version. *
9 * Edward is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU Affero Public License for more details. *
14 * You should have received a copy of the GNU Affero Public License *
15 * along with Edward. If not, see <http://www.gnu.org/licenses/>. *
17 * Copyright (C) 2014-2015 Andrew Engelbrecht (AGPLv3+) *
18 * Copyright (C) 2014 Josh Drake (AGPLv3+) *
19 * Copyright (C) 2014 Lisa Marie Maginnis (AGPLv3+) *
20 * Copyright (C) 2009-2015 Tails developers <tails@boum.org> ( GPLv3+) *
21 * Copyright (C) 2009 W. Trevor King <wking@drexel.edu> ( GPLv2+) *
23 * Special thanks to Josh Drake for writing the original edward bot! :) *
25 ************************************************************************
27 Code sourced from these projects:
29 * http://agpl.fsf.org/emailselfdefense.fsf.org/edward/CURRENT/edward.tar.gz
30 * https://git-tails.immerda.ch/whisperback/tree/whisperBack/encryption.py?h=feature/python3
31 * http://www.physics.drexel.edu/~wking/code/python/send_pgp_mime
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 'keys' is a list of fingerprints of keys obtained in public key blocks.
159 sigkey_missing
= False
163 class ReplyInfo (object):
165 ReplyInfo contains details that edward uses in generating its reply.
167 Instances of this class contain information about whether a message was
168 successfully encrypted or signed, and whether a public key was attached, or
169 retrievable, from the local GPG store. It stores the fingerprints of
170 potential encryption key candidates and the message (if any at all) to
171 quote in edward's reply.
173 'replies' points one of the dictionaries of translated replies.
175 'target_key' refers to the fingerprint of a key used to sign encrypted
176 data. This is the preferred key, if it is set, and if is available.
178 'fallback_target_key' referst to the fingerprint of a key used to sign
179 unencrypted data; alternatively it may be a public key attached to the
182 'encrypt_to_key' the key object to use when encrypting edward's reply
184 'msg_to_quote' refers to the part of a message which edward should quote in
185 his reply. This should remain as None if there was no encrypted and singed
186 part. This is to avoid making edward a service for decrypting other
187 people's messages to edward.
189 'decrypt_success' is set to True if edward could decrypt part of the
192 'sig_success' is set to True if edward could to some extent verify the
193 signature of a signed part of the message to edward.
195 'pubkey_success' is set to True if edward successfully imported a public
198 'sigkey_missing' is set to True if edward doesn't have the public key
199 needed for signature verification.
201 'have_repy_key' is set to True if edward has a public key to encrypt its
208 fallback_target_key
= None
209 encrypt_to_key
= None
212 decrypt_success
= False
214 pubkey_success
= False
216 sigkey_missing
= False
217 have_reply_key
= False
223 This is the main function for edward, a GPG reply bot.
225 Edward responds to GPG-encrypted and signed mail, encrypting and signing
226 the response if the user's public key is, or was, included in the message.
235 Mime or plaintext email passing in through standard input. Portions of
236 the email may be encrypted. If the To: address contains the text
237 "edward-ja", then the reply will contain a reply written in the
238 Japanese language. There are other languages as well. The default
242 A reply email will be printed to standard output. The contents of the
243 reply email depends on whether the original email was encrypted or not,
244 has or doesn't have a signature, whether a public key used in the
245 original message is provided or locally stored, and the language
246 implied by the To: address in the original email.
249 print_reply_only
= handle_args()
251 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
252 edward_config
.sign_with_key
)
254 email_text
= sys
.stdin
.read()
255 email_struct
= parse_pgp_mime(email_text
, gpgme_ctx
)
257 email_to
, email_from
, email_subject
= email_to_from_subject(email_text
)
258 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
260 replyinfo_obj
= ReplyInfo()
261 replyinfo_obj
.replies
= lang
.replies
263 prepare_for_reply(email_struct
, replyinfo_obj
)
264 get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
265 reply_plaintext
= write_reply(replyinfo_obj
)
267 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_from
, \
268 email_subject
, replyinfo_obj
.encrypt_to_key
,
271 if print_reply_only
== True:
274 send_reply(reply_mime
, email_subject
, email_from
, reply_from
)
277 def get_gpg_context (gnupghome
, sign_with_key_fp
):
279 This function returns the GPG context needed for encryption and signing.
281 The context is needed by other functions which use GPG functionality.
284 gnupghome: The path to "~/.gnupg/" or its alternative.
285 sign_with_key: The fingerprint of the key to sign with
288 A gpgme context to be used for GPG functions.
291 the 'armor' flag is set to True and the list of signing keys contains
292 the single specified key
295 os
.environ
['GNUPGHOME'] = gnupghome
297 gpgme_ctx
= gpgme
.Context()
298 gpgme_ctx
.armor
= True
301 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
302 except gpgme
.GpgmeError
:
303 error("unable to load signing key. is the gnupghome "
304 + "and signing key properly set in the edward_config.py?")
307 gpgme_ctx
.signers
= [sign_with_key
]
312 def parse_pgp_mime (email_text
, gpgme_ctx
):
313 """Parses the email for mime payloads and decrypts/verfies signatures.
315 This function creates a representation of a mime or plaintext email with
316 the EddyMsg class. It then splits each mime payload into one or more pieces
317 which may be plain text or GPG data. It then decrypts encrypted parts and
318 does some very basic signature verification on those parts.
321 email_text: an email message in string format
322 gpgme_ctx: a gpgme context
325 A message as an instance of EddyMsg
328 the returned EddyMsg instance has split, decrypted, verified and pubkey
332 email_struct
= email
.parser
.Parser().parsestr(email_text
)
334 eddymsg_obj
= parse_mime(email_struct
)
335 split_payloads(eddymsg_obj
)
336 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
341 def parse_mime(msg_struct
):
342 """Translates python's email.parser format into an EddyMsg format
344 If the message is multi-part, then a recursive object is created, where
345 each sub-part is also a EddyMsg instance.
348 msg_struct: an email parsed with email.parser.Parser(), which can be
352 an instance of EddyMsg, potentially a recursive one.
355 eddymsg_obj
= EddyMsg()
357 if msg_struct
.is_multipart() == True:
358 payloads
= msg_struct
.get_payload()
360 eddymsg_obj
.multipart
= True
361 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
364 eddymsg_obj
= get_subpart_data(msg_struct
)
369 def scan_and_split (payload_piece
, match_name
, pattern
):
370 """This splits the payloads of an EddyMsg object into GPG and text parts.
372 An EddyMsg object's payload_pieces starts off as a list containing a single
373 PayloadPiece object. This function returns a list of these objects which
374 have been split into GPG data and regular text, if such splits need to be/
378 payload_piece: a single payload or a split part of a payload
379 match_name: the type of data to try to spit out from the payload piece
380 pattern: the search pattern to be used for finding that type of data
383 a list of objects of the PayloadPiece class, in the order that the
384 string part of payload_piece originally was, broken up according to
385 matches specified by 'pattern'.
388 # don't try to re-split pieces containing gpg data
389 if payload_piece
.piece_type
!= TxtType
.text
:
390 return [payload_piece
]
392 flags
= re
.DOTALL | re
.MULTILINE
393 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
394 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
397 pieces
= [payload_piece
]
401 beginning
= PayloadPiece()
402 beginning
.string
= matches
.group('beginning')
403 beginning
.piece_type
= payload_piece
.piece_type
405 match
= PayloadPiece()
406 match
.string
= matches
.group('match')
407 match
.piece_type
= match_name
409 rest
= PayloadPiece()
410 rest
.string
= matches
.group('rest')
411 rest
.piece_type
= payload_piece
.piece_type
413 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
414 pieces
= [beginning
, match
] + more_pieces
419 def get_subpart_data (part
):
420 """This function grabs information from a single part mime object.
422 It copies needed data from a single part email.parser.Parser() object over
423 to an EddyMsg object.
426 part: a non-multi-part mime.parser.Parser() object
429 a single-part EddyMsg() object
434 mime_decoded_bytes
= part
.get_payload(decode
=True)
435 charset
= part
.get_content_charset()
437 # your guess is as good as a-myy-ee-ine...
441 payload_string
= part
.as_string()
442 if payload_string
!= None:
443 obj
.payload_bytes
= payload_string
.encode(charset
)
445 obj
.filename
= part
.get_filename()
446 obj
.content_type
= part
.get_content_type()
447 obj
.description_list
= part
['content-description']
449 if mime_decoded_bytes
!= None:
451 payload
= PayloadPiece()
452 payload
.string
= mime_decoded_bytes
.decode(charset
)
453 payload
.piece_type
= TxtType
.text
455 obj
.payload_pieces
= [payload
]
456 except UnicodeDecodeError:
462 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
463 """A function which maps another function onto a message's subparts.
465 This is a higer-order function which recursively performs a specified
466 function on each subpart of a multi-part message. Each single-part sub-part
467 has the function applied to it. This function also works if the part passed
471 function_to_do: function to perform on sub-parts
472 eddymsg_obj: a single part or multi-part EddyMsg object
473 data: a second argument to pass to 'function_to_do'
479 The passed-in EddyMsg object is transformed recursively on its
480 sub-parts according to 'function_to_do'.
483 if eddymsg_obj
.multipart
== True:
484 for sub
in eddymsg_obj
.subparts
:
485 do_to_eddys_pieces(function_to_do
, sub
, data
)
487 function_to_do(eddymsg_obj
, data
)
490 def split_payloads (eddymsg_obj
):
491 """Splits all (sub-)payloads of a message into GPG data and regular text.
493 Recursively performs payload splitting on all sub-parts of an EddyMsg
494 object into the various GPG data types, such as GPG messages, public key
495 blocks and signed text.
498 eddymsg_obj: an instance of EddyMsg
504 The EddyMsg object has payloads that are unsplit (by may be split)..
507 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
510 for match_pair
in match_pairs
:
511 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
514 def split_payload_pieces (eddymsg_obj
, match_pair
):
515 """A helper function for split_payloads(); works on PayloadPiece objects.
517 This function splits up PayloadPiece objects into multipe PayloadPiece
518 objects and replaces the EddyMsg object's previous list of payload pieces
519 with the new split up one.
522 eddymsg_obj: a single-part EddyMsg object.
523 match_pair: a tuple from the match_pairs list, which specifies a match
524 name and a match pattern.
530 The payload piece(s) of an EddyMsg object may be already split or
534 The EddyMsg object's payload piece(s) are split into a list of pieces
535 if matches of the match_pair are found.
538 (match_name
, pattern
) = match_pair
541 for piece
in eddymsg_obj
.payload_pieces
:
542 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
544 eddymsg_obj
.payload_pieces
= new_pieces_list
547 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
548 """Performs GPG operations on the GPG parts of the message
550 This function decrypts text, verifies signatures, and imports public keys
551 included in an email.
554 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
555 and non-GPG sections by split_payloads()
556 gpgme_ctx: a gpgme context
558 prev_parts: a list of mime parts that occur before the eddymsg_obj
559 part, under the same multi-part mime part. This is used for
560 verifying detached signatures. For the root mime part, this should
561 be an empty list, which is the default value if this paramater is
568 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
571 Decryption, verification and key imports occur. the gpg_data member of
572 PayloadPiece objects get filled in with GPGData objects.
575 if eddymsg_obj
.multipart
== True:
577 for sub
in eddymsg_obj
.subparts
:
578 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
583 for piece
in eddymsg_obj
.payload_pieces
:
585 if piece
.piece_type
== TxtType
.text
:
586 # don't transform the plaintext.
589 elif piece
.piece_type
== TxtType
.message
:
590 piece
.gpg_data
= GPGData()
592 (plaintext
, sigs
, sigkey_missing
) = decrypt_block(piece
.string
, gpgme_ctx
)
594 piece
.gpg_data
.sigkey_missing
= sigkey_missing
597 piece
.gpg_data
.decrypted
= True
598 piece
.gpg_data
.sigs
= sigs
600 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
603 # if not encrypted, check to see if this is an armored signature.
604 (plaintext
, sigs
, sigkey_missing
) = verify_sig_message(piece
.string
, gpgme_ctx
)
606 piece
.gpg_data
.sigkey_missing
= sigkey_missing
609 piece
.piece_type
= TxtType
.signature
610 piece
.gpg_data
.sigs
= sigs
612 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
614 elif piece
.piece_type
== TxtType
.pubkey
:
615 key_fps
= add_gpg_key(piece
.string
, gpgme_ctx
)
618 piece
.gpg_data
= GPGData()
619 piece
.gpg_data
.keys
= key_fps
621 elif piece
.piece_type
== TxtType
.detachedsig
:
622 piece
.gpg_data
= GPGData()
624 for prev
in prev_parts
:
625 (sig_fps
, sigkey_missing
) = verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
627 piece
.gpg_data
.sigkey_missing
= sigkey_missing
630 piece
.gpg_data
.sigs
= sig_fps
631 piece
.gpg_data
.plainobj
= prev
638 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
639 """Updates replyinfo_obj with info on the message's GPG success/failures
641 This function marks replyinfo_obj with information about whether encrypted
642 text in eddymsg_obj was successfully decrypted, signatures were verified
643 and whether a public key was found or not.
646 eddymsg_obj: a message in the EddyMsg format
647 replyinfo_obj: an instance of ReplyInfo
653 eddymsg_obj has had its gpg_data created by gpg_on_payloads
656 replyinfo_obj has been updated with info about decryption/sig
657 verififcation status, etc. However the desired key isn't imported until
658 later, so the success or failure of that updates the values set here.
661 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
663 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
664 """A helper function for prepare_for_reply
666 It updates replyinfo_obj with GPG success/failure information, when
667 supplied a single-part EddyMsg object.
670 eddymsg_obj: a single-part message in the EddyMsg format
671 replyinfo_obj: an object which holds information about the message's
678 eddymsg_obj is a single-part message. (it may be a part of a multi-part
679 message.) It has had its gpg_data created by gpg_on_payloads if it has
683 replyinfo_obj has been updated with gpg success/failure information
686 for piece
in eddymsg_obj
.payload_pieces
:
687 if piece
.piece_type
== TxtType
.text
:
688 # don't quote the plaintext part.
691 elif piece
.piece_type
== TxtType
.message
:
692 prepare_for_reply_message(piece
, replyinfo_obj
)
694 elif piece
.piece_type
== TxtType
.pubkey
:
695 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
697 elif (piece
.piece_type
== TxtType
.detachedsig
) \
698 or (piece
.piece_type
== TxtType
.signature
):
699 prepare_for_reply_sig(piece
, replyinfo_obj
)
702 def prepare_for_reply_message (piece
, replyinfo_obj
):
703 """Helper function for prepare_for_reply()
705 This function is called when the piece_type of a payload piece is
706 TxtType.message, or GPG Message block. This should be encrypted text. If
707 the encryted block is correclty signed, a sig will be attached to
708 .target_key unless there is already one there.
711 piece: a PayloadPiece object.
712 replyinfo_obj: object which gets updated with decryption status, etc.
718 the piece.payload_piece value should be TxtType.message.
721 replyinfo_obj gets updated with decryption status, signing status, a
722 potential signing key, and posession status of the public key for the
726 if piece
.gpg_data
== None or piece
.gpg_data
.plainobj
== None:
729 replyinfo_obj
.decrypt_success
= True
731 # we already have a key (and a message)
732 if replyinfo_obj
.target_key
!= None:
735 if piece
.gpg_data
.sigs
!= []:
736 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
737 replyinfo_obj
.sig_success
= True
738 get_signed_part
= False
741 if piece
.gpg_data
.sigkey_missing
== True:
742 replyinfo_obj
.sigkey_missing
= True
744 # only include a signed message in the reply.
745 get_signed_part
= True
747 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
749 # to catch public keys in encrypted blocks
750 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
753 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
754 """Helper function for prepare_for_reply(). Marks pubkey import status.
756 Marks replyinfo_obj with pub key import status.
759 piece: a PayloadPiece object
760 replyinfo_obj: a ReplyInfo object
763 piece.piece_type should be set to TxtType.pubkey .
766 replyinfo_obj has its fields updated.
769 if piece
.gpg_data
== None or piece
.gpg_data
.keys
== []:
772 replyinfo_obj
.pubkey_success
= True
774 # prefer public key as a fallback for the encrypted reply
775 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
778 def prepare_for_reply_sig (piece
, replyinfo_obj
):
779 """Helper function for prepare_for_reply(). Marks sig verification status.
781 Marks replyinfo_obj with signature verification status.
784 piece: a PayloadPiece object
785 replyinfo_obj: a ReplyInfo object
788 piece.piece_type should be set to TxtType.signature, or
789 TxtType.detachedsig .
792 replyinfo_obj has its fields updated.
795 if piece
.gpg_data
== None or piece
.gpg_data
.sigs
== []:
797 if piece
.gpg_data
.sigkey_missing
== True:
798 replyinfo_obj
.sigkey_missing
= True
801 replyinfo_obj
.sig_success
= True
803 if replyinfo_obj
.fallback_target_key
== None:
804 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
807 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
808 """For creating a string representation of a signed, encrypted part.
810 When given a decrypted payload, it will add either the plaintext or signed
811 plaintext to the reply message, depeding on 'get_signed_part'. This is
812 useful for ensuring that the reply message only comes from a signed and
813 ecrypted GPG message. It also sets the target_key for encrypting the reply
814 if it's told to get signed text only.
817 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
819 replyinfo_obj: a ReplyInfo object for holding the message to quote and
820 the target_key to encrypt to.
821 get_signed_part: True if we should only include text that contains a
822 further signature. If False, then include plain text.
828 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
829 which represents decrypted text. It may or may not be signed on that
833 the ReplyInfo instance may have a new 'target_key' set and its
834 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
838 if eddymsg_obj
== None:
841 # recurse on multi-part mime
842 if eddymsg_obj
.multipart
== True:
843 for sub
in eddymsg_obj
.subparts
:
844 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
846 for piece
in eddymsg_obj
.payload_pieces
:
847 if (get_signed_part
):
848 if ((piece
.piece_type
== TxtType
.detachedsig
) \
849 or (piece
.piece_type
== TxtType
.signature
)) \
850 and (piece
.gpg_data
!= None) \
851 and (piece
.gpg_data
.plainobj
!= None):
852 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
853 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
856 if piece
.piece_type
== TxtType
.text
:
857 replyinfo_obj
.msg_to_quote
+= piece
.string
860 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
861 """Obtains a public key object from a key fingerprint
863 If the .target_key is not set, then we use .fallback_target_key, if
867 replyinfo_obj: ReplyInfo instance
868 gpgme_ctx: the gpgme context
871 The key object of the key of either the target_key or the fallback one
872 if .target_key is not set. If the key cannot be loaded, then return
876 Loading a key requires that we have the public key imported. This
877 requires that they email contains the pub key block, or that it was
878 previously sent to edward.
881 If the key can be loaded, then replyinfo_obj.reply_to_key points to the
882 public key object. If the key cannot be loaded, then the replyinfo_obj
883 is marked as having no public key available.
886 for key
in (replyinfo_obj
.target_key
, replyinfo_obj
.fallback_target_key
):
889 encrypt_to_key
= gpgme_ctx
.get_key(key
)
890 replyinfo_obj
.encrypt_to_key
= encrypt_to_key
891 replyinfo_obj
.have_reply_key
= True
894 except gpgme
.GpgmeError
:
898 def write_reply (replyinfo_obj
):
899 """Write the reply email body about the GPG successes/failures.
901 The reply is about whether decryption, sig verification and key
902 import/loading was successful or failed. If text was successfully decrypted
903 and verified, then the first instance of such text will be included in
907 replyinfo_obj: contains details of GPG processing status
910 the plaintext message to be sent to the user
913 replyinfo_obj should be populated with info about GPG processing status.
918 if replyinfo_obj
.decrypt_success
== True:
919 debug('decrypt success')
920 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
921 reply_plain
+= "\n\n"
923 if (replyinfo_obj
.sig_success
== True) and (replyinfo_obj
.have_reply_key
== True):
924 debug('message quoted')
925 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
926 reply_plain
+= quoted_text
927 reply_plain
+= "\n\n"
930 debug('decrypt failure')
931 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
932 reply_plain
+= "\n\n"
934 if replyinfo_obj
.sig_success
== True:
935 debug('signature success')
936 reply_plain
+= replyinfo_obj
.replies
['sig_success']
937 reply_plain
+= "\n\n"
940 debug('signature failure')
941 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
942 reply_plain
+= "\n\n"
944 if (replyinfo_obj
.pubkey_success
== True):
945 debug('public key received')
946 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
947 reply_plain
+= "\n\n"
949 elif (replyinfo_obj
.sigkey_missing
== True):
950 debug('no public key')
951 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
952 reply_plain
+= "\n\n"
955 reply_plain
+= replyinfo_obj
.replies
['signature']
956 reply_plain
+= "\n\n"
961 def add_gpg_key (key_block
, gpgme_ctx
):
962 """Adds a GPG pubkey to the local keystore
964 This adds keys received through email into the key store so they can be
968 key_block: the string form of the ascii-armored public key block
969 gpgme_ctx: the gpgme context
972 the fingerprint(s) of the imported key(s)
975 fp
= io
.BytesIO(key_block
.encode('ascii'))
978 result
= gpgme_ctx
.import_(fp
)
979 imports
= result
.imports
980 except gpgme
.GpgmeError
:
983 key_fingerprints
= []
986 for import_
in imports
:
987 fingerprint
= import_
[0]
988 key_fingerprints
+= [fingerprint
]
990 debug("added gpg key: " + fingerprint
)
992 return key_fingerprints
995 def verify_sig_message (msg_block
, gpgme_ctx
):
996 """Verifies the signature of a signed, ascii-armored block of text.
998 It encodes the string into ascii, since binary GPG files are currently
999 unsupported, and alternative, the ascii-armored format is encodable into
1003 msg_block: a GPG Message block in string form. It may be encrypted or
1004 not. If it is encrypted, it will return empty results.
1005 gpgme_ctx: the gpgme context
1008 A tuple containing the plaintext of the signed part, the list of
1009 fingerprints of keys signing the data, and a boolean marking whether
1010 edward is missing all public keys for validating any of the signatures.
1011 If verification failed, perhaps because the message was also encrypted,
1012 then empty results are returned.
1015 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1016 plain_b
= io
.BytesIO()
1019 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
1020 except gpgme
.GpgmeError
:
1021 return ("",[],False)
1023 plaintext
= plain_b
.getvalue().decode('utf-8')
1025 sigkey_missing
= False
1028 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1029 fingerprints
+= [sig
.fpr
]
1030 sigkey_missing
= False
1033 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1034 sigkey_missing
= True
1036 return (plaintext
, fingerprints
, sigkey_missing
)
1039 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1040 """Verifies the signature of a detached signature.
1042 This requires the signature part and the signed part as separate arguments.
1045 detached_sig: the signature part of the detached signature
1046 plaintext_bytes: the byte form of the message being signed.
1047 gpgme_ctx: the gpgme context
1050 A tuple containging a list of signing fingerprints if the signature
1051 verification was sucessful, and a boolean marking whether edward is
1052 missing all public keys for validating any of the signatures.
1053 Otherwise, a tuple containing an empty list and True are returned.
1056 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1057 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1060 result
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1061 except gpgme
.GpgmeError
:
1064 sigkey_missing
= False
1065 sig_fingerprints
= []
1067 if (res_
.summary
== 0) or (res_
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (res_
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1068 sig_fingerprints
+= [res_
.fpr
]
1069 sigkey_missing
= False
1072 if (res_
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1073 sigkey_missing
= True
1075 return (sig_fingerprints
, sigkey_missing
)
1078 def decrypt_block (msg_block
, gpgme_ctx
):
1079 """Decrypts a block of GPG text and verifies any included sigatures.
1081 Some encypted messages have embeded signatures, so those are verified too.
1084 msg_block: the encrypted(/signed) text
1085 gpgme_ctx: the gpgme context
1088 A tuple containing plaintext, signatures (if the decryption and
1089 signature verification were successful, respectively), and a boolean
1090 marking whether edward is missing all public keys for validating any of
1094 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1095 plain_b
= io
.BytesIO()
1098 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1099 except gpgme
.GpgmeError
:
1100 return ("",[],False)
1102 plaintext
= plain_b
.getvalue().decode('utf-8')
1104 sigkey_missing
= False
1107 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1108 fingerprints
+= [sig
.fpr
]
1109 sigkey_missing
= False
1112 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1113 sigkey_missing
= True
1115 return (plaintext
, fingerprints
, sigkey_missing
)
1118 def email_to_from_subject (email_text
):
1119 """Returns the values of the email's To:, From: and Subject: fields
1121 Returns this information from an email.
1124 email_text: the string form of the email
1127 the email To:, From:, and Subject: fields as strings
1130 email_struct
= email
.parser
.Parser().parsestr(email_text
)
1132 email_to
= email_struct
['To']
1133 email_from
= email_struct
['From']
1134 email_subject
= email_struct
['Subject']
1136 return email_to
, email_from
, email_subject
1139 def import_lang_pick_address(email_to
, hostname
):
1140 """Imports language file for i18n support; makes reply from address
1142 The language imported depends on the To: address of the email received by
1143 edward. an -en ending implies the English language, whereas a -ja ending
1144 implies Japanese. The list of supported languages is listed in the 'langs'
1145 list at the beginning of the program. This function also chooses the
1146 language-dependent address which can be used as the From address in the
1150 email_to: the string containing the email address that the mail was
1152 hostname: the hostname part of the reply email's from address
1155 the reference to the imported language module. The only variable in
1156 this file is the 'replies' dictionary.
1162 if email_to
!= None:
1164 if "edward-" + lang
in email_to
:
1168 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1169 lang_module
= importlib
.import_module(lang_mod_name
)
1171 reply_from
= "edward-" + use_lang
+ "@" + hostname
1173 return lang_module
, reply_from
1176 def generate_encrypted_mime (plaintext
, email_to
, email_subject
, encrypt_to_key
,
1178 """This function creates the mime email reply. It can encrypt the email.
1180 If the encrypt_key is included, then the email is encrypted and signed.
1181 Otherwise it is unencrypted.
1184 plaintext: the plaintext body of the message to create.
1185 email_to: the email address to reply to
1186 email_subject: the subject to use in reply
1187 encrypt_to_key: the key object to use for encrypting the email. (or
1189 gpgme_ctx: the gpgme context
1192 A string version of the mime message, possibly encrypted and signed.
1195 if (encrypt_to_key
!= None):
1197 plaintext_mime
= MIMEText(plaintext
)
1198 plaintext_mime
.set_charset('utf-8')
1200 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1204 control_mime
= MIMEApplication("Version: 1",
1205 _subtype
='pgp-encrypted',
1206 _encoder
=email
.encoders
.encode_7or8bit
)
1207 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1208 control_mime
.set_charset('us-ascii')
1210 encoded_mime
= MIMEApplication(encrypted_text
,
1211 _subtype
='octet-stream; name="encrypted.asc"',
1212 _encoder
=email
.encoders
.encode_7or8bit
)
1213 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1214 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1215 encoded_mime
.set_charset('us-ascii')
1217 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1218 message_mime
.attach(control_mime
)
1219 message_mime
.attach(encoded_mime
)
1220 message_mime
['Content-Disposition'] = 'inline'
1223 message_mime
= MIMEText(plaintext
)
1224 message_mime
.set_charset('utf-8')
1226 message_mime
['To'] = email_to
1227 message_mime
['Subject'] = email_subject
1229 reply
= message_mime
.as_string()
1234 def send_reply(email_txt
, subject
, reply_to
, reply_from
):
1236 email_bytes
= email_txt
.encode('ascii')
1238 p
= subprocess
.Popen(["/usr/sbin/sendmail", "-f", reply_from
, "-F", "Edward, GPG Bot", "-i", reply_to
], stdin
=subprocess
.PIPE
)
1240 (stdout
, stderr
) = p
.communicate(email_bytes
)
1243 debug("sendmail stdout: " + str(stdout
))
1245 error("sendmail stderr: " + str(stderr
))
1248 def email_quote_text (text
):
1249 """Quotes input text by inserting "> "s
1251 This is useful for quoting a text for the reply message. It inserts "> "
1252 strings at the beginning of lines.
1255 text: plain text to quote
1261 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1263 return quoted_message
1266 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1267 """Encrypts and signs plaintext
1269 This encrypts and signs a message.
1272 plaintext: text to sign and ecrypt
1273 encrypt_to_key: the key object to encrypt to
1274 gpgme_ctx: the gpgme context
1277 An encrypted and signed string of text
1280 # the plaintext should be mime encoded in an ascii-compatible form
1281 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1282 encrypted_bytes
= io
.BytesIO()
1284 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1285 plaintext_bytes
, encrypted_bytes
)
1287 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1288 return encrypted_txt
1291 def error (error_msg
):
1292 """Write an error message to stdout
1294 The error message includes the program name.
1297 error_msg: the message to print
1303 An error message is printed to stdout
1306 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1309 def debug (debug_msg
):
1310 """Writes a debug message to stdout if debug == True
1312 If the debug option is set in edward_config.py, then the passed message
1313 gets printed to stdout.
1316 debug_msg: the message to print to stdout
1322 A debug message is printed to stdout
1325 if edward_config
.debug
== True:
1330 """Sets the progname variable and processes optional argument
1332 If there are more than two arguments then edward complains and quits. An
1333 single "-p" argument sets the print_reply_only option, which makes edward
1334 print email replies instead of mailing them.
1340 True if edward should print arguments instead of mailing them,
1341 otherwise it returns False.
1344 Exits with error 1 if there are more than two arguments, otherwise
1345 returns the print_reply_only option.
1349 progname
= sys
.argv
[0]
1351 print_reply_only
= False
1353 if len(sys
.argv
) > 2:
1354 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1355 + " -p print reply message to stdout, do not mail it\n", \
1359 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1360 print_reply_only
= True
1362 return print_reply_only
1365 if __name__
== "__main__":
1366 """Executes main if this file is not loaded interactively"""