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
.multipart
import MIMEMultipart
48 from email
.mime
.application
import MIMEApplication
49 from email
.mime
.nonmultipart
import MIMENonMultipart
53 langs
= ["de", "el", "en", "fr", "ja", "pt-br", "ro", "ru", "tr"]
55 """This list contains the abbreviated names of reply languages available to
58 class TxtType (enum
.Enum
):
66 match_pairs
= [(TxtType
.message
,
67 '-----BEGIN PGP MESSAGE-----.*?-----END PGP MESSAGE-----'),
69 '-----BEGIN PGP PUBLIC KEY BLOCK-----.*?-----END PGP PUBLIC KEY BLOCK-----'),
71 '-----BEGIN PGP SIGNATURE-----.*?-----END PGP SIGNATURE-----')]
73 """This list of tuples matches query names with re.search() queries used
74 to find GPG data for edward to process."""
77 class EddyMsg (object):
79 The EddyMsg class represents relevant parts of a mime message.
81 The represented message can be single-part or multi-part.
83 'multipart' is set to True if there are multiple mime parts.
85 'subparts' points to a list of mime sub-parts if it is a multi-part
86 message. Otherwise it points to an empty list.
88 'payload_bytes' is a binary representation of the mime part before header
89 removal and message decoding.
91 'payload_pieces' is a list of objects containing strings that when strung
92 together form the fully-decoded string representation of the mime part.
94 The 'filename', 'content_type' and 'description_list' come from the mime
106 description_list
= None
109 class PayloadPiece (object):
111 PayloadPiece represents a complte or sub-section of a mime part.
113 Instances of this class are often strung together within one or more arrays
114 pointed to by each instance of the EddyMsg class.
116 'piece_type' refers to an enum whose value describes the content of
117 'string'. Examples include TxtType.pubkey, for public keys, and
118 TxtType.message, for encrypted data (or armored signatures until they are
119 known to be such.) Some of the names derive from the header and footer of
120 each of these ascii-encoded gpg blocks.
122 'string' contains some string of text, such as non-GPG text, an encrypted
123 block of text, a signature, or a public key.
125 'gpg_data' points to any instances of GPGData that have been created based
126 on the contents of 'string'.
134 class GPGData (object):
136 GPGData holds info from decryption, sig. verification, and/or pub. keys.
138 Instances of this class contain decrypted information, signature
139 fingerprints and/or fingerprints of processed and imported public keys.
141 'decrypted' is set to True if 'plainobj' was created from encrypted data.
143 'plainobj' points to any decrypted, or signed part of, a GPG signature. It
144 is intended to be an instance of the EddyMsg class.
146 'sigs' is a list of fingerprints of keys used to sign the data in plainobj.
148 'keys' is a list of fingerprints of keys obtained in public key blocks.
158 class ReplyInfo (object):
160 ReplyInfo contains details that edward uses in generating its reply.
162 Instances of this class contain information about whether a message was
163 successfully encrypted or signed, and whether a public key was attached, or
164 retrievable, from the local GPG store. It stores the fingerprints of
165 potential encryption key candidates and the message (if any at all) to
166 quote in edward's reply.
168 'replies' points one of the dictionaries of translated replies.
170 'target_key' refers to the fingerprint of a key used to sign encrypted
171 data. This is the preferred key, if it is set, and if is available.
173 'fallback_target_key' referst to the fingerprint of a key used to sign
174 unencrypted data; alternatively it may be a public key attached to the
177 'msg_to_quote' refers to the part of a message which edward should quote in
178 his reply. This should remain as None if there was no encrypted and singed
179 part. This is to avoid making edward a service for decrypting other
180 people's messages to edward.
182 'success_decrypt' is set to True if edward could decrypt part of the
185 'failed_decrypt' is set to True if edward failed to decrypt part of the
188 'publick_key_received' is set to True if edward successfully imported a
191 'no_public_key' is set to True if edward doesn't have a key to encrypt to
192 when replying to the user.
194 'sig_success' is set to True if edward could to some extent verify the
195 signature of a signed part of the message to edward.
197 'sig_failure' is set to True if edward failed to some extent verify the
198 signature of a signed part of the message to edward.
204 fallback_target_key
= None
207 success_decrypt
= False
208 failed_decrypt
= False
209 public_key_received
= False
210 no_public_key
= False
218 This is the main function for edward, a GPG reply bot.
220 Edward responds to GPG-encrypted and signed mail, encrypting and signing
221 the response if the user's public key is, or was, included in the message.
230 Mime or plaintext email passing in through standard input. Portions of
231 the email may be encrypted. If the To: address contains the text
232 "edward-ja", then the reply will contain a reply written in the
233 Japanese language. There are other languages as well. The default
237 A reply email will be printed to standard output. The contents of the
238 reply email depends on whether the original email was encrypted or not,
239 has or doesn't have a signature, whether a public key used in the
240 original message is provided or locally stored, and the language
241 implied by the To: address in the original email.
244 print_reply_only
= handle_args()
246 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
247 edward_config
.sign_with_key
)
249 email_text
= sys
.stdin
.read()
250 email_struct
= parse_pgp_mime(email_text
, gpgme_ctx
)
252 email_to
, email_from
, email_subject
= email_to_from_subject(email_text
)
253 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
255 replyinfo_obj
= ReplyInfo()
256 replyinfo_obj
.replies
= lang
.replies
258 prepare_for_reply(email_struct
, replyinfo_obj
)
259 encrypt_to_key
= get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
260 reply_plaintext
= write_reply(replyinfo_obj
)
262 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_from
, \
263 email_subject
, encrypt_to_key
,
266 if print_reply_only
== True:
269 send_reply(reply_mime
, email_subject
, email_from
, reply_from
)
272 def get_gpg_context (gnupghome
, sign_with_key_fp
):
274 This function returns the GPG context needed for encryption and signing.
276 The context is needed by other functions which use GPG functionality.
279 gnupghome: The path to "~/.gnupg/" or its alternative.
280 sign_with_key: The fingerprint of the key to sign with
283 A gpgme context to be used for GPG functions.
286 the 'armor' flag is set to True and the list of signing keys contains
287 the single specified key
290 os
.environ
['GNUPGHOME'] = gnupghome
292 gpgme_ctx
= gpgme
.Context()
293 gpgme_ctx
.armor
= True
296 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
297 except gpgme
.GpgmeError
:
298 error("unable to load signing key. is the gnupghome "
299 + "and signing key properly set in the edward_config.py?")
302 gpgme_ctx
.signers
= [sign_with_key
]
307 def parse_pgp_mime (email_text
, gpgme_ctx
):
308 """Parses the email for mime payloads and decrypts/verfies signatures.
310 This function creates a representation of a mime or plaintext email with
311 the EddyMsg class. It then splits each mime payload into one or more pieces
312 which may be plain text or GPG data. It then decrypts encrypted parts and
313 does some very basic signature verification on those parts.
316 email_text: an email message in string format
317 gpgme_ctx: a gpgme context
320 A message as an instance of EddyMsg
323 the returned EddyMsg instance has split, decrypted, verified and pubkey
327 email_struct
= email
.parser
.Parser().parsestr(email_text
)
329 eddymsg_obj
= parse_mime(email_struct
)
330 split_payloads(eddymsg_obj
)
331 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
336 def parse_mime(msg_struct
):
337 """Translates python's email.parser format into an EddyMsg format
339 If the message is multi-part, then a recursive object is created, where
340 each sub-part is also a EddyMsg instance.
343 msg_struct: an email parsed with email.parser.Parser(), which can be
347 an instance of EddyMsg, potentially a recursive one.
350 eddymsg_obj
= EddyMsg()
352 if msg_struct
.is_multipart() == True:
353 payloads
= msg_struct
.get_payload()
355 eddymsg_obj
.multipart
= True
356 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
359 eddymsg_obj
= get_subpart_data(msg_struct
)
364 def scan_and_split (payload_piece
, match_name
, pattern
):
365 """This splits the payloads of an EddyMsg object into GPG and text parts.
367 An EddyMsg object's payload_pieces starts off as a list containing a single
368 PayloadPiece object. This function returns a list of these objects which
369 have been split into GPG data and regular text, if such splits need to be/
373 payload_piece: a single payload or a split part of a payload
374 match_name: the type of data to try to spit out from the payload piece
375 pattern: the search pattern to be used for finding that type of data
378 a list of objects of the PayloadPiece class, in the order that the
379 string part of payload_piece originally was, broken up according to
380 matches specified by 'pattern'.
383 # don't try to re-split pieces containing gpg data
384 if payload_piece
.piece_type
!= TxtType
.text
:
385 return [payload_piece
]
387 flags
= re
.DOTALL | re
.MULTILINE
388 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
389 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
392 pieces
= [payload_piece
]
396 beginning
= PayloadPiece()
397 beginning
.string
= matches
.group('beginning')
398 beginning
.piece_type
= payload_piece
.piece_type
400 match
= PayloadPiece()
401 match
.string
= matches
.group('match')
402 match
.piece_type
= match_name
404 rest
= PayloadPiece()
405 rest
.string
= matches
.group('rest')
406 rest
.piece_type
= payload_piece
.piece_type
408 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
409 pieces
= [beginning
, match
] + more_pieces
414 def get_subpart_data (part
):
415 """This function grabs information from a single part mime object.
417 It copies needed data from a single part email.parser.Parser() object over
418 to an EddyMsg object.
421 part: a non-multi-part mime.parser.Parser() object
424 a single-part EddyMsg() object
427 charset
= part
.get_content_charset()
428 mime_decoded_bytes
= part
.get_payload(decode
=True)
431 obj
.payload_bytes
= part
.as_bytes()
433 obj
.filename
= part
.get_filename()
434 obj
.content_type
= part
.get_content_type()
435 obj
.description_list
= part
['content-description']
437 # your guess is as good as a-myy-ee-ine...
441 if mime_decoded_bytes
!= None:
443 payload
= PayloadPiece()
444 payload
.string
= mime_decoded_bytes
.decode(charset
)
445 payload
.piece_type
= TxtType
.text
447 obj
.payload_pieces
= [payload
]
448 except UnicodeDecodeError:
454 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
455 """A function which maps another function onto a message's subparts.
457 This is a higer-order function which recursively performs a specified
458 function on each subpart of a multi-part message. Each single-part sub-part
459 has the function applied to it. This function also works if the part passed
463 function_to_do: function to perform on sub-parts
464 eddymsg_obj: a single part or multi-part EddyMsg object
465 data: a second argument to pass to 'function_to_do'
471 The passed-in EddyMsg object is transformed recursively on its
472 sub-parts according to 'function_to_do'.
475 if eddymsg_obj
.multipart
== True:
476 for sub
in eddymsg_obj
.subparts
:
477 do_to_eddys_pieces(function_to_do
, sub
, data
)
479 function_to_do(eddymsg_obj
, data
)
482 def split_payloads (eddymsg_obj
):
483 """Splits all (sub-)payloads of a message into GPG data and regular text.
485 Recursively performs payload splitting on all sub-parts of an EddyMsg
486 object into the various GPG data types, such as GPG messages, public key
487 blocks and signed text.
490 eddymsg_obj: an instance of EddyMsg
496 The EddyMsg object has payloads that are unsplit (by may be split)..
499 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
502 for match_pair
in match_pairs
:
503 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
506 def split_payload_pieces (eddymsg_obj
, match_pair
):
507 """A helper function for split_payloads(); works on PayloadPiece objects.
509 This function splits up PayloadPiece objects into multipe PayloadPiece
510 objects and replaces the EddyMsg object's previous list of payload pieces
511 with the new split up one.
514 eddymsg_obj: a single-part EddyMsg object.
515 match_pair: a tuple from the match_pairs list, which specifies a match
516 name and a match pattern.
522 The payload piece(s) of an EddyMsg object may be already split or
526 The EddyMsg object's payload piece(s) are split into a list of pieces
527 if matches of the match_pair are found.
530 (match_name
, pattern
) = match_pair
533 for piece
in eddymsg_obj
.payload_pieces
:
534 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
536 eddymsg_obj
.payload_pieces
= new_pieces_list
539 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
540 """Performs GPG operations on the GPG parts of the message
542 This function decrypts text, verifies signatures, and imports public keys
543 included in an email.
546 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
547 and non-GPG sections by split_payloads()
548 gpgme_ctx: a gpgme context
550 prev_parts: a list of mime parts that occur before the eddymsg_obj
551 part, under the same multi-part mime part. This is used for
552 verifying detached signatures. For the root mime part, this should
553 be an empty list, which is the default value if this paramater is
560 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
563 Decryption, verification and key imports occur. the gpg_data member of
564 PayloadPiece objects get filled in with GPGData objects.
567 if eddymsg_obj
.multipart
== True:
569 for sub
in eddymsg_obj
.subparts
:
570 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
575 for piece
in eddymsg_obj
.payload_pieces
:
577 if piece
.piece_type
== TxtType
.text
:
578 # don't transform the plaintext.
581 elif piece
.piece_type
== TxtType
.message
:
582 (plaintext
, sigs
) = decrypt_block(piece
.string
, gpgme_ctx
)
585 piece
.gpg_data
= GPGData()
586 piece
.gpg_data
.decrypted
= True
587 piece
.gpg_data
.sigs
= sigs
589 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
592 # if not encrypted, check to see if this is an armored signature.
593 (plaintext
, sigs
) = verify_sig_message(piece
.string
, gpgme_ctx
)
596 piece
.piece_type
= TxtType
.signature
597 piece
.gpg_data
= GPGData()
598 piece
.gpg_data
.sigs
= sigs
600 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext
, gpgme_ctx
)
602 # FIXME: consider handling pubkeys first, so that signatures can be
603 # validated on freshly imported keys
604 elif piece
.piece_type
== TxtType
.pubkey
:
605 key_fps
= add_gpg_key(piece
.string
, gpgme_ctx
)
608 piece
.gpg_data
= GPGData()
609 piece
.gpg_data
.keys
= key_fps
611 elif piece
.piece_type
== TxtType
.detachedsig
:
612 for prev
in prev_parts
:
613 sig_fps
= verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
616 piece
.gpg_data
= GPGData()
617 piece
.gpg_data
.sigs
= sig_fps
618 piece
.gpg_data
.plainobj
= prev
625 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
626 """Updates replyinfo_obj with info on the message's GPG success/failures
628 This function marks replyinfo_obj with information about whether encrypted
629 text in eddymsg_obj was successfully decrypted, signatures were verified
630 and whether a public key was found or not.
633 eddymsg_obj: a message in the EddyMsg format
634 replyinfo_obj: an instance of ReplyInfo
640 eddymsg_obj has had its gpg_data created by gpg_on_payloads
643 replyinfo_obj has been updated with info about decryption/sig
644 verififcation status, etc. However the desired key isn't imported until
645 later, so the success or failure of that updates the values set here.
648 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
650 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
651 """A helper function for prepare_for_reply
653 It updates replyinfo_obj with GPG success/failure information, when
654 supplied a single-part EddyMsg object.
657 eddymsg_obj: a single-part message in the EddyMsg format
658 replyinfo_obj: an object which holds information about the message's
665 eddymsg_obj is a single-part message. (it may be a part of a multi-part
666 message.) It has had its gpg_data created by gpg_on_payloads if it has
670 replyinfo_obj has been updated with gpg success/failure information
673 for piece
in eddymsg_obj
.payload_pieces
:
674 if piece
.piece_type
== TxtType
.text
:
675 # don't quote the plaintext part.
678 elif piece
.piece_type
== TxtType
.message
:
679 prepare_for_reply_message(piece
, replyinfo_obj
)
681 elif piece
.piece_type
== TxtType
.pubkey
:
682 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
684 elif (piece
.piece_type
== TxtType
.detachedsig
) \
685 or (piece
.piece_type
== TxtType
.signature
):
686 prepare_for_reply_sig(piece
, replyinfo_obj
)
689 def prepare_for_reply_message (piece
, replyinfo_obj
):
690 """Helper function for prepare_for_reply()
692 This function is called when the piece_type of a payload piece is
693 TxtType.message, or GPG Message block. This should be encrypted text. If the
694 encryted block is signed, a sig will be attached to .target_key unless
695 there is already one there.
698 piece: a PayloadPiece object.
699 replyinfo_obj: object which gets updated with decryption status, etc.
706 the piece.payload_piece value should be TxtType.message.
709 replyinfo_obj gets updated with decryption status, signing status and a
710 potential signing key.
713 if piece
.gpg_data
== None:
714 replyinfo_obj
.failed_decrypt
= True
717 replyinfo_obj
.success_decrypt
= True
719 # we already have a key (and a message)
720 if replyinfo_obj
.target_key
!= None:
723 if piece
.gpg_data
.sigs
!= []:
724 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
725 get_signed_part
= False
727 # only include a signed message in the reply.
728 get_signed_part
= True
730 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
732 # to catch public keys in encrypted blocks
733 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
736 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
737 """Helper function for prepare_for_reply(). Marks pubkey import status.
739 Marks replyinfo_obj with pub key import status.
742 piece: a PayloadPiece object
743 replyinfo_obj: a ReplyInfo object
746 piece.piece_type should be set to TxtType.pubkey .
749 replyinfo_obj has its fields updated.
752 if piece
.gpg_data
== None or piece
.gpg_data
.keys
== []:
753 replyinfo_obj
.no_public_key
= True
755 replyinfo_obj
.public_key_received
= True
757 # prefer public key as a fallback for the encrypted reply
758 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
761 def prepare_for_reply_sig (piece
, replyinfo_obj
):
762 """Helper function for prepare_for_reply(). Marks sig verification status.
764 Marks replyinfo_obj with signature verification status.
767 piece: a PayloadPiece object
768 replyinfo_obj: a ReplyInfo object
771 piece.piece_type should be set to TxtType.signature, or
772 TxtType.detachedsig .
775 replyinfo_obj has its fields updated.
778 if piece
.gpg_data
== None or piece
.gpg_data
.sigs
== []:
779 replyinfo_obj
.sig_failure
= True
781 replyinfo_obj
.sig_success
= True
783 if replyinfo_obj
.fallback_target_key
== None:
784 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
787 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
788 """For creating a string representation of a signed, encrypted part.
790 When given a decrypted payload, it will add either the plaintext or signed
791 plaintext to the reply message, depeding on 'get_signed_part'. This is
792 useful for ensuring that the reply message only comes from a signed and
793 ecrypted GPG message. It also sets the target_key for encrypting the reply
794 if it's told to get signed text only.
797 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
799 replyinfo_obj: a ReplyInfo object for holding the message to quote and
800 the target_key to encrypt to.
801 get_signed_part: True if we should only include text that contains a
802 further signature. If False, then include plain text.
808 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
809 which represents decrypted text. It may or may not be signed on that
813 the ReplyInfo instance may have a new 'target_key' set and its
814 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
818 if eddymsg_obj
== None:
821 # recurse on multi-part mime
822 if eddymsg_obj
.multipart
== True:
823 for sub
in eddymsg_obj
.subparts
:
824 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
826 for piece
in eddymsg_obj
.payload_pieces
:
827 if (get_signed_part
):
828 if ((piece
.piece_type
== TxtType
.detachedsig
) \
829 or (piece
.piece_type
== TxtType
.signature
)) \
830 and (piece
.gpg_data
!= None):
831 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
832 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
835 if piece
.piece_type
== TxtType
.text
:
836 replyinfo_obj
.msg_to_quote
+= piece
.string
839 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
840 """Obtains a public key object from a key fingerprint
842 If the .target_key is not set, then we use .fallback_target_key.
845 replyinfo_obj: ReplyInfo instance
846 gpgme_ctx: the gpgme context
849 The key object of the key of either the target_key or the fallback one
850 if .target_key is not set. If the key cannot be loaded, then return
854 Loading a key requires that we have the public key imported. This
855 requires that they email contains the pub key block, or that it was
856 previously sent to edward.
859 If the key cannot be loaded, then the replyinfo_obj is marked for
860 having no public key available.
863 if replyinfo_obj
.target_key
== None:
864 replyinfo_obj
.target_key
= replyinfo_obj
.fallback_target_key
866 if replyinfo_obj
.target_key
!= None:
868 encrypt_to_key
= gpgme_ctx
.get_key(replyinfo_obj
.target_key
)
869 return encrypt_to_key
871 except gpgme
.GpgmeError
:
874 # no available key to use
875 replyinfo_obj
.target_key
= None
876 replyinfo_obj
.fallback_target_key
= None
878 replyinfo_obj
.no_public_key
= True
879 replyinfo_obj
.public_key_received
= False
884 def write_reply (replyinfo_obj
):
885 """Write the reply email body about the GPG successes/failures.
887 The reply is about whether decryption, sig verification and key
888 import/loading was successful or failed. If text was successfully decrypted
889 and verified, then the first instance of such text will be included in
893 replyinfo_obj: contains details of GPG processing status
896 the plaintext message to be sent to the user
899 replyinfo_obj should be populated with info about GPG processing status.
904 if replyinfo_obj
.success_decrypt
== True:
905 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
907 if replyinfo_obj
.no_public_key
== False:
908 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
909 reply_plain
+= quoted_text
911 elif replyinfo_obj
.failed_decrypt
== True:
912 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
915 if replyinfo_obj
.sig_success
== True:
916 reply_plain
+= "\n\n"
917 reply_plain
+= replyinfo_obj
.replies
['sig_success']
919 elif replyinfo_obj
.sig_failure
== True:
920 reply_plain
+= "\n\n"
921 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
924 if replyinfo_obj
.public_key_received
== True:
925 reply_plain
+= "\n\n"
926 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
928 elif replyinfo_obj
.no_public_key
== True:
929 reply_plain
+= "\n\n"
930 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
933 reply_plain
+= "\n\n"
934 reply_plain
+= replyinfo_obj
.replies
['signature']
939 def add_gpg_key (key_block
, gpgme_ctx
):
940 """Adds a GPG pubkey to the local keystore
942 This adds keys received through email into the key store so they can be
946 key_block: the string form of the ascii-armored public key block
947 gpgme_ctx: the gpgme context
950 the fingerprint(s) of the imported key(s)
953 fp
= io
.BytesIO(key_block
.encode('ascii'))
956 result
= gpgme_ctx
.import_(fp
)
957 imports
= result
.imports
958 except gpgme
.GpgmeError
:
961 key_fingerprints
= []
964 for import_
in imports
:
965 fingerprint
= import_
[0]
966 key_fingerprints
+= [fingerprint
]
968 debug("added gpg key: " + fingerprint
)
970 return key_fingerprints
973 def verify_sig_message (msg_block
, gpgme_ctx
):
974 """Verifies the signature of a signed, ascii-armored block of text.
976 It encodes the string into ascii, since binary GPG files are currently
977 unsupported, and alternative, the ascii-armored format is encodable into
981 msg_block: a GPG Message block in string form. It may be encrypted or
982 not. If it is encrypted, it will return empty results.
983 gpgme_ctx: the gpgme context
986 A tuple of the plaintext of the signed part and the list of
987 fingerprints of keys signing the data. If verification failed, perhaps
988 because the message was also encrypted, then empty results are
992 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
993 plain_b
= io
.BytesIO()
996 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
997 except gpgme
.GpgmeError
:
1000 plaintext
= plain_b
.getvalue().decode('utf-8')
1004 fingerprints
+= [sig
.fpr
]
1005 return (plaintext
, fingerprints
)
1008 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1009 """Verifies the signature of a detached signature.
1011 This requires the signature part and the signed part as separate arguments.
1014 detached_sig: the signature part of the detached signature
1015 plaintext_bytes: the byte form of the message being signed.
1016 gpgme_ctx: the gpgme context
1019 A list of signing fingerprints if the signature verification was
1020 sucessful. Otherwise, an empty list is returned.
1023 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1024 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1027 result
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1028 except gpgme
.GpgmeError
:
1031 sig_fingerprints
= []
1033 sig_fingerprints
+= [res_
.fpr
]
1035 return sig_fingerprints
1038 def decrypt_block (msg_block
, gpgme_ctx
):
1039 """Decrypts a block of GPG text, and verifies any included sigatures.
1041 Some encypted messages have embeded signatures, so those are verified too.
1044 msg_block: the encrypted(/signed) text
1045 gpgme_ctx: the gpgme context
1048 A tuple of plaintext and signatures, if the decryption and signature
1049 verification were successful, respectively.
1052 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1053 plain_b
= io
.BytesIO()
1056 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1057 except gpgme
.GpgmeError
:
1060 plaintext
= plain_b
.getvalue().decode('utf-8')
1064 fingerprints
+= [sig
.fpr
]
1065 return (plaintext
, fingerprints
)
1068 def email_to_from_subject (email_text
):
1069 """Returns the values of the email's To:, From: and Subject: fields
1071 Returns this information from an email.
1074 email_text: the string form of the email
1077 the email To:, From:, and Subject: fields as strings
1080 email_struct
= email
.parser
.Parser().parsestr(email_text
)
1082 email_to
= email_struct
['To']
1083 email_from
= email_struct
['From']
1084 email_subject
= email_struct
['Subject']
1086 return email_to
, email_from
, email_subject
1089 def import_lang_pick_address(email_to
, hostname
):
1090 """Imports language file for i18n support; makes reply from address
1092 The language imported depends on the To: address of the email received by
1093 edward. an -en ending implies the English language, whereas a -ja ending
1094 implies Japanese. The list of supported languages is listed in the 'langs'
1095 list at the beginning of the program. This function also chooses the
1096 language-dependent address which can be used as the From address in the
1100 email_to: the string containing the email address that the mail was
1102 hostname: the hostname part of the reply email's from address
1105 the reference to the imported language module. The only variable in
1106 this file is the 'replies' dictionary.
1112 if email_to
!= None:
1114 if "edward-" + lang
in email_to
:
1118 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1119 lang_module
= importlib
.import_module(lang_mod_name
)
1121 reply_from
= "edward-" + use_lang
+ "@" + hostname
1123 return lang_module
, reply_from
1126 def generate_encrypted_mime (plaintext
, email_to
, email_subject
, encrypt_to_key
,
1128 """This function creates the mime email reply. It can encrypt the email.
1130 If the encrypt_key is included, then the email is encrypted and signed.
1131 Otherwise it is unencrypted.
1134 plaintext: the plaintext body of the message to create.
1135 email_to: the email address to reply to
1136 email_subject: the subject to use in reply
1137 encrypt_to_key: the key object to use for encrypting the email. (or
1139 gpgme_ctx: the gpgme context
1142 A string version of the mime message, possibly encrypted and signed.
1145 # quoted printable encoding lets most ascii characters look normal
1146 # before the mime message is decoded.
1147 char_set
= email
.charset
.Charset("utf-8")
1148 char_set
.body_encoding
= email
.charset
.QP
1150 # MIMEText doesn't allow setting the text encoding
1151 # so we use MIMENonMultipart.
1152 plaintext_mime
= MIMENonMultipart('text', 'plain')
1153 plaintext_mime
.set_payload(plaintext
, charset
=char_set
)
1155 if (encrypt_to_key
!= None):
1157 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1160 gpg_payload
= encrypted_text
1163 signed_text
= sign_message(plaintext_mime
.as_string(), gpgme_ctx
)
1164 gpg_payload
= signed_text
1166 control_mime
= MIMEApplication("Version: 1",
1167 _subtype
='pgp-encrypted',
1168 _encoder
=email
.encoders
.encode_7or8bit
)
1169 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1170 control_mime
.set_charset('us-ascii')
1172 encoded_mime
= MIMEApplication(gpg_payload
,
1173 _subtype
='octet-stream; name="encrypted.asc"',
1174 _encoder
=email
.encoders
.encode_7or8bit
)
1175 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1176 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1177 encoded_mime
.set_charset('us-ascii')
1179 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1180 message_mime
.attach(control_mime
)
1181 message_mime
.attach(encoded_mime
)
1182 message_mime
['Content-Disposition'] = 'inline'
1185 message_mime
['To'] = email_to
1186 message_mime
['Subject'] = email_subject
1188 reply
= message_mime
.as_string()
1193 def send_reply(email_txt
, subject
, reply_to
, reply_from
):
1195 email_bytes
= email_txt
.encode('ascii')
1197 p
= subprocess
.Popen(["/usr/sbin/sendmail", "-f", reply_from
, "-F", "Edward, GPG Bot", "-i", reply_to
], stdin
=subprocess
.PIPE
)
1199 (stdout
, stderr
) = p
.communicate(email_bytes
)
1202 debug("sendmail stdout: " + str(stdout
))
1204 error("sendmail stderr: " + str(stderr
))
1207 def email_quote_text (text
):
1208 """Quotes input text by inserting "> "s
1210 This is useful for quoting a text for the reply message. It inserts "> "
1211 strings at the beginning of lines.
1214 text: plain text to quote
1220 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1222 return quoted_message
1225 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1226 """Encrypts and signs plaintext
1228 This encrypts and signs a message.
1231 plaintext: text to sign and ecrypt
1232 encrypt_to_key: the key object to encrypt to
1233 gpgme_ctx: the gpgme context
1236 An encrypted and signed string of text
1239 # the plaintext should be mime encoded in an ascii-compatible form
1240 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1241 encrypted_bytes
= io
.BytesIO()
1243 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1244 plaintext_bytes
, encrypted_bytes
)
1246 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1247 return encrypted_txt
1250 def sign_message (plaintext
, gpgme_ctx
):
1253 This signs a message.
1256 plaintext: text to sign
1257 gpgme_ctx: the gpgme context
1260 An armored signature as a string of text
1263 # the plaintext should be mime encoded in an ascii-compatible form
1264 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1265 signed_bytes
= io
.BytesIO()
1267 gpgme_ctx
.sign(plaintext_bytes
, signed_bytes
, gpgme
.SIG_MODE_NORMAL
)
1269 signed_txt
= signed_bytes
.getvalue().decode('ascii')
1273 def error (error_msg
):
1274 """Write an error message to stdout
1276 The error message includes the program name.
1279 error_msg: the message to print
1285 An error message is printed to stdout
1288 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1291 def debug (debug_msg
):
1292 """Writes a debug message to stdout if debug == True
1294 If the debug option is set in edward_config.py, then the passed message
1295 gets printed to stdout.
1298 debug_msg: the message to print to stdout
1304 A debug message is printed to stdout
1307 if edward_config
.debug
== True:
1312 """Sets the progname variable and processes optional argument
1314 If there are more than two arguments then edward complains and quits. An
1315 single "-p" argument sets the print_reply_only option, which makes edward
1316 print email replies instead of mailing them.
1322 True if edward should print arguments instead of mailing them,
1323 otherwise it returns False.
1326 Exits with error 1 if there are more than two arguments, otherwise
1327 returns the print_reply_only option.
1331 progname
= sys
.argv
[0]
1333 print_reply_only
= False
1335 if len(sys
.argv
) > 2:
1336 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1337 + " -p print reply message to stdout, do not mail it\n", \
1341 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1342 print_reply_only
= True
1344 return print_reply_only
1347 if __name__
== "__main__":
1348 """Executes main if this file is not loaded interactively"""