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 'sig_failure' is set to True if edward could not verify a siganture.
197 'pubkey_success' is set to True if edward successfully imported a public
200 'sigkey_missing' is set to True if edward doesn't have the public key
201 needed for signature verification.
203 'have_repy_key' is set to True if edward has a public key to encrypt its
210 fallback_target_key
= None
211 encrypt_to_key
= None
214 decrypt_success
= False
216 pubkey_success
= False
218 decrypt_failure
= False
220 sigkey_missing
= False
222 have_reply_key
= False
228 This is the main function for edward, a GPG reply bot.
230 Edward responds to GPG-encrypted and signed mail, encrypting and signing
231 the response if the user's public key is, or was, included in the message.
240 Mime or plaintext email passing in through standard input. Portions of
241 the email may be encrypted. If the To: address contains the text
242 "edward-ja", then the reply will contain a reply written in the
243 Japanese language. There are other languages as well. The default
247 A reply email will be printed to standard output. The contents of the
248 reply email depends on whether the original email was encrypted or not,
249 has or doesn't have a signature, whether a public key used in the
250 original message is provided or locally stored, and the language
251 implied by the To: address in the original email.
254 print_reply_only
= handle_args()
256 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
257 edward_config
.sign_with_key
)
259 email_bytes
= sys
.stdin
.buffer.read()
260 email_struct
= parse_pgp_mime(email_bytes
, gpgme_ctx
)
262 email_to
, email_from
, email_subject
= email_to_from_subject(email_bytes
)
263 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
265 replyinfo_obj
= ReplyInfo()
266 replyinfo_obj
.replies
= lang
.replies
268 prepare_for_reply(email_struct
, replyinfo_obj
)
269 get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
270 reply_plaintext
= write_reply(replyinfo_obj
)
272 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_from
, \
273 email_subject
, replyinfo_obj
.encrypt_to_key
,
276 if print_reply_only
== True:
279 send_reply(reply_mime
, email_subject
, email_from
, reply_from
)
282 def get_gpg_context (gnupghome
, sign_with_key_fp
):
284 This function returns the GPG context needed for encryption and signing.
286 The context is needed by other functions which use GPG functionality.
289 gnupghome: The path to "~/.gnupg/" or its alternative.
290 sign_with_key: The fingerprint of the key to sign with
293 A gpgme context to be used for GPG functions.
296 the 'armor' flag is set to True and the list of signing keys contains
297 the single specified key
300 os
.environ
['GNUPGHOME'] = gnupghome
302 gpgme_ctx
= gpgme
.Context()
303 gpgme_ctx
.armor
= True
306 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
307 except gpgme
.GpgmeError
:
308 error("unable to load signing key. is the gnupghome "
309 + "and signing key properly set in the edward_config.py?")
312 gpgme_ctx
.signers
= [sign_with_key
]
317 def parse_pgp_mime (email_bytes
, gpgme_ctx
):
318 """Parses the email for mime payloads and decrypts/verfies signatures.
320 This function creates a representation of a mime or plaintext email with
321 the EddyMsg class. It then splits each mime payload into one or more pieces
322 which may be plain text or GPG data. It then decrypts encrypted parts and
323 does some very basic signature verification on those parts.
326 email_bytes: an email message in byte string format
327 gpgme_ctx: a gpgme context
330 A message as an instance of EddyMsg
333 the returned EddyMsg instance has split, decrypted, verified and pubkey
337 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
339 eddymsg_obj
= parse_mime(email_struct
)
340 split_payloads(eddymsg_obj
)
341 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
346 def parse_mime(msg_struct
):
347 """Translates python's email.parser format into an EddyMsg format
349 If the message is multi-part, then a recursive object is created, where
350 each sub-part is also a EddyMsg instance.
353 msg_struct: an email parsed with email.parser.Parser(), which can be
357 an instance of EddyMsg, potentially a recursive one.
360 eddymsg_obj
= EddyMsg()
362 if msg_struct
.is_multipart() == True:
363 payloads
= msg_struct
.get_payload()
365 eddymsg_obj
.multipart
= True
366 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
369 eddymsg_obj
= get_subpart_data(msg_struct
)
374 def scan_and_split (payload_piece
, match_name
, pattern
):
375 """This splits the payloads of an EddyMsg object into GPG and text parts.
377 An EddyMsg object's payload_pieces starts off as a list containing a single
378 PayloadPiece object. This function returns a list of these objects which
379 have been split into GPG data and regular text, if such splits need to be/
383 payload_piece: a single payload or a split part of a payload
384 match_name: the type of data to try to spit out from the payload piece
385 pattern: the search pattern to be used for finding that type of data
388 a list of objects of the PayloadPiece class, in the order that the
389 string part of payload_piece originally was, broken up according to
390 matches specified by 'pattern'.
393 # don't try to re-split pieces containing gpg data
394 if payload_piece
.piece_type
!= TxtType
.text
:
395 return [payload_piece
]
397 flags
= re
.DOTALL | re
.MULTILINE
398 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
399 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
402 pieces
= [payload_piece
]
406 beginning
= PayloadPiece()
407 beginning
.string
= matches
.group('beginning')
408 beginning
.piece_type
= payload_piece
.piece_type
410 match
= PayloadPiece()
411 match
.string
= matches
.group('match')
412 match
.piece_type
= match_name
414 rest
= PayloadPiece()
415 rest
.string
= matches
.group('rest')
416 rest
.piece_type
= payload_piece
.piece_type
418 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
419 pieces
= [beginning
, match
] + more_pieces
424 def get_subpart_data (part
):
425 """This function grabs information from a single part mime object.
427 It copies needed data from a single part email.parser.Parser() object over
428 to an EddyMsg object.
431 part: a non-multi-part mime.parser.Parser() object
434 a single-part EddyMsg() object
439 mime_decoded_bytes
= part
.get_payload(decode
=True)
440 charset
= part
.get_content_charset()
442 # your guess is as good as a-myy-ee-ine...
446 payload_string
= part
.as_string()
447 if payload_string
!= None:
448 obj
.payload_bytes
= payload_string
.encode(charset
)
450 obj
.filename
= part
.get_filename()
451 obj
.content_type
= part
.get_content_type()
452 obj
.description_list
= part
['content-description']
454 if mime_decoded_bytes
!= None:
456 payload
= PayloadPiece()
457 payload
.string
= mime_decoded_bytes
.decode(charset
)
458 payload
.piece_type
= TxtType
.text
460 obj
.payload_pieces
= [payload
]
461 except UnicodeDecodeError:
467 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
468 """A function which maps another function onto a message's subparts.
470 This is a higer-order function which recursively performs a specified
471 function on each subpart of a multi-part message. Each single-part sub-part
472 has the function applied to it. This function also works if the part passed
476 function_to_do: function to perform on sub-parts
477 eddymsg_obj: a single part or multi-part EddyMsg object
478 data: a second argument to pass to 'function_to_do'
484 The passed-in EddyMsg object is transformed recursively on its
485 sub-parts according to 'function_to_do'.
488 if eddymsg_obj
.multipart
== True:
489 for sub
in eddymsg_obj
.subparts
:
490 do_to_eddys_pieces(function_to_do
, sub
, data
)
492 function_to_do(eddymsg_obj
, data
)
495 def split_payloads (eddymsg_obj
):
496 """Splits all (sub-)payloads of a message into GPG data and regular text.
498 Recursively performs payload splitting on all sub-parts of an EddyMsg
499 object into the various GPG data types, such as GPG messages, public key
500 blocks and signed text.
503 eddymsg_obj: an instance of EddyMsg
509 The EddyMsg object has payloads that are unsplit (by may be split)..
512 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
515 for match_pair
in match_pairs
:
516 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
519 def split_payload_pieces (eddymsg_obj
, match_pair
):
520 """A helper function for split_payloads(); works on PayloadPiece objects.
522 This function splits up PayloadPiece objects into multipe PayloadPiece
523 objects and replaces the EddyMsg object's previous list of payload pieces
524 with the new split up one.
527 eddymsg_obj: a single-part EddyMsg object.
528 match_pair: a tuple from the match_pairs list, which specifies a match
529 name and a match pattern.
535 The payload piece(s) of an EddyMsg object may be already split or
539 The EddyMsg object's payload piece(s) are split into a list of pieces
540 if matches of the match_pair are found.
543 (match_name
, pattern
) = match_pair
546 for piece
in eddymsg_obj
.payload_pieces
:
547 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
549 eddymsg_obj
.payload_pieces
= new_pieces_list
552 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
553 """Performs GPG operations on the GPG parts of the message
555 This function decrypts text, verifies signatures, and imports public keys
556 included in an email.
559 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
560 and non-GPG sections by split_payloads()
561 gpgme_ctx: a gpgme context
563 prev_parts: a list of mime parts that occur before the eddymsg_obj
564 part, under the same multi-part mime part. This is used for
565 verifying detached signatures. For the root mime part, this should
566 be an empty list, which is the default value if this paramater is
573 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
576 Decryption, verification and key imports occur. the gpg_data member of
577 PayloadPiece objects get filled in with GPGData objects.
580 if eddymsg_obj
.multipart
== True:
582 for sub
in eddymsg_obj
.subparts
:
583 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
588 for piece
in eddymsg_obj
.payload_pieces
:
590 if piece
.piece_type
== TxtType
.text
:
591 # don't transform the plaintext.
594 elif piece
.piece_type
== TxtType
.message
:
595 piece
.gpg_data
= GPGData()
597 (plaintext_b
, sigs
, sigkey_missing
) = decrypt_block(piece
.string
, gpgme_ctx
)
599 piece
.gpg_data
.sigkey_missing
= sigkey_missing
602 piece
.gpg_data
.decrypted
= True
603 piece
.gpg_data
.sigs
= sigs
605 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
608 # if not encrypted, check to see if this is an armored signature.
609 (plaintext_b
, sigs
, sigkey_missing
) = verify_sig_message(piece
.string
, gpgme_ctx
)
611 piece
.gpg_data
.sigkey_missing
= sigkey_missing
614 piece
.piece_type
= TxtType
.signature
615 piece
.gpg_data
.sigs
= sigs
617 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
619 elif piece
.piece_type
== TxtType
.pubkey
:
620 key_fps
= add_gpg_key(piece
.string
, gpgme_ctx
)
623 piece
.gpg_data
= GPGData()
624 piece
.gpg_data
.keys
= key_fps
626 elif piece
.piece_type
== TxtType
.detachedsig
:
627 piece
.gpg_data
= GPGData()
629 for prev
in prev_parts
:
630 (sig_fps
, sigkey_missing
) = verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
632 piece
.gpg_data
.sigkey_missing
= sigkey_missing
635 piece
.gpg_data
.sigs
= sig_fps
636 piece
.gpg_data
.plainobj
= prev
643 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
644 """Updates replyinfo_obj with info on the message's GPG success/failures
646 This function marks replyinfo_obj with information about whether encrypted
647 text in eddymsg_obj was successfully decrypted, signatures were verified
648 and whether a public key was found or not.
651 eddymsg_obj: a message in the EddyMsg format
652 replyinfo_obj: an instance of ReplyInfo
658 eddymsg_obj has had its gpg_data created by gpg_on_payloads
661 replyinfo_obj has been updated with info about decryption/sig
662 verififcation status, etc. However the desired key isn't imported until
663 later, so the success or failure of that updates the values set here.
666 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
668 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
669 """A helper function for prepare_for_reply
671 It updates replyinfo_obj with GPG success/failure information, when
672 supplied a single-part EddyMsg object.
675 eddymsg_obj: a single-part message in the EddyMsg format
676 replyinfo_obj: an object which holds information about the message's
683 eddymsg_obj is a single-part message. (it may be a part of a multi-part
684 message.) It has had its gpg_data created by gpg_on_payloads if it has
688 replyinfo_obj has been updated with gpg success/failure information
691 for piece
in eddymsg_obj
.payload_pieces
:
692 if piece
.piece_type
== TxtType
.text
:
693 # don't quote the plaintext part.
696 elif piece
.piece_type
== TxtType
.message
:
697 prepare_for_reply_message(piece
, replyinfo_obj
)
699 elif piece
.piece_type
== TxtType
.pubkey
:
700 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
702 elif (piece
.piece_type
== TxtType
.detachedsig
) \
703 or (piece
.piece_type
== TxtType
.signature
):
704 prepare_for_reply_sig(piece
, replyinfo_obj
)
707 def prepare_for_reply_message (piece
, replyinfo_obj
):
708 """Helper function for prepare_for_reply()
710 This function is called when the piece_type of a payload piece is
711 TxtType.message, or GPG Message block. This should be encrypted text. If
712 the encryted block is correclty signed, a sig will be attached to
713 .target_key unless there is already one there.
716 piece: a PayloadPiece object.
717 replyinfo_obj: object which gets updated with decryption status, etc.
723 the piece.payload_piece value should be TxtType.message.
726 replyinfo_obj gets updated with decryption status, signing status, a
727 potential signing key, and posession status of the public key for the
731 if piece
.gpg_data
== None or piece
.gpg_data
.plainobj
== None:
732 replyinfo_obj
.decrypt_failure
= True
735 replyinfo_obj
.decrypt_success
= True
737 # we already have a key (and a message)
738 if replyinfo_obj
.target_key
!= None:
741 if piece
.gpg_data
.sigs
!= []:
742 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
743 replyinfo_obj
.sig_success
= True
744 get_signed_part
= False
747 if piece
.gpg_data
.sigkey_missing
== True:
748 replyinfo_obj
.sigkey_missing
= True
750 # only include a signed message in the reply.
751 get_signed_part
= True
753 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
755 # to catch public keys in encrypted blocks
756 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
759 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
760 """Helper function for prepare_for_reply(). Marks pubkey import status.
762 Marks replyinfo_obj with pub key import status.
765 piece: a PayloadPiece object
766 replyinfo_obj: a ReplyInfo object
769 piece.piece_type should be set to TxtType.pubkey .
772 replyinfo_obj has its fields updated.
775 if piece
.gpg_data
== None or piece
.gpg_data
.keys
== []:
778 replyinfo_obj
.pubkey_success
= True
780 # prefer public key as a fallback for the encrypted reply
781 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
784 def prepare_for_reply_sig (piece
, replyinfo_obj
):
785 """Helper function for prepare_for_reply(). Marks sig verification status.
787 Marks replyinfo_obj with signature verification status.
790 piece: a PayloadPiece object
791 replyinfo_obj: a ReplyInfo object
794 piece.piece_type should be set to TxtType.signature, or
795 TxtType.detachedsig .
798 replyinfo_obj has its fields updated.
801 if piece
.gpg_data
== None or piece
.gpg_data
.sigs
== []:
802 replyinfo_obj
.sig_failure
= True
804 if piece
.gpg_data
.sigkey_missing
== True:
805 replyinfo_obj
.sigkey_missing
= True
808 replyinfo_obj
.sig_success
= True
810 if replyinfo_obj
.fallback_target_key
== None:
811 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
813 if (piece
.piece_type
== TxtType
.signature
):
814 # to catch public keys in signature blocks
815 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
818 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
819 """For creating a string representation of a signed, encrypted part.
821 When given a decrypted payload, it will add either the plaintext or signed
822 plaintext to the reply message, depeding on 'get_signed_part'. This is
823 useful for ensuring that the reply message only comes from a signed and
824 ecrypted GPG message. It also sets the target_key for encrypting the reply
825 if it's told to get signed text only.
828 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
830 replyinfo_obj: a ReplyInfo object for holding the message to quote and
831 the target_key to encrypt to.
832 get_signed_part: True if we should only include text that contains a
833 further signature. If False, then include plain text.
839 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
840 which represents decrypted text. It may or may not be signed on that
844 the ReplyInfo instance may have a new 'target_key' set and its
845 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
849 if eddymsg_obj
== None:
852 # recurse on multi-part mime
853 if eddymsg_obj
.multipart
== True:
854 for sub
in eddymsg_obj
.subparts
:
855 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
857 for piece
in eddymsg_obj
.payload_pieces
:
858 if (get_signed_part
):
859 if ((piece
.piece_type
== TxtType
.detachedsig
) \
860 or (piece
.piece_type
== TxtType
.signature
)) \
861 and (piece
.gpg_data
!= None) \
862 and (piece
.gpg_data
.plainobj
!= None):
863 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
864 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
867 if piece
.piece_type
== TxtType
.text
:
868 replyinfo_obj
.msg_to_quote
+= piece
.string
871 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
872 """Obtains a public key object from a key fingerprint
874 If the .target_key is not set, then we use .fallback_target_key, if
878 replyinfo_obj: ReplyInfo instance
879 gpgme_ctx: the gpgme context
882 The key object of the key of either the target_key or the fallback one
883 if .target_key is not set. If the key cannot be loaded, then return
887 Loading a key requires that we have the public key imported. This
888 requires that they email contains the pub key block, or that it was
889 previously sent to edward.
892 If the key can be loaded, then replyinfo_obj.reply_to_key points to the
893 public key object. If the key cannot be loaded, then the replyinfo_obj
894 is marked as having no public key available.
897 for key
in (replyinfo_obj
.target_key
, replyinfo_obj
.fallback_target_key
):
900 encrypt_to_key
= gpgme_ctx
.get_key(key
)
901 replyinfo_obj
.encrypt_to_key
= encrypt_to_key
902 replyinfo_obj
.have_reply_key
= True
905 except gpgme
.GpgmeError
:
909 def write_reply (replyinfo_obj
):
910 """Write the reply email body about the GPG successes/failures.
912 The reply is about whether decryption, sig verification and key
913 import/loading was successful or failed. If text was successfully decrypted
914 and verified, then the first instance of such text will be included in
918 replyinfo_obj: contains details of GPG processing status
921 the plaintext message to be sent to the user
924 replyinfo_obj should be populated with info about GPG processing status.
929 if (replyinfo_obj
.pubkey_success
== True):
930 reply_plain
+= replyinfo_obj
.replies
['greeting']
931 reply_plain
+= "\n\n"
934 if replyinfo_obj
.decrypt_success
== True:
935 debug('decrypt success')
936 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
938 if (replyinfo_obj
.sig_success
== True) and (replyinfo_obj
.have_reply_key
== True):
939 debug('message quoted')
940 reply_plain
+= replyinfo_obj
.replies
['space']
941 reply_plain
+= replyinfo_obj
.replies
['quote_follows']
942 reply_plain
+= "\n\n"
943 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
944 reply_plain
+= quoted_text
946 reply_plain
+= "\n\n"
948 elif replyinfo_obj
.decrypt_failure
== True:
949 debug('decrypt failure')
950 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
951 reply_plain
+= "\n\n"
954 if replyinfo_obj
.sig_success
== True:
955 debug('signature success')
956 reply_plain
+= replyinfo_obj
.replies
['sig_success']
957 reply_plain
+= "\n\n"
959 elif replyinfo_obj
.sig_failure
== True:
960 debug('signature failure')
961 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
962 reply_plain
+= "\n\n"
965 if (replyinfo_obj
.pubkey_success
== True):
966 debug('public key received')
967 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
968 reply_plain
+= "\n\n"
970 elif (replyinfo_obj
.sigkey_missing
== True):
971 debug('no public key')
972 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
973 reply_plain
+= "\n\n"
976 if (reply_plain
== ""):
977 debug('plaintext message')
978 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
979 reply_plain
+= "\n\n"
982 reply_plain
+= replyinfo_obj
.replies
['signature']
983 reply_plain
+= "\n\n"
988 def add_gpg_key (key_block
, gpgme_ctx
):
989 """Adds a GPG pubkey to the local keystore
991 This adds keys received through email into the key store so they can be
995 key_block: the string form of the ascii-armored public key block
996 gpgme_ctx: the gpgme context
999 the fingerprint(s) of the imported key(s)
1002 fp
= io
.BytesIO(key_block
.encode('ascii'))
1005 result
= gpgme_ctx
.import_(fp
)
1006 imports
= result
.imports
1007 except gpgme
.GpgmeError
:
1010 key_fingerprints
= []
1013 for import_
in imports
:
1014 fingerprint
= import_
[0]
1015 key_fingerprints
+= [fingerprint
]
1017 debug("added gpg key: " + fingerprint
)
1019 return key_fingerprints
1022 def verify_sig_message (msg_block
, gpgme_ctx
):
1023 """Verifies the signature of a signed, ascii-armored block of text.
1025 It encodes the string into ascii, since binary GPG files are currently
1026 unsupported, and alternative, the ascii-armored format is encodable into
1030 msg_block: a GPG Message block in string form. It may be encrypted or
1031 not. If it is encrypted, it will return empty results.
1032 gpgme_ctx: the gpgme context
1035 A tuple containing the plaintext bytes of the signed part, the list of
1036 fingerprints of keys signing the data, and a boolean marking whether
1037 edward is missing all public keys for validating any of the signatures.
1038 If verification failed, perhaps because the message was also encrypted,
1039 then empty results are returned.
1042 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1043 plain_b
= io
.BytesIO()
1046 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
1047 except gpgme
.GpgmeError
:
1048 return ("",[],False)
1050 plaintext_b
= plain_b
.getvalue()
1052 sigkey_missing
= False
1055 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1056 fingerprints
+= [sig
.fpr
]
1057 sigkey_missing
= False
1060 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1061 sigkey_missing
= True
1063 return (plaintext_b
, fingerprints
, sigkey_missing
)
1066 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1067 """Verifies the signature of a detached signature.
1069 This requires the signature part and the signed part as separate arguments.
1072 detached_sig: the signature part of the detached signature
1073 plaintext_bytes: the byte form of the message being signed.
1074 gpgme_ctx: the gpgme context
1077 A tuple containging a list of signing fingerprints if the signature
1078 verification was sucessful, and a boolean marking whether edward is
1079 missing all public keys for validating any of the signatures.
1080 Otherwise, a tuple containing an empty list and True are returned.
1083 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1084 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1087 result
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1088 except gpgme
.GpgmeError
:
1091 sigkey_missing
= False
1092 sig_fingerprints
= []
1094 if (res_
.summary
== 0) or (res_
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (res_
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1095 sig_fingerprints
+= [res_
.fpr
]
1096 sigkey_missing
= False
1099 if (res_
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1100 sigkey_missing
= True
1102 return (sig_fingerprints
, sigkey_missing
)
1105 def decrypt_block (msg_block
, gpgme_ctx
):
1106 """Decrypts a block of GPG text and verifies any included sigatures.
1108 Some encypted messages have embeded signatures, so those are verified too.
1111 msg_block: the encrypted(/signed) text
1112 gpgme_ctx: the gpgme context
1115 A tuple containing plaintext bytes, signatures (if the decryption and
1116 signature verification were successful, respectively), and a boolean
1117 marking whether edward is missing all public keys for validating any of
1121 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1122 plain_b
= io
.BytesIO()
1125 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1126 except gpgme
.GpgmeError
:
1127 return ("",[],False)
1129 plaintext_b
= plain_b
.getvalue()
1131 sigkey_missing
= False
1134 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1135 fingerprints
+= [sig
.fpr
]
1136 sigkey_missing
= False
1139 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1140 sigkey_missing
= True
1142 return (plaintext_b
, fingerprints
, sigkey_missing
)
1145 def email_to_from_subject (email_bytes
):
1146 """Returns the values of the email's To:, From: and Subject: fields
1148 Returns this information from an email.
1151 email_bytes: the byte string form of the email
1154 the email To:, From:, and Subject: fields as strings
1157 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
1159 email_to
= email_struct
['To']
1160 email_from
= email_struct
['From']
1161 email_subject
= email_struct
['Subject']
1163 return email_to
, email_from
, email_subject
1166 def import_lang_pick_address(email_to
, hostname
):
1167 """Imports language file for i18n support; makes reply from address
1169 The language imported depends on the To: address of the email received by
1170 edward. an -en ending implies the English language, whereas a -ja ending
1171 implies Japanese. The list of supported languages is listed in the 'langs'
1172 list at the beginning of the program. This function also chooses the
1173 language-dependent address which can be used as the From address in the
1177 email_to: the string containing the email address that the mail was
1179 hostname: the hostname part of the reply email's from address
1182 the reference to the imported language module. The only variable in
1183 this file is the 'replies' dictionary.
1189 if email_to
!= None:
1191 if "edward-" + lang
in email_to
:
1195 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1196 lang_module
= importlib
.import_module(lang_mod_name
)
1198 reply_from
= "edward-" + use_lang
+ "@" + hostname
1200 return lang_module
, reply_from
1203 def generate_encrypted_mime (plaintext
, email_to
, email_subject
, encrypt_to_key
,
1205 """This function creates the mime email reply. It can encrypt the email.
1207 If the encrypt_key is included, then the email is encrypted and signed.
1208 Otherwise it is unencrypted.
1211 plaintext: the plaintext body of the message to create.
1212 email_to: the email address to reply to
1213 email_subject: the subject to use in reply
1214 encrypt_to_key: the key object to use for encrypting the email. (or
1216 gpgme_ctx: the gpgme context
1219 A string version of the mime message, possibly encrypted and signed.
1222 if (encrypt_to_key
!= None):
1224 plaintext_mime
= MIMEText(plaintext
)
1225 plaintext_mime
.set_charset('utf-8')
1227 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1231 control_mime
= MIMEApplication("Version: 1",
1232 _subtype
='pgp-encrypted',
1233 _encoder
=email
.encoders
.encode_7or8bit
)
1234 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1235 control_mime
.set_charset('us-ascii')
1237 encoded_mime
= MIMEApplication(encrypted_text
,
1238 _subtype
='octet-stream; name="encrypted.asc"',
1239 _encoder
=email
.encoders
.encode_7or8bit
)
1240 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1241 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1242 encoded_mime
.set_charset('us-ascii')
1244 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1245 message_mime
.attach(control_mime
)
1246 message_mime
.attach(encoded_mime
)
1247 message_mime
['Content-Disposition'] = 'inline'
1250 message_mime
= MIMEText(plaintext
)
1251 message_mime
.set_charset('utf-8')
1253 message_mime
['To'] = email_to
1254 message_mime
['Subject'] = email_subject
1256 reply
= message_mime
.as_string()
1261 def send_reply(email_txt
, subject
, reply_to
, reply_from
):
1263 email_bytes
= email_txt
.encode('ascii')
1265 p
= subprocess
.Popen(["/usr/sbin/sendmail", "-f", reply_from
, "-F", "Edward, GPG Bot", "-i", reply_to
], stdin
=subprocess
.PIPE
)
1267 (stdout
, stderr
) = p
.communicate(email_bytes
)
1270 debug("sendmail stdout: " + str(stdout
))
1272 error("sendmail stderr: " + str(stderr
))
1275 def email_quote_text (text
):
1276 """Quotes input text by inserting "> "s
1278 This is useful for quoting a text for the reply message. It inserts "> "
1279 strings at the beginning of lines.
1282 text: plain text to quote
1288 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1290 return quoted_message
1293 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1294 """Encrypts and signs plaintext
1296 This encrypts and signs a message.
1299 plaintext: text to sign and ecrypt
1300 encrypt_to_key: the key object to encrypt to
1301 gpgme_ctx: the gpgme context
1304 An encrypted and signed string of text
1307 # the plaintext should be mime encoded in an ascii-compatible form
1308 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1309 encrypted_bytes
= io
.BytesIO()
1311 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1312 plaintext_bytes
, encrypted_bytes
)
1314 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1315 return encrypted_txt
1318 def error (error_msg
):
1319 """Write an error message to stdout
1321 The error message includes the program name.
1324 error_msg: the message to print
1330 An error message is printed to stdout
1333 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1336 def debug (debug_msg
):
1337 """Writes a debug message to stdout if debug == True
1339 If the debug option is set in edward_config.py, then the passed message
1340 gets printed to stdout.
1343 debug_msg: the message to print to stdout
1349 A debug message is printed to stdout
1352 if edward_config
.debug
== True:
1357 """Sets the progname variable and processes optional argument
1359 If there are more than two arguments then edward complains and quits. An
1360 single "-p" argument sets the print_reply_only option, which makes edward
1361 print email replies instead of mailing them.
1367 True if edward should print arguments instead of mailing them,
1368 otherwise it returns False.
1371 Exits with error 1 if there are more than two arguments, otherwise
1372 returns the print_reply_only option.
1376 progname
= sys
.argv
[0]
1378 print_reply_only
= False
1380 if len(sys
.argv
) > 2:
1381 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1382 + " -p print reply message to stdout, do not mail it\n", \
1386 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1387 print_reply_only
= True
1389 return print_reply_only
1392 if __name__
== "__main__":
1393 """Executes main if this file is not loaded interactively"""