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", "fr", "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 'keys' is a list of fingerprints of keys obtained in public key blocks.
159 class ReplyInfo (object):
161 ReplyInfo contains details that edward uses in generating its reply.
163 Instances of this class contain information about whether a message was
164 successfully encrypted or signed, and whether a public key was attached, or
165 retrievable, from the local GPG store. It stores the fingerprints of
166 potential encryption key candidates and the message (if any at all) to
167 quote in edward's reply.
169 'replies' points one of the dictionaries of translated replies.
171 'target_key' refers to the fingerprint of a key used to sign encrypted
172 data. This is the preferred key, if it is set, and if is available.
174 'fallback_target_key' referst to the fingerprint of a key used to sign
175 unencrypted data; alternatively it may be a public key attached to the
178 'msg_to_quote' refers to the part of a message which edward should quote in
179 his reply. This should remain as None if there was no encrypted and singed
180 part. This is to avoid making edward a service for decrypting other
181 people's messages to edward.
183 'success_decrypt' is set to True if edward could decrypt part of the
186 'failed_decrypt' is set to True if edward failed to decrypt part of the
189 'publick_key_received' is set to True if edward successfully imported a
192 'no_public_key' is set to True if edward doesn't have a key to encrypt to
193 when replying to the user.
195 'sig_success' is set to True if edward could to some extent verify the
196 signature of a signed part of the message to edward.
198 'sig_failure' is set to True if edward failed to some extent verify the
199 signature of a signed part of the message to edward.
205 fallback_target_key
= None
208 success_decrypt
= False
209 failed_decrypt
= False
210 public_key_received
= False
211 no_public_key
= False
219 This is the main function for edward, a GPG reply bot.
221 Edward responds to GPG-encrypted and signed mail, encrypting and signing
222 the response if the user's public key is, or was, included in the message.
231 Mime or plaintext email passing in through standard input. Portions of
232 the email may be encrypted. If the To: address contains the text
233 "edward-ja", then the reply will contain a reply written in the
234 Japanese language. There are other languages as well. The default
238 A reply email will be printed to standard output. The contents of the
239 reply email depends on whether the original email was encrypted or not,
240 has or doesn't have a signature, whether a public key used in the
241 original message is provided or locally stored, and the language
242 implied by the To: address in the original email.
245 print_reply_only
= handle_args()
247 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
248 edward_config
.sign_with_key
)
250 email_text
= sys
.stdin
.read()
251 email_struct
= parse_pgp_mime(email_text
, gpgme_ctx
)
253 email_to
, email_from
, email_subject
= email_to_from_subject(email_text
)
254 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
256 replyinfo_obj
= ReplyInfo()
257 replyinfo_obj
.replies
= lang
.replies
259 prepare_for_reply(email_struct
, replyinfo_obj
)
260 encrypt_to_key
= get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
261 reply_plaintext
= write_reply(replyinfo_obj
)
263 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_from
, \
264 email_subject
, encrypt_to_key
,
267 if print_reply_only
== True:
270 send_reply(reply_mime
, email_subject
, email_from
, reply_from
)
273 def get_gpg_context (gnupghome
, sign_with_key_fp
):
275 This function returns the GPG context needed for encryption and signing.
277 The context is needed by other functions which use GPG functionality.
280 gnupghome: The path to "~/.gnupg/" or its alternative.
281 sign_with_key: The fingerprint of the key to sign with
284 A gpgme context to be used for GPG functions.
287 the 'armor' flag is set to True and the list of signing keys contains
288 the single specified key
291 os
.environ
['GNUPGHOME'] = gnupghome
293 gpgme_ctx
= gpgme
.Context()
294 gpgme_ctx
.armor
= True
297 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
298 except gpgme
.GpgmeError
:
299 error("unable to load signing key. is the gnupghome "
300 + "and signing key properly set in the edward_config.py?")
303 gpgme_ctx
.signers
= [sign_with_key
]
308 def parse_pgp_mime (email_text
, gpgme_ctx
):
309 """Parses the email for mime payloads and decrypts/verfies signatures.
311 This function creates a representation of a mime or plaintext email with
312 the EddyMsg class. It then splits each mime payload into one or more pieces
313 which may be plain text or GPG data. It then decrypts encrypted parts and
314 does some very basic signature verification on those parts.
317 email_text: an email message in string format
318 gpgme_ctx: a gpgme context
321 A message as an instance of EddyMsg
324 the returned EddyMsg instance has split, decrypted, verified and pubkey
328 email_struct
= email
.parser
.Parser().parsestr(email_text
)
330 eddymsg_obj
= parse_mime(email_struct
)
331 split_payloads(eddymsg_obj
)
332 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
337 def parse_mime(msg_struct
):
338 """Translates python's email.parser format into an EddyMsg format
340 If the message is multi-part, then a recursive object is created, where
341 each sub-part is also a EddyMsg instance.
344 msg_struct: an email parsed with email.parser.Parser(), which can be
348 an instance of EddyMsg, potentially a recursive one.
351 eddymsg_obj
= EddyMsg()
353 if msg_struct
.is_multipart() == True:
354 payloads
= msg_struct
.get_payload()
356 eddymsg_obj
.multipart
= True
357 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
360 eddymsg_obj
= get_subpart_data(msg_struct
)
365 def scan_and_split (payload_piece
, match_name
, pattern
):
366 """This splits the payloads of an EddyMsg object into GPG and text parts.
368 An EddyMsg object's payload_pieces starts off as a list containing a single
369 PayloadPiece object. This function returns a list of these objects which
370 have been split into GPG data and regular text, if such splits need to be/
374 payload_piece: a single payload or a split part of a payload
375 match_name: the type of data to try to spit out from the payload piece
376 pattern: the search pattern to be used for finding that type of data
379 a list of objects of the PayloadPiece class, in the order that the
380 string part of payload_piece originally was, broken up according to
381 matches specified by 'pattern'.
384 # don't try to re-split pieces containing gpg data
385 if payload_piece
.piece_type
!= TxtType
.text
:
386 return [payload_piece
]
388 flags
= re
.DOTALL | re
.MULTILINE
389 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
390 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
393 pieces
= [payload_piece
]
397 beginning
= PayloadPiece()
398 beginning
.string
= matches
.group('beginning')
399 beginning
.piece_type
= payload_piece
.piece_type
401 match
= PayloadPiece()
402 match
.string
= matches
.group('match')
403 match
.piece_type
= match_name
405 rest
= PayloadPiece()
406 rest
.string
= matches
.group('rest')
407 rest
.piece_type
= payload_piece
.piece_type
409 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
410 pieces
= [beginning
, match
] + more_pieces
415 def get_subpart_data (part
):
416 """This function grabs information from a single part mime object.
418 It copies needed data from a single part email.parser.Parser() object over
419 to an EddyMsg object.
422 part: a non-multi-part mime.parser.Parser() object
425 a single-part EddyMsg() object
428 charset
= part
.get_content_charset()
429 mime_decoded_bytes
= part
.get_payload(decode
=True)
432 obj
.payload_bytes
= part
.as_bytes()
434 obj
.filename
= part
.get_filename()
435 obj
.content_type
= part
.get_content_type()
436 obj
.description_list
= part
['content-description']
438 # your guess is as good as a-myy-ee-ine...
442 if mime_decoded_bytes
!= None:
444 payload
= PayloadPiece()
445 payload
.string
= mime_decoded_bytes
.decode(charset
)
446 payload
.piece_type
= TxtType
.text
448 obj
.payload_pieces
= [payload
]
449 except UnicodeDecodeError:
455 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
456 """A function which maps another function onto a message's subparts.
458 This is a higer-order function which recursively performs a specified
459 function on each subpart of a multi-part message. Each single-part sub-part
460 has the function applied to it. This function also works if the part passed
464 function_to_do: function to perform on sub-parts
465 eddymsg_obj: a single part or multi-part EddyMsg object
466 data: a second argument to pass to 'function_to_do'
472 The passed-in EddyMsg object is transformed recursively on its
473 sub-parts according to 'function_to_do'.
476 if eddymsg_obj
.multipart
== True:
477 for sub
in eddymsg_obj
.subparts
:
478 do_to_eddys_pieces(function_to_do
, sub
, data
)
480 function_to_do(eddymsg_obj
, data
)
483 def split_payloads (eddymsg_obj
):
484 """Splits all (sub-)payloads of a message into GPG data and regular text.
486 Recursively performs payload splitting on all sub-parts of an EddyMsg
487 object into the various GPG data types, such as GPG messages, public key
488 blocks and signed text.
491 eddymsg_obj: an instance of EddyMsg
497 The EddyMsg object has payloads that are unsplit (by may be split)..
500 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
503 for match_pair
in match_pairs
:
504 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
507 def split_payload_pieces (eddymsg_obj
, match_pair
):
508 """A helper function for split_payloads(); works on PayloadPiece objects.
510 This function splits up PayloadPiece objects into multipe PayloadPiece
511 objects and replaces the EddyMsg object's previous list of payload pieces
512 with the new split up one.
515 eddymsg_obj: a single-part EddyMsg object.
516 match_pair: a tuple from the match_pairs list, which specifies a match
517 name and a match pattern.
523 The payload piece(s) of an EddyMsg object may be already split or
527 The EddyMsg object's payload piece(s) are split into a list of pieces
528 if matches of the match_pair are found.
531 (match_name
, pattern
) = match_pair
534 for piece
in eddymsg_obj
.payload_pieces
:
535 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
537 eddymsg_obj
.payload_pieces
= new_pieces_list
540 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
541 """Performs GPG operations on the GPG parts of the message
543 This function decrypts text, verifies signatures, and imports public keys
544 included in an email.
547 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
548 and non-GPG sections by split_payloads()
549 gpgme_ctx: a gpgme context
551 prev_parts: a list of mime parts that occur before the eddymsg_obj
552 part, under the same multi-part mime part. This is used for
553 verifying detached signatures. For the root mime part, this should
554 be an empty list, which is the default value if this paramater is
561 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
564 Decryption, verification and key imports occur. the gpg_data member of
565 PayloadPiece objects get filled in with GPGData objects.
568 if eddymsg_obj
.multipart
== True:
570 for sub
in eddymsg_obj
.subparts
:
571 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
576 for piece
in eddymsg_obj
.payload_pieces
:
578 if piece
.piece_type
== TxtType
.text
:
579 # don't transform the plaintext.
582 elif piece
.piece_type
== TxtType
.message
:
583 (plaintext
, sigs
) = decrypt_block(piece
.string
, gpgme_ctx
)
586 piece
.gpg_data
= GPGData()
587 piece
.gpg_data
.decrypted
= True
588 piece
.gpg_data
.sigs
= sigs
590 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
593 # if not encrypted, check to see if this is an armored signature.
594 (plaintext
, sigs
) = verify_sig_message(piece
.string
, gpgme_ctx
)
597 piece
.piece_type
= TxtType
.signature
598 piece
.gpg_data
= GPGData()
599 piece
.gpg_data
.sigs
= sigs
601 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
603 # FIXME: consider handling pubkeys first, so that signatures can be
604 # validated on freshly imported keys
605 elif piece
.piece_type
== TxtType
.pubkey
:
606 key_fps
= add_gpg_key(piece
.string
, gpgme_ctx
)
609 piece
.gpg_data
= GPGData()
610 piece
.gpg_data
.keys
= key_fps
612 elif piece
.piece_type
== TxtType
.detachedsig
:
613 for prev
in prev_parts
:
614 sig_fps
= verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
617 piece
.gpg_data
= GPGData()
618 piece
.gpg_data
.sigs
= sig_fps
619 piece
.gpg_data
.plainobj
= prev
626 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
627 """Updates replyinfo_obj with info on the message's GPG success/failures
629 This function marks replyinfo_obj with information about whether encrypted
630 text in eddymsg_obj was successfully decrypted, signatures were verified
631 and whether a public key was found or not.
634 eddymsg_obj: a message in the EddyMsg format
635 replyinfo_obj: an instance of ReplyInfo
641 eddymsg_obj has had its gpg_data created by gpg_on_payloads
644 replyinfo_obj has been updated with info about decryption/sig
645 verififcation status, etc. However the desired key isn't imported until
646 later, so the success or failure of that updates the values set here.
649 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
651 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
652 """A helper function for prepare_for_reply
654 It updates replyinfo_obj with GPG success/failure information, when
655 supplied a single-part EddyMsg object.
658 eddymsg_obj: a single-part message in the EddyMsg format
659 replyinfo_obj: an object which holds information about the message's
666 eddymsg_obj is a single-part message. (it may be a part of a multi-part
667 message.) It has had its gpg_data created by gpg_on_payloads if it has
671 replyinfo_obj has been updated with gpg success/failure information
674 for piece
in eddymsg_obj
.payload_pieces
:
675 if piece
.piece_type
== TxtType
.text
:
676 # don't quote the plaintext part.
679 elif piece
.piece_type
== TxtType
.message
:
680 prepare_for_reply_message(piece
, replyinfo_obj
)
682 elif piece
.piece_type
== TxtType
.pubkey
:
683 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
685 elif (piece
.piece_type
== TxtType
.detachedsig
) \
686 or (piece
.piece_type
== TxtType
.signature
):
687 prepare_for_reply_sig(piece
, replyinfo_obj
)
690 def prepare_for_reply_message (piece
, replyinfo_obj
):
691 """Helper function for prepare_for_reply()
693 This function is called when the piece_type of a payload piece is
694 TxtType.message, or GPG Message block. This should be encrypted text. If the
695 encryted block is signed, a sig will be attached to .target_key unless
696 there is already one there.
699 piece: a PayloadPiece object.
700 replyinfo_obj: object which gets updated with decryption status, etc.
707 the piece.payload_piece value should be TxtType.message.
710 replyinfo_obj gets updated with decryption status, signing status and a
711 potential signing key.
714 if piece
.gpg_data
== None:
715 replyinfo_obj
.failed_decrypt
= True
718 replyinfo_obj
.success_decrypt
= True
720 # we already have a key (and a message)
721 if replyinfo_obj
.target_key
!= None:
724 if piece
.gpg_data
.sigs
!= []:
725 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
726 get_signed_part
= False
728 # only include a signed message in the reply.
729 get_signed_part
= True
731 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
733 # to catch public keys in encrypted blocks
734 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
737 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
738 """Helper function for prepare_for_reply(). Marks pubkey import status.
740 Marks replyinfo_obj with pub key import status.
743 piece: a PayloadPiece object
744 replyinfo_obj: a ReplyInfo object
747 piece.piece_type should be set to TxtType.pubkey .
750 replyinfo_obj has its fields updated.
753 if piece
.gpg_data
== None or piece
.gpg_data
.keys
== []:
754 replyinfo_obj
.no_public_key
= True
756 replyinfo_obj
.public_key_received
= True
758 # prefer public key as a fallback for the encrypted reply
759 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
762 def prepare_for_reply_sig (piece
, replyinfo_obj
):
763 """Helper function for prepare_for_reply(). Marks sig verification status.
765 Marks replyinfo_obj with signature verification status.
768 piece: a PayloadPiece object
769 replyinfo_obj: a ReplyInfo object
772 piece.piece_type should be set to TxtType.signature, or
773 TxtType.detachedsig .
776 replyinfo_obj has its fields updated.
779 if piece
.gpg_data
== None or piece
.gpg_data
.sigs
== []:
780 replyinfo_obj
.sig_failure
= True
782 replyinfo_obj
.sig_success
= True
784 if replyinfo_obj
.fallback_target_key
== None:
785 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
788 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
789 """For creating a string representation of a signed, encrypted part.
791 When given a decrypted payload, it will add either the plaintext or signed
792 plaintext to the reply message, depeding on 'get_signed_part'. This is
793 useful for ensuring that the reply message only comes from a signed and
794 ecrypted GPG message. It also sets the target_key for encrypting the reply
795 if it's told to get signed text only.
798 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
800 replyinfo_obj: a ReplyInfo object for holding the message to quote and
801 the target_key to encrypt to.
802 get_signed_part: True if we should only include text that contains a
803 further signature. If False, then include plain text.
809 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
810 which represents decrypted text. It may or may not be signed on that
814 the ReplyInfo instance may have a new 'target_key' set and its
815 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
819 if eddymsg_obj
== None:
822 # recurse on multi-part mime
823 if eddymsg_obj
.multipart
== True:
824 for sub
in eddymsg_obj
.subparts
:
825 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
827 for piece
in eddymsg_obj
.payload_pieces
:
828 if (get_signed_part
):
829 if ((piece
.piece_type
== TxtType
.detachedsig
) \
830 or (piece
.piece_type
== TxtType
.signature
)) \
831 and (piece
.gpg_data
!= None):
832 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
833 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
836 if piece
.piece_type
== TxtType
.text
:
837 replyinfo_obj
.msg_to_quote
+= piece
.string
840 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
841 """Obtains a public key object from a key fingerprint
843 If the .target_key is not set, then we use .fallback_target_key.
846 replyinfo_obj: ReplyInfo instance
847 gpgme_ctx: the gpgme context
850 The key object of the key of either the target_key or the fallback one
851 if .target_key is not set. If the key cannot be loaded, then return
855 Loading a key requires that we have the public key imported. This
856 requires that they email contains the pub key block, or that it was
857 previously sent to edward.
860 If the key cannot be loaded, then the replyinfo_obj is marked for
861 having no public key available.
864 if replyinfo_obj
.target_key
== None:
865 replyinfo_obj
.target_key
= replyinfo_obj
.fallback_target_key
867 if replyinfo_obj
.target_key
!= None:
869 encrypt_to_key
= gpgme_ctx
.get_key(replyinfo_obj
.target_key
)
870 return encrypt_to_key
872 except gpgme
.GpgmeError
:
875 # no available key to use
876 replyinfo_obj
.target_key
= None
877 replyinfo_obj
.fallback_target_key
= None
879 replyinfo_obj
.no_public_key
= True
880 replyinfo_obj
.public_key_received
= False
885 def write_reply (replyinfo_obj
):
886 """Write the reply email body about the GPG successes/failures.
888 The reply is about whether decryption, sig verification and key
889 import/loading was successful or failed. If text was successfully decrypted
890 and verified, then the first instance of such text will be included in
894 replyinfo_obj: contains details of GPG processing status
897 the plaintext message to be sent to the user
900 replyinfo_obj should be populated with info about GPG processing status.
905 if replyinfo_obj
.success_decrypt
== True:
906 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
908 if replyinfo_obj
.no_public_key
== False:
909 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
910 reply_plain
+= quoted_text
912 elif replyinfo_obj
.failed_decrypt
== True:
913 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
916 if replyinfo_obj
.sig_success
== True:
917 reply_plain
+= "\n\n"
918 reply_plain
+= replyinfo_obj
.replies
['sig_success']
920 elif replyinfo_obj
.sig_failure
== True:
921 reply_plain
+= "\n\n"
922 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
925 if replyinfo_obj
.public_key_received
== True:
926 reply_plain
+= "\n\n"
927 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
929 elif replyinfo_obj
.no_public_key
== True:
930 reply_plain
+= "\n\n"
931 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
934 reply_plain
+= "\n\n"
935 reply_plain
+= replyinfo_obj
.replies
['signature']
940 def add_gpg_key (key_block
, gpgme_ctx
):
941 """Adds a GPG pubkey to the local keystore
943 This adds keys received through email into the key store so they can be
947 key_block: the string form of the ascii-armored public key block
948 gpgme_ctx: the gpgme context
951 the fingerprint(s) of the imported key(s)
954 fp
= io
.BytesIO(key_block
.encode('ascii'))
957 result
= gpgme_ctx
.import_(fp
)
958 imports
= result
.imports
959 except gpgme
.GpgmeError
:
962 key_fingerprints
= []
965 for import_
in imports
:
966 fingerprint
= import_
[0]
967 key_fingerprints
+= [fingerprint
]
969 debug("added gpg key: " + fingerprint
)
971 return key_fingerprints
974 def verify_sig_message (msg_block
, gpgme_ctx
):
975 """Verifies the signature of a signed, ascii-armored block of text.
977 It encodes the string into ascii, since binary GPG files are currently
978 unsupported, and alternative, the ascii-armored format is encodable into
982 msg_block: a GPG Message block in string form. It may be encrypted or
983 not. If it is encrypted, it will return empty results.
984 gpgme_ctx: the gpgme context
987 A tuple of the plaintext of the signed part and the list of
988 fingerprints of keys signing the data. If verification failed, perhaps
989 because the message was also encrypted, then empty results are
993 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
994 plain_b
= io
.BytesIO()
997 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
998 except gpgme
.GpgmeError
:
1001 plaintext
= plain_b
.getvalue().decode('utf-8')
1005 fingerprints
+= [sig
.fpr
]
1006 return (plaintext
, fingerprints
)
1009 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1010 """Verifies the signature of a detached signature.
1012 This requires the signature part and the signed part as separate arguments.
1015 detached_sig: the signature part of the detached signature
1016 plaintext_bytes: the byte form of the message being signed.
1017 gpgme_ctx: the gpgme context
1020 A list of signing fingerprints if the signature verification was
1021 sucessful. Otherwise, an empty list is returned.
1024 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1025 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1028 result
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1029 except gpgme
.GpgmeError
:
1032 sig_fingerprints
= []
1034 sig_fingerprints
+= [res_
.fpr
]
1036 return sig_fingerprints
1039 def decrypt_block (msg_block
, gpgme_ctx
):
1040 """Decrypts a block of GPG text, and verifies any included sigatures.
1042 Some encypted messages have embeded signatures, so those are verified too.
1045 msg_block: the encrypted(/signed) text
1046 gpgme_ctx: the gpgme context
1049 A tuple of plaintext and signatures, if the decryption and signature
1050 verification were successful, respectively.
1053 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1054 plain_b
= io
.BytesIO()
1057 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1058 except gpgme
.GpgmeError
:
1061 plaintext
= plain_b
.getvalue().decode('utf-8')
1065 fingerprints
+= [sig
.fpr
]
1066 return (plaintext
, fingerprints
)
1069 def email_to_from_subject (email_text
):
1070 """Returns the values of the email's To:, From: and Subject: fields
1072 Returns this information from an email.
1075 email_text: the string form of the email
1078 the email To:, From:, and Subject: fields as strings
1081 email_struct
= email
.parser
.Parser().parsestr(email_text
)
1083 email_to
= email_struct
['To']
1084 email_from
= email_struct
['From']
1085 email_subject
= email_struct
['Subject']
1087 return email_to
, email_from
, email_subject
1090 def import_lang_pick_address(email_to
, hostname
):
1091 """Imports language file for i18n support; makes reply from address
1093 The language imported depends on the To: address of the email received by
1094 edward. an -en ending implies the English language, whereas a -ja ending
1095 implies Japanese. The list of supported languages is listed in the 'langs'
1096 list at the beginning of the program. This function also chooses the
1097 language-dependent address which can be used as the From address in the
1101 email_to: the string containing the email address that the mail was
1103 hostname: the hostname part of the reply email's from address
1106 the reference to the imported language module. The only variable in
1107 this file is the 'replies' dictionary.
1113 if email_to
!= None:
1115 if "edward-" + lang
in email_to
:
1119 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1120 lang_module
= importlib
.import_module(lang_mod_name
)
1122 reply_from
= "edward-" + use_lang
+ "@" + hostname
1124 return lang_module
, reply_from
1127 def generate_encrypted_mime (plaintext
, email_to
, email_subject
, encrypt_to_key
,
1129 """This function creates the mime email reply. It can encrypt the email.
1131 If the encrypt_key is included, then the email is encrypted and signed.
1132 Otherwise it is unencrypted.
1135 plaintext: the plaintext body of the message to create.
1136 email_to: the email address to reply to
1137 email_subject: the subject to use in reply
1138 encrypt_to_key: the key object to use for encrypting the email. (or
1140 gpgme_ctx: the gpgme context
1143 A string version of the mime message, possibly encrypted and signed.
1146 if (encrypt_to_key
!= None):
1148 # quoted printable encoding lets most ascii characters look normal
1149 # before the mime message is decoded.
1150 char_set
= email
.charset
.Charset("utf-8")
1151 char_set
.body_encoding
= email
.charset
.QP
1153 # MIMEText doesn't allow setting the text encoding
1154 # so we use MIMENonMultipart.
1155 plaintext_mime
= MIMENonMultipart('text', 'plain')
1156 plaintext_mime
.set_payload(plaintext
, charset
=char_set
)
1158 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1162 control_mime
= MIMEApplication("Version: 1",
1163 _subtype
='pgp-encrypted',
1164 _encoder
=email
.encoders
.encode_7or8bit
)
1165 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1166 control_mime
.set_charset('us-ascii')
1168 encoded_mime
= MIMEApplication(encrypted_text
,
1169 _subtype
='octet-stream; name="encrypted.asc"',
1170 _encoder
=email
.encoders
.encode_7or8bit
)
1171 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1172 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1173 encoded_mime
.set_charset('us-ascii')
1175 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1176 message_mime
.attach(control_mime
)
1177 message_mime
.attach(encoded_mime
)
1178 message_mime
['Content-Disposition'] = 'inline'
1181 message_mime
= MIMEText(plaintext
)
1183 message_mime
['To'] = email_to
1184 message_mime
['Subject'] = email_subject
1186 reply
= message_mime
.as_string()
1191 def send_reply(email_txt
, subject
, reply_to
, reply_from
):
1193 email_bytes
= email_txt
.encode('ascii')
1195 p
= subprocess
.Popen(["/usr/sbin/sendmail", "-f", reply_from
, "-F", "Edward, GPG Bot", "-i", reply_to
], stdin
=subprocess
.PIPE
)
1197 (stdout
, stderr
) = p
.communicate(email_bytes
)
1200 debug("sendmail stdout: " + str(stdout
))
1202 error("sendmail stderr: " + str(stderr
))
1205 def email_quote_text (text
):
1206 """Quotes input text by inserting "> "s
1208 This is useful for quoting a text for the reply message. It inserts "> "
1209 strings at the beginning of lines.
1212 text: plain text to quote
1218 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1220 return quoted_message
1223 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1224 """Encrypts and signs plaintext
1226 This encrypts and signs a message.
1229 plaintext: text to sign and ecrypt
1230 encrypt_to_key: the key object to encrypt to
1231 gpgme_ctx: the gpgme context
1234 An encrypted and signed string of text
1237 # the plaintext should be mime encoded in an ascii-compatible form
1238 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1239 encrypted_bytes
= io
.BytesIO()
1241 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1242 plaintext_bytes
, encrypted_bytes
)
1244 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1245 return encrypted_txt
1248 def error (error_msg
):
1249 """Write an error message to stdout
1251 The error message includes the program name.
1254 error_msg: the message to print
1260 An error message is printed to stdout
1263 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1266 def debug (debug_msg
):
1267 """Writes a debug message to stdout if debug == True
1269 If the debug option is set in edward_config.py, then the passed message
1270 gets printed to stdout.
1273 debug_msg: the message to print to stdout
1279 A debug message is printed to stdout
1282 if edward_config
.debug
== True:
1287 """Sets the progname variable and processes optional argument
1289 If there are more than two arguments then edward complains and quits. An
1290 single "-p" argument sets the print_reply_only option, which makes edward
1291 print email replies instead of mailing them.
1297 True if edward should print arguments instead of mailing them,
1298 otherwise it returns False.
1301 Exits with error 1 if there are more than two arguments, otherwise
1302 returns the print_reply_only option.
1306 progname
= sys
.argv
[0]
1308 print_reply_only
= False
1310 if len(sys
.argv
) > 2:
1311 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1312 + " -p print reply message to stdout, do not mail it\n", \
1316 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1317 print_reply_only
= True
1319 return print_reply_only
1322 if __name__
== "__main__":
1323 """Executes main if this file is not loaded interactively"""