22 | """
23 |
24 | class Plugin(plugins.ServerPlugin):
25 | authors = ['Austin DeFrancesco', 'Spencer McIntyre', 'Mike Stringer', 'Erik Daguerre']
26 | classifiers = ['Plugin :: Server :: Notifications :: Alerts']
27 | title = 'Campaign Alerts: via Python 3 SMTPLib'
28 | description = """
29 | Send campaign alerts via the SMTP Python 3 lib. This requires that users specify
30 | their email through the King Phisher client to subscribe to notifications.
31 | """
32 | homepage = 'https://github.com/securestate/king-phisher-plugins'
33 | version = '1.1'
34 |
35 | # Email accounts with 2FA, such as Gmail, will not work unless "less secure apps" are allowed
36 | # Reference: https://support.google.com/accounts/answer/60610255
37 | # Gmail and other providers require SSL on port 465, TLS will start with the activation of SSL
38 | options = [
39 | plugin_opts.OptionString(
40 | name='smtp_server',
41 | description='Location of SMTP server',
42 | default='localhost'
43 | ),
44 | plugin_opts.OptionInteger(
45 | name='smtp_port',
46 | description='Port used for SMTP server',
47 | default=25
48 | ),
49 | plugin_opts.OptionString(
50 | name='smtp_email',
51 | description='SMTP email address to send notifications from',
52 | default=''
53 | ),
54 | plugin_opts.OptionString(
55 | name='smtp_username',
56 | description='Username to authenticate to the SMTP server with'
57 | ),
58 | plugin_opts.OptionString(
59 | name='smtp_password',
60 | description='Password to authenticate to the SMTP server with',
61 | default=''
62 | ),
63 | plugin_opts.OptionBoolean(
64 | name='smtp_ssl',
65 | description='Connect to the SMTP server with SSL',
66 | default=False
67 | ),
68 | plugin_opts.OptionString(
69 | name='email_jinja_template',
70 | description='Custom email jinja template to use for alerts',
71 | default=''
72 | ),
73 | ]
74 | req_min_version = '1.12.0b2'
75 | def initialize(self):
76 | signals.campaign_alert.connect(self.on_campaign_alert)
77 | signals.campaign_alert_expired.connect(self.on_campaign_alert_expired)
78 | template_path = self.config['email_jinja_template']
79 | if not template_path:
80 | template_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'template.html')
81 | if not os.path.isfile(template_path):
82 | self.logger.warning('invalid email template: ' + template_path)
83 | return False
84 | with open(template_path, 'r') as file_:
85 | template_data = file_.read()
86 | self.render_template = templates.TemplateEnvironmentBase().from_string(template_data)
87 | return True
88 |
89 | def on_campaign_alert(self, table, alert_subscription, count):
90 | return self.send_alert(alert_subscription)
91 |
92 | def on_campaign_alert_expired(self, camapign, alert_subscription):
93 | return self.send_alert(alert_subscription)
94 |
95 | def get_template_vars(self, alert_subscription):
96 | campaign = alert_subscription.campaign
97 | template_vars = {
98 | 'campaign': {
99 | 'id': str(campaign.id),
100 | 'name': campaign.name,
101 | 'created': campaign.created,
102 | 'expiration': campaign.expiration,
103 | 'has_expired': campaign.has_expired,
104 | 'message_count': len(campaign.messages),
105 | 'visit_count': len(campaign.visits),
106 | 'credential_count': len(campaign.credentials)
107 | },
108 | 'time': {
109 | 'local': datetime.datetime.now(),
110 | 'utc': datetime.datetime.utcnow()
111 | }
112 | }
113 | return template_vars
114 |
115 | def create_message(self, alert_subscription):
116 | message = MIMEMultipart()
117 | message['Subject'] = "Campaign Event: {0}".format(alert_subscription.campaign.name)
118 | message['From'] = "<{0}>".format(self.config['smtp_email'])
119 | message['To'] = "<{0}>".format(alert_subscription.user.email_address)
120 |
121 | textual_message = MIMEMultipart('alternative')
122 | plaintext_part = MIMEText('This message requires an HTML aware email agent to be properly viewed.\r\n\r\n', 'plain')
123 | textual_message.attach(plaintext_part)
124 |
125 | try:
126 | rendered_email = self.render_template.render(self.get_template_vars(alert_subscription))
127 | except:
128 | self.logger.warning('failed to render the email template', exc_info=True)
129 | return False
130 | html_part = MIMEText(rendered_email, 'html')
131 | textual_message.attach(html_part)
132 |
133 | message.attach(textual_message)
134 | encoded_email = message.as_string()
135 | return encoded_email
136 |
137 | def send_alert(self, alert_subscription):
138 | user = alert_subscription.user
139 | if not user.email_address:
140 | self.logger.debug("user {0} has no email address specified, skipping SMTP alert".format(user.name))
141 | return False
142 |
143 | msg = self.create_message(alert_subscription)
144 | if not msg:
145 | return False
146 |
147 | if self.config['smtp_ssl']:
148 | SmtpClass = smtplib.SMTP_SSL
149 | else:
150 | SmtpClass = smtplib.SMTP
151 | try:
152 | server = SmtpClass(self.config['smtp_server'], self.config['smtp_port'], timeout=15)
153 | server.ehlo()
154 | except smtplib.SMTPException:
155 | self.logger.warning('received an SMTPException while connecting to the SMTP server', exc_info=True)
156 | return False
157 | except socket.error:
158 | self.logger.warning('received a socket.error while connecting to the SMTP server')
159 | return False
160 |
161 | if not self.config['smtp_ssl'] and 'starttls' in server.esmtp_features:
162 | self.logger.debug('target SMTP server supports the STARTTLS extension')
163 | try:
164 | server.starttls()
165 | server.ehlo()
166 | except smtplib.SMTPException:
167 | self.logger.warning('received an SMTPException wile negotiating STARTTLS with SMTP server', exc_info=True)
168 | return False
169 |
170 | if self.config['smtp_username']:
171 | try:
172 | server.login(self.config['smtp_username'], self.config['smtp_password'])
173 | except smtplib.SMTPNotSupportedError:
174 | self.logger.debug('SMTP server does not support authentication')
175 | except smtplib.SMTPException as error:
176 | self.logger.warning("received an {0} while authenticating to the SMTP server".format(error.__class__.__name__))
177 | server.quit()
178 | return False
179 |
180 | mail_options = ['SMTPUTF8'] if server.has_extn('SMTPUTF8') else []
181 | try:
182 | server.sendmail(self.config['smtp_email'], alert_subscription.user.email_address, msg, mail_options)
183 | except smtplib.SMTPException as error:
184 | self.logger.warning("received error {0} while sending mail".format(error.__class__.__name__))
185 | return False
186 | finally:
187 | server.quit()
188 | self.logger.debug("successfully sent an email campaign alert to user: {0}".format(user.name))
189 | return True
190 |
--------------------------------------------------------------------------------
/client/dmarc.py:
--------------------------------------------------------------------------------
1 | import argparse
2 | import collections
3 |
4 | import king_phisher.color as color
5 | import king_phisher.constants as constants
6 | import king_phisher.spf as spf
7 | import king_phisher.client.mailer as mailer
8 | import king_phisher.client.plugins as plugins
9 | import king_phisher.client.gui_utilities as gui_utilities
10 |
11 | import dns.rdtypes.ANY.TXT
12 | import dns.resolver
13 |
14 | TAGS = {
15 | 'adkim': 'r',
16 | 'aspf': 'r',
17 | 'fo': '0',
18 | 'p': None,
19 | 'pct': '100',
20 | 'rf': 'afrf',
21 | 'ri': '86400',
22 | 'rua': None,
23 | 'ruf': None,
24 | 'sp': None,
25 | 'v': None
26 | }
27 | """
28 | A dictionary of all tags defined in RFC-7489 with their default value as a
29 | string, or None if no default value is specified.
30 | """
31 |
32 | class DMARCError(Exception):
33 | def __init__(self, message):
34 | self.message = message
35 |
36 | def __repr__(self):
37 | return "<{0} message='{1}' >".format(self.__class__.__name__, self.message)
38 |
39 | class DMARCNoRecordError(DMARCError):
40 | pass
41 |
42 | class DMARCParseError(DMARCError):
43 | def __init__(self, message, tag=None):
44 | self.message = message
45 | self.tag = tag
46 |
47 | class DMARCPolicy(object):
48 | def __init__(self, record):
49 | record = record.strip()
50 | self.record = record
51 | self.tags = collections.OrderedDict()
52 | record = record.split(';')
53 | # the tag specification is defined in the DKIM spec (RFC 6376) https://tools.ietf.org/html/rfc6376#section-3.2
54 | for token in record:
55 | token = token.strip()
56 | if not token:
57 | continue
58 | if not '=' in token:
59 | raise DMARCParseError('can not separate record token: ' + token)
60 | tag, value = token.split('=', 1)
61 | if tag not in TAGS:
62 | # ignore unknown tags per https://tools.ietf.org/html/rfc7489#section-6.3
63 | continue
64 | self.tags[tag.strip()] = value.strip()
65 | if 'p' in self.tags and self.tags['p'] not in ('none', 'quarantine', 'reject'):
66 | raise DMARCParseError("invalid dmarc record (invalid policy: {0})".format(self.tags['p']), tag='p')
67 | if self.version is None:
68 | raise DMARCParseError('invalid dmarc record (missing version tag)', tag='v')
69 | if self.version != 'DMARC1':
70 | raise DMARCParseError("invalid dmarc record (invalid version value: {0})".format(self.version), tag='v')
71 |
72 | def __repr__(self):
73 | return "<{0} v={1} >".format(self.__class__.__name__, self.version)
74 |
75 | def __str__(self):
76 | return self.record
77 |
78 | @classmethod
79 | def from_domain(cls, domain):
80 | if not domain.startswith('_dmarc.'):
81 | domain = '_dmarc.' + domain
82 | try:
83 | answers = dns.resolver.query(domain, 'TXT')
84 | except dns.exception.DNSException:
85 | raise DMARCNoRecordError("DNS resolution error for: {0} TXT".format(domain)) from None
86 | answers = list(answer for answer in answers if isinstance(answer, dns.rdtypes.ANY.TXT.TXT))
87 |
88 | answers = [answer for answer in answers if answer.strings[0].decode('utf-8').startswith('v=DMARC')]
89 | if len(answers) == 0:
90 | raise DMARCParseError('failed to parse dmarc record for domain: ' + domain)
91 | record = ''.join([part.decode('utf-8') for part in answers[0].strings])
92 | return cls(record)
93 |
94 | def get(self, tag):
95 | if not tag in TAGS:
96 | raise KeyError(tag)
97 | return self.tags.get(tag, TAGS[tag])
98 |
99 | @property
100 | def policy(self):
101 | return self.tags.get('p')
102 |
103 | @property
104 | def version(self):
105 | return self.tags.get('v')
106 |
107 | class Plugin(plugins.ClientPlugin):
108 | authors = ['Spencer McIntyre']
109 | classifiers = [
110 | 'Plugin :: Client :: Email :: Spam Evasion',
111 | 'Script :: CLI'
112 | ]
113 | title = 'DMARC Check'
114 | description = """
115 | This plugin adds another safety check to the message precheck routines to
116 | verify that if DMARC exists the message will not be quarentined or rejected.
117 | If no DMARC policy is present, the policy is set to none or the percentage
118 | is set to 0, the message sending operation will proceed.
119 | """
120 | homepage = 'https://github.com/securestate/king-phisher-plugins'
121 | reference_urls = ['https://dmarc.org/overview/']
122 | req_min_version = '1.5.0'
123 | version = '1.2'
124 | def initialize(self):
125 | self.signal_connect('send-precheck', self.signal_send_precheck, gobject=self.application.main_tabs['mailer'])
126 | return True
127 |
128 | def signal_send_precheck(self, mailer_tab):
129 | test_ip = mailer.guess_smtp_server_address(
130 | self.application.config['smtp_server'],
131 | (self.application.config['ssh_server'] if self.application.config['smtp_ssh_enable'] else None)
132 | )
133 | if not test_ip:
134 | self.logger.info('skipping dmarc policy check because the smtp server address could not be resolved')
135 | return True
136 | test_sender, test_domain = self.application.config['mailer.source_email_smtp'].split('@')
137 | self.logger.debug('checking the dmarc policy for domain: ' + test_domain)
138 | text_insert = mailer_tab.tabs['send_messages'].text_insert
139 |
140 | text_insert("Checking the DMARC policy of target domain '{0}'... ".format(test_domain))
141 | try:
142 | spf_result = spf.check_host(test_ip, test_domain, sender=test_sender)
143 | except spf.SPFError as error:
144 | text_insert("done, encountered exception: {0}.\n".format(error.__class__.__name__))
145 | return True
146 |
147 | try:
148 | dmarc_policy = DMARCPolicy.from_domain(test_domain)
149 | except DMARCNoRecordError:
150 | self.logger.debug('no dmarc policy found for domain: ' + test_domain)
151 | text_insert('done, no policy found.\n')
152 | return True
153 | except DMARCError as error:
154 | self.logger.warning('dmarc error: ' + error.message)
155 | text_insert("done, encountered exception: {0}.\n".format(error.__class__.__name__))
156 | return False
157 | text_insert('done.\n')
158 | self.logger.debug("dmarc policy set to {0!r} for domain: {1}".format(dmarc_policy.policy, test_domain))
159 | text_insert('Found DMARC policy:\n')
160 | text_insert(' Policy: ' + dmarc_policy.policy + '\n')
161 | text_insert(' Percent: ' + dmarc_policy.get('pct') + '\n')
162 | if dmarc_policy.get('rua'):
163 | text_insert(' RUA URI: ' + dmarc_policy.get('rua') + '\n')
164 | if dmarc_policy.get('ruf'):
165 | text_insert(' RUF URI: ' + dmarc_policy.get('ruf') + '\n')
166 |
167 | if spf_result == constants.SPFResult.PASS:
168 | return True
169 | if dmarc_policy.policy == 'none' or dmarc_policy.get('pct') == '0':
170 | return True
171 |
172 | if dmarc_policy.policy == 'quarantine':
173 | message = 'The DMARC policy results in these messages being quarantined.'
174 | elif dmarc_policy.policy == 'reject':
175 | message = 'The DMARC policy results in these messages being rejected.'
176 | text_insert('WARNING: ' + message + '\n')
177 | ignore = gui_utilities.show_dialog_yes_no(
178 | 'DMARC Policy Failure',
179 | self.application.get_active_window(),
180 | message + '\nContinue sending messages anyways?'
181 | )
182 | return ignore
183 |
184 | def main():
185 | parser = argparse.ArgumentParser(description='DMARC Check Utility', conflict_handler='resolve')
186 | parser.add_argument('domain', help='the name of the domain to check')
187 | arguments = parser.parse_args()
188 |
189 | try:
190 | policy = DMARCPolicy.from_domain(arguments.domain)
191 | except DMARCNoRecordError:
192 | color.print_error('dmarc policy not found')
193 | return
194 |
195 | color.print_status('dmarc policy found')
196 | color.print_status('record: ' + policy.record)
197 | color.print_status('version: ' + policy.version)
198 | color.print_status('policy: ' + policy.policy)
199 |
200 | if __name__ == '__main__':
201 | main()
202 |
--------------------------------------------------------------------------------
/client/sftp_client/tasks.py:
--------------------------------------------------------------------------------
1 | import threading
2 | import time
3 | import logging
4 |
5 | logger = logging.getLogger('KingPhisher.Plugins.SFTPClient.tasks')
6 |
7 | class TaskQueue(object):
8 | """
9 | Task queue used for transfer tasks that handles thread and task management
10 | in a way to prevent errors.
11 | """
12 | def __init__(self):
13 | self.mutex = threading.RLock()
14 | self.not_empty = threading.Condition(self.mutex)
15 | self.not_full = threading.Condition(self.mutex)
16 | self.queue = []
17 | self.unfinished_tasks = 0
18 |
19 | @property
20 | def queue_ready(self):
21 | for task in self.queue:
22 | if task.is_ready:
23 | yield task
24 |
25 | def _qsize(self, len=len): # pylint: disable=redefined-builtin
26 | return len(list(self.queue))
27 |
28 | def _qsize_ready(self, len=len): # pylint: disable=redefined-builtin
29 | return len(list(self.queue_ready))
30 |
31 | def get(self, block=True, timeout=None):
32 | self.not_empty.acquire()
33 | try:
34 | if not block:
35 | if not self._qsize_ready():
36 | return None
37 | elif timeout is None:
38 | while not self._qsize_ready():
39 | self.not_empty.wait()
40 | elif timeout < 0:
41 | raise ValueError('\'timeout\' must be a non-negative number')
42 | else:
43 | endtime = time() + timeout # pylint: disable = not-callable
44 | while not self._qsize_ready():
45 | remaining = endtime - time() # pylint: disable = not-callable
46 | if remaining <= 0.0:
47 | return None
48 | self.not_empty.wait(remaining)
49 | task = next(self.queue_ready)
50 | task.state = 'Active'
51 | self.not_full.notify()
52 | return task
53 | finally:
54 | self.not_empty.release()
55 |
56 | def put(self, task):
57 | """
58 | Put a task in the queue.
59 |
60 | :param task: A task to be put in the queue.
61 | """
62 | if not isinstance(task, Task):
63 | raise TypeError('argument 1 task must be Task instance')
64 | with self.not_full:
65 | task.register(self.not_empty)
66 | self.queue.append(task)
67 | self.unfinished_tasks += 1
68 | self.not_empty.notify()
69 | logger.debug('queued task: ' + str(task))
70 |
71 | def remove(self, task):
72 | """
73 | Remove a task from the queue.
74 |
75 | :param task: A task to be removed from the queue.
76 | """
77 | with self.mutex:
78 | self.queue.remove(task)
79 | self.unfinished_tasks += 1
80 | self.not_full.notify()
81 |
82 | class Task(object):
83 | """
84 | Generic task class that contains information about task state and readiness.
85 | """
86 | _states = ('Active', 'Cancelled', 'Completed', 'Error', 'Paused', 'Pending')
87 | _ready_states = ('Pending',)
88 | __slots__ = ('_ready', '_state')
89 | def __init__(self, state=None):
90 | self._ready = None
91 | self._state = None
92 | self.state = (state or 'Pending')
93 |
94 | @property
95 | def is_done(self):
96 | return self._state in ('Cancelled', 'Completed', 'Error')
97 |
98 | @property
99 | def is_ready(self):
100 | return self._state in self._ready_states
101 |
102 | @property
103 | def state(self):
104 | return self._state
105 |
106 | @state.setter
107 | def state(self, value):
108 | if value not in self._states:
109 | raise ValueError('invalid state')
110 | self._state = value
111 | if self._state in self._ready_states and self._ready is not None:
112 | self._ready.notify()
113 |
114 | def register(self, ready_event):
115 | if self._ready is not None:
116 | raise RuntimeError('this task has already been registered')
117 | self._ready = ready_event
118 |
119 | class ShutdownTask(Task):
120 | """
121 | Dummy task used to signal the queue to shutdown.
122 | """
123 | def __str__(self):
124 | return 'shutdown'
125 |
126 | class TransferTask(Task):
127 | """
128 | Task used to model transfers. Each task is put in the queue where it will be
129 | pass into the _transfer method of the FileManager class for the transfer to
130 | occur.
131 | """
132 | _states = ('Active', 'Cancelled', 'Completed', 'Error', 'Paused', 'Pending', 'Transferring')
133 | __slots__ = ('_state', 'local_path', 'remote_path', 'size', 'transferred', 'treerowref', 'parent')
134 | def __init__(self, local_path, remote_path, parent=None, size=None, state=None):
135 | super(TransferTask, self).__init__(state=state)
136 | self.local_path = local_path
137 | """A string representing the local filesystem path of the transfer."""
138 | self.remote_path = remote_path
139 | """A string representing the remote filesystem path of the transfer."""
140 | self.transferred = 0
141 | """
142 | If the task is a file transfer, an integer of the number of bytes transferred,
143 | if the task is a directory transfer, the number of children files transferred.
144 | """
145 | self.size = size
146 | """
147 | If the task is a file transfer, an integer of the total number of bytes,
148 | if the task is a directory transfer, the total number of children files.
149 | """
150 | self.treerowref = None
151 | """A TreeRowReference object representing the Tasks position in the treeview."""
152 | self.parent = parent
153 |
154 | def __repr__(self):
155 | return "<{0} local_path={1!r} remote_path={2!r} state={3!r}>".format(self.__class__.__name__, self.local_path, self.remote_path, self.state)
156 |
157 | @property
158 | def parents(self):
159 | parents = []
160 | node = self
161 | while node.parent is not None:
162 | parents.append(node.parent)
163 | node = node.parent
164 | return parents
165 |
166 | @property
167 | def progress(self):
168 | if self.size is None:
169 | percent = 0
170 | elif self.size == 0:
171 | percent = 1
172 | else:
173 | percent = (float(self.transferred) / float(self.size))
174 | return min(int(percent * 100), 100)
175 |
176 | @property
177 | def state(self):
178 | return Task.state.fget(self)
179 |
180 | @state.setter
181 | def state(self, value):
182 | if value == Task.state.fget(self):
183 | return
184 | Task.state.fset(self, value)
185 | if value in ('Cancelled', 'Completed'):
186 | for parent_task in self.parents:
187 | if value == 'Cancelled':
188 | parent_task.size -= 1
189 | else:
190 | parent_task.transferred += 1
191 | if parent_task.size == parent_task.transferred:
192 | parent_task.state = ('Completed' if parent_task.size else 'Cancelled')
193 |
194 | class DownloadTask(TransferTask):
195 | """
196 | Subclass of TransferTask that indicates
197 | the task is downloading files.
198 | """
199 | transfer_direction = 'download'
200 | def __str__(self):
201 | return "download file {0} -> {1}".format(self.remote_path, self.local_path)
202 |
203 | class UploadTask(TransferTask):
204 | """
205 | Subclass of TransferTask that indicates
206 | the task is uploading files.
207 | """
208 | transfer_direction = 'upload'
209 | def __str__(self):
210 | return "upload file {0} -> {1}".format(self.local_path, self.remote_path)
211 |
212 | class TransferDirectoryTask(TransferTask):
213 | """
214 | Task to model a folder transfer. Acts as a parent task
215 | to other TransferTasks and is passed into _transfer_dir.
216 | """
217 | pass
218 |
219 | class DownloadDirectoryTask(DownloadTask, TransferDirectoryTask):
220 | """
221 | Subclass of DownloadTask and TransferDirectoryTask that indicates the task
222 | is downloading folders.
223 | """
224 | def __str__(self):
225 | return "download directory {0} -> {1}".format(self.remote_path, self.local_path)
226 | DownloadTask.dir_cls = DownloadDirectoryTask
227 |
228 | class UploadDirectoryTask(UploadTask, TransferDirectoryTask):
229 | """
230 | Subclass of UploadTask and TransferDirectoryTask that indicates the task is
231 | uploading folders.
232 | """
233 | def __str__(self):
234 | return "upload directory {0} -> {1}".format(self.remote_path, self.local_path)
235 | UploadTask.dir_cls = UploadDirectoryTask
236 |
--------------------------------------------------------------------------------
/client/message_padding.py:
--------------------------------------------------------------------------------
1 | import king_phisher.client.plugins as plugins
2 |
3 | import os
4 |
5 | PLUGIN_PATH = os.path.realpath(os.path.dirname(__file__))
6 | STATIC_PADDING = """\
7 | It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. \
8 | The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it \
9 | look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem \
10 | ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose. \
11 | Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 \
12 | years old. Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a \
13 | Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections \
14 | 1.10.32 and 1.10.33 of 'de Finibus Bonorum et Malorum' (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory \
15 | of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, 'Lorem ipsum dolor sit amet..', comes from a line in section 1.10.32. The \
16 | standard chunk of Lorem Ipsum used since the 1500s is reproduced below for those interested. Sections 1.10.32 and 1.10.33 from 'de Finibus Bonorum et \
17 | Malorum' by Cicero are also reproduced in their exact original form, accompanied by English versions from the 1914 translation by H. Rackham. The \
18 | point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it \
19 | look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem \
20 | ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose. \
21 | Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 \
22 | years old. Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a \
23 | Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections \
24 | 1.10.32 and 1.10.33 of 'de Finibus Bonorum et Malorum' (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory \
25 | of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, 'Lorem ipsum dolor sit amet..', comes from a line in section 1.10.32. The \
26 | standard chunk of Lorem Ipsum used since the 1500s is reproduced below for those interested. Sections 1.10.32 and 1.10.33 from 'de Finibus Bonorum et \
27 | Malorum' by Cicero are also reproduced in their exact original form, accompanied by English versions from the 1914 translation by H. Rackham. \
28 | The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it \
29 | look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem \
30 | ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose. \
31 | Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 \
32 | years old. Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a \
33 | Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections \
34 | 1.10.32 and 1.10.33 of 'de Finibus Bonorum et Malorum' (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory \
35 | of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, 'Lorem ipsum dolor sit amet..', comes from a line in section 1.10.32. The \
36 | standard chunk of Lorem Ipsum used since the 1500s is reproduced below for those interested. Sections 1.10.32 and 1.10.33 from 'de Finibus Bonorum et \
37 | Malorum' by Cicero are also reproduced in their exact original form, accompanied by English versions from the 1914 translation by H. Rackham.
\
38 | """
39 |
40 | try:
41 | import markovify
42 | except ImportError:
43 | has_markovify = False
44 | else:
45 | has_markovify = True
46 |
47 | class Plugin(plugins.ClientPlugin):
48 | authors = ['Spencer McIntyre', 'Mike Stringer']
49 | classifiers = ['Plugin :: Client :: Email :: Spam Evasion']
50 | title = 'Message Padding'
51 | description = """
52 | Add and modify custom HTML messages from a file to reduce Spam Assassin
53 | scores. This plugin interacts with the message content to append a long
54 | series of randomly generated sentences to meet the ideal image-text ratio.
55 | """
56 | homepage = 'https://github.com/securestate/king-phisher-plugins'
57 | options = [
58 | plugins.ClientOptionString(
59 | 'corpus',
60 | description='Text file containing text to generate dynamic padding',
61 | default=os.path.join(PLUGIN_PATH, 'corpus.txt'),
62 | display_name='Corpus File'
63 | ),
64 | plugins.ClientOptionBoolean(
65 | 'dynamic_padding',
66 | description='Sets whether dynamically generated or static padding is appended to the messaged',
67 | default=True
68 | )
69 | ]
70 | req_min_version = '1.10.0'
71 | version = '1.0'
72 | req_packages = {
73 | 'markovify': has_markovify
74 | }
75 | def initialize(self):
76 | mailer_tab = self.application.main_tabs['mailer']
77 | self.signal_connect('message-create', self.signal_message_create, gobject=mailer_tab)
78 | if os.path.isfile(os.path.realpath(self.config['corpus'])):
79 | self.corpus = os.path.realpath(self.config['corpus'])
80 | else:
81 | self.corpus = None
82 | self.logger.debug('corpus file: ' + repr(self.corpus))
83 | if self.corpus:
84 | self.dynamic = self.config['dynamic_padding']
85 | else:
86 | if self.config['dynamic_padding']:
87 | self.logger.warning('the corpus file is unavailable, ignoring the dynamic padding setting')
88 | self.dynamic = False
89 | return True
90 |
91 | def signal_message_create(self, mailer_tab, target, message):
92 | for part in message.walk():
93 | if not part.get_content_type().startswith('text/html'):
94 | continue
95 | payload_string = part.payload_string
96 | tag = '