8853564b0ed9d8288f34ef0ef22e2c45e08a5b15
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
45 from email
.mime
.multipart
import MIMEMultipart
46 from email
.mime
.application
import MIMEApplication
47 from email
.mime
.nonmultipart
import MIMENonMultipart
51 langs
= ["de", "el", "en", "fr", "ja", "pt-br", "ro", "ru", "tr"]
53 """This list contains the abbreviated names of reply languages available to
57 match_types
= [('message',
58 '-----BEGIN PGP MESSAGE-----.*?-----END PGP MESSAGE-----'),
60 '-----BEGIN PGP PUBLIC KEY BLOCK-----.*?-----END PGP PUBLIC KEY BLOCK-----'),
62 '-----BEGIN PGP SIGNATURE-----.*?-----END PGP SIGNATURE-----')]
64 """This list of tuples matches query names with re.search() queries used
65 to find GPG data for edward to process."""
68 class EddyMsg (object):
70 The EddyMsg class represents relevant parts of a mime message.
72 The represented message can be single-part or multi-part.
74 'multipart' is set to True if there are multiple mime parts.
76 'subparts' points to a list of mime sub-parts if it is a multi-part
77 message. Otherwise it points to an empty list.
79 'payload_bytes' is a binary representation of the mime part before header
80 removal and message decoding.
82 'payload_pieces' is a list of objects containing strings that when strung
83 together form the fully-decoded string representation of the mime part.
85 The 'filename', 'content_type' and 'description_list' come from the mime
97 description_list
= None
100 class PayloadPiece (object):
102 PayloadPiece represents a complte or sub-section of a mime part.
104 Instances of this class are often strung together within one or more arrays
105 pointed to by each instance of the EddyMsg class.
107 'piece_type' refers to a string whose value describes the content of
108 'string'. Examples include "pubkey", for public keys, and "message", for
109 encrypted data (or armored signatures until they are known to be such.) The
110 names derive from the header and footer of each of these ascii-encoded gpg
113 'string' contains some string of text, such as non-GPG text, an encrypted
114 block of text, a signature, or a public key.
116 'gpg_data' points to any instances of GPGData that have been created based
117 on the contents of 'string'.
125 class GPGData (object):
127 GPGData holds info from decryption, sig. verification, and/or pub. keys.
129 Instances of this class contain decrypted information, signature
130 fingerprints and/or fingerprints of processed and imported public keys.
132 'decrypted' is set to True if 'plainobj' was created from encrypted data.
134 'plainobj' points to any decrypted, or signed part of, a GPG signature. It
135 is intended to be an instance of the EddyMsg class.
137 'sigs' is a list of fingerprints of keys used to sign the data in plainobj.
139 'keys' is a list of fingerprints of keys obtained in public key blocks.
149 class ReplyInfo (object):
151 ReplyInfo contains details that edward uses in generating its reply.
153 Instances of this class contain information about whether a message was
154 successfully encrypted or signed, and whether a public key was attached, or
155 retrievable, from the local GPG store. It stores the fingerprints of
156 potential encryption key candidates and the message (if any at all) to
157 quote in edward's reply.
159 'replies' points one of the dictionaries of translated replies.
161 'target_key' refers to the fingerprint of a key used to sign encrypted
162 data. This is the preferred key, if it is set, and if is available.
164 'fallback_target_key' referst to the fingerprint of a key used to sign
165 unencrypted data; alternatively it may be a public key attached to the
168 'msg_to_quote' refers to the part of a message which edward should quote in
169 his reply. This should remain as None if there was no encrypted and singed
170 part. This is to avoid making edward a service for decrypting other
171 people's messages to edward.
173 'success_decrypt' is set to True if edward could decrypt part of the
176 'failed_decrypt' is set to True if edward failed to decrypt part of the
179 'publick_key_received' is set to True if edward successfully imported a
182 'no_public_key' is set to True if edward doesn't have a key to encrypt to
183 when replying to the user.
185 'sig_success' is set to True if edward could to some extent verify the
186 signature of a signed part of the message to edward.
188 'sig_failure' is set to True if edward failed to some extent verify the
189 signature of a signed part of the message to edward.
195 fallback_target_key
= None
198 success_decrypt
= False
199 failed_decrypt
= False
200 public_key_received
= False
201 no_public_key
= False
209 This is the main function for edward, a GPG reply bot.
211 Edward responds to GPG-encrypted and signed mail, encrypting and signing
212 the response if the user's public key is, or was, included in the message.
221 Mime or plaintext email passing in through standard input. Portions of
222 the email may be encrypted. If the To: address contains the text
223 "edward-ja", then the reply will contain a reply written in the
224 Japanese language. There are other languages as well. The default
228 A reply email will be printed to standard output. The contents of the
229 reply email depends on whether the original email was encrypted or not,
230 has or doesn't have a signature, whether a public key used in the
231 original message is provided or locally stored, and the language
232 implied by the To: address in the original email.
237 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
238 edward_config
.sign_with_key
)
240 email_text
= sys
.stdin
.read()
241 email_struct
= parse_pgp_mime(email_text
, gpgme_ctx
)
243 email_to
, email_from
, email_subject
= email_to_from_subject(email_text
)
244 lang
= import_lang(email_to
)
246 replyinfo_obj
= ReplyInfo()
247 replyinfo_obj
.replies
= lang
.replies
249 prepare_for_reply(email_struct
, replyinfo_obj
)
250 encrypt_to_key
= get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
251 reply_plaintext
= write_reply(replyinfo_obj
)
253 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_from
, \
254 email_subject
, encrypt_to_key
,
260 def get_gpg_context (gnupghome
, sign_with_key_fp
):
262 This function returns the GPG context needed for encryption and signing.
264 The context is needed by other functions which use GPG functionality.
267 gnupghome: The path to "~/.gnupg/" or its alternative.
268 sign_with_key: The fingerprint of the key to sign with
271 A gpgme context to be used for GPG functions.
274 the 'armor' flag is set to True and the list of signing keys contains
275 the single specified key
278 os
.environ
['GNUPGHOME'] = gnupghome
280 gpgme_ctx
= gpgme
.Context()
281 gpgme_ctx
.armor
= True
284 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
285 except gpgme
.GpgmeError
:
286 error("unable to load signing key. is the gnupghome "
287 + "and signing key properly set in the edward_config.py?")
290 gpgme_ctx
.signers
= [sign_with_key
]
295 def parse_pgp_mime (email_text
, gpgme_ctx
):
296 """Parses the email for mime payloads and decrypts/verfies signatures.
298 This function creates a representation of a mime or plaintext email with
299 the EddyMsg class. It then splits each mime payload into one or more pieces
300 which may be plain text or GPG data. It then decrypts encrypted parts and
301 does some very basic signature verification on those parts.
304 email_text: an email message in string format
305 gpgme_ctx: a gpgme context
308 A message as an instance of EddyMsg
311 the returned EddyMsg instance has split, decrypted, verified and pubkey
315 email_struct
= email
.parser
.Parser().parsestr(email_text
)
317 eddymsg_obj
= parse_mime(email_struct
)
318 split_payloads(eddymsg_obj
)
319 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
324 def parse_mime(msg_struct
):
325 """Translates python's email.parser format into an EddyMsg format
327 If the message is multi-part, then a recursive object is created, where
328 each sub-part is also a EddyMsg instance.
331 msg_struct: an email parsed with email.parser.Parser(), which can be
335 an instance of EddyMsg, potentially a recursive one.
338 eddymsg_obj
= EddyMsg()
340 if msg_struct
.is_multipart() == True:
341 payloads
= msg_struct
.get_payload()
343 eddymsg_obj
.multipart
= True
344 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
347 eddymsg_obj
= get_subpart_data(msg_struct
)
352 def scan_and_split (payload_piece
, match_type
, pattern
):
353 """This splits the payloads of an EddyMsg object into GPG and text parts.
355 An EddyMsg object's payload_pieces starts off as a list containing a single
356 PayloadPiece object. This function returns a list of these objects which
357 have been split into GPG data and regular text, if such splits need to be/
361 payload_piece: a single payload or a split part of a payload
362 match_type: the type of data to try to spit out from the payload piece
363 pattern: the search pattern to be used for finding that type of data
366 a list of objects of the PayloadPiece class, in the order that the
367 string part of payload_piece originally was, broken up according to
368 matches specified by 'pattern'.
371 # don't try to re-split pieces containing gpg data
372 if payload_piece
.piece_type
!= "text":
373 return [payload_piece
]
375 flags
= re
.DOTALL | re
.MULTILINE
376 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
377 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
380 pieces
= [payload_piece
]
384 beginning
= PayloadPiece()
385 beginning
.string
= matches
.group('beginning')
386 beginning
.piece_type
= payload_piece
.piece_type
388 match
= PayloadPiece()
389 match
.string
= matches
.group('match')
390 match
.piece_type
= match_type
392 rest
= PayloadPiece()
393 rest
.string
= matches
.group('rest')
394 rest
.piece_type
= payload_piece
.piece_type
396 more_pieces
= scan_and_split(rest
, match_type
, pattern
)
397 pieces
= [beginning
, match
] + more_pieces
402 def get_subpart_data (part
):
403 """This function grabs information from a single part mime object.
405 It copies needed data from a single part email.parser.Parser() object over
406 to an EddyMsg object.
409 part: a non-multi-part mime.parser.Parser() object
412 a single-part EddyMsg() object
415 charset
= part
.get_content_charset()
416 mime_decoded_bytes
= part
.get_payload(decode
=True)
419 obj
.payload_bytes
= part
.as_bytes()
421 obj
.filename
= part
.get_filename()
422 obj
.content_type
= part
.get_content_type()
423 obj
.description_list
= part
['content-description']
425 # your guess is as good as a-myy-ee-ine...
429 if mime_decoded_bytes
!= None:
431 payload
= PayloadPiece()
432 payload
.string
= mime_decoded_bytes
.decode(charset
)
433 payload
.piece_type
= 'text'
435 obj
.payload_pieces
= [payload
]
436 except UnicodeDecodeError:
442 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
443 """A function which maps another function onto a message's subparts.
445 This is a higer-order function which recursively performs a specified
446 function on each subpart of a multi-part message. Each single-part sub-part
447 has the function applied to it. This function also works if the part passed
451 function_to_do: function to perform on sub-parts
452 eddymsg_obj: a single part or multi-part EddyMsg object
453 data: a second argument to pass to 'function_to_do'
459 The passed-in EddyMsg object is transformed recursively on its
460 sub-parts according to 'function_to_do'.
463 if eddymsg_obj
.multipart
== True:
464 for sub
in eddymsg_obj
.subparts
:
465 do_to_eddys_pieces(function_to_do
, sub
, data
)
467 function_to_do(eddymsg_obj
, data
)
470 def split_payloads (eddymsg_obj
):
471 """Splits all (sub-)payloads of a message into GPG data and regular text.
473 Recursively performs payload splitting on all sub-parts of an EddyMsg
474 object into the various GPG data types, such as GPG messages, public key
475 blocks and signed text.
478 eddymsg_obj: an instance of EddyMsg
484 The EddyMsg object has payloads that are unsplit (by may be split)..
487 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
490 for match_type
in match_types
:
491 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_type
)
494 def split_payload_pieces (eddymsg_obj
, match_type
):
495 """A helper function for split_payloads(); works on PayloadPiece objects.
497 This function splits up PayloadPiece objects into multipe PayloadPiece
498 objects and replaces the EddyMsg object's previous list of payload pieces
499 with the new split up one.
502 eddymsg_obj: a single-part EddyMsg object.
503 match_type: a tuple from the match_types list, which specifies a match
504 name and a match pattern.
510 The payload piece(s) of an EddyMsg object may be already split or
514 The EddyMsg object's payload piece(s) are split into a list of pieces
515 if matches of the match_type are found.
518 (match_name
, pattern
) = match_type
521 for piece
in eddymsg_obj
.payload_pieces
:
522 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
524 eddymsg_obj
.payload_pieces
= new_pieces_list
527 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
528 """Performs GPG operations on the GPG parts of the message
530 This function decrypts text, verifies signatures, and imports public keys
531 included in an email.
534 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
535 and non-GPG sections by split_payloads()
536 gpgme_ctx: a gpgme context
538 prev_parts: a list of mime parts that occur before the eddymsg_obj
539 part, under the same multi-part mime part. This is used for
540 verifying detached signatures. For the root mime part, this should
541 be an empty list, which is the default value if this paramater is
548 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
551 Decryption, verification and key imports occur. the gpg_data member of
552 PayloadPiece objects get filled in with GPGData objects.
555 if eddymsg_obj
.multipart
== True:
557 for sub
in eddymsg_obj
.subparts
:
558 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
563 for piece
in eddymsg_obj
.payload_pieces
:
565 if piece
.piece_type
== "text":
566 # don't transform the plaintext.
569 elif piece
.piece_type
== "message":
570 (plaintext
, sigs
) = decrypt_block(piece
.string
, gpgme_ctx
)
573 piece
.gpg_data
= GPGData()
574 piece
.gpg_data
.decrypted
= True
575 piece
.gpg_data
.sigs
= sigs
577 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
580 # if not encrypted, check to see if this is an armored signature.
581 (plaintext
, sigs
) = verify_sig_message(piece
.string
, gpgme_ctx
)
584 piece
.piece_type
= "signature"
585 piece
.gpg_data
= GPGData()
586 piece
.gpg_data
.sigs
= sigs
588 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
590 # FIXME: consider handling pubkeys first, so that signatures can be
591 # validated on freshly imported keys
592 elif piece
.piece_type
== "pubkey":
593 key_fps
= add_gpg_key(piece
.string
, gpgme_ctx
)
596 piece
.gpg_data
= GPGData()
597 piece
.gpg_data
.keys
= key_fps
599 elif piece
.piece_type
== "detachedsig":
600 for prev
in prev_parts
:
601 sig_fps
= verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
604 piece
.gpg_data
= GPGData()
605 piece
.gpg_data
.sigs
= sig_fps
606 piece
.gpg_data
.plainobj
= prev
613 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
614 """Updates replyinfo_obj with info on the message's GPG success/failures
616 This function marks replyinfo_obj with information about whether encrypted
617 text in eddymsg_obj was successfully decrypted, signatures were verified
618 and whether a public key was found or not.
621 eddymsg_obj: a message in the EddyMsg format
622 replyinfo_obj: an instance of ReplyInfo
628 eddymsg_obj has had its gpg_data created by gpg_on_payloads
631 replyinfo_obj has been updated with info about decryption/sig
632 verififcation status, etc. However the desired key isn't imported until
633 later, so the success or failure of that updates the values set here.
636 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
638 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
639 """A helper function for prepare_for_reply
641 It updates replyinfo_obj with GPG success/failure information, when
642 supplied a single-part EddyMsg object.
645 eddymsg_obj: a single-part message in the EddyMsg format
646 replyinfo_obj: an object which holds information about the message's
653 eddymsg_obj is a single-part message. (it may be a part of a multi-part
654 message.) It has had its gpg_data created by gpg_on_payloads if it has
658 replyinfo_obj has been updated with gpg success/failure information
661 for piece
in eddymsg_obj
.payload_pieces
:
662 if piece
.piece_type
== "text":
663 # don't quote the plaintext part.
666 elif piece
.piece_type
== "message":
667 prepare_for_reply_message(piece
, replyinfo_obj
)
669 elif piece
.piece_type
== "pubkey":
670 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
672 elif (piece
.piece_type
== "detachedsig") \
673 or (piece
.piece_type
== "signature"):
674 prepare_for_reply_sig(piece
, replyinfo_obj
)
677 def prepare_for_reply_message (piece
, replyinfo_obj
):
678 """Helper function for prepare_for_reply()
680 This function is called when the piece_type of a payload piece is
681 "message", or GPG Message block. This should be encrypted text. If the
682 encryted block is signed, a sig will be attached to .target_key unless
683 there is already one there.
686 piece: a PayloadPiece object.
687 replyinfo_obj: object which gets updated with decryption status, etc.
694 the piece.payload_piece value should be "message".
697 replyinfo_obj gets updated with decryption status, signing status and a
698 potential signing key.
701 if piece
.gpg_data
== None:
702 replyinfo_obj
.failed_decrypt
= True
705 replyinfo_obj
.success_decrypt
= True
707 # we already have a key (and a message)
708 if replyinfo_obj
.target_key
!= None:
711 if piece
.gpg_data
.sigs
!= []:
712 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
713 get_signed_part
= False
715 # only include a signed message in the reply.
716 get_signed_part
= True
718 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
720 # to catch public keys in encrypted blocks
721 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
724 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
725 """Helper function for prepare_for_reply(). Marks pubkey import status.
727 Marks replyinfo_obj with pub key import status.
730 piece: a PayloadPiece object
731 replyinfo_obj: a ReplyInfo object
734 piece.piece_type should be set to "pubkey".
737 replyinfo_obj has its fields updated.
740 if piece
.gpg_data
== None or piece
.gpg_data
.keys
== []:
741 replyinfo_obj
.no_public_key
= True
743 replyinfo_obj
.public_key_received
= True
745 # prefer public key as a fallback for the encrypted reply
746 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
749 def prepare_for_reply_sig (piece
, replyinfo_obj
):
750 """Helper function for prepare_for_reply(). Marks sig verification status.
752 Marks replyinfo_obj with signature verification status.
755 piece: a PayloadPiece object
756 replyinfo_obj: a ReplyInfo object
759 piece.piece_type should be set to "signature", or "detachedsig".
762 replyinfo_obj has its fields updated.
765 if piece
.gpg_data
== None or piece
.gpg_data
.sigs
== []:
766 replyinfo_obj
.sig_failure
= True
768 replyinfo_obj
.sig_success
= True
770 if replyinfo_obj
.fallback_target_key
== None:
771 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
774 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
775 """For creating a string representation of a signed, encrypted part.
777 When given a decrypted payload, it will add either the plaintext or signed
778 plaintext to the reply message, depeding on 'get_signed_part'. This is
779 useful for ensuring that the reply message only comes from a signed and
780 ecrypted GPG message. It also sets the target_key for encrypting the reply
781 if it's told to get signed text only.
784 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
786 replyinfo_obj: a ReplyInfo object for holding the message to quote and
787 the target_key to encrypt to.
788 get_signed_part: True if we should only include text that contains a
789 further signature. If False, then include plain text.
795 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
796 which represents decrypted text. It may or may not be signed on that
800 the ReplyInfo instance may have a new 'target_key' set and its
801 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
805 if eddymsg_obj
== None:
808 # recurse on multi-part mime
809 if eddymsg_obj
.multipart
== True:
810 for sub
in eddymsg_obj
.subparts
:
811 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
813 for piece
in eddymsg_obj
.payload_pieces
:
814 if (get_signed_part
):
815 if ((piece
.piece_type
== "detachedsig") \
816 or (piece
.piece_type
== "signature")) \
817 and (piece
.gpg_data
!= None):
818 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
819 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
822 if piece
.piece_type
== "text":
823 replyinfo_obj
.msg_to_quote
+= piece
.string
826 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
827 """Obtains a public key object from a key fingerprint
829 If the .target_key is not set, then we use .fallback_target_key.
832 replyinfo_obj: ReplyInfo instance
833 gpgme_ctx: the gpgme context
836 The key object of the key of either the target_key or the fallback one
837 if .target_key is not set. If the key cannot be loaded, then return
841 Loading a key requires that we have the public key imported. This
842 requires that they email contains the pub key block, or that it was
843 previously sent to edward.
846 If the key cannot be loaded, then the replyinfo_obj is marked for
847 having no public key available.
850 if replyinfo_obj
.target_key
== None:
851 replyinfo_obj
.target_key
= replyinfo_obj
.fallback_target_key
853 if replyinfo_obj
.target_key
!= None:
855 encrypt_to_key
= gpgme_ctx
.get_key(replyinfo_obj
.target_key
)
856 return encrypt_to_key
858 except gpgme
.GpgmeError
:
861 # no available key to use
862 replyinfo_obj
.target_key
= None
863 replyinfo_obj
.fallback_target_key
= None
865 replyinfo_obj
.no_public_key
= True
866 replyinfo_obj
.public_key_received
= False
871 def write_reply (replyinfo_obj
):
872 """Write the reply email body about the GPG successes/failures.
874 The reply is about whether decryption, sig verification and key
875 import/loading was successful or failed. If text was successfully decrypted
876 and verified, then the first instance of such text will be included in
880 replyinfo_obj: contains details of GPG processing status
883 the plaintext message to be sent to the user
886 replyinfo_obj should be populated with info about GPG processing status.
891 if replyinfo_obj
.success_decrypt
== True:
892 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
894 if replyinfo_obj
.no_public_key
== False:
895 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
896 reply_plain
+= quoted_text
898 elif replyinfo_obj
.failed_decrypt
== True:
899 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
902 if replyinfo_obj
.sig_success
== True:
903 reply_plain
+= "\n\n"
904 reply_plain
+= replyinfo_obj
.replies
['sig_success']
906 elif replyinfo_obj
.sig_failure
== True:
907 reply_plain
+= "\n\n"
908 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
911 if replyinfo_obj
.public_key_received
== True:
912 reply_plain
+= "\n\n"
913 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
915 elif replyinfo_obj
.no_public_key
== True:
916 reply_plain
+= "\n\n"
917 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
920 reply_plain
+= "\n\n"
921 reply_plain
+= replyinfo_obj
.replies
['signature']
926 def add_gpg_key (key_block
, gpgme_ctx
):
927 """Adds a GPG pubkey to the local keystore
929 This adds keys received through email into the key store so they can be
933 key_block: the string form of the ascii-armored public key block
934 gpgme_ctx: the gpgme context
937 the fingerprint(s) of the imported key(s)
940 fp
= io
.BytesIO(key_block
.encode('ascii'))
943 result
= gpgme_ctx
.import_(fp
)
944 imports
= result
.imports
945 except gpgme
.GpgmeError
:
948 key_fingerprints
= []
951 for import_
in imports
:
952 fingerprint
= import_
[0]
953 key_fingerprints
+= [fingerprint
]
955 debug("added gpg key: " + fingerprint
)
957 return key_fingerprints
960 def verify_sig_message (msg_block
, gpgme_ctx
):
961 """Verifies the signature of a signed, ascii-armored block of text.
963 It encodes the string into ascii, since binary GPG files are currently
964 unsupported, and alternative, the ascii-armored format is encodable into
968 msg_block: a GPG Message block in string form. It may be encrypted or
969 not. If it is encrypted, it will return empty results.
970 gpgme_ctx: the gpgme context
973 A tuple of the plaintext of the signed part and the list of
974 fingerprints of keys signing the data. If verification failed, perhaps
975 because the message was also encrypted, then empty results are
979 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
980 plain_b
= io
.BytesIO()
983 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
984 except gpgme
.GpgmeError
:
987 plaintext
= plain_b
.getvalue().decode('utf-8')
991 fingerprints
+= [sig
.fpr
]
992 return (plaintext
, fingerprints
)
995 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
996 """Verifies the signature of a detached signature.
998 This requires the signature part and the signed part as separate arguments.
1001 detached_sig: the signature part of the detached signature
1002 plaintext_bytes: the byte form of the message being signed.
1003 gpgme_ctx: the gpgme context
1006 A list of signing fingerprints if the signature verification was
1007 sucessful. Otherwise, an empty list is returned.
1010 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1011 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1014 result
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1015 except gpgme
.GpgmeError
:
1018 sig_fingerprints
= []
1020 sig_fingerprints
+= [res_
.fpr
]
1022 return sig_fingerprints
1025 def decrypt_block (msg_block
, gpgme_ctx
):
1026 """Decrypts a block of GPG text, and verifies any included sigatures.
1028 Some encypted messages have embeded signatures, so those are verified too.
1031 msg_block: the encrypted(/signed) text
1032 gpgme_ctx: the gpgme context
1035 A tuple of plaintext and signatures, if the decryption and signature
1036 verification were successful, respectively.
1039 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1040 plain_b
= io
.BytesIO()
1043 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1044 except gpgme
.GpgmeError
:
1047 plaintext
= plain_b
.getvalue().decode('utf-8')
1051 fingerprints
+= [sig
.fpr
]
1052 return (plaintext
, fingerprints
)
1055 def email_to_from_subject (email_text
):
1056 """Returns the values of the email's To:, From: and Subject: fields
1058 Returns this information from an email.
1061 email_text: the string form of the email
1064 the email To:, From:, and Subject: fields as strings
1067 email_struct
= email
.parser
.Parser().parsestr(email_text
)
1069 email_to
= email_struct
['To']
1070 email_from
= email_struct
['From']
1071 email_subject
= email_struct
['Subject']
1073 return email_to
, email_from
, email_subject
1076 def import_lang(email_to
):
1077 """Imports appropriate language file for basic i18n support
1079 The language imported depends on the To: address of the email received by
1080 edward. an -en ending implies the English language, whereas a -ja ending
1081 implies Japanese. The list of supported languages is listed in the 'langs'
1082 list at the beginning of the program.
1085 email_to: the string containing the email address that the mail was
1089 the reference to the imported language module. The only variable in
1090 this file is the 'replies' dictionary.
1093 lang_module
= "lang.en"
1095 if email_to
!= None:
1097 if "edward-" + lang
in email_to
:
1098 lang_module
= "lang." + re
.sub('-', '_', lang
)
1100 return importlib
.import_module(lang_module
)
1103 def generate_encrypted_mime (plaintext
, email_to
, email_subject
, encrypt_to_key
,
1105 """This function creates the mime email reply. It can encrypt the email.
1107 If the encrypt_key is included, then the email is encrypted and signed.
1108 Otherwise it is unencrypted.
1111 plaintext: the plaintext body of the message to create.
1112 email_to: the email address to reply to
1113 email_subject: the subject to use in reply
1114 encrypt_to_key: the key object to use for encrypting the email. (or
1116 gpgme_ctx: the gpgme context
1119 A string version of the mime message, possibly encrypted and signed.
1122 # quoted printable encoding lets most ascii characters look normal
1123 # before the mime message is decoded.
1124 char_set
= email
.charset
.Charset("utf-8")
1125 char_set
.body_encoding
= email
.charset
.QP
1127 # MIMEText doesn't allow setting the text encoding
1128 # so we use MIMENonMultipart.
1129 plaintext_mime
= MIMENonMultipart('text', 'plain')
1130 plaintext_mime
.set_payload(plaintext
, charset
=char_set
)
1132 if (encrypt_to_key
!= None):
1134 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1137 gpg_payload
= encrypted_text
1140 signed_text
= sign_message(plaintext_mime
.as_string(), gpgme_ctx
)
1141 gpg_payload
= signed_text
1143 control_mime
= MIMEApplication("Version: 1",
1144 _subtype
='pgp-encrypted',
1145 _encoder
=email
.encoders
.encode_7or8bit
)
1146 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1147 control_mime
.set_charset('us-ascii')
1149 encoded_mime
= MIMEApplication(gpg_payload
,
1150 _subtype
='octet-stream; name="encrypted.asc"',
1151 _encoder
=email
.encoders
.encode_7or8bit
)
1152 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1153 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1154 encoded_mime
.set_charset('us-ascii')
1156 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1157 message_mime
.attach(control_mime
)
1158 message_mime
.attach(encoded_mime
)
1159 message_mime
['Content-Disposition'] = 'inline'
1162 message_mime
['To'] = email_to
1163 message_mime
['Subject'] = email_subject
1165 reply
= message_mime
.as_string()
1170 def email_quote_text (text
):
1171 """Quotes input text by inserting "> "s
1173 This is useful for quoting a text for the reply message. It inserts "> "
1174 strings at the beginning of lines.
1177 text: plain text to quote
1183 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1185 return quoted_message
1188 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1189 """Encrypts and signs plaintext
1191 This encrypts and signs a message.
1194 plaintext: text to sign and ecrypt
1195 encrypt_to_key: the key object to encrypt to
1196 gpgme_ctx: the gpgme context
1199 An encrypted and signed string of text
1202 # the plaintext should be mime encoded in an ascii-compatible form
1203 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1204 encrypted_bytes
= io
.BytesIO()
1206 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1207 plaintext_bytes
, encrypted_bytes
)
1209 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1210 return encrypted_txt
1213 def sign_message (plaintext
, gpgme_ctx
):
1216 This signs a message.
1219 plaintext: text to sign
1220 gpgme_ctx: the gpgme context
1223 An armored signature as a string of text
1226 # the plaintext should be mime encoded in an ascii-compatible form
1227 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1228 signed_bytes
= io
.BytesIO()
1230 gpgme_ctx
.sign(plaintext_bytes
, signed_bytes
, gpgme
.SIG_MODE_NORMAL
)
1232 signed_txt
= signed_bytes
.getvalue().decode('ascii')
1236 def error (error_msg
):
1237 """Write an error message to stdout
1239 The error message includes the program name.
1242 error_msg: the message to print
1248 An error message is printed to stdout
1251 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1254 def debug (debug_msg
):
1255 """Writes a debug message to stdout if debug == True
1257 If the debug option is set in edward_config.py, then the passed message
1258 gets printed to stdout.
1261 debug_msg: the message to print to stdout
1267 A debug message is printed to stdout
1270 if edward_config
.debug
== True:
1275 """Sets the progname variable and complains about any arguments
1277 If there are any arguments, then edward complains and quits, because input
1287 Exits with error 1 if there are arguments, otherwise returns to the
1288 calling function, such as main().
1292 progname
= sys
.argv
[0]
1294 if len(sys
.argv
) > 1:
1295 print(progname
+ ": error, this program doesn't " \
1296 "need any arguments.", file=sys
.stderr
)
1300 if __name__
== "__main__":
1301 """Executes main if this file is not loaded interactively"""