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
219 sigkey_missing
= False
220 have_reply_key
= False
226 This is the main function for edward, a GPG reply bot.
228 Edward responds to GPG-encrypted and signed mail, encrypting and signing
229 the response if the user's public key is, or was, included in the message.
238 Mime or plaintext email passing in through standard input. Portions of
239 the email may be encrypted. If the To: address contains the text
240 "edward-ja", then the reply will contain a reply written in the
241 Japanese language. There are other languages as well. The default
245 A reply email will be printed to standard output. The contents of the
246 reply email depends on whether the original email was encrypted or not,
247 has or doesn't have a signature, whether a public key used in the
248 original message is provided or locally stored, and the language
249 implied by the To: address in the original email.
252 print_reply_only
= handle_args()
254 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
255 edward_config
.sign_with_key
)
257 email_bytes
= sys
.stdin
.buffer.read()
258 email_struct
= parse_pgp_mime(email_bytes
, gpgme_ctx
)
260 email_to
, email_from
, email_subject
= email_to_from_subject(email_bytes
)
261 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
263 replyinfo_obj
= ReplyInfo()
264 replyinfo_obj
.replies
= lang
.replies
266 prepare_for_reply(email_struct
, replyinfo_obj
)
267 get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
268 reply_plaintext
= write_reply(replyinfo_obj
)
270 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_from
, \
271 email_subject
, replyinfo_obj
.encrypt_to_key
,
274 if print_reply_only
== True:
277 send_reply(reply_mime
, email_subject
, email_from
, reply_from
)
280 def get_gpg_context (gnupghome
, sign_with_key_fp
):
282 This function returns the GPG context needed for encryption and signing.
284 The context is needed by other functions which use GPG functionality.
287 gnupghome: The path to "~/.gnupg/" or its alternative.
288 sign_with_key: The fingerprint of the key to sign with
291 A gpgme context to be used for GPG functions.
294 the 'armor' flag is set to True and the list of signing keys contains
295 the single specified key
298 os
.environ
['GNUPGHOME'] = gnupghome
300 gpgme_ctx
= gpgme
.Context()
301 gpgme_ctx
.armor
= True
304 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
305 except gpgme
.GpgmeError
:
306 error("unable to load signing key. is the gnupghome "
307 + "and signing key properly set in the edward_config.py?")
310 gpgme_ctx
.signers
= [sign_with_key
]
315 def parse_pgp_mime (email_bytes
, gpgme_ctx
):
316 """Parses the email for mime payloads and decrypts/verfies signatures.
318 This function creates a representation of a mime or plaintext email with
319 the EddyMsg class. It then splits each mime payload into one or more pieces
320 which may be plain text or GPG data. It then decrypts encrypted parts and
321 does some very basic signature verification on those parts.
324 email_bytes: an email message in byte string format
325 gpgme_ctx: a gpgme context
328 A message as an instance of EddyMsg
331 the returned EddyMsg instance has split, decrypted, verified and pubkey
335 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
337 eddymsg_obj
= parse_mime(email_struct
)
338 split_payloads(eddymsg_obj
)
339 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
344 def parse_mime(msg_struct
):
345 """Translates python's email.parser format into an EddyMsg format
347 If the message is multi-part, then a recursive object is created, where
348 each sub-part is also a EddyMsg instance.
351 msg_struct: an email parsed with email.parser.Parser(), which can be
355 an instance of EddyMsg, potentially a recursive one.
358 eddymsg_obj
= EddyMsg()
360 if msg_struct
.is_multipart() == True:
361 payloads
= msg_struct
.get_payload()
363 eddymsg_obj
.multipart
= True
364 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
367 eddymsg_obj
= get_subpart_data(msg_struct
)
372 def scan_and_split (payload_piece
, match_name
, pattern
):
373 """This splits the payloads of an EddyMsg object into GPG and text parts.
375 An EddyMsg object's payload_pieces starts off as a list containing a single
376 PayloadPiece object. This function returns a list of these objects which
377 have been split into GPG data and regular text, if such splits need to be/
381 payload_piece: a single payload or a split part of a payload
382 match_name: the type of data to try to spit out from the payload piece
383 pattern: the search pattern to be used for finding that type of data
386 a list of objects of the PayloadPiece class, in the order that the
387 string part of payload_piece originally was, broken up according to
388 matches specified by 'pattern'.
391 # don't try to re-split pieces containing gpg data
392 if payload_piece
.piece_type
!= TxtType
.text
:
393 return [payload_piece
]
395 flags
= re
.DOTALL | re
.MULTILINE
396 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
397 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
400 pieces
= [payload_piece
]
404 beginning
= PayloadPiece()
405 beginning
.string
= matches
.group('beginning')
406 beginning
.piece_type
= payload_piece
.piece_type
408 match
= PayloadPiece()
409 match
.string
= matches
.group('match')
410 match
.piece_type
= match_name
412 rest
= PayloadPiece()
413 rest
.string
= matches
.group('rest')
414 rest
.piece_type
= payload_piece
.piece_type
416 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
417 pieces
= [beginning
, match
] + more_pieces
422 def get_subpart_data (part
):
423 """This function grabs information from a single part mime object.
425 It copies needed data from a single part email.parser.Parser() object over
426 to an EddyMsg object.
429 part: a non-multi-part mime.parser.Parser() object
432 a single-part EddyMsg() object
437 mime_decoded_bytes
= part
.get_payload(decode
=True)
438 charset
= part
.get_content_charset()
440 # your guess is as good as a-myy-ee-ine...
444 payload_string
= part
.as_string()
445 if payload_string
!= None:
446 obj
.payload_bytes
= payload_string
.encode(charset
)
448 obj
.filename
= part
.get_filename()
449 obj
.content_type
= part
.get_content_type()
450 obj
.description_list
= part
['content-description']
452 if mime_decoded_bytes
!= None:
454 payload
= PayloadPiece()
455 payload
.string
= mime_decoded_bytes
.decode(charset
)
456 payload
.piece_type
= TxtType
.text
458 obj
.payload_pieces
= [payload
]
459 except UnicodeDecodeError:
465 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
466 """A function which maps another function onto a message's subparts.
468 This is a higer-order function which recursively performs a specified
469 function on each subpart of a multi-part message. Each single-part sub-part
470 has the function applied to it. This function also works if the part passed
474 function_to_do: function to perform on sub-parts
475 eddymsg_obj: a single part or multi-part EddyMsg object
476 data: a second argument to pass to 'function_to_do'
482 The passed-in EddyMsg object is transformed recursively on its
483 sub-parts according to 'function_to_do'.
486 if eddymsg_obj
.multipart
== True:
487 for sub
in eddymsg_obj
.subparts
:
488 do_to_eddys_pieces(function_to_do
, sub
, data
)
490 function_to_do(eddymsg_obj
, data
)
493 def split_payloads (eddymsg_obj
):
494 """Splits all (sub-)payloads of a message into GPG data and regular text.
496 Recursively performs payload splitting on all sub-parts of an EddyMsg
497 object into the various GPG data types, such as GPG messages, public key
498 blocks and signed text.
501 eddymsg_obj: an instance of EddyMsg
507 The EddyMsg object has payloads that are unsplit (by may be split)..
510 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
513 for match_pair
in match_pairs
:
514 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
517 def split_payload_pieces (eddymsg_obj
, match_pair
):
518 """A helper function for split_payloads(); works on PayloadPiece objects.
520 This function splits up PayloadPiece objects into multipe PayloadPiece
521 objects and replaces the EddyMsg object's previous list of payload pieces
522 with the new split up one.
525 eddymsg_obj: a single-part EddyMsg object.
526 match_pair: a tuple from the match_pairs list, which specifies a match
527 name and a match pattern.
533 The payload piece(s) of an EddyMsg object may be already split or
537 The EddyMsg object's payload piece(s) are split into a list of pieces
538 if matches of the match_pair are found.
541 (match_name
, pattern
) = match_pair
544 for piece
in eddymsg_obj
.payload_pieces
:
545 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
547 eddymsg_obj
.payload_pieces
= new_pieces_list
550 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
551 """Performs GPG operations on the GPG parts of the message
553 This function decrypts text, verifies signatures, and imports public keys
554 included in an email.
557 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
558 and non-GPG sections by split_payloads()
559 gpgme_ctx: a gpgme context
561 prev_parts: a list of mime parts that occur before the eddymsg_obj
562 part, under the same multi-part mime part. This is used for
563 verifying detached signatures. For the root mime part, this should
564 be an empty list, which is the default value if this paramater is
571 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
574 Decryption, verification and key imports occur. the gpg_data member of
575 PayloadPiece objects get filled in with GPGData objects.
578 if eddymsg_obj
.multipart
== True:
580 for sub
in eddymsg_obj
.subparts
:
581 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
586 for piece
in eddymsg_obj
.payload_pieces
:
588 if piece
.piece_type
== TxtType
.text
:
589 # don't transform the plaintext.
592 elif piece
.piece_type
== TxtType
.message
:
593 piece
.gpg_data
= GPGData()
595 (plaintext_b
, sigs
, sigkey_missing
) = decrypt_block(piece
.string
, gpgme_ctx
)
597 piece
.gpg_data
.sigkey_missing
= sigkey_missing
600 piece
.gpg_data
.decrypted
= True
601 piece
.gpg_data
.sigs
= sigs
603 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
606 # if not encrypted, check to see if this is an armored signature.
607 (plaintext_b
, sigs
, sigkey_missing
) = verify_sig_message(piece
.string
, gpgme_ctx
)
609 piece
.gpg_data
.sigkey_missing
= sigkey_missing
612 piece
.piece_type
= TxtType
.signature
613 piece
.gpg_data
.sigs
= sigs
615 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
617 elif piece
.piece_type
== TxtType
.pubkey
:
618 key_fps
= add_gpg_key(piece
.string
, gpgme_ctx
)
621 piece
.gpg_data
= GPGData()
622 piece
.gpg_data
.keys
= key_fps
624 elif piece
.piece_type
== TxtType
.detachedsig
:
625 piece
.gpg_data
= GPGData()
627 for prev
in prev_parts
:
628 (sig_fps
, sigkey_missing
) = verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
630 piece
.gpg_data
.sigkey_missing
= sigkey_missing
633 piece
.gpg_data
.sigs
= sig_fps
634 piece
.gpg_data
.plainobj
= prev
641 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
642 """Updates replyinfo_obj with info on the message's GPG success/failures
644 This function marks replyinfo_obj with information about whether encrypted
645 text in eddymsg_obj was successfully decrypted, signatures were verified
646 and whether a public key was found or not.
649 eddymsg_obj: a message in the EddyMsg format
650 replyinfo_obj: an instance of ReplyInfo
656 eddymsg_obj has had its gpg_data created by gpg_on_payloads
659 replyinfo_obj has been updated with info about decryption/sig
660 verififcation status, etc. However the desired key isn't imported until
661 later, so the success or failure of that updates the values set here.
664 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
666 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
667 """A helper function for prepare_for_reply
669 It updates replyinfo_obj with GPG success/failure information, when
670 supplied a single-part EddyMsg object.
673 eddymsg_obj: a single-part message in the EddyMsg format
674 replyinfo_obj: an object which holds information about the message's
681 eddymsg_obj is a single-part message. (it may be a part of a multi-part
682 message.) It has had its gpg_data created by gpg_on_payloads if it has
686 replyinfo_obj has been updated with gpg success/failure information
689 for piece
in eddymsg_obj
.payload_pieces
:
690 if piece
.piece_type
== TxtType
.text
:
691 # don't quote the plaintext part.
694 elif piece
.piece_type
== TxtType
.message
:
695 prepare_for_reply_message(piece
, replyinfo_obj
)
697 elif piece
.piece_type
== TxtType
.pubkey
:
698 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
700 elif (piece
.piece_type
== TxtType
.detachedsig
) \
701 or (piece
.piece_type
== TxtType
.signature
):
702 prepare_for_reply_sig(piece
, replyinfo_obj
)
705 def prepare_for_reply_message (piece
, replyinfo_obj
):
706 """Helper function for prepare_for_reply()
708 This function is called when the piece_type of a payload piece is
709 TxtType.message, or GPG Message block. This should be encrypted text. If
710 the encryted block is correclty signed, a sig will be attached to
711 .target_key unless there is already one there.
714 piece: a PayloadPiece object.
715 replyinfo_obj: object which gets updated with decryption status, etc.
721 the piece.payload_piece value should be TxtType.message.
724 replyinfo_obj gets updated with decryption status, signing status, a
725 potential signing key, and posession status of the public key for the
729 if piece
.gpg_data
== None or piece
.gpg_data
.plainobj
== None:
732 replyinfo_obj
.decrypt_success
= True
734 # we already have a key (and a message)
735 if replyinfo_obj
.target_key
!= None:
738 if piece
.gpg_data
.sigs
!= []:
739 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
740 replyinfo_obj
.sig_success
= True
741 get_signed_part
= False
744 if piece
.gpg_data
.sigkey_missing
== True:
745 replyinfo_obj
.sigkey_missing
= True
747 # only include a signed message in the reply.
748 get_signed_part
= True
750 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
752 # to catch public keys in encrypted blocks
753 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
756 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
757 """Helper function for prepare_for_reply(). Marks pubkey import status.
759 Marks replyinfo_obj with pub key import status.
762 piece: a PayloadPiece object
763 replyinfo_obj: a ReplyInfo object
766 piece.piece_type should be set to TxtType.pubkey .
769 replyinfo_obj has its fields updated.
772 if piece
.gpg_data
== None or piece
.gpg_data
.keys
== []:
775 replyinfo_obj
.pubkey_success
= True
777 # prefer public key as a fallback for the encrypted reply
778 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
781 def prepare_for_reply_sig (piece
, replyinfo_obj
):
782 """Helper function for prepare_for_reply(). Marks sig verification status.
784 Marks replyinfo_obj with signature verification status.
787 piece: a PayloadPiece object
788 replyinfo_obj: a ReplyInfo object
791 piece.piece_type should be set to TxtType.signature, or
792 TxtType.detachedsig .
795 replyinfo_obj has its fields updated.
798 if piece
.gpg_data
== None or piece
.gpg_data
.sigs
== []:
799 replyinfo_obj
.sig_failure
= True
801 if piece
.gpg_data
.sigkey_missing
== True:
802 replyinfo_obj
.sigkey_missing
= True
805 replyinfo_obj
.sig_success
= True
807 if replyinfo_obj
.fallback_target_key
== None:
808 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
811 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
812 """For creating a string representation of a signed, encrypted part.
814 When given a decrypted payload, it will add either the plaintext or signed
815 plaintext to the reply message, depeding on 'get_signed_part'. This is
816 useful for ensuring that the reply message only comes from a signed and
817 ecrypted GPG message. It also sets the target_key for encrypting the reply
818 if it's told to get signed text only.
821 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
823 replyinfo_obj: a ReplyInfo object for holding the message to quote and
824 the target_key to encrypt to.
825 get_signed_part: True if we should only include text that contains a
826 further signature. If False, then include plain text.
832 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
833 which represents decrypted text. It may or may not be signed on that
837 the ReplyInfo instance may have a new 'target_key' set and its
838 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
842 if eddymsg_obj
== None:
845 # recurse on multi-part mime
846 if eddymsg_obj
.multipart
== True:
847 for sub
in eddymsg_obj
.subparts
:
848 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
850 for piece
in eddymsg_obj
.payload_pieces
:
851 if (get_signed_part
):
852 if ((piece
.piece_type
== TxtType
.detachedsig
) \
853 or (piece
.piece_type
== TxtType
.signature
)) \
854 and (piece
.gpg_data
!= None) \
855 and (piece
.gpg_data
.plainobj
!= None):
856 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
857 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
860 if piece
.piece_type
== TxtType
.text
:
861 replyinfo_obj
.msg_to_quote
+= piece
.string
864 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
865 """Obtains a public key object from a key fingerprint
867 If the .target_key is not set, then we use .fallback_target_key, if
871 replyinfo_obj: ReplyInfo instance
872 gpgme_ctx: the gpgme context
875 The key object of the key of either the target_key or the fallback one
876 if .target_key is not set. If the key cannot be loaded, then return
880 Loading a key requires that we have the public key imported. This
881 requires that they email contains the pub key block, or that it was
882 previously sent to edward.
885 If the key can be loaded, then replyinfo_obj.reply_to_key points to the
886 public key object. If the key cannot be loaded, then the replyinfo_obj
887 is marked as having no public key available.
890 for key
in (replyinfo_obj
.target_key
, replyinfo_obj
.fallback_target_key
):
893 encrypt_to_key
= gpgme_ctx
.get_key(key
)
894 replyinfo_obj
.encrypt_to_key
= encrypt_to_key
895 replyinfo_obj
.have_reply_key
= True
898 except gpgme
.GpgmeError
:
902 def write_reply (replyinfo_obj
):
903 """Write the reply email body about the GPG successes/failures.
905 The reply is about whether decryption, sig verification and key
906 import/loading was successful or failed. If text was successfully decrypted
907 and verified, then the first instance of such text will be included in
911 replyinfo_obj: contains details of GPG processing status
914 the plaintext message to be sent to the user
917 replyinfo_obj should be populated with info about GPG processing status.
922 if replyinfo_obj
.decrypt_success
== True:
923 debug('decrypt success')
924 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
925 reply_plain
+= "\n\n"
927 if (replyinfo_obj
.sig_success
== True) and (replyinfo_obj
.have_reply_key
== True):
928 debug('message quoted')
929 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
930 reply_plain
+= quoted_text
931 reply_plain
+= "\n\n"
934 debug('decrypt failure')
935 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
936 reply_plain
+= "\n\n"
938 if replyinfo_obj
.sig_success
== True:
939 debug('signature success')
940 reply_plain
+= replyinfo_obj
.replies
['sig_success']
941 reply_plain
+= "\n\n"
943 elif replyinfo_obj
.sig_failure
== True:
944 debug('signature failure')
945 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
946 reply_plain
+= "\n\n"
948 if (replyinfo_obj
.pubkey_success
== True):
949 debug('public key received')
950 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
951 reply_plain
+= "\n\n"
953 elif (replyinfo_obj
.sigkey_missing
== True):
954 debug('no public key')
955 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
956 reply_plain
+= "\n\n"
959 reply_plain
+= replyinfo_obj
.replies
['signature']
960 reply_plain
+= "\n\n"
965 def add_gpg_key (key_block
, gpgme_ctx
):
966 """Adds a GPG pubkey to the local keystore
968 This adds keys received through email into the key store so they can be
972 key_block: the string form of the ascii-armored public key block
973 gpgme_ctx: the gpgme context
976 the fingerprint(s) of the imported key(s)
979 fp
= io
.BytesIO(key_block
.encode('ascii'))
982 result
= gpgme_ctx
.import_(fp
)
983 imports
= result
.imports
984 except gpgme
.GpgmeError
:
987 key_fingerprints
= []
990 for import_
in imports
:
991 fingerprint
= import_
[0]
992 key_fingerprints
+= [fingerprint
]
994 debug("added gpg key: " + fingerprint
)
996 return key_fingerprints
999 def verify_sig_message (msg_block
, gpgme_ctx
):
1000 """Verifies the signature of a signed, ascii-armored block of text.
1002 It encodes the string into ascii, since binary GPG files are currently
1003 unsupported, and alternative, the ascii-armored format is encodable into
1007 msg_block: a GPG Message block in string form. It may be encrypted or
1008 not. If it is encrypted, it will return empty results.
1009 gpgme_ctx: the gpgme context
1012 A tuple containing the plaintext bytes of the signed part, the list of
1013 fingerprints of keys signing the data, and a boolean marking whether
1014 edward is missing all public keys for validating any of the signatures.
1015 If verification failed, perhaps because the message was also encrypted,
1016 then empty results are returned.
1019 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1020 plain_b
= io
.BytesIO()
1023 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
1024 except gpgme
.GpgmeError
:
1025 return ("",[],False)
1027 plaintext_b
= plain_b
.getvalue()
1029 sigkey_missing
= False
1032 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1033 fingerprints
+= [sig
.fpr
]
1034 sigkey_missing
= False
1037 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1038 sigkey_missing
= True
1040 return (plaintext_b
, fingerprints
, sigkey_missing
)
1043 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1044 """Verifies the signature of a detached signature.
1046 This requires the signature part and the signed part as separate arguments.
1049 detached_sig: the signature part of the detached signature
1050 plaintext_bytes: the byte form of the message being signed.
1051 gpgme_ctx: the gpgme context
1054 A tuple containging a list of signing fingerprints if the signature
1055 verification was sucessful, and a boolean marking whether edward is
1056 missing all public keys for validating any of the signatures.
1057 Otherwise, a tuple containing an empty list and True are returned.
1060 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1061 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1064 result
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1065 except gpgme
.GpgmeError
:
1068 sigkey_missing
= False
1069 sig_fingerprints
= []
1071 if (res_
.summary
== 0) or (res_
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (res_
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1072 sig_fingerprints
+= [res_
.fpr
]
1073 sigkey_missing
= False
1076 if (res_
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1077 sigkey_missing
= True
1079 return (sig_fingerprints
, sigkey_missing
)
1082 def decrypt_block (msg_block
, gpgme_ctx
):
1083 """Decrypts a block of GPG text and verifies any included sigatures.
1085 Some encypted messages have embeded signatures, so those are verified too.
1088 msg_block: the encrypted(/signed) text
1089 gpgme_ctx: the gpgme context
1092 A tuple containing plaintext bytes, signatures (if the decryption and
1093 signature verification were successful, respectively), and a boolean
1094 marking whether edward is missing all public keys for validating any of
1098 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1099 plain_b
= io
.BytesIO()
1102 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1103 except gpgme
.GpgmeError
:
1104 return ("",[],False)
1106 plaintext_b
= plain_b
.getvalue()
1108 sigkey_missing
= False
1111 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1112 fingerprints
+= [sig
.fpr
]
1113 sigkey_missing
= False
1116 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1117 sigkey_missing
= True
1119 return (plaintext_b
, fingerprints
, sigkey_missing
)
1122 def email_to_from_subject (email_bytes
):
1123 """Returns the values of the email's To:, From: and Subject: fields
1125 Returns this information from an email.
1128 email_bytes: the byte string form of the email
1131 the email To:, From:, and Subject: fields as strings
1134 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
1136 email_to
= email_struct
['To']
1137 email_from
= email_struct
['From']
1138 email_subject
= email_struct
['Subject']
1140 return email_to
, email_from
, email_subject
1143 def import_lang_pick_address(email_to
, hostname
):
1144 """Imports language file for i18n support; makes reply from address
1146 The language imported depends on the To: address of the email received by
1147 edward. an -en ending implies the English language, whereas a -ja ending
1148 implies Japanese. The list of supported languages is listed in the 'langs'
1149 list at the beginning of the program. This function also chooses the
1150 language-dependent address which can be used as the From address in the
1154 email_to: the string containing the email address that the mail was
1156 hostname: the hostname part of the reply email's from address
1159 the reference to the imported language module. The only variable in
1160 this file is the 'replies' dictionary.
1166 if email_to
!= None:
1168 if "edward-" + lang
in email_to
:
1172 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1173 lang_module
= importlib
.import_module(lang_mod_name
)
1175 reply_from
= "edward-" + use_lang
+ "@" + hostname
1177 return lang_module
, reply_from
1180 def generate_encrypted_mime (plaintext
, email_to
, email_subject
, encrypt_to_key
,
1182 """This function creates the mime email reply. It can encrypt the email.
1184 If the encrypt_key is included, then the email is encrypted and signed.
1185 Otherwise it is unencrypted.
1188 plaintext: the plaintext body of the message to create.
1189 email_to: the email address to reply to
1190 email_subject: the subject to use in reply
1191 encrypt_to_key: the key object to use for encrypting the email. (or
1193 gpgme_ctx: the gpgme context
1196 A string version of the mime message, possibly encrypted and signed.
1199 if (encrypt_to_key
!= None):
1201 plaintext_mime
= MIMEText(plaintext
)
1202 plaintext_mime
.set_charset('utf-8')
1204 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1208 control_mime
= MIMEApplication("Version: 1",
1209 _subtype
='pgp-encrypted',
1210 _encoder
=email
.encoders
.encode_7or8bit
)
1211 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1212 control_mime
.set_charset('us-ascii')
1214 encoded_mime
= MIMEApplication(encrypted_text
,
1215 _subtype
='octet-stream; name="encrypted.asc"',
1216 _encoder
=email
.encoders
.encode_7or8bit
)
1217 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1218 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1219 encoded_mime
.set_charset('us-ascii')
1221 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1222 message_mime
.attach(control_mime
)
1223 message_mime
.attach(encoded_mime
)
1224 message_mime
['Content-Disposition'] = 'inline'
1227 message_mime
= MIMEText(plaintext
)
1228 message_mime
.set_charset('utf-8')
1230 message_mime
['To'] = email_to
1231 message_mime
['Subject'] = email_subject
1233 reply
= message_mime
.as_string()
1238 def send_reply(email_txt
, subject
, reply_to
, reply_from
):
1240 email_bytes
= email_txt
.encode('ascii')
1242 p
= subprocess
.Popen(["/usr/sbin/sendmail", "-f", reply_from
, "-F", "Edward, GPG Bot", "-i", reply_to
], stdin
=subprocess
.PIPE
)
1244 (stdout
, stderr
) = p
.communicate(email_bytes
)
1247 debug("sendmail stdout: " + str(stdout
))
1249 error("sendmail stderr: " + str(stderr
))
1252 def email_quote_text (text
):
1253 """Quotes input text by inserting "> "s
1255 This is useful for quoting a text for the reply message. It inserts "> "
1256 strings at the beginning of lines.
1259 text: plain text to quote
1265 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1267 return quoted_message
1270 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1271 """Encrypts and signs plaintext
1273 This encrypts and signs a message.
1276 plaintext: text to sign and ecrypt
1277 encrypt_to_key: the key object to encrypt to
1278 gpgme_ctx: the gpgme context
1281 An encrypted and signed string of text
1284 # the plaintext should be mime encoded in an ascii-compatible form
1285 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1286 encrypted_bytes
= io
.BytesIO()
1288 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1289 plaintext_bytes
, encrypted_bytes
)
1291 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1292 return encrypted_txt
1295 def error (error_msg
):
1296 """Write an error message to stdout
1298 The error message includes the program name.
1301 error_msg: the message to print
1307 An error message is printed to stdout
1310 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1313 def debug (debug_msg
):
1314 """Writes a debug message to stdout if debug == True
1316 If the debug option is set in edward_config.py, then the passed message
1317 gets printed to stdout.
1320 debug_msg: the message to print to stdout
1326 A debug message is printed to stdout
1329 if edward_config
.debug
== True:
1334 """Sets the progname variable and processes optional argument
1336 If there are more than two arguments then edward complains and quits. An
1337 single "-p" argument sets the print_reply_only option, which makes edward
1338 print email replies instead of mailing them.
1344 True if edward should print arguments instead of mailing them,
1345 otherwise it returns False.
1348 Exits with error 1 if there are more than two arguments, otherwise
1349 returns the print_reply_only option.
1353 progname
= sys
.argv
[0]
1355 print_reply_only
= False
1357 if len(sys
.argv
) > 2:
1358 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1359 + " -p print reply message to stdout, do not mail it\n", \
1363 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1364 print_reply_only
= True
1366 return print_reply_only
1369 if __name__
== "__main__":
1370 """Executes main if this file is not loaded interactively"""