edward-bot

   1 #! /usr/bin/env python3
   2
   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.                                  *
   8 *                                                                      *
   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.                          *
  13 *                                                                      *
  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/>.      *
  16 *                                                                      *
  17 * Copyright (C) 2014-2015 Andrew Engelbrecht                (AGPLv3+)  *
  18 * Copyright (C) 2014      Josh Drake                        (AGPLv3+)  *
  19 * Copyright (C) 2014      Lisa Marie Maginnis               (AGPLv3+)  *
  20 *                                                                      *
  21 * Special thanks to Josh Drake for writing the original edward bot! :) *
  22 *                                                                      *
  23 ************************************************************************
  24
  25 Code used from:
  26
  27 * http://agpl.fsf.org/emailselfdefense.fsf.org/edward/CURRENT/edward.tar.gz
  28
  29 """
  30
  31 import sys
  32 import email.parser
  33 import gpgme
  34 import re
  35 import io
  36 import time
  37
  38
  39 def main ():
  40
  41     handle_args()
  42
  43     email_text = sys.stdin.read()
  44
  45     plaintext, keys = email_decode_flatten (email_text)
  46     email_from, email_subject = email_from_subject(email_text)
  47
  48     print("From: " + email_from)
  49     print("Subject: " + email_subject)
  50     print(plaintext)
  51
  52     for key in keys:
  53         print(key.subkeys[0].fpr)
  54
  55
  56 def email_decode_flatten (email_text):
  57
  58     body = ""
  59     keys = []
  60
  61     email_struct = email.parser.Parser().parsestr(email_text)
  62
  63     for subpart in email_struct.walk():
  64
  65         payload, description, filename, content_type \
  66                 = get_email_subpart_info(subpart)
  67
  68         if payload == "":
  69             continue
  70
  71         if content_type == "multipart":
  72             continue
  73
  74         if content_type == "application/pgp-encrypted":
  75             if description == "PGP/MIME version identification":
  76                 if payload.strip() != "Version: 1":
  77                     print(progname + ": Warning: unknown " \
  78                             + description + ": " \
  79                             + payload.strip(), file=sys.stderr)
  80             continue
  81
  82
  83         if (filename == "encrypted.asc") or (content_type == "pgp/mime"):
  84             plaintext, more_keys = decrypt_text(payload)
  85
  86             body += plaintext
  87             keys += more_keys
  88
  89         elif content_type == "text/plain":
  90             body += payload + "\n"
  91
  92         else:
  93             body += payload + "\n"
  94
  95     return body, keys
  96
  97
  98 def email_from_subject (email_text):
  99
 100     email_struct = email.parser.Parser().parsestr(email_text)
 101
 102     email_from      = email_struct['From']
 103     email_subject   = email_struct['Subject']
 104
 105     return email_from, email_subject
 106
 107
 108 def get_email_subpart_info (part):
 109
 110     charset             = part.get_content_charset()
 111     payload_bytes       = part.get_payload(decode=True)
 112
 113     filename            = part.get_filename()
 114     content_type        = part.get_content_type()
 115     description_list    = part.get_params(header='content-description')
 116
 117     if charset == None:
 118         charset = 'utf-8'
 119
 120     if payload_bytes != None:
 121         payload = payload_bytes.decode(charset)
 122     else:
 123         payload = ""
 124
 125     if description_list != None:
 126         description = description_list[0][0]
 127     else:
 128         description = ""
 129
 130     return payload, description, filename, content_type
 131
 132
 133 def decrypt_text (gpg_text):
 134
 135     body = ""
 136     keys = []
 137
 138     gpg_chunks = split_message(gpg_text)
 139
 140     plaintext_and_sigs_chunks = decrypt_chunks(gpg_chunks)
 141
 142     for chunk in plaintext_and_sigs_chunks:
 143         plaintext   = chunk[0]
 144         sigs        = chunk[1]
 145
 146         for sig in sigs:
 147             key = get_pub_key(sig)
 148             keys += [key]
 149
 150         # recursive for nested layers of mime and/or gpg
 151         plaintext, more_keys = email_decode_flatten(plaintext)
 152
 153         body += plaintext
 154         keys += more_keys
 155
 156     return body, keys
 157
 158
 159 def get_pub_key (sig):
 160
 161     gpgme_ctx = gpgme.Context()
 162
 163     fingerprint = sig.fpr
 164     key = gpgme_ctx.get_key(fingerprint)
 165
 166     return key
 167
 168
 169 def split_message (text):
 170
 171     gpg_matches = re.search( \
 172             '(-----BEGIN PGP MESSAGE-----' + \
 173             '.*' + \
 174             '-----END PGP MESSAGE-----)', \
 175             text, \
 176             re.DOTALL)
 177
 178     if gpg_matches != None:
 179         gpg_chunks = gpg_matches.groups()
 180     else:
 181         gpg_chunks = ()
 182
 183     return gpg_chunks
 184
 185
 186 def decrypt_chunks (gpg_chunks):
 187
 188     plaintext_and_sigs_chunks = []
 189
 190     for gpg_chunk in gpg_chunks:
 191         plaintext_and_sigs_chunks += [decrypt_chunk(gpg_chunk)]
 192
 193     return plaintext_and_sigs_chunks
 194
 195
 196 def decrypt_chunk (gpg_chunk):
 197
 198     gpgme_ctx = gpgme.Context()
 199
 200     chunk_b = io.BytesIO(gpg_chunk.encode('ASCII'))
 201     plain_b = io.BytesIO()
 202
 203     sigs = gpgme_ctx.decrypt_verify(chunk_b, plain_b)
 204
 205     plaintext = plain_b.getvalue().decode('ASCII')
 206     return (plaintext, sigs)
 207
 208
 209 def handle_args ():
 210     if __name__ == "__main__":
 211
 212         global progname
 213         progname = sys.argv[0]
 214
 215         if len(sys.argv) > 1:
 216             print(progname + ": error, this program doesn't " \
 217                     "need any arguments.", file=sys.stderr)
 218             exit(1)
 219
 220
 221 main()
 222