Port-Knocker-Prototype

#!/usr/bin/env python3

"""
Der Prozess öffnet drei Ports und wartet bis ein Client Port
für Port den passenden Text übermittelt.

Wenn der Timeout nicht überschritten wird, die Ports in der richtigen
Reihenfolge mit den zugehörigen Schlüsselwörtern übermittelt werden,
wird der Port 22 für eine kurze Zeit geöffnet und dann wieder geschlossen.

Bereits bestehende Verbindungen werden dadurch nicht beeinflusst.
"""

import socket
import subprocess
from shlex import split
import time
import logging

FORMAT = '%(asctime)-15s %(message)s'
logging.basicConfig(format=FORMAT)
log = logging.getLogger()
log.setLevel(logging.INFO)

def bind(ip, port):
    """
    Erstellt einen TCP-Socket und öffnet ihn auf der jeweiligen IP und Port.
    """
    addr = (ip, port)
    sock = socket.socket()
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.bind(addr)
    sock.listen(5)
    log.info('Listening: {}:{}'.format(*addr))
    return sock

def main(ports, keys):
    lock_ssh() # Neue SSH-Verbindungen abweisen.
    sockets = [bind('0.0.0.0', port) for port in ports] #erstellt die Sockets
    try:
        while True:
            last_client = None
            last_time = None
            for sock, key in zip(sockets, keys):
                # das muss noch geändert werden
                client, addr = sock.accept()
                if not last_client:
                    last_client = addr[0]
                if not last_client == addr[0]:
                    log.info('Address {} does not fit to {}'.format(addr[0], last_client))
                    break
                log.info('Client {}{} connected'.format(*addr))
                data = client.recv(len(key) + 2).strip()
                client.close()
                log.info('Received: {}'.format(data))
                if last_time and (time.time() - last_time) > 0.5:
                    log.info('Time is up')
                    break
                if not last_time:
                    last_time = time.time()
                if key != data:
                    break
            else:
                log.info('Success')
                log.info('Opening SSH Port')
                unlock_ssh()
                time.sleep(0.5)
                log.info('Closing SSH Port')
                lock_ssh()
    except KeyboardInterrupt:
        [s.close() for s in sockets]
        unlock_ssh()

def lock_ssh():
    """
    Sperrt den Port 22 für neue Verbindungen
    """
    cmd = split('iptables -A INPUT -p tcp -m tcp --dport 22 -m state --state NEW -j REJECT')
    proc = subprocess.call(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, shell=False)

def unlock_ssh():
    """
    Entfernt die Regel wieder.
    """
    cmd = split('iptables -D INPUT -p tcp -m tcp --dport 22 -m state --state NEW -j REJECT')
    proc = subprocess.call(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, shell=False)

if __name__ == '__main__':
    ports = [1025, 1026, 1027]
    keys = [b'foo', b'bar', b'baz']
    main(ports, keys)


# Client:
# echo "foo" | nc localhost 1025; echo "bar" | nc localhost 1026; echo "baz" | nc localhost 1027; ssh localhost