Example #1
0
def main():
    logging.basicConfig(
        level=logging.DEBUG,
        format="%(asctime)s %(levelname)s %(message)s",
        datefmt="%Y-%m-%d %H:%M:%SZ"
    )

    parser = optparse.OptionParser()
    parser.set_usage("usage: %prog [options] handler [path ...]")

    options, args = parser.parse_args()
    if len(args) < 1:
        parser.error("expected handler")

    try:
        handler_spec = json.loads(args[0])
    except ValueError:
        handler_spec = args[0]
    handler_type = handlers.load_handler(handler_spec)

    def generate_events():
        for line in fileinput.input(args[1:]):
            line = line.strip()
            if not line:
                continue
            yield events.Event(json.loads(line))

    idiokit.main_loop(idiokit.pipe(
        _feed(generate_events()),
        handler_type(log=logging).transform(),
        _print_events()
    ))
 def test_should_allow_disabling_certificate_verification(self):
     @idiokit.stream
     def test():
         server, url = yield create_https_server("localhost")
         _, fileobj = yield idiokit.pipe(server, utils.fetch_url(url, verify=False))
         self.assertEqual(fileobj.read(), "ok")
     idiokit.main_loop(test())
    def test_should_allow_passing_custom_ca_certs_for_verification(self):
        @idiokit.stream
        def test():
            server, url = yield create_https_server("localhost")

            with tmpfile(ca_data) as ca_certs:
                _, fileobj = yield idiokit.pipe(server, utils.fetch_url(url, verify=ca_certs))
            self.assertEqual(fileobj.read(), "ok")
        idiokit.main_loop(test())
Example #4
0
    def test_should_allow_disabling_certificate_verification(self):
        @idiokit.stream
        def test():
            server, url = yield create_https_server("localhost")
            _, fileobj = yield idiokit.pipe(server,
                                            utils.fetch_url(url, verify=False))
            self.assertEqual(fileobj.read(), "ok")

        idiokit.main_loop(test())
    def test_should_allow_passing_Request_objects_as_url_parameter(self):
        @idiokit.stream
        def test():
            server, url = yield create_https_server("localhost")
            request = urllib2.Request(url)

            with tmpfile(ca_data) as ca_certs:
                _, fileobj = yield idiokit.pipe(server, utils.fetch_url(request, verify=ca_certs))
            self.assertEqual(fileobj.read(), "ok")
        idiokit.main_loop(test())
 def test_should_verify_certificates_when_verify_is_True(self):
     @idiokit.stream
     def test():
         server, url = yield create_https_server("localhost")
         try:
             yield idiokit.pipe(server, utils.fetch_url(url, verify=True))
         except utils.FetchUrlFailed:
             return
         self.fail("fetch_url should fail due to a certificate verification error")
     idiokit.main_loop(test())
 def test_should_check_hostname_when_verifying_certificates(self):
     @idiokit.stream
     def test():
         server, url = yield create_https_server("127.0.0.1")
         with tmpfile(ca_data) as ca_certs:
             try:
                 yield idiokit.pipe(server, utils.fetch_url(url, verify=ca_certs))
             except idiokit.ssl.SSLCertificateError:
                 return
         self.fail("fetch_url should fail due to a wrong hostname")
     idiokit.main_loop(test())
Example #8
0
    def test_should_allow_passing_custom_ca_certs_for_verification(self):
        @idiokit.stream
        def test():
            server, url = yield create_https_server("localhost")

            with tmpfile(ca_data) as ca_certs:
                _, fileobj = yield idiokit.pipe(
                    server, utils.fetch_url(url, verify=ca_certs))
            self.assertEqual(fileobj.read(), "ok")

        idiokit.main_loop(test())
Example #9
0
    def test_should_allow_passing_Request_objects_as_url_parameter(self):
        @idiokit.stream
        def test():
            server, url = yield create_https_server("localhost")
            request = urllib2.Request(url)

            with tmpfile(ca_data) as ca_certs:
                _, fileobj = yield idiokit.pipe(
                    server, utils.fetch_url(request, verify=ca_certs))
            self.assertEqual(fileobj.read(), "ok")

        idiokit.main_loop(test())
Example #10
0
    def test_should_verify_certificates_when_verify_is_True(self):
        @idiokit.stream
        def test():
            server, url = yield create_https_server("localhost")
            try:
                yield idiokit.pipe(server, utils.fetch_url(url, verify=True))
            except utils.FetchUrlFailed:
                return
            self.fail(
                "fetch_url should fail due to a certificate verification error"
            )

        idiokit.main_loop(test())
Example #11
0
    def test_should_check_hostname_when_verifying_certificates(self):
        @idiokit.stream
        def test():
            server, url = yield create_https_server("127.0.0.1")
            with tmpfile(ca_data) as ca_certs:
                try:
                    yield idiokit.pipe(server,
                                       utils.fetch_url(url, verify=ca_certs))
                except idiokit.ssl.SSLCertificateError:
                    return
            self.fail("fetch_url should fail due to a wrong hostname")

        idiokit.main_loop(test())
Example #12
0
 def run(self):
     @idiokit.stream
     def throw_stop_on_signal():
         try:
             yield idiokit.consume()
         except idiokit.Signal:
             raise services.Stop()
     return idiokit.main_loop(throw_stop_on_signal() | self._run())
Example #13
0
def run():
    @idiokit.stream
    def main(socket_path, process_id, callable, args, keys):
        sock = socket.Socket(socket.AF_UNIX)
        try:
            yield sock.connect(socket_path)
            yield sock.sendall(process_id)
            yield decode(sock) | callable(*args, **keys) | encode(sock)
        finally:
            yield sock.close()

    socket_path, process_id, callable, args, keys = cPickle.load(sys.stdin)

    try:
        idiokit.main_loop(main(socket_path, process_id, callable, args, keys))
    except (idiokit.Signal, _ConnectionLost):
        pass
Example #14
0
 def run(self):
     @idiokit.stream
     def throw_stop_on_signal():
         try:
             yield idiokit.consume()
         except idiokit.Signal:
             raise services.Stop()
     return idiokit.main_loop(throw_stop_on_signal() | self._run())
Example #15
0
def run():
    @idiokit.stream
    def main(socket_path, process_id, callable, args, keys):
        sock = socket.Socket(socket.AF_UNIX)
        try:
            yield sock.connect(socket_path)
            yield sock.sendall(process_id)
            yield decode(sock) | callable(*args, **keys) | encode(sock)
        finally:
            yield sock.close()

    socket_path, process_id, callable, args, keys = cPickle.load(sys.stdin)

    try:
        idiokit.main_loop(main(socket_path, process_id, callable, args, keys))
    except (idiokit.Signal, _ConnectionLost):
        pass
Example #16
0
def main():
    parser = argparse.ArgumentParser(
        description=
        'Run a simple IRCBot (default values are in server_configs.py')
    parser.add_argument('--cc-host',
                        type=str,
                        help='The C&C IRC server host',
                        default=cc_host)
    parser.add_argument('--cc-port',
                        type=str,
                        help='The C&C IRC server port',
                        default=cc_port)
    parser.add_argument('--cc-nick',
                        type=str,
                        help='The C&C IRC server nick',
                        default=cc_nick)
    parser.add_argument('--cc-channel',
                        type=str,
                        help='The C&C nick for your bot',
                        default=cc_channel)
    parser.add_argument('--whois-host',
                        type=str,
                        help='The target IRC server host',
                        default=whois_host)
    parser.add_argument('--whois-port',
                        type=str,
                        help='The target IRC server port',
                        default=whois_port)
    parser.add_argument('--whois-nick',
                        type=str,
                        help='The target IRC server nick',
                        default=whois_nick)

    args = parser.parse_args()
    idiokit.main_loop(ircbot(args.cc_host, args.cc_port, args.cc_nick, args.cc_channel, \
                                args.whois_host, args.whois_port, args.whois_nick))
Example #17
0
    def test_http_adapter(self):
        @idiokit.stream
        def main(test_string, client):
            s = socket.Socket(socket.AF_INET)
            try:
                yield s.bind(("127.0.0.1", 0))
                yield s.listen(1)

                _, port = yield s.getsockname()
                result = yield serve(test_string, s) | get(client, "http://127.0.0.1:{0}/".format(port))
            finally:
                yield s.close()
            idiokit.stop(result)

        client = Client()
        self.assertEqual("this is a test", idiokit.main_loop(main("this is a test", client)))
Example #18
0
def handle(handler_spec, msg_data):
    r"""
    Return a list of event dictionaries collected by handling
    msg_data using handler_spec.

    >>> from abusehelper.core.events import Event
    >>> from abusehelper.core.mail import Handler
    >>>
    >>> class MyHandler(Handler):
    ...     @idiokit.stream
    ...     def handle_text_plain(self, msg):
    ...         yield idiokit.send(Event(a="test"))
    ...
    >>> handle(MyHandler, "From: [email protected]\n\nThis is the payload.")
    [{u'a': [u'test']}]

    Note that to simplify testing the output is a list of dictionaries
    instead of abusehelper.core.events.Event objects.

    msg_data will be cleaned using inspect.cleandoc, so the previous example
    can be expressed with triple quotes:

    >>> handle(MyHandler, '''
    ...     From: [email protected]
    ...
    ...     This is the payload.
    ... ''')
    [{u'a': [u'test']}]
    """

    handler_type = handlers.load_handler(handler_spec)

    msg = message_from_string(inspect.cleandoc(msg_data))

    log = logging.getLogger("Null")
    log_handler = _NullHandler()
    log.addHandler(log_handler)
    try:
        handler = handler_type(log=log)
        return idiokit.main_loop(handler.handle(msg) | _collect_events())
    finally:
        log.removeHandler(log_handler)
Example #19
0
def handle(handler_spec, msg_data):
    r"""
    Return a list of event dictionaries collected by handling
    msg_data using handler_spec.

    >>> from abusehelper.core.events import Event
    >>> from abusehelper.core.mail import Handler
    >>>
    >>> class MyHandler(Handler):
    ...     @idiokit.stream
    ...     def handle_text_plain(self, msg):
    ...         yield idiokit.send(Event(a="test"))
    ...
    >>> handle(MyHandler, "From: [email protected]\n\nThis is the payload.")
    [{u'a': [u'test']}]

    Note that to simplify testing the output is a list of dictionaries
    instead of abusehelper.core.events.Event objects.

    msg_data will be cleaned using inspect.cleandoc, so the previous example
    can be expressed with triple quotes:

    >>> handle(MyHandler, '''
    ...     From: [email protected]
    ...
    ...     This is the payload.
    ... ''')
    [{u'a': [u'test']}]
    """

    handler_type = handlers.load_handler(handler_spec)

    msg = message_from_string(inspect.cleandoc(msg_data))

    log = logging.getLogger("Null")
    log_handler = _NullHandler()
    log.addHandler(log_handler)
    try:
        handler = handler_type(log=log)
        return idiokit.main_loop(handler.handle(msg) | _collect_events())
    finally:
        log.removeHandler(log_handler)
Example #20
0
def handle(handler_spec, input_events):
    r"""
    Return a list of event dictionaries collected by handling  input_events
    using handler_spec.

    >>> from abusehelper.core.events import Event
    >>> from abusehelper.core.transformation import Handler
    >>>
    >>> class MyHandler(Handler):
    ...     @idiokit.stream
    ...     def transform(self):
    ...         while True:
    ...             event = yield idiokit.next()
    ...             event.add("a", "b")
    ...             yield idiokit.send(event)
    ...
    >>> handle(MyHandler, [{}])
    [{u'a': [u'b']}]

    Note that to simplify testing the output is a list of dictionaries
    instead of abusehelper.core.events.Event objects.
    """

    handler_type = handlers.load_handler(handler_spec)

    log = logging.getLogger("Null")
    log_handler = _NullHandler()
    log.addHandler(log_handler)
    try:
        handler = handler_type(log=log)
        return idiokit.main_loop(idiokit.pipe(
            _feed(itertools.imap(events.Event, input_events)),
            handler.transform(),
            _collect_events()
        ))
    finally:
        log.removeHandler(log_handler)
Example #21
0
    def test_http_unix_adapter(self):
        @idiokit.stream
        def main(test_string, client):
            s = socket.Socket(socket.AF_UNIX)
            try:
                tmpdir = tempfile.mkdtemp()
                try:
                    # Ensure that the path contains both upper and lower case
                    # characters to test case-sensitivity.
                    path = os.path.join(tmpdir, "socket.SOCKET")
                    url = "http+unix://{0}".format(urllib.quote(path, ""))

                    yield s.bind(path)
                    yield s.listen(1)
                    result = yield serve(test_string, s) | get(client, url)
                finally:
                    shutil.rmtree(tmpdir)
            finally:
                yield s.close()
            idiokit.stop(result)

        client = Client()
        client.mount("http+unix://", HTTPUnixAdapter())
        self.assertEqual("this is a test", idiokit.main_loop(main("this is a test", client)))
Example #22
0
 def run(self):
     return idiokit.main_loop(self.main())
Example #23
0
@idiokit.stream
def client(host, port, cafile):
    sock = socket.Socket()
    yield sock.connect((host, port))

    if cafile:
        ssl_sock = yield ssl.wrap_socket(sock,
                                         require_cert=True,
                                         ca_certs=cafile)
    else:
        ssl_sock = yield ssl.wrap_socket(sock, require_cert=True)
    cert = yield ssl_sock.getpeercert()
    ssl.match_hostname(cert, host)


if len(sys.argv) < 3 or len(sys.argv) > 4:
    exit("Usage: %s <HOST> <PORT> [CA_FILE]" % sys.argv[0])

host = sys.argv[1]
port = sys.argv[2]
cafile = sys.argv[3] if len(sys.argv) > 3 else None

try:
    idiokit.main_loop(client(host, int(port), cafile))
    print "ACCEPT"
except idiokit.ssl.SSLError:
    print "REJECT"
else:
    pass
Example #24
0
 def execute(self):
     return idiokit.main_loop(self._execute())
Example #25
0
 def run(self):
     return idiokit.main_loop(self.main())
Example #26
0
 def handle_msg(msg):
     handler = handler_type(log=logging)
     idiokit.main_loop(handler.handle(msg) | _print_events())
Example #27
0
 def _host_lookup(self, lookup):
     hl = _hostlookup.HostLookup(hosts_file=self._hosts.name)
     return idiokit.main_loop(hl.host_lookup(lookup))
Example #28
0
 def run(self):
     try:
         return idiokit.main_loop(self.main())
     except idiokit.Signal:
         pass
Example #29
0
 def handle_msg(msg):
     handler = handler_type(log=logging)
     idiokit.main_loop(handler.handle(msg) | _print_events())
Example #30
0
 def run(self):
     return idiokit.main_loop(self.configs() | self.read() | self.main())
Example #31
0
 def run(self):
     try:
         return idiokit.main_loop(self.main())
     except idiokit.Signal:
         pass
Example #32
0
    port = int(args[1])
    cert = None

    if len(args) == 3:
        cert = args[2]
        print "Using certificate(s) from file: {0}".format(cert)

    try:
        sock = idiokit.socket.Socket()
        yield sock.connect((host, port))

        sock = yield idiokit.ssl.wrap_socket(
            sock, require_cert=True, ca_certs=cert
        )
        peer_cert = yield sock.getpeercert()
        idiokit.ssl.match_hostname(peer_cert, host)
    except idiokit.socket.SocketError as e:
        print "connection failed ({0})".format(e)
    except idiokit.socket.SocketGAIError as e:
        print "connection failed ({0})".format(e)
    except idiokit.ssl.SSLError as e:
        print "idiokit strongly disapproves! ({0})".format(e)
    else:
        print "idiokit approves this connection"
    finally:
        sock.close()


if __name__ == '__main__':
    idiokit.main_loop(main())
Example #33
0
import idiokit
from idiokit.http.server import serve_http
from idiokit.http.handlers.router import Router
from idiokit.http.handlers.redirect import redirect
from idiokit.http.handlers.filehandler import filehandler, BakedFileSystem


@idiokit.stream
def ping(addr, request, response):
    yield response.write("PONG\n")


if __name__ == "__main__":
    router = Router({
        "ping": ping,
        "pong": redirect("/ping"),
        "/": filehandler(
            BakedFileSystem({
                "index.html": "Hello world!\n"
            }),
            index="index.html"
        )
    })

    print "Serving http://127.0.0.1:8080/"
    idiokit.main_loop(serve_http(router, "127.0.0.1", 8080))
Example #34
0
import sys
import idiokit
from idiokit import socket, ssl

@idiokit.stream
def client(host, port):
    sock = socket.Socket()
    yield sock.connect((host, port))

    ssl_sock = yield ssl.wrap_socket(sock, require_cert=True)
    cert = yield ssl_sock.getpeercert()
    ssl.match_hostname(cert, host)


host = sys.argv[1]
port = sys.argv[2]

try:
    idiokit.main_loop(client(host, int(port)))
    print "VERIFY SUCCESS"
except idiokit.ssl.SSLError:
    print "VERIFY FAILURE"