def send(self, mail):
# mail is of email module
d = defer.Deferred()
senderArgs = {
'username': self.username,
'password': self.password,
'fromEmail': self.address,
'toEmail': self._getRawAddress(mail['To']),
'file': StringIO(str(mail)),
'deferred': d,
'retries': 5,
}
if self.ssl:
senderArgs['contextFactory'] = ClientContextFactory()
sender = ESMTPSenderFactory(**senderArgs)
if self.ssl:
port = self.port or 465
reactor.connectSSL(self.server, port, sender,
ClientContextFactory())
else:
port = self.port or 25
reactor.connectTCP(self.server, port, sender)
d.addCallback(self.sent)
d.addErrback(self.fail)
def build_irc(self):
"""The main starting method that creates a protocol object
according to the config variables, ready for whenever
the reactor starts running.
"""
wlog('building irc')
if self.tx_irc_client:
raise Exception('irc already built')
if self.usessl.lower() == 'true' and not self.socks5.lower() == 'true':
factory = TxIRCFactory(self)
ctx = ClientContextFactory()
reactor.connectSSL(self.serverport[0], self.serverport[1], factory,
ctx)
elif self.socks5.lower() == 'true':
factory = TxIRCFactory(self)
#str() casts needed else unicode error
torEndpoint = TCP4ClientEndpoint(reactor, str(self.socks5_host),
self.socks5_port)
ircEndpoint = SOCKS5ClientEndpoint(str(self.serverport[0]),
self.serverport[1], torEndpoint)
if self.usessl.lower() == 'true':
ctx = ClientContextFactory()
tlsEndpoint = TLSWrapClientEndpoint(ctx, ircEndpoint)
tlsEndpoint.connect(factory)
else:
ircEndpoint.connect(factory)
else:
try:
factory = TxIRCFactory(self)
wlog('build_irc: ', self.serverport[0], self.serverport[1],
self.channel)
self.tcp_connector = reactor.connectTCP(
self.serverport[0], self.serverport[1], factory)
except Exception as e:
wlog('error in buildirc: ' + repr(e))
def start_reactor(host, port, factory=None, snickerfactory=None, ish=True,
daemon=False, rs=True, gui=False): #pragma: no cover
#(Cannot start the reactor in tests)
#Not used in prod (twisted logging):
#startLogging(stdout)
usessl = True if jm_single().config.get("DAEMON",
"use_ssl") != 'false' else False
if daemon:
try:
from jmdaemon import JMDaemonServerProtocolFactory, start_daemon, \
SNICKERDaemonServerProtocolFactory
except ImportError:
jlog.error("Cannot start daemon without jmdaemon package; "
"either install it, and restart, or, if you want "
"to run the daemon separately, edit the DAEMON "
"section of the config. Quitting.")
return
dfactory = JMDaemonServerProtocolFactory()
if snickerfactory:
sdfactory = SNICKERDaemonServerProtocolFactory()
orgport = port
while True:
try:
start_daemon(host, port, dfactory, usessl,
'./ssl/key.pem', './ssl/cert.pem')
jlog.info("Listening on port " + str(port))
break
except Exception:
jlog.warn("Cannot listen on port " + str(port) + ", trying next port")
if port >= (orgport + 100):
jlog.error("Tried 100 ports but cannot listen on any of them. Quitting.")
sys.exit(EXIT_FAILURE)
port += 1
if snickerfactory:
start_daemon(host, port-1000, sdfactory, usessl,
'./ssl/key.pem', './ssl/cert.pem')
jlog.info("(SNICKER) Listening on port " + str(port-1000))
if usessl:
if factory:
reactor.connectSSL(host, port, factory, ClientContextFactory())
if snickerfactory:
reactor.connectSSL(host, port-1000, snickerfactory,
ClientContextFactory())
else:
if factory:
reactor.connectTCP(host, port, factory)
if snickerfactory:
reactor.connectTCP(host, port-1000, snickerfactory)
if rs:
if not gui:
reactor.run(installSignalHandlers=ish)
if isinstance(jm_single().bc_interface, RegtestBitcoinCoreInterface):
jm_single().bc_interface.shutdown_signal = True
def sendmail(authenticationUsername, authenticationSecret, fromAddress, toAddress, messageFile, smtpHost, smtpPort=25):
"""
Sends an email using SSLv3 over SMTP
@param authenticationUsername: account username
@param authenticationSecret: account password
@param fromAddress: the from address field of the email
@param toAddress: the to address field of the email
@param messageFile: the message content
@param smtpHost: the smtp host
@param smtpPort: the smtp port
"""
contextFactory = ClientContextFactory()
contextFactory.method = SSL.SSLv3_METHOD
resultDeferred = defer.Deferred()
senderFactory = ESMTPSenderFactory(
authenticationUsername,
authenticationSecret,
fromAddress,
toAddress,
messageFile,
resultDeferred,
contextFactory=contextFactory)
reactor.connectTCP(smtpHost, smtpPort, senderFactory)
return resultDeferred
def request(self, method, uri, headers=None, bodyProducer=None):
url = urlparse.urlparse(uri, scheme='http')
host = url.hostname
port = url.port
if port is None:
port = 443 if (url.scheme == 'https') else 80
# Translate from Agent's Headers object back into a dict.
if headers is not None:
old_headers = {}
for name, value_list in headers.getAllRawHeaders():
old_headers[name] = value_list[0]
headers = old_headers
f = client.HTTPClientFactory(uri,
method=method,
headers=headers,
timeout=2)
def gotResponse(page):
return _HTTP10Agent._FakeResponse(int(f.status))
f.deferred.addBoth(gotResponse)
if url.scheme == 'https':
self._reactor.connectSSL(host, port, f, ClientContextFactory())
else:
self._reactor.connectTCP(host, port, f)
return f.deferred
def sendmail(username,
password,
fromAddress,
toAddress,
message,
smtpHost,
smtpPort=25):
"""
@param username: The username with which to authenticate.
@param password: The password with which to authenticate.
@param fromAddress: The SMTP reverse path (ie, MAIL FROM)
@param toAddress: The SMTP forward path (ie, RCPT TO)
@param message: text containing the headers and body of the message to send.
@param smtpHost: The MX host to which to connect.
@param smtpPort: The port number to which to connect.
@return: A Deferred which will be called back when the message has been
sent or which will errback if it cannot be sent.
"""
# Create a context factory which only allows SSLv3 and does not verify
# the peer's certificate.
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
d = Deferred()
senderFactory = ESMTPSenderFactory(username,
password,
fromAddress,
toAddress,
StringIO(message),
d,
contextFactory=contextFactory)
reactor.connectTCP(smtpHost, smtpPort, senderFactory)
return d
def sendmail(authenticationUsername,
authenticationSecret,
fromAddress,
toAddress,
messageFile,
smtpHost,
smtpPort=25):
"""
"""
contextFactory = ClientContextFactory()
contextFactory.method = SSL.SSLv3_METHOD
resultDeferred = Deferred()
senderFactory = ESMTPSenderFactory(authenticationUsername,
authenticationSecret,
fromAddress,
toAddress,
messageFile,
resultDeferred,
contextFactory=contextFactory)
reactor.connectTCP(smtpHost, smtpPort, senderFactory)
return resultDeferred
def build_control_amp_service(test_case, reactor=None):
"""
Create a new ``ControlAMPService``.
:param TestCase test_case: The test this service is for.
:return ControlAMPService: Not started.
"""
if reactor is None:
reactor = Clock()
cluster_state = ClusterStateService(reactor)
cluster_state.startService()
test_case.addCleanup(cluster_state.stopService)
persistence_service = ConfigurationPersistenceService(
reactor, test_case.make_temporary_directory())
persistence_service.startService()
test_case.addCleanup(persistence_service.stopService)
return ControlAMPService(
reactor,
cluster_state,
persistence_service,
TCP4ServerEndpoint(MemoryReactor(), 1234),
# Easiest TLS context factory to create:
ClientContextFactory(),
)
def clientEndpoint(self, reactor, serverAddress):
"""
Construct a TCP client endpoint wrapped to immediately start TLS.
"""
return StartTLSClientEndpoint(
TCP4ClientEndpoint(reactor, '127.0.0.1', serverAddress.port),
ClientContextFactory())
def connectionMade(self):
self.log = getLogger(serverLog, self)
self.transport.pauseProducing()
client = self.clientProtocolFactory()
client.setServer(self)
reactor.connectSSL(self.factory.host, self.factory.port, client,
ClientContextFactory())
def start_reactor(host,
port,
factory,
ish=True,
daemon=False): #pragma: no cover
#(Cannot start the reactor in tests)
usessl = True if jm_single().config.get("DAEMON",
"use_ssl") != 'false' else False
if daemon:
try:
from jmdaemon import JMDaemonServerProtocolFactory
except ImportError:
jlog.error("Cannot start daemon without jmdaemon package; "
"either install it, and restart, or, if you want "
"to run the daemon separately, edit the DAEMON "
"section of the config. Quitting.")
return
dfactory = JMDaemonServerProtocolFactory()
if usessl:
reactor.listenSSL(
port, dfactory,
ssl.DefaultOpenSSLContextFactory("./ssl/key.pem",
"./ssl/cert.pem"))
else:
reactor.listenTCP(port, dfactory)
if usessl:
ctx = ClientContextFactory()
reactor.connectSSL(host, port, factory, ctx)
else:
reactor.connectTCP(host, port, factory)
reactor.run(installSignalHandlers=ish)
def sendmail(config, to, messageFile):
"""
Sends an email
"""
contextFactory = ClientContextFactory()
# evilaliv3:
# in order to understand and before change this settings please
# read the comment inside tor2web.utils.tls
contextFactory.method = SSL.SSLv23_METHOD
resultDeferred = defer.Deferred()
senderFactory = ESMTPSenderFactory(
config.smtpuser.encode('utf-8'),
config.smtppass.encode('utf-8'),
config.smtpmail,
to,
messageFile,
resultDeferred,
contextFactory=contextFactory,
requireAuthentication=True,
requireTransportSecurity=(config.smtpsecurity != 'SSL'),
retries=0,
timeout=15)
if config.security == "SSL":
senderFactory = tls.TLSMemoryBIOFactory(contextFactory, True, senderFactory)
reactor.connectTCP(config.smtpdomain, config.smtpport, senderFactory)
return resultDeferred
def setUp(self):
self.deployer = ControllableDeployer(u"127.0.0.1", [], [])
self.reactor = MemoryReactorClock()
self.service = AgentLoopService(reactor=self.reactor,
deployer=self.deployer,
host=u"example.com",
port=1234,
context_factory=ClientContextFactory())
def sendmail(mailconf, message):
"""Takes a regular dictionary as mailconf, as follows.
Example::
mailconf = dict(
host="smtp.gmail.com", # required
port=25, # optional, default 25 or 587 for SSL/TLS
username=foo, # optional, no default
password=bar, # optional, no default
tls=True, # optional, default False
)
d = mail.sendmail(mailconf, msg)
d.addCallback(on_response)
"""
if not isinstance(mailconf, types.DictType):
raise TypeError("mailconf must be a regular python dictionary")
if not isinstance(message, Message):
raise TypeError("message must be an instance of cyclone.mail.Message")
host = mailconf.get("host")
if isinstance(host, unicode):
host = str(unicode)
if not isinstance(host, types.StringType):
raise ValueError("mailconf requires a 'host' configuration")
use_tls = mailconf.get("tls")
if use_tls:
port = mailconf.get("port", 587)
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
else:
port = mailconf.get("port", 25)
contextFactory = None
if not isinstance(port, types.IntType):
raise ValueError("mailconf requires a proper 'port' configuration")
result = Deferred()
u = mailconf.get("username")
p = mailconf.get("password")
factory = ESMTPSenderFactory(u,
p,
quoteaddr(message.from_addr),
message.to_addrs,
message.render(),
result,
contextFactory=contextFactory,
requireAuthentication=(u and p),
requireTransportSecurity=use_tls)
reactor.connectTCP(host, port, factory)
return result
def main():
config = SafeConfigParser()
config.read("relaybot.config")
defaults = config.defaults()
for section in config.sections():
def get(option):
if option in defaults or config.has_option(section, option):
return config.get(section, option) or defaults[option]
else:
return None
options = {}
for option in [
"timeout", "host", "port", "nick", "channel", "info",
"heartbeat", "password", "username", "realname", "ssl"
]:
options[option] = get(option)
mode = get("mode")
#Not using endpoints pending http://twistedmatrix.com/trac/ticket/4735
#(ReconnectingClientFactory equivalent for endpoints.)
factory = None
if mode == "Default":
factory = RelayFactory
elif mode == "FLIP":
factory = FLIPFactory
elif mode == "NickServ":
factory = NickServFactory
options["nickServPassword"] = get("nickServPassword")
elif mode == "ReadOnly":
factory = ReadOnlyFactory
options["nickServPassword"] = get("nickServPassword")
factory = factory(options)
optionAsBoolean = {
"": False,
"False": False,
"false": False,
"no": False,
"True": True,
"true": True,
"yes": True
}
sentinel = object()
ssl = options.get(option['ssl'], sentinel)
if sentinel == ssl:
raise TypeError("Cannot convert '{}' to boolean.".format(ssl))
elif ssl:
reactor.connectSSL(options['host'], int(options['port']), factory,
ClientContextFactory(), int(options['timeout']))
else:
reactor.connectTCP(options['host'], int(options['port']), factory,
int(options['timeout']))
reactor.callWhenRunning(signal, SIGINT, handler)
def main():
startLogging(file('client.log', 'a'), False)
factory = Factory()
factory.contextFactory = ClientContextFactory()
factory.protocol = OnionClient
endpoint = clientFromString(reactor, argv[1])
endpoint.connect(OnionFactory(factory))
reactor.run()
def clientEndpoint(self, reactor, serverAddress):
"""
Create an SSL client endpoint which will connect localhost on
the port given by C{serverAddress}.
@type serverAddress: L{IPv4Address}
"""
return SSL4ClientEndpoint(reactor, '127.0.0.1', serverAddress.port,
ClientContextFactory())
def _connect(self, factory):
host, port = factory.host, factory.port
if factory.scheme == 'https':
if ssl_supported:
return reactor.connectSSL(host, port, factory, \
ClientContextFactory())
raise NotSupported(
"HTTPS not supported: install pyopenssl library")
else:
return reactor.connectTCP(host, port, factory)
def _get_noverify_context(self):
"""
Use ClientContextFactory directly and set the method if necessary.
This will perform no host verification at all.
"""
from twisted.internet.ssl import ClientContextFactory
context_factory = ClientContextFactory()
if self.ssl_method is not None:
context_factory.method = self.ssl_method
return context_factory.getContext()
def _connect(self, servers):
for server in servers:
if server.ssl:
if SSL:
reactor.connectSSL(server.host, server.port,
server._factory, ClientContextFactory())
else:
print "Error: Cannot connect to '%s', pyOpenSSL not installed" % server.serverlabel
self.databasemanager.delServer(server.serverlabel)
else:
reactor.connectTCP(server.host, server.port, server._factory)
def _build_service(test):
"""
Fixture for creating ``AgentLoopService``.
"""
service = AgentLoopService(reactor=None,
deployer=object(),
host=u"example.com",
port=1234,
context_factory=ClientContextFactory())
service.cluster_status = StubFSM()
return service
def start_electrum_proto(self, electrum_server=None):
self.server, self.port = self.get_server(electrum_server)
self.factory = TxElectrumClientProtocolFactory(self)
if DEFAULT_PROTO == 's':
ctx = ClientContextFactory()
reactor.connectSSL(self.server, self.port, self.factory, ctx)
elif DEFAULT_PROTO == 't':
reactor.connectTCP(self.server, self.port, self.factory)
else:
raise Exception("Unrecognized connection protocol to Electrum, "
"should be one of 't' or 's' (TCP or SSL), "
"critical error, quitting.")
def sendmail(mailconf, message):
"""Takes a regular dictionary as mailconf, as follows:
mailconf["host"] = "your.smtp.com" (required)
mailconf["port"] = 25 (optional, default 25 or 587 for TLS)
mailconf["username"] = "******" (optional)
mailconf["password"] = "******" (optional)
mailconf["ssl"] = True | False (optional, default False)
mailconf["tls"] = True | False (optional, default False)
mailconf["retries"] = 0 (optional, default 0)
mailconf["timeout"] = 30 (optional, default 30)
"""
if not isinstance(mailconf, types.DictType):
raise TypeError("mailconf must be a regular python dictionary")
if not isinstance(message, Message):
raise TypeError("message must be an instance of nuswit.mail.Message")
host = mailconf.get("host")
if not isinstance(host, types.StringType):
raise ValueError("mailconf requires a 'host' configuration")
ssl = mailconf.get("ssl", True)
tls = mailconf.get("tls", True)
if ssl is True:
port = mailconf.get("port", 587)
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
else:
port = mailconf.get("port", 25)
contextFactory = None
retries = mailconf.get("retries", 0)
timeout = mailconf.get("timeout", 30)
if not isinstance(port, types.IntType):
raise ValueError("mailconf requires a proper 'port' configuration")
deferred = Deferred()
username, password = mailconf.get("username"), mailconf.get("password")
factory = ESMTPSenderFactory(
username, password,
message.from_addr, message.to_addrs, message.render(),
deferred, contextFactory=contextFactory,
requireAuthentication=(username and password),
requireTransportSecurity=tls,
retries=retries, timeout=timeout)
if not ssl:
connector = reactor.connectTCP(host, port, factory, timeout=timeout)
else:
connector = reactor.connectSSL(host, port, factory, contextFactory, timeout=timeout)
return deferred, connector
def connectionMade(self):
print "Received connection from %s:%d" % self.transport.getPeer()[1:]
# Add one connection, and check if we still allow connections
self.factory.nbConnections += 1
if (self.factory.nbConnections > MAX_NB_CONNECTIONS):
self.transport.loseConnection()
# At this point create a connection to the server
clientFactory = SSLClientProxyFactory(self)
self.remote = reactor.connectSSL(REMOTE_SERVER,
REMOTE_PORT,
clientFactory,
ClientContextFactory(),
timeout=CONNECTION_TIMEOUT)
def connect(self):
"""Connect to the API state server, with a timeout of 20s.
@return: A deferred that will callback with a connected APIClient
if we could connect, or errback with the relevant error.
"""
uri = self._get_uri(self.addr)
factory = self.factoryClass()
contextFactory = ClientContextFactory() # TODO: verify certificate
endpoint = WebSocketsEndpoint(
self._reactor, uri, sslContextFactory=contextFactory, timeout=20)
deferred = endpoint.connect(factory)
return deferred.addCallback(
lambda protocol: self.clientClass(protocol))
def sendmail_async(authenticationUsername,
authenticationSecret,
fromAddress,
toAddress,
messageFile,
smtpHost,
smtpPort=25):
"""
@param authenticationUsername: The username with which to authenticate.
@param authenticationSecret: The password with which to authenticate.
@param fromAddress: The SMTP reverse path (ie, MAIL FROM)
@param toAddress: The SMTP forward path (ie, RCPT TO)
@param messageFile: A file-like object containing the headers and body of
the message to send.
@param smtpHost: The MX host to which to connect.
@param smtpPort: The port number to which to connect.
@return: A Deferred which will be called back when the message has been
sent or which will errback if it cannot be sent.
"""
# Create a context factory which only allows SSLv3 and does not verify
# the peer's certificate.
contextFactory = ClientContextFactory()
contextFactory.method = SSLv3_METHOD
resultDeferred = defer.Deferred()
senderFactory = ESMTPSenderFactory(authenticationUsername,
authenticationSecret,
fromAddress,
toAddress,
messageFile,
resultDeferred,
contextFactory=contextFactory,
heloFallback=True,
requireTransportSecurity=False,
requireAuthentication=False)
#pylint: disable-msg=E1101
s = reactor.connectTCP(smtpHost, smtpPort, senderFactory)
#pylint: enable-msg=E1101
def close_socket(d):
s.disconnect()
return d
return resultDeferred.addBoth(close_socket)
def send(self):
ctx = ClientContextFactory()
ctx.method = SSLv3_METHOD
result = Deferred()
message = StringIO.StringIO(self._message.as_string())
sender = ESMTPSenderFactory(self._username,
self._password,
self._from,
self._to,
message,
result,
contextFactory=ctx)
from twisted.internet import reactor
reactor.connectTCP(self._smtphost, self._port, sender)
return result
def createIRC(*args, **kwargs):
f = QWebIRCFactory(*args, **kwargs)
server = config.irc["server"]
port = config.irc["port"]
bind_ip = config.irc["bind_ip"]
bindToAddress = None
if bind_ip:
bindToAddress = (bind_ip, 0)
if config.irc["ssl"]:
from twisted.internet.ssl import ClientContextFactory
reactor.connectSSL(server, port, f, ClientContextFactory(), bindAddress=bindToAddress)
else:
reactor.connectTCP(server, port, f, bindAddress=bindToAddress)
return f
def checkForMessages(self):
self.state = MailCollectingTask.STATE_COLLECTING
self.makeFactory()
if self.options.usessl:
log.debug("Connecting to server %s:%s using SSL as %s",
self.options.pophost, self.options.popport, self.options.popuser)
self._connection = reactor.connectSSL(self.options.pophost, self.options.popport,
self.factory, ClientContextFactory())
else:
log.debug("Connecting to server %s:%s using plaintext as %s",
self.options.pophost, self.options.popport, self.options.popuser)
self._connection = reactor.connectTCP(self.options.pophost, self.options.popport,
self.factory)
return defer.succeed("Connected to server %s:%s" % (
self.options.pophost, self.options.popport))
def writeMetric(metric_path,
value,
timestamp,
host,
port,
username,
password,
vhost,
exchange,
spec=None,
channel_number=1,
ssl=False):
if not spec:
spec = txamqp.spec.load(
os.path.normpath(
os.path.join(os.path.dirname(__file__), 'amqp0-8.xml')))
delegate = TwistedDelegate()
connector = ClientCreator(reactor,
AMQClient,
delegate=delegate,
vhost=vhost,
spec=spec)
if ssl:
from twisted.internet.ssl import ClientContextFactory
conn = yield connector.connectSSL(host, port, ClientContextFactory())
else:
conn = yield connector.connectTCP(host, port)
yield conn.authenticate(username, password)
channel = yield conn.channel(channel_number)
yield channel.channel_open()
yield channel.exchange_declare(exchange=exchange,
type="topic",
durable=True,
auto_delete=False)
message = Content("%f %d" % (value, timestamp))
message["delivery mode"] = 2
channel.basic_publish(exchange=exchange,
content=message,
routing_key=metric_path)
yield channel.channel_close()
