797fc92bfd22ec4c8861ffcfa6c199c88de3724d
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 'sig_failure' is a boolean noting whether any signatures failed to verify.
151 'keys' is a list of fingerprints of keys obtained in public key blocks.
162 class ReplyInfo (object):
164 ReplyInfo contains details that edward uses in generating its reply.
166 Instances of this class contain information about whether a message was
167 successfully encrypted or signed, and whether a public key was attached, or
168 retrievable, from the local GPG store. It stores the fingerprints of
169 potential encryption key candidates and the message (if any at all) to
170 quote in edward's reply.
172 'replies' points one of the dictionaries of translated replies.
174 'target_key' refers to the fingerprint of a key used to sign encrypted
175 data. This is the preferred key, if it is set, and if is available.
177 'fallback_target_key' referst to the fingerprint of a key used to sign
178 unencrypted data; alternatively it may be a public key attached to the
181 'msg_to_quote' refers to the part of a message which edward should quote in
182 his reply. This should remain as None if there was no encrypted and singed
183 part. This is to avoid making edward a service for decrypting other
184 people's messages to edward.
186 'success_decrypt' is set to True if edward could decrypt part of the
189 'failed_decrypt' is set to True if edward failed to decrypt part of the
192 'publick_key_received' is set to True if edward successfully imported a
195 'no_public_key' is set to True if edward doesn't have a key to encrypt to
196 when replying to the user.
198 'sig_success' is set to True if edward could to some extent verify the
199 signature of a signed part of the message to edward.
201 'sig_failure' is set to True if edward failed to some extent verify the
202 signature of a signed part of the message to edward.
208 fallback_target_key
= None
211 success_decrypt
= False
212 failed_decrypt
= False
213 public_key_received
= False
214 no_public_key
= False
222 This is the main function for edward, a GPG reply bot.
224 Edward responds to GPG-encrypted and signed mail, encrypting and signing
225 the response if the user's public key is, or was, included in the message.
234 Mime or plaintext email passing in through standard input. Portions of
235 the email may be encrypted. If the To: address contains the text
236 "edward-ja", then the reply will contain a reply written in the
237 Japanese language. There are other languages as well. The default
241 A reply email will be printed to standard output. The contents of the
242 reply email depends on whether the original email was encrypted or not,
243 has or doesn't have a signature, whether a public key used in the
244 original message is provided or locally stored, and the language
245 implied by the To: address in the original email.
248 print_reply_only
= handle_args()
250 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
251 edward_config
.sign_with_key
)
253 email_text
= sys
.stdin
.read()
254 email_struct
= parse_pgp_mime(email_text
, gpgme_ctx
)
256 email_to
, email_from
, email_subject
= email_to_from_subject(email_text
)
257 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
259 replyinfo_obj
= ReplyInfo()
260 replyinfo_obj
.replies
= lang
.replies
262 prepare_for_reply(email_struct
, replyinfo_obj
)
263 encrypt_to_key
= get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
264 reply_plaintext
= write_reply(replyinfo_obj
)
266 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_from
, \
267 email_subject
, encrypt_to_key
,
270 if print_reply_only
== True:
273 send_reply(reply_mime
, email_subject
, email_from
, reply_from
)
276 def get_gpg_context (gnupghome
, sign_with_key_fp
):
278 This function returns the GPG context needed for encryption and signing.
280 The context is needed by other functions which use GPG functionality.
283 gnupghome: The path to "~/.gnupg/" or its alternative.
284 sign_with_key: The fingerprint of the key to sign with
287 A gpgme context to be used for GPG functions.
290 the 'armor' flag is set to True and the list of signing keys contains
291 the single specified key
294 os
.environ
['GNUPGHOME'] = gnupghome
296 gpgme_ctx
= gpgme
.Context()
297 gpgme_ctx
.armor
= True
300 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
301 except gpgme
.GpgmeError
:
302 error("unable to load signing key. is the gnupghome "
303 + "and signing key properly set in the edward_config.py?")
306 gpgme_ctx
.signers
= [sign_with_key
]
311 def parse_pgp_mime (email_text
, gpgme_ctx
):
312 """Parses the email for mime payloads and decrypts/verfies signatures.
314 This function creates a representation of a mime or plaintext email with
315 the EddyMsg class. It then splits each mime payload into one or more pieces
316 which may be plain text or GPG data. It then decrypts encrypted parts and
317 does some very basic signature verification on those parts.
320 email_text: an email message in string format
321 gpgme_ctx: a gpgme context
324 A message as an instance of EddyMsg
327 the returned EddyMsg instance has split, decrypted, verified and pubkey
331 email_struct
= email
.parser
.Parser().parsestr(email_text
)
333 eddymsg_obj
= parse_mime(email_struct
)
334 split_payloads(eddymsg_obj
)
335 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
340 def parse_mime(msg_struct
):
341 """Translates python's email.parser format into an EddyMsg format
343 If the message is multi-part, then a recursive object is created, where
344 each sub-part is also a EddyMsg instance.
347 msg_struct: an email parsed with email.parser.Parser(), which can be
351 an instance of EddyMsg, potentially a recursive one.
354 eddymsg_obj
= EddyMsg()
356 if msg_struct
.is_multipart() == True:
357 payloads
= msg_struct
.get_payload()
359 eddymsg_obj
.multipart
= True
360 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
363 eddymsg_obj
= get_subpart_data(msg_struct
)
368 def scan_and_split (payload_piece
, match_name
, pattern
):
369 """This splits the payloads of an EddyMsg object into GPG and text parts.
371 An EddyMsg object's payload_pieces starts off as a list containing a single
372 PayloadPiece object. This function returns a list of these objects which
373 have been split into GPG data and regular text, if such splits need to be/
377 payload_piece: a single payload or a split part of a payload
378 match_name: the type of data to try to spit out from the payload piece
379 pattern: the search pattern to be used for finding that type of data
382 a list of objects of the PayloadPiece class, in the order that the
383 string part of payload_piece originally was, broken up according to
384 matches specified by 'pattern'.
387 # don't try to re-split pieces containing gpg data
388 if payload_piece
.piece_type
!= TxtType
.text
:
389 return [payload_piece
]
391 flags
= re
.DOTALL | re
.MULTILINE
392 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
393 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
396 pieces
= [payload_piece
]
400 beginning
= PayloadPiece()
401 beginning
.string
= matches
.group('beginning')
402 beginning
.piece_type
= payload_piece
.piece_type
404 match
= PayloadPiece()
405 match
.string
= matches
.group('match')
406 match
.piece_type
= match_name
408 rest
= PayloadPiece()
409 rest
.string
= matches
.group('rest')
410 rest
.piece_type
= payload_piece
.piece_type
412 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
413 pieces
= [beginning
, match
] + more_pieces
418 def get_subpart_data (part
):
419 """This function grabs information from a single part mime object.
421 It copies needed data from a single part email.parser.Parser() object over
422 to an EddyMsg object.
425 part: a non-multi-part mime.parser.Parser() object
428 a single-part EddyMsg() object
431 charset
= part
.get_content_charset()
432 mime_decoded_bytes
= part
.get_payload(decode
=True)
435 obj
.payload_bytes
= part
.as_bytes()
437 obj
.filename
= part
.get_filename()
438 obj
.content_type
= part
.get_content_type()
439 obj
.description_list
= part
['content-description']
441 # your guess is as good as a-myy-ee-ine...
445 if mime_decoded_bytes
!= None:
447 payload
= PayloadPiece()
448 payload
.string
= mime_decoded_bytes
.decode(charset
)
449 payload
.piece_type
= TxtType
.text
451 obj
.payload_pieces
= [payload
]
452 except UnicodeDecodeError:
458 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
459 """A function which maps another function onto a message's subparts.
461 This is a higer-order function which recursively performs a specified
462 function on each subpart of a multi-part message. Each single-part sub-part
463 has the function applied to it. This function also works if the part passed
467 function_to_do: function to perform on sub-parts
468 eddymsg_obj: a single part or multi-part EddyMsg object
469 data: a second argument to pass to 'function_to_do'
475 The passed-in EddyMsg object is transformed recursively on its
476 sub-parts according to 'function_to_do'.
479 if eddymsg_obj
.multipart
== True:
480 for sub
in eddymsg_obj
.subparts
:
481 do_to_eddys_pieces(function_to_do
, sub
, data
)
483 function_to_do(eddymsg_obj
, data
)
486 def split_payloads (eddymsg_obj
):
487 """Splits all (sub-)payloads of a message into GPG data and regular text.
489 Recursively performs payload splitting on all sub-parts of an EddyMsg
490 object into the various GPG data types, such as GPG messages, public key
491 blocks and signed text.
494 eddymsg_obj: an instance of EddyMsg
500 The EddyMsg object has payloads that are unsplit (by may be split)..
503 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
506 for match_pair
in match_pairs
:
507 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
510 def split_payload_pieces (eddymsg_obj
, match_pair
):
511 """A helper function for split_payloads(); works on PayloadPiece objects.
513 This function splits up PayloadPiece objects into multipe PayloadPiece
514 objects and replaces the EddyMsg object's previous list of payload pieces
515 with the new split up one.
518 eddymsg_obj: a single-part EddyMsg object.
519 match_pair: a tuple from the match_pairs list, which specifies a match
520 name and a match pattern.
526 The payload piece(s) of an EddyMsg object may be already split or
530 The EddyMsg object's payload piece(s) are split into a list of pieces
531 if matches of the match_pair are found.
534 (match_name
, pattern
) = match_pair
537 for piece
in eddymsg_obj
.payload_pieces
:
538 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
540 eddymsg_obj
.payload_pieces
= new_pieces_list
543 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
544 """Performs GPG operations on the GPG parts of the message
546 This function decrypts text, verifies signatures, and imports public keys
547 included in an email.
550 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
551 and non-GPG sections by split_payloads()
552 gpgme_ctx: a gpgme context
554 prev_parts: a list of mime parts that occur before the eddymsg_obj
555 part, under the same multi-part mime part. This is used for
556 verifying detached signatures. For the root mime part, this should
557 be an empty list, which is the default value if this paramater is
564 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
567 Decryption, verification and key imports occur. the gpg_data member of
568 PayloadPiece objects get filled in with GPGData objects.
571 if eddymsg_obj
.multipart
== True:
573 for sub
in eddymsg_obj
.subparts
:
574 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
579 for piece
in eddymsg_obj
.payload_pieces
:
581 if piece
.piece_type
== TxtType
.text
:
582 # don't transform the plaintext.
585 elif piece
.piece_type
== TxtType
.message
:
586 (plaintext
, sigs
, sig_failure
) = decrypt_block(piece
.string
, gpgme_ctx
)
589 piece
.gpg_data
= GPGData()
590 piece
.gpg_data
.decrypted
= True
591 piece
.gpg_data
.sigs
= sigs
592 piece
.gpg_data
.sig_failure
= sig_failure
594 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
597 # if not encrypted, check to see if this is an armored signature.
598 (plaintext
, sigs
, sig_failure
) = verify_sig_message(piece
.string
, gpgme_ctx
)
601 piece
.piece_type
= TxtType
.signature
602 piece
.gpg_data
= GPGData()
603 piece
.gpg_data
.sigs
= sigs
604 piece
.gpg_data
.sig_failure
= sig_failure
606 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
608 elif piece
.piece_type
== TxtType
.pubkey
:
609 key_fps
= add_gpg_key(piece
.string
, gpgme_ctx
)
612 piece
.gpg_data
= GPGData()
613 piece
.gpg_data
.keys
= key_fps
615 elif piece
.piece_type
== TxtType
.detachedsig
:
616 for prev
in prev_parts
:
617 (sig_fps
, sig_failure
) = verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
620 piece
.gpg_data
= GPGData()
621 piece
.gpg_data
.sigs
= sig_fps
622 piece
.gpg_data
.sig_failure
= sig_failure
623 piece
.gpg_data
.plainobj
= prev
630 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
631 """Updates replyinfo_obj with info on the message's GPG success/failures
633 This function marks replyinfo_obj with information about whether encrypted
634 text in eddymsg_obj was successfully decrypted, signatures were verified
635 and whether a public key was found or not.
638 eddymsg_obj: a message in the EddyMsg format
639 replyinfo_obj: an instance of ReplyInfo
645 eddymsg_obj has had its gpg_data created by gpg_on_payloads
648 replyinfo_obj has been updated with info about decryption/sig
649 verififcation status, etc. However the desired key isn't imported until
650 later, so the success or failure of that updates the values set here.
653 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
655 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
656 """A helper function for prepare_for_reply
658 It updates replyinfo_obj with GPG success/failure information, when
659 supplied a single-part EddyMsg object.
662 eddymsg_obj: a single-part message in the EddyMsg format
663 replyinfo_obj: an object which holds information about the message's
670 eddymsg_obj is a single-part message. (it may be a part of a multi-part
671 message.) It has had its gpg_data created by gpg_on_payloads if it has
675 replyinfo_obj has been updated with gpg success/failure information
678 for piece
in eddymsg_obj
.payload_pieces
:
679 if piece
.piece_type
== TxtType
.text
:
680 # don't quote the plaintext part.
683 elif piece
.piece_type
== TxtType
.message
:
684 prepare_for_reply_message(piece
, replyinfo_obj
)
686 elif piece
.piece_type
== TxtType
.pubkey
:
687 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
689 elif (piece
.piece_type
== TxtType
.detachedsig
) \
690 or (piece
.piece_type
== TxtType
.signature
):
691 prepare_for_reply_sig(piece
, replyinfo_obj
)
694 def prepare_for_reply_message (piece
, replyinfo_obj
):
695 """Helper function for prepare_for_reply()
697 This function is called when the piece_type of a payload piece is
698 TxtType.message, or GPG Message block. This should be encrypted text. If
699 the encryted block is correclty signed, a sig will be attached to
700 .target_key unless there is already one there.
703 piece: a PayloadPiece object.
704 replyinfo_obj: object which gets updated with decryption status, etc.
711 the piece.payload_piece value should be TxtType.message.
714 replyinfo_obj gets updated with decryption status, signing status and a
715 potential signing key.
718 if piece
.gpg_data
== None:
719 replyinfo_obj
.failed_decrypt
= True
722 replyinfo_obj
.success_decrypt
= True
724 # we already have a key (and a message)
725 if replyinfo_obj
.target_key
!= None:
728 if piece
.gpg_data
.sigs
!= []:
729 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
730 replyinfo_obj
.sig_success
= True
731 get_signed_part
= False
733 if piece
.gpg_data
.sig_failure
== True:
734 replyinfo_obj
.sig_failure
= True
736 # only include a signed message in the reply.
737 get_signed_part
= True
739 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
741 # to catch public keys in encrypted blocks
742 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
745 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
746 """Helper function for prepare_for_reply(). Marks pubkey import status.
748 Marks replyinfo_obj with pub key import status.
751 piece: a PayloadPiece object
752 replyinfo_obj: a ReplyInfo object
755 piece.piece_type should be set to TxtType.pubkey .
758 replyinfo_obj has its fields updated.
761 if piece
.gpg_data
== None or piece
.gpg_data
.keys
== []:
762 replyinfo_obj
.no_public_key
= True
764 replyinfo_obj
.public_key_received
= True
766 # prefer public key as a fallback for the encrypted reply
767 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
770 def prepare_for_reply_sig (piece
, replyinfo_obj
):
771 """Helper function for prepare_for_reply(). Marks sig verification status.
773 Marks replyinfo_obj with signature verification status.
776 piece: a PayloadPiece object
777 replyinfo_obj: a ReplyInfo object
780 piece.piece_type should be set to TxtType.signature, or
781 TxtType.detachedsig .
784 replyinfo_obj has its fields updated.
787 if piece
.gpg_data
== None or piece
.gpg_data
.sigs
== []:
788 replyinfo_obj
.sig_failure
= True
790 replyinfo_obj
.sig_success
= True
792 if piece
.gpg_data
.sig_failure
== True:
793 replyinfo_obj
.sig_failure
= True
795 if replyinfo_obj
.fallback_target_key
== None:
796 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
799 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
800 """For creating a string representation of a signed, encrypted part.
802 When given a decrypted payload, it will add either the plaintext or signed
803 plaintext to the reply message, depeding on 'get_signed_part'. This is
804 useful for ensuring that the reply message only comes from a signed and
805 ecrypted GPG message. It also sets the target_key for encrypting the reply
806 if it's told to get signed text only.
809 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
811 replyinfo_obj: a ReplyInfo object for holding the message to quote and
812 the target_key to encrypt to.
813 get_signed_part: True if we should only include text that contains a
814 further signature. If False, then include plain text.
820 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
821 which represents decrypted text. It may or may not be signed on that
825 the ReplyInfo instance may have a new 'target_key' set and its
826 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
830 if eddymsg_obj
== None:
833 # recurse on multi-part mime
834 if eddymsg_obj
.multipart
== True:
835 for sub
in eddymsg_obj
.subparts
:
836 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
838 for piece
in eddymsg_obj
.payload_pieces
:
839 if (get_signed_part
):
840 if ((piece
.piece_type
== TxtType
.detachedsig
) \
841 or (piece
.piece_type
== TxtType
.signature
)) \
842 and (piece
.gpg_data
!= None):
843 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
844 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
847 if piece
.piece_type
== TxtType
.text
:
848 replyinfo_obj
.msg_to_quote
+= piece
.string
851 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
852 """Obtains a public key object from a key fingerprint
854 If the .target_key is not set, then we use .fallback_target_key.
857 replyinfo_obj: ReplyInfo instance
858 gpgme_ctx: the gpgme context
861 The key object of the key of either the target_key or the fallback one
862 if .target_key is not set. If the key cannot be loaded, then return
866 Loading a key requires that we have the public key imported. This
867 requires that they email contains the pub key block, or that it was
868 previously sent to edward.
871 If the key cannot be loaded, then the replyinfo_obj is marked for
872 having no public key available.
875 if replyinfo_obj
.target_key
== None:
876 replyinfo_obj
.target_key
= replyinfo_obj
.fallback_target_key
878 if replyinfo_obj
.target_key
!= None:
880 encrypt_to_key
= gpgme_ctx
.get_key(replyinfo_obj
.target_key
)
881 return encrypt_to_key
883 except gpgme
.GpgmeError
:
886 # no available key to use
887 replyinfo_obj
.target_key
= None
888 replyinfo_obj
.fallback_target_key
= None
890 replyinfo_obj
.no_public_key
= True
891 replyinfo_obj
.public_key_received
= False
896 def write_reply (replyinfo_obj
):
897 """Write the reply email body about the GPG successes/failures.
899 The reply is about whether decryption, sig verification and key
900 import/loading was successful or failed. If text was successfully decrypted
901 and verified, then the first instance of such text will be included in
905 replyinfo_obj: contains details of GPG processing status
908 the plaintext message to be sent to the user
911 replyinfo_obj should be populated with info about GPG processing status.
916 if replyinfo_obj
.success_decrypt
== True:
917 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
919 if (replyinfo_obj
.sig_success
== True) and (replyinfo_obj
.no_public_key
== False):
920 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
921 reply_plain
+= quoted_text
923 elif replyinfo_obj
.failed_decrypt
== True:
924 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
927 if replyinfo_obj
.sig_success
== True:
928 reply_plain
+= "\n\n"
929 reply_plain
+= replyinfo_obj
.replies
['sig_success']
932 reply_plain
+= "\n\n"
933 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
936 if replyinfo_obj
.public_key_received
== True:
937 reply_plain
+= "\n\n"
938 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
940 elif replyinfo_obj
.no_public_key
== True:
941 reply_plain
+= "\n\n"
942 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
945 reply_plain
+= "\n\n"
946 reply_plain
+= replyinfo_obj
.replies
['signature']
952 def add_gpg_key (key_block
, gpgme_ctx
):
953 """Adds a GPG pubkey to the local keystore
955 This adds keys received through email into the key store so they can be
959 key_block: the string form of the ascii-armored public key block
960 gpgme_ctx: the gpgme context
963 the fingerprint(s) of the imported key(s)
966 fp
= io
.BytesIO(key_block
.encode('ascii'))
969 result
= gpgme_ctx
.import_(fp
)
970 imports
= result
.imports
971 except gpgme
.GpgmeError
:
974 key_fingerprints
= []
977 for import_
in imports
:
978 fingerprint
= import_
[0]
979 key_fingerprints
+= [fingerprint
]
981 debug("added gpg key: " + fingerprint
)
983 return key_fingerprints
986 def verify_sig_message (msg_block
, gpgme_ctx
):
987 """Verifies the signature of a signed, ascii-armored block of text.
989 It encodes the string into ascii, since binary GPG files are currently
990 unsupported, and alternative, the ascii-armored format is encodable into
994 msg_block: a GPG Message block in string form. It may be encrypted or
995 not. If it is encrypted, it will return empty results.
996 gpgme_ctx: the gpgme context
999 A tuple containing the plaintext of the signed part, the list of
1000 fingerprints of keys signing the data, and a boolean marking whether
1001 there were any invalid signatures. If verification failed, perhaps
1002 because the message was also encrypted, then empty results are
1006 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1007 plain_b
= io
.BytesIO()
1010 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
1011 except gpgme
.GpgmeError
:
1014 plaintext
= plain_b
.getvalue().decode('utf-8')
1019 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1020 fingerprints
+= [sig
.fpr
]
1024 return (plaintext
, fingerprints
, sig_failure
)
1027 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1028 """Verifies the signature of a detached signature.
1030 This requires the signature part and the signed part as separate arguments.
1033 detached_sig: the signature part of the detached signature
1034 plaintext_bytes: the byte form of the message being signed.
1035 gpgme_ctx: the gpgme context
1038 A tuple containging a list of signing fingerprints if the signature
1039 verification was sucessful, and a boolean noting whether there were any
1040 failed signature validations. Otherwise, a tuple containing an empty
1041 list and True are returned.
1044 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1045 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1048 result
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1049 except gpgme
.GpgmeError
:
1053 sig_fingerprints
= []
1055 if (res_
.summary
== 0) or (res_
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (res_
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1056 sig_fingerprints
+= [res_
.fpr
]
1060 return (sig_fingerprints
, sig_failure
)
1063 def decrypt_block (msg_block
, gpgme_ctx
):
1064 """Decrypts a block of GPG text and verifies any included sigatures.
1066 Some encypted messages have embeded signatures, so those are verified too.
1069 msg_block: the encrypted(/signed) text
1070 gpgme_ctx: the gpgme context
1073 A tuple containing plaintext, signatures (if the decryption and
1074 signature verification were successful, respectively), and a boolean
1075 noting whether there were signatures that could not be validated.
1078 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1079 plain_b
= io
.BytesIO()
1082 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1083 except gpgme
.GpgmeError
:
1086 plaintext
= plain_b
.getvalue().decode('utf-8')
1091 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1092 fingerprints
+= [sig
.fpr
]
1096 return (plaintext
, fingerprints
, sig_failure
)
1099 def email_to_from_subject (email_text
):
1100 """Returns the values of the email's To:, From: and Subject: fields
1102 Returns this information from an email.
1105 email_text: the string form of the email
1108 the email To:, From:, and Subject: fields as strings
1111 email_struct
= email
.parser
.Parser().parsestr(email_text
)
1113 email_to
= email_struct
['To']
1114 email_from
= email_struct
['From']
1115 email_subject
= email_struct
['Subject']
1117 return email_to
, email_from
, email_subject
1120 def import_lang_pick_address(email_to
, hostname
):
1121 """Imports language file for i18n support; makes reply from address
1123 The language imported depends on the To: address of the email received by
1124 edward. an -en ending implies the English language, whereas a -ja ending
1125 implies Japanese. The list of supported languages is listed in the 'langs'
1126 list at the beginning of the program. This function also chooses the
1127 language-dependent address which can be used as the From address in the
1131 email_to: the string containing the email address that the mail was
1133 hostname: the hostname part of the reply email's from address
1136 the reference to the imported language module. The only variable in
1137 this file is the 'replies' dictionary.
1143 if email_to
!= None:
1145 if "edward-" + lang
in email_to
:
1149 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1150 lang_module
= importlib
.import_module(lang_mod_name
)
1152 reply_from
= "edward-" + use_lang
+ "@" + hostname
1154 return lang_module
, reply_from
1157 def generate_encrypted_mime (plaintext
, email_to
, email_subject
, encrypt_to_key
,
1159 """This function creates the mime email reply. It can encrypt the email.
1161 If the encrypt_key is included, then the email is encrypted and signed.
1162 Otherwise it is unencrypted.
1165 plaintext: the plaintext body of the message to create.
1166 email_to: the email address to reply to
1167 email_subject: the subject to use in reply
1168 encrypt_to_key: the key object to use for encrypting the email. (or
1170 gpgme_ctx: the gpgme context
1173 A string version of the mime message, possibly encrypted and signed.
1176 if (encrypt_to_key
!= None):
1178 plaintext_mime
= MIMEText(plaintext
)
1179 plaintext_mime
.set_charset('utf-8')
1181 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1185 control_mime
= MIMEApplication("Version: 1",
1186 _subtype
='pgp-encrypted',
1187 _encoder
=email
.encoders
.encode_7or8bit
)
1188 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1189 control_mime
.set_charset('us-ascii')
1191 encoded_mime
= MIMEApplication(encrypted_text
,
1192 _subtype
='octet-stream; name="encrypted.asc"',
1193 _encoder
=email
.encoders
.encode_7or8bit
)
1194 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1195 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1196 encoded_mime
.set_charset('us-ascii')
1198 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1199 message_mime
.attach(control_mime
)
1200 message_mime
.attach(encoded_mime
)
1201 message_mime
['Content-Disposition'] = 'inline'
1204 message_mime
= MIMEText(plaintext
)
1205 message_mime
.set_charset('utf-8')
1207 message_mime
['To'] = email_to
1208 message_mime
['Subject'] = email_subject
1210 reply
= message_mime
.as_string()
1215 def send_reply(email_txt
, subject
, reply_to
, reply_from
):
1217 email_bytes
= email_txt
.encode('ascii')
1219 p
= subprocess
.Popen(["/usr/sbin/sendmail", "-f", reply_from
, "-F", "Edward, GPG Bot", "-i", reply_to
], stdin
=subprocess
.PIPE
)
1221 (stdout
, stderr
) = p
.communicate(email_bytes
)
1224 debug("sendmail stdout: " + str(stdout
))
1226 error("sendmail stderr: " + str(stderr
))
1229 def email_quote_text (text
):
1230 """Quotes input text by inserting "> "s
1232 This is useful for quoting a text for the reply message. It inserts "> "
1233 strings at the beginning of lines.
1236 text: plain text to quote
1242 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1244 return quoted_message
1247 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1248 """Encrypts and signs plaintext
1250 This encrypts and signs a message.
1253 plaintext: text to sign and ecrypt
1254 encrypt_to_key: the key object to encrypt to
1255 gpgme_ctx: the gpgme context
1258 An encrypted and signed string of text
1261 # the plaintext should be mime encoded in an ascii-compatible form
1262 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1263 encrypted_bytes
= io
.BytesIO()
1265 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1266 plaintext_bytes
, encrypted_bytes
)
1268 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1269 return encrypted_txt
1272 def error (error_msg
):
1273 """Write an error message to stdout
1275 The error message includes the program name.
1278 error_msg: the message to print
1284 An error message is printed to stdout
1287 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1290 def debug (debug_msg
):
1291 """Writes a debug message to stdout if debug == True
1293 If the debug option is set in edward_config.py, then the passed message
1294 gets printed to stdout.
1297 debug_msg: the message to print to stdout
1303 A debug message is printed to stdout
1306 if edward_config
.debug
== True:
1311 """Sets the progname variable and processes optional argument
1313 If there are more than two arguments then edward complains and quits. An
1314 single "-p" argument sets the print_reply_only option, which makes edward
1315 print email replies instead of mailing them.
1321 True if edward should print arguments instead of mailing them,
1322 otherwise it returns False.
1325 Exits with error 1 if there are more than two arguments, otherwise
1326 returns the print_reply_only option.
1330 progname
= sys
.argv
[0]
1332 print_reply_only
= False
1334 if len(sys
.argv
) > 2:
1335 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1336 + " -p print reply message to stdout, do not mail it\n", \
1340 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1341 print_reply_only
= True
1343 return print_reply_only
1346 if __name__
== "__main__":
1347 """Executes main if this file is not loaded interactively"""