1 #! /usr/bin/env python3
2 # -*- coding: utf-8 -*-
3 """*********************************************************************
4 * Edward is free software: you can redistribute it and/or modify *
5 * it under the terms of the GNU Affero Public License as published by *
6 * the Free Software Foundation, either version 3 of the License, or *
7 * (at your option) any later version. *
9 * Edward is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU Affero Public License for more details. *
14 * You should have received a copy of the GNU Affero Public License *
15 * along with Edward. If not, see <http://www.gnu.org/licenses/>. *
17 * Copyright (C) 2014-2015 Andrew Engelbrecht (AGPLv3+) *
18 * Copyright (C) 2014 Josh Drake (AGPLv3+) *
19 * Copyright (C) 2014 Lisa Marie Maginnis (AGPLv3+) *
20 * Copyright (C) 2009-2015 Tails developers <tails@boum.org> ( GPLv3+) *
21 * Copyright (C) 2009 W. Trevor King <wking@drexel.edu> ( GPLv2+) *
23 * Special thanks to Josh Drake for writing the original edward bot! :) *
25 ************************************************************************
27 Code sourced from these projects:
29 * http://agpl.fsf.org/emailselfdefense.fsf.org/edward/CURRENT/edward.tar.gz
30 * https://git-tails.immerda.ch/whisperback/tree/whisperBack/encryption.py?h=feature/python3
31 * http://www.physics.drexel.edu/~wking/code/python/send_pgp_mime
47 from email
.mime
.text
import MIMEText
48 from email
.mime
.multipart
import MIMEMultipart
49 from email
.mime
.application
import MIMEApplication
50 from email
.mime
.nonmultipart
import MIMENonMultipart
54 langs
= ["de", "el", "en", "es", "fr", "it", "ja", "pt-br", "ro", "ru", "tr"]
56 """This list contains the abbreviated names of reply languages available to
59 class TxtType (enum
.Enum
):
67 match_pairs
= [(TxtType
.message
,
68 '-----BEGIN PGP MESSAGE-----.*?-----END PGP MESSAGE-----'),
70 '-----BEGIN PGP PUBLIC KEY BLOCK-----.*?-----END PGP PUBLIC KEY BLOCK-----'),
72 '-----BEGIN PGP SIGNATURE-----.*?-----END PGP SIGNATURE-----')]
74 """This list of tuples matches query names with re.search() queries used
75 to find GPG data for edward to process."""
78 class EddyMsg (object):
80 The EddyMsg class represents relevant parts of a mime message.
82 The represented message can be single-part or multi-part.
84 'multipart' is set to True if there are multiple mime parts.
86 'subparts' points to a list of mime sub-parts if it is a multi-part
87 message. Otherwise it points to an empty list.
89 'payload_bytes' is a binary representation of the mime part before header
90 removal and message decoding.
92 'payload_pieces' is a list of objects containing strings that when strung
93 together form the fully-decoded string representation of the mime part.
95 The 'filename', 'content_type' and 'description_list' come from the mime
107 description_list
= None
110 class PayloadPiece (object):
112 PayloadPiece represents a complte or sub-section of a mime part.
114 Instances of this class are often strung together within one or more arrays
115 pointed to by each instance of the EddyMsg class.
117 'piece_type' refers to an enum whose value describes the content of
118 'string'. Examples include TxtType.pubkey, for public keys, and
119 TxtType.message, for encrypted data (or armored signatures until they are
120 known to be such.) Some of the names derive from the header and footer of
121 each of these ascii-encoded gpg blocks.
123 'string' contains some string of text, such as non-GPG text, an encrypted
124 block of text, a signature, or a public key.
126 'gpg_data' points to any instances of GPGData that have been created based
127 on the contents of 'string'.
135 class GPGData (object):
137 GPGData holds info from decryption, sig. verification, and/or pub. keys.
139 Instances of this class contain decrypted information, signature
140 fingerprints and/or fingerprints of processed and imported public keys.
142 'decrypted' is set to True if 'plainobj' was created from encrypted data.
144 'plainobj' points to any decrypted, or signed part of, a GPG signature. It
145 is intended to be an instance of the EddyMsg class.
147 'sigs' is a list of fingerprints of keys used to sign the data in plainobj.
149 'sigkey_missing' is set to True if edward doesn't have the key it needs to
150 verify the signature on a block of text.
152 'keys' is a list of fingerprints of keys obtained in public key blocks.
159 sigkey_missing
= False
163 class ReplyInfo (object):
165 ReplyInfo contains details that edward uses in generating its reply.
167 Instances of this class contain information about whether a message was
168 successfully encrypted or signed, and whether a public key was attached, or
169 retrievable, from the local GPG store. It stores the fingerprints of
170 potential encryption key candidates and the message (if any at all) to
171 quote in edward's reply.
173 'replies' points one of the dictionaries of translated replies.
175 'target_key' refers to the fingerprint of a key used to sign encrypted
176 data. This is the preferred key, if it is set, and if is available.
178 'fallback_target_key' referst to the fingerprint of a key used to sign
179 unencrypted data; alternatively it may be a public key attached to the
182 'encrypt_to_key' the key object to use when encrypting edward's reply
184 'msg_to_quote' refers to the part of a message which edward should quote in
185 his reply. This should remain as None if there was no encrypted and singed
186 part. This is to avoid making edward a service for decrypting other
187 people's messages to edward.
189 'decrypt_success' is set to True if edward could decrypt part of the
192 'sig_success' is set to True if edward could to some extent verify the
193 signature of a signed part of the message to edward.
195 'sig_failure' is set to True if edward could not verify a siganture.
197 'pubkey_success' is set to True if edward successfully imported a public
200 'sigkey_missing' is set to True if edward doesn't have the public key
201 needed for signature verification.
203 'have_repy_key' is set to True if edward has a public key to encrypt its
210 fallback_target_key
= None
211 encrypt_to_key
= None
214 decrypt_success
= False
216 pubkey_success
= False
218 decrypt_failure
= False
220 sigkey_missing
= False
221 have_reply_key
= False
227 This is the main function for edward, a GPG reply bot.
229 Edward responds to GPG-encrypted and signed mail, encrypting and signing
230 the response if the user's public key is, or was, included in the message.
239 Mime or plaintext email passing in through standard input. Portions of
240 the email may be encrypted. If the To: address contains the text
241 "edward-ja", then the reply will contain a reply written in the
242 Japanese language. There are other languages as well. The default
246 A reply email will be printed to standard output. The contents of the
247 reply email depends on whether the original email was encrypted or not,
248 has or doesn't have a signature, whether a public key used in the
249 original message is provided or locally stored, and the language
250 implied by the To: address in the original email.
253 print_reply_only
= handle_args()
255 gpgme_ctx
= get_gpg_context(edward_config
.gnupghome
,
256 edward_config
.sign_with_key
)
258 email_bytes
= sys
.stdin
.buffer.read()
259 email_struct
= parse_pgp_mime(email_bytes
, gpgme_ctx
)
261 email_to
, email_from
, email_subject
= email_to_from_subject(email_bytes
)
262 lang
, reply_from
= import_lang_pick_address(email_to
, edward_config
.hostname
)
264 replyinfo_obj
= ReplyInfo()
265 replyinfo_obj
.replies
= lang
.replies
267 prepare_for_reply(email_struct
, replyinfo_obj
)
268 get_key_from_fp(replyinfo_obj
, gpgme_ctx
)
269 reply_plaintext
= write_reply(replyinfo_obj
)
271 reply_mime
= generate_encrypted_mime(reply_plaintext
, email_from
, \
272 email_subject
, replyinfo_obj
.encrypt_to_key
,
275 if print_reply_only
== True:
278 send_reply(reply_mime
, email_subject
, email_from
, reply_from
)
281 def get_gpg_context (gnupghome
, sign_with_key_fp
):
283 This function returns the GPG context needed for encryption and signing.
285 The context is needed by other functions which use GPG functionality.
288 gnupghome: The path to "~/.gnupg/" or its alternative.
289 sign_with_key: The fingerprint of the key to sign with
292 A gpgme context to be used for GPG functions.
295 the 'armor' flag is set to True and the list of signing keys contains
296 the single specified key
299 os
.environ
['GNUPGHOME'] = gnupghome
301 gpgme_ctx
= gpgme
.Context()
302 gpgme_ctx
.armor
= True
305 sign_with_key
= gpgme_ctx
.get_key(sign_with_key_fp
)
306 except gpgme
.GpgmeError
:
307 error("unable to load signing key. is the gnupghome "
308 + "and signing key properly set in the edward_config.py?")
311 gpgme_ctx
.signers
= [sign_with_key
]
316 def parse_pgp_mime (email_bytes
, gpgme_ctx
):
317 """Parses the email for mime payloads and decrypts/verfies signatures.
319 This function creates a representation of a mime or plaintext email with
320 the EddyMsg class. It then splits each mime payload into one or more pieces
321 which may be plain text or GPG data. It then decrypts encrypted parts and
322 does some very basic signature verification on those parts.
325 email_bytes: an email message in byte string format
326 gpgme_ctx: a gpgme context
329 A message as an instance of EddyMsg
332 the returned EddyMsg instance has split, decrypted, verified and pubkey
336 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
338 eddymsg_obj
= parse_mime(email_struct
)
339 split_payloads(eddymsg_obj
)
340 gpg_on_payloads(eddymsg_obj
, gpgme_ctx
)
345 def parse_mime(msg_struct
):
346 """Translates python's email.parser format into an EddyMsg format
348 If the message is multi-part, then a recursive object is created, where
349 each sub-part is also a EddyMsg instance.
352 msg_struct: an email parsed with email.parser.Parser(), which can be
356 an instance of EddyMsg, potentially a recursive one.
359 eddymsg_obj
= EddyMsg()
361 if msg_struct
.is_multipart() == True:
362 payloads
= msg_struct
.get_payload()
364 eddymsg_obj
.multipart
= True
365 eddymsg_obj
.subparts
= list(map(parse_mime
, payloads
))
368 eddymsg_obj
= get_subpart_data(msg_struct
)
373 def scan_and_split (payload_piece
, match_name
, pattern
):
374 """This splits the payloads of an EddyMsg object into GPG and text parts.
376 An EddyMsg object's payload_pieces starts off as a list containing a single
377 PayloadPiece object. This function returns a list of these objects which
378 have been split into GPG data and regular text, if such splits need to be/
382 payload_piece: a single payload or a split part of a payload
383 match_name: the type of data to try to spit out from the payload piece
384 pattern: the search pattern to be used for finding that type of data
387 a list of objects of the PayloadPiece class, in the order that the
388 string part of payload_piece originally was, broken up according to
389 matches specified by 'pattern'.
392 # don't try to re-split pieces containing gpg data
393 if payload_piece
.piece_type
!= TxtType
.text
:
394 return [payload_piece
]
396 flags
= re
.DOTALL | re
.MULTILINE
397 matches
= re
.search("(?P<beginning>.*?)(?P<match>" + pattern
+
398 ")(?P<rest>.*)", payload_piece
.string
, flags
=flags
)
401 pieces
= [payload_piece
]
405 beginning
= PayloadPiece()
406 beginning
.string
= matches
.group('beginning')
407 beginning
.piece_type
= payload_piece
.piece_type
409 match
= PayloadPiece()
410 match
.string
= matches
.group('match')
411 match
.piece_type
= match_name
413 rest
= PayloadPiece()
414 rest
.string
= matches
.group('rest')
415 rest
.piece_type
= payload_piece
.piece_type
417 more_pieces
= scan_and_split(rest
, match_name
, pattern
)
418 pieces
= [beginning
, match
] + more_pieces
423 def get_subpart_data (part
):
424 """This function grabs information from a single part mime object.
426 It copies needed data from a single part email.parser.Parser() object over
427 to an EddyMsg object.
430 part: a non-multi-part mime.parser.Parser() object
433 a single-part EddyMsg() object
438 mime_decoded_bytes
= part
.get_payload(decode
=True)
439 charset
= part
.get_content_charset()
441 # your guess is as good as a-myy-ee-ine...
445 payload_string
= part
.as_string()
446 if payload_string
!= None:
447 obj
.payload_bytes
= payload_string
.encode(charset
)
449 obj
.filename
= part
.get_filename()
450 obj
.content_type
= part
.get_content_type()
451 obj
.description_list
= part
['content-description']
453 if mime_decoded_bytes
!= None:
455 payload
= PayloadPiece()
456 payload
.string
= mime_decoded_bytes
.decode(charset
)
457 payload
.piece_type
= TxtType
.text
459 obj
.payload_pieces
= [payload
]
460 except UnicodeDecodeError:
466 def do_to_eddys_pieces (function_to_do
, eddymsg_obj
, data
):
467 """A function which maps another function onto a message's subparts.
469 This is a higer-order function which recursively performs a specified
470 function on each subpart of a multi-part message. Each single-part sub-part
471 has the function applied to it. This function also works if the part passed
475 function_to_do: function to perform on sub-parts
476 eddymsg_obj: a single part or multi-part EddyMsg object
477 data: a second argument to pass to 'function_to_do'
483 The passed-in EddyMsg object is transformed recursively on its
484 sub-parts according to 'function_to_do'.
487 if eddymsg_obj
.multipart
== True:
488 for sub
in eddymsg_obj
.subparts
:
489 do_to_eddys_pieces(function_to_do
, sub
, data
)
491 function_to_do(eddymsg_obj
, data
)
494 def split_payloads (eddymsg_obj
):
495 """Splits all (sub-)payloads of a message into GPG data and regular text.
497 Recursively performs payload splitting on all sub-parts of an EddyMsg
498 object into the various GPG data types, such as GPG messages, public key
499 blocks and signed text.
502 eddymsg_obj: an instance of EddyMsg
508 The EddyMsg object has payloads that are unsplit (by may be split)..
511 The EddyMsg object's payloads are all split into GPG and non-GPG parts.
514 for match_pair
in match_pairs
:
515 do_to_eddys_pieces(split_payload_pieces
, eddymsg_obj
, match_pair
)
518 def split_payload_pieces (eddymsg_obj
, match_pair
):
519 """A helper function for split_payloads(); works on PayloadPiece objects.
521 This function splits up PayloadPiece objects into multipe PayloadPiece
522 objects and replaces the EddyMsg object's previous list of payload pieces
523 with the new split up one.
526 eddymsg_obj: a single-part EddyMsg object.
527 match_pair: a tuple from the match_pairs list, which specifies a match
528 name and a match pattern.
534 The payload piece(s) of an EddyMsg object may be already split or
538 The EddyMsg object's payload piece(s) are split into a list of pieces
539 if matches of the match_pair are found.
542 (match_name
, pattern
) = match_pair
545 for piece
in eddymsg_obj
.payload_pieces
:
546 new_pieces_list
+= scan_and_split(piece
, match_name
, pattern
)
548 eddymsg_obj
.payload_pieces
= new_pieces_list
551 def gpg_on_payloads (eddymsg_obj
, gpgme_ctx
, prev_parts
=[]):
552 """Performs GPG operations on the GPG parts of the message
554 This function decrypts text, verifies signatures, and imports public keys
555 included in an email.
558 eddymsg_obj: an EddyMsg object with its payload_pieces split into GPG
559 and non-GPG sections by split_payloads()
560 gpgme_ctx: a gpgme context
562 prev_parts: a list of mime parts that occur before the eddymsg_obj
563 part, under the same multi-part mime part. This is used for
564 verifying detached signatures. For the root mime part, this should
565 be an empty list, which is the default value if this paramater is
572 eddymsg_obj should have its payloads split into gpg and non-gpg pieces.
575 Decryption, verification and key imports occur. the gpg_data member of
576 PayloadPiece objects get filled in with GPGData objects.
579 if eddymsg_obj
.multipart
== True:
581 for sub
in eddymsg_obj
.subparts
:
582 gpg_on_payloads (sub
, gpgme_ctx
, prev_parts
)
587 for piece
in eddymsg_obj
.payload_pieces
:
589 if piece
.piece_type
== TxtType
.text
:
590 # don't transform the plaintext.
593 elif piece
.piece_type
== TxtType
.message
:
594 piece
.gpg_data
= GPGData()
596 (plaintext_b
, sigs
, sigkey_missing
) = decrypt_block(piece
.string
, gpgme_ctx
)
598 piece
.gpg_data
.sigkey_missing
= sigkey_missing
601 piece
.gpg_data
.decrypted
= True
602 piece
.gpg_data
.sigs
= sigs
604 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
607 # if not encrypted, check to see if this is an armored signature.
608 (plaintext_b
, sigs
, sigkey_missing
) = verify_sig_message(piece
.string
, gpgme_ctx
)
610 piece
.gpg_data
.sigkey_missing
= sigkey_missing
613 piece
.piece_type
= TxtType
.signature
614 piece
.gpg_data
.sigs
= sigs
616 piece
.gpg_data
.plainobj
= parse_pgp_mime(plaintext_b
, gpgme_ctx
)
618 elif piece
.piece_type
== TxtType
.pubkey
:
619 key_fps
= add_gpg_key(piece
.string
, gpgme_ctx
)
622 piece
.gpg_data
= GPGData()
623 piece
.gpg_data
.keys
= key_fps
625 elif piece
.piece_type
== TxtType
.detachedsig
:
626 piece
.gpg_data
= GPGData()
628 for prev
in prev_parts
:
629 (sig_fps
, sigkey_missing
) = verify_detached_signature(piece
.string
, prev
.payload_bytes
, gpgme_ctx
)
631 piece
.gpg_data
.sigkey_missing
= sigkey_missing
634 piece
.gpg_data
.sigs
= sig_fps
635 piece
.gpg_data
.plainobj
= prev
642 def prepare_for_reply (eddymsg_obj
, replyinfo_obj
):
643 """Updates replyinfo_obj with info on the message's GPG success/failures
645 This function marks replyinfo_obj with information about whether encrypted
646 text in eddymsg_obj was successfully decrypted, signatures were verified
647 and whether a public key was found or not.
650 eddymsg_obj: a message in the EddyMsg format
651 replyinfo_obj: an instance of ReplyInfo
657 eddymsg_obj has had its gpg_data created by gpg_on_payloads
660 replyinfo_obj has been updated with info about decryption/sig
661 verififcation status, etc. However the desired key isn't imported until
662 later, so the success or failure of that updates the values set here.
665 do_to_eddys_pieces(prepare_for_reply_pieces
, eddymsg_obj
, replyinfo_obj
)
667 def prepare_for_reply_pieces (eddymsg_obj
, replyinfo_obj
):
668 """A helper function for prepare_for_reply
670 It updates replyinfo_obj with GPG success/failure information, when
671 supplied a single-part EddyMsg object.
674 eddymsg_obj: a single-part message in the EddyMsg format
675 replyinfo_obj: an object which holds information about the message's
682 eddymsg_obj is a single-part message. (it may be a part of a multi-part
683 message.) It has had its gpg_data created by gpg_on_payloads if it has
687 replyinfo_obj has been updated with gpg success/failure information
690 for piece
in eddymsg_obj
.payload_pieces
:
691 if piece
.piece_type
== TxtType
.text
:
692 # don't quote the plaintext part.
695 elif piece
.piece_type
== TxtType
.message
:
696 prepare_for_reply_message(piece
, replyinfo_obj
)
698 elif piece
.piece_type
== TxtType
.pubkey
:
699 prepare_for_reply_pubkey(piece
, replyinfo_obj
)
701 elif (piece
.piece_type
== TxtType
.detachedsig
) \
702 or (piece
.piece_type
== TxtType
.signature
):
703 prepare_for_reply_sig(piece
, replyinfo_obj
)
706 def prepare_for_reply_message (piece
, replyinfo_obj
):
707 """Helper function for prepare_for_reply()
709 This function is called when the piece_type of a payload piece is
710 TxtType.message, or GPG Message block. This should be encrypted text. If
711 the encryted block is correclty signed, a sig will be attached to
712 .target_key unless there is already one there.
715 piece: a PayloadPiece object.
716 replyinfo_obj: object which gets updated with decryption status, etc.
722 the piece.payload_piece value should be TxtType.message.
725 replyinfo_obj gets updated with decryption status, signing status, a
726 potential signing key, and posession status of the public key for the
730 if piece
.gpg_data
== None or piece
.gpg_data
.plainobj
== None:
731 replyinfo_obj
.decrypt_failure
= True
734 replyinfo_obj
.decrypt_success
= True
736 # we already have a key (and a message)
737 if replyinfo_obj
.target_key
!= None:
740 if piece
.gpg_data
.sigs
!= []:
741 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
742 replyinfo_obj
.sig_success
= True
743 get_signed_part
= False
746 if piece
.gpg_data
.sigkey_missing
== True:
747 replyinfo_obj
.sigkey_missing
= True
749 # only include a signed message in the reply.
750 get_signed_part
= True
752 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, get_signed_part
)
754 # to catch public keys in encrypted blocks
755 prepare_for_reply(piece
.gpg_data
.plainobj
, replyinfo_obj
)
758 def prepare_for_reply_pubkey (piece
, replyinfo_obj
):
759 """Helper function for prepare_for_reply(). Marks pubkey import status.
761 Marks replyinfo_obj with pub key import status.
764 piece: a PayloadPiece object
765 replyinfo_obj: a ReplyInfo object
768 piece.piece_type should be set to TxtType.pubkey .
771 replyinfo_obj has its fields updated.
774 if piece
.gpg_data
== None or piece
.gpg_data
.keys
== []:
777 replyinfo_obj
.pubkey_success
= True
779 # prefer public key as a fallback for the encrypted reply
780 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.keys
[0]
783 def prepare_for_reply_sig (piece
, replyinfo_obj
):
784 """Helper function for prepare_for_reply(). Marks sig verification status.
786 Marks replyinfo_obj with signature verification status.
789 piece: a PayloadPiece object
790 replyinfo_obj: a ReplyInfo object
793 piece.piece_type should be set to TxtType.signature, or
794 TxtType.detachedsig .
797 replyinfo_obj has its fields updated.
800 if piece
.gpg_data
== None or piece
.gpg_data
.sigs
== []:
801 replyinfo_obj
.sig_failure
= True
803 if piece
.gpg_data
.sigkey_missing
== True:
804 replyinfo_obj
.sigkey_missing
= True
807 replyinfo_obj
.sig_success
= True
809 if replyinfo_obj
.fallback_target_key
== None:
810 replyinfo_obj
.fallback_target_key
= piece
.gpg_data
.sigs
[0]
813 def flatten_decrypted_payloads (eddymsg_obj
, replyinfo_obj
, get_signed_part
):
814 """For creating a string representation of a signed, encrypted part.
816 When given a decrypted payload, it will add either the plaintext or signed
817 plaintext to the reply message, depeding on 'get_signed_part'. This is
818 useful for ensuring that the reply message only comes from a signed and
819 ecrypted GPG message. It also sets the target_key for encrypting the reply
820 if it's told to get signed text only.
823 eddymsg_obj: the message in EddyMsg format created by decrypting GPG
825 replyinfo_obj: a ReplyInfo object for holding the message to quote and
826 the target_key to encrypt to.
827 get_signed_part: True if we should only include text that contains a
828 further signature. If False, then include plain text.
834 The EddyMsg instance passed in should be a piece.gpg_data.plainobj
835 which represents decrypted text. It may or may not be signed on that
839 the ReplyInfo instance may have a new 'target_key' set and its
840 'msg_to_quote' will be updated with (possibly signed) plaintext, if any
844 if eddymsg_obj
== None:
847 # recurse on multi-part mime
848 if eddymsg_obj
.multipart
== True:
849 for sub
in eddymsg_obj
.subparts
:
850 flatten_decrypted_payloads(sub
, replyinfo_obj
, get_signed_part
)
852 for piece
in eddymsg_obj
.payload_pieces
:
853 if (get_signed_part
):
854 if ((piece
.piece_type
== TxtType
.detachedsig
) \
855 or (piece
.piece_type
== TxtType
.signature
)) \
856 and (piece
.gpg_data
!= None) \
857 and (piece
.gpg_data
.plainobj
!= None):
858 flatten_decrypted_payloads(piece
.gpg_data
.plainobj
, replyinfo_obj
, False)
859 replyinfo_obj
.target_key
= piece
.gpg_data
.sigs
[0]
862 if piece
.piece_type
== TxtType
.text
:
863 replyinfo_obj
.msg_to_quote
+= piece
.string
866 def get_key_from_fp (replyinfo_obj
, gpgme_ctx
):
867 """Obtains a public key object from a key fingerprint
869 If the .target_key is not set, then we use .fallback_target_key, if
873 replyinfo_obj: ReplyInfo instance
874 gpgme_ctx: the gpgme context
877 The key object of the key of either the target_key or the fallback one
878 if .target_key is not set. If the key cannot be loaded, then return
882 Loading a key requires that we have the public key imported. This
883 requires that they email contains the pub key block, or that it was
884 previously sent to edward.
887 If the key can be loaded, then replyinfo_obj.reply_to_key points to the
888 public key object. If the key cannot be loaded, then the replyinfo_obj
889 is marked as having no public key available.
892 for key
in (replyinfo_obj
.target_key
, replyinfo_obj
.fallback_target_key
):
895 encrypt_to_key
= gpgme_ctx
.get_key(key
)
896 replyinfo_obj
.encrypt_to_key
= encrypt_to_key
897 replyinfo_obj
.have_reply_key
= True
900 except gpgme
.GpgmeError
:
904 def write_reply (replyinfo_obj
):
905 """Write the reply email body about the GPG successes/failures.
907 The reply is about whether decryption, sig verification and key
908 import/loading was successful or failed. If text was successfully decrypted
909 and verified, then the first instance of such text will be included in
913 replyinfo_obj: contains details of GPG processing status
916 the plaintext message to be sent to the user
919 replyinfo_obj should be populated with info about GPG processing status.
924 if (replyinfo_obj
.pubkey_success
== True):
925 reply_plain
+= replyinfo_obj
.replies
['greeting']
926 reply_plain
+= "\n\n"
928 if replyinfo_obj
.decrypt_success
== True:
929 debug('decrypt success')
930 reply_plain
+= replyinfo_obj
.replies
['success_decrypt']
932 if (replyinfo_obj
.sig_success
== True) and (replyinfo_obj
.have_reply_key
== True):
933 debug('message quoted')
934 reply_plain
+= replyinfo_obj
.replies
['space']
935 reply_plain
+= replyinfo_obj
.replies
['quote_follows']
936 reply_plain
+= "\n\n"
937 quoted_text
= email_quote_text(replyinfo_obj
.msg_to_quote
)
938 reply_plain
+= quoted_text
940 reply_plain
+= "\n\n"
942 elif replyinfo_obj
.decrypt_failure
== True:
943 debug('decrypt failure')
944 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
945 reply_plain
+= "\n\n"
947 if replyinfo_obj
.sig_success
== True:
948 debug('signature success')
949 reply_plain
+= replyinfo_obj
.replies
['sig_success']
950 reply_plain
+= "\n\n"
952 elif replyinfo_obj
.sig_failure
== True:
953 debug('signature failure')
954 reply_plain
+= replyinfo_obj
.replies
['sig_failure']
955 reply_plain
+= "\n\n"
957 if (replyinfo_obj
.pubkey_success
== True):
958 debug('public key received')
959 reply_plain
+= replyinfo_obj
.replies
['public_key_received']
960 reply_plain
+= "\n\n"
962 elif (replyinfo_obj
.sigkey_missing
== True):
963 debug('no public key')
964 reply_plain
+= replyinfo_obj
.replies
['no_public_key']
965 reply_plain
+= "\n\n"
968 if (reply_plain
== ""):
969 debug('plaintext message')
970 reply_plain
+= replyinfo_obj
.replies
['failed_decrypt']
971 reply_plain
+= "\n\n"
974 reply_plain
+= replyinfo_obj
.replies
['signature']
975 reply_plain
+= "\n\n"
980 def add_gpg_key (key_block
, gpgme_ctx
):
981 """Adds a GPG pubkey to the local keystore
983 This adds keys received through email into the key store so they can be
987 key_block: the string form of the ascii-armored public key block
988 gpgme_ctx: the gpgme context
991 the fingerprint(s) of the imported key(s)
994 fp
= io
.BytesIO(key_block
.encode('ascii'))
997 result
= gpgme_ctx
.import_(fp
)
998 imports
= result
.imports
999 except gpgme
.GpgmeError
:
1002 key_fingerprints
= []
1005 for import_
in imports
:
1006 fingerprint
= import_
[0]
1007 key_fingerprints
+= [fingerprint
]
1009 debug("added gpg key: " + fingerprint
)
1011 return key_fingerprints
1014 def verify_sig_message (msg_block
, gpgme_ctx
):
1015 """Verifies the signature of a signed, ascii-armored block of text.
1017 It encodes the string into ascii, since binary GPG files are currently
1018 unsupported, and alternative, the ascii-armored format is encodable into
1022 msg_block: a GPG Message block in string form. It may be encrypted or
1023 not. If it is encrypted, it will return empty results.
1024 gpgme_ctx: the gpgme context
1027 A tuple containing the plaintext bytes of the signed part, the list of
1028 fingerprints of keys signing the data, and a boolean marking whether
1029 edward is missing all public keys for validating any of the signatures.
1030 If verification failed, perhaps because the message was also encrypted,
1031 then empty results are returned.
1034 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1035 plain_b
= io
.BytesIO()
1038 sigs
= gpgme_ctx
.verify(block_b
, None, plain_b
)
1039 except gpgme
.GpgmeError
:
1040 return ("",[],False)
1042 plaintext_b
= plain_b
.getvalue()
1044 sigkey_missing
= False
1047 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1048 fingerprints
+= [sig
.fpr
]
1049 sigkey_missing
= False
1052 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1053 sigkey_missing
= True
1055 return (plaintext_b
, fingerprints
, sigkey_missing
)
1058 def verify_detached_signature (detached_sig
, plaintext_bytes
, gpgme_ctx
):
1059 """Verifies the signature of a detached signature.
1061 This requires the signature part and the signed part as separate arguments.
1064 detached_sig: the signature part of the detached signature
1065 plaintext_bytes: the byte form of the message being signed.
1066 gpgme_ctx: the gpgme context
1069 A tuple containging a list of signing fingerprints if the signature
1070 verification was sucessful, and a boolean marking whether edward is
1071 missing all public keys for validating any of the signatures.
1072 Otherwise, a tuple containing an empty list and True are returned.
1075 detached_sig_fp
= io
.BytesIO(detached_sig
.encode('ascii'))
1076 plaintext_fp
= io
.BytesIO(plaintext_bytes
)
1079 result
= gpgme_ctx
.verify(detached_sig_fp
, plaintext_fp
, None)
1080 except gpgme
.GpgmeError
:
1083 sigkey_missing
= False
1084 sig_fingerprints
= []
1086 if (res_
.summary
== 0) or (res_
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (res_
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1087 sig_fingerprints
+= [res_
.fpr
]
1088 sigkey_missing
= False
1091 if (res_
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1092 sigkey_missing
= True
1094 return (sig_fingerprints
, sigkey_missing
)
1097 def decrypt_block (msg_block
, gpgme_ctx
):
1098 """Decrypts a block of GPG text and verifies any included sigatures.
1100 Some encypted messages have embeded signatures, so those are verified too.
1103 msg_block: the encrypted(/signed) text
1104 gpgme_ctx: the gpgme context
1107 A tuple containing plaintext bytes, signatures (if the decryption and
1108 signature verification were successful, respectively), and a boolean
1109 marking whether edward is missing all public keys for validating any of
1113 block_b
= io
.BytesIO(msg_block
.encode('ascii'))
1114 plain_b
= io
.BytesIO()
1117 sigs
= gpgme_ctx
.decrypt_verify(block_b
, plain_b
)
1118 except gpgme
.GpgmeError
:
1119 return ("",[],False)
1121 plaintext_b
= plain_b
.getvalue()
1123 sigkey_missing
= False
1126 if (sig
.summary
== 0) or (sig
.summary
& gpgme
.SIGSUM_VALID
!= 0) or (sig
.summary
& gpgme
.SIGSUM_GREEN
!= 0):
1127 fingerprints
+= [sig
.fpr
]
1128 sigkey_missing
= False
1131 if (sig
.summary
& gpgme
.SIGSUM_KEY_MISSING
!= 0):
1132 sigkey_missing
= True
1134 return (plaintext_b
, fingerprints
, sigkey_missing
)
1137 def email_to_from_subject (email_bytes
):
1138 """Returns the values of the email's To:, From: and Subject: fields
1140 Returns this information from an email.
1143 email_bytes: the byte string form of the email
1146 the email To:, From:, and Subject: fields as strings
1149 email_struct
= email
.parser
.BytesParser().parsebytes(email_bytes
)
1151 email_to
= email_struct
['To']
1152 email_from
= email_struct
['From']
1153 email_subject
= email_struct
['Subject']
1155 return email_to
, email_from
, email_subject
1158 def import_lang_pick_address(email_to
, hostname
):
1159 """Imports language file for i18n support; makes reply from address
1161 The language imported depends on the To: address of the email received by
1162 edward. an -en ending implies the English language, whereas a -ja ending
1163 implies Japanese. The list of supported languages is listed in the 'langs'
1164 list at the beginning of the program. This function also chooses the
1165 language-dependent address which can be used as the From address in the
1169 email_to: the string containing the email address that the mail was
1171 hostname: the hostname part of the reply email's from address
1174 the reference to the imported language module. The only variable in
1175 this file is the 'replies' dictionary.
1181 if email_to
!= None:
1183 if "edward-" + lang
in email_to
:
1187 lang_mod_name
= "lang." + re
.sub('-', '_', use_lang
)
1188 lang_module
= importlib
.import_module(lang_mod_name
)
1190 reply_from
= "edward-" + use_lang
+ "@" + hostname
1192 return lang_module
, reply_from
1195 def generate_encrypted_mime (plaintext
, email_to
, email_subject
, encrypt_to_key
,
1197 """This function creates the mime email reply. It can encrypt the email.
1199 If the encrypt_key is included, then the email is encrypted and signed.
1200 Otherwise it is unencrypted.
1203 plaintext: the plaintext body of the message to create.
1204 email_to: the email address to reply to
1205 email_subject: the subject to use in reply
1206 encrypt_to_key: the key object to use for encrypting the email. (or
1208 gpgme_ctx: the gpgme context
1211 A string version of the mime message, possibly encrypted and signed.
1214 if (encrypt_to_key
!= None):
1216 plaintext_mime
= MIMEText(plaintext
)
1217 plaintext_mime
.set_charset('utf-8')
1219 encrypted_text
= encrypt_sign_message(plaintext_mime
.as_string(),
1223 control_mime
= MIMEApplication("Version: 1",
1224 _subtype
='pgp-encrypted',
1225 _encoder
=email
.encoders
.encode_7or8bit
)
1226 control_mime
['Content-Description'] = 'PGP/MIME version identification'
1227 control_mime
.set_charset('us-ascii')
1229 encoded_mime
= MIMEApplication(encrypted_text
,
1230 _subtype
='octet-stream; name="encrypted.asc"',
1231 _encoder
=email
.encoders
.encode_7or8bit
)
1232 encoded_mime
['Content-Description'] = 'OpenPGP encrypted message'
1233 encoded_mime
['Content-Disposition'] = 'inline; filename="encrypted.asc"'
1234 encoded_mime
.set_charset('us-ascii')
1236 message_mime
= MIMEMultipart(_subtype
="encrypted", protocol
="application/pgp-encrypted")
1237 message_mime
.attach(control_mime
)
1238 message_mime
.attach(encoded_mime
)
1239 message_mime
['Content-Disposition'] = 'inline'
1242 message_mime
= MIMEText(plaintext
)
1243 message_mime
.set_charset('utf-8')
1245 message_mime
['To'] = email_to
1246 message_mime
['Subject'] = email_subject
1248 reply
= message_mime
.as_string()
1253 def send_reply(email_txt
, subject
, reply_to
, reply_from
):
1255 email_bytes
= email_txt
.encode('ascii')
1257 p
= subprocess
.Popen(["/usr/sbin/sendmail", "-f", reply_from
, "-F", "Edward, GPG Bot", "-i", reply_to
], stdin
=subprocess
.PIPE
)
1259 (stdout
, stderr
) = p
.communicate(email_bytes
)
1262 debug("sendmail stdout: " + str(stdout
))
1264 error("sendmail stderr: " + str(stderr
))
1267 def email_quote_text (text
):
1268 """Quotes input text by inserting "> "s
1270 This is useful for quoting a text for the reply message. It inserts "> "
1271 strings at the beginning of lines.
1274 text: plain text to quote
1280 quoted_message
= re
.sub(r
'^', r
'> ', text
, flags
=re
.MULTILINE
)
1282 return quoted_message
1285 def encrypt_sign_message (plaintext
, encrypt_to_key
, gpgme_ctx
):
1286 """Encrypts and signs plaintext
1288 This encrypts and signs a message.
1291 plaintext: text to sign and ecrypt
1292 encrypt_to_key: the key object to encrypt to
1293 gpgme_ctx: the gpgme context
1296 An encrypted and signed string of text
1299 # the plaintext should be mime encoded in an ascii-compatible form
1300 plaintext_bytes
= io
.BytesIO(plaintext
.encode('ascii'))
1301 encrypted_bytes
= io
.BytesIO()
1303 gpgme_ctx
.encrypt_sign([encrypt_to_key
], gpgme
.ENCRYPT_ALWAYS_TRUST
,
1304 plaintext_bytes
, encrypted_bytes
)
1306 encrypted_txt
= encrypted_bytes
.getvalue().decode('ascii')
1307 return encrypted_txt
1310 def error (error_msg
):
1311 """Write an error message to stdout
1313 The error message includes the program name.
1316 error_msg: the message to print
1322 An error message is printed to stdout
1325 sys
.stderr
.write(progname
+ ": " + str(error_msg
) + "\n")
1328 def debug (debug_msg
):
1329 """Writes a debug message to stdout if debug == True
1331 If the debug option is set in edward_config.py, then the passed message
1332 gets printed to stdout.
1335 debug_msg: the message to print to stdout
1341 A debug message is printed to stdout
1344 if edward_config
.debug
== True:
1349 """Sets the progname variable and processes optional argument
1351 If there are more than two arguments then edward complains and quits. An
1352 single "-p" argument sets the print_reply_only option, which makes edward
1353 print email replies instead of mailing them.
1359 True if edward should print arguments instead of mailing them,
1360 otherwise it returns False.
1363 Exits with error 1 if there are more than two arguments, otherwise
1364 returns the print_reply_only option.
1368 progname
= sys
.argv
[0]
1370 print_reply_only
= False
1372 if len(sys
.argv
) > 2:
1373 print(progname
+ " usage: " + progname
+ " [-p]\n\n" \
1374 + " -p print reply message to stdout, do not mail it\n", \
1378 elif (len(sys
.argv
) == 2) and (sys
.argv
[1] == "-p"):
1379 print_reply_only
= True
1381 return print_reply_only
1384 if __name__
== "__main__":
1385 """Executes main if this file is not loaded interactively"""