from twisted.conch import avatar, interfaces
from twisted.conch.openssh_compat import primes
from twisted.conch.ssh import factory, userauth, connection, keys, transport, session
from twisted.conch.ssh.common import getNS
from twisted.cred import portal, credentials
from twisted.cred.checkers import InMemoryUsernamePasswordDatabaseDontUse
from twisted.internet import reactor, protocol
from twisted.internet.endpoints import TCP4ServerEndpoint, TCP6ServerEndpoint
from zope.interface import implementer
import json,time

class WelcomeProtocol(protocol.Protocol):
    def __init__(self, username):
        self.username = username

    def connectionMade(self):
        self.transport.write("Welcome %s!\r\n" % (self.username))
        self.transport.loseConnection()

@implementer(interfaces.ISession)
class Session(avatar.ConchUser):
    def __init__(self, username):
        avatar.ConchUser.__init__(self)
        self.username = username
        self.channelLookup.update({'session': session.SSHSession})

    def openShell(self, transport):
        protocol = WelcomeProtocol(self.username)
        protocol.makeConnection(transport)
        transport.makeConnection(session.wrapProtocol(protocol))

    def getPty(self, terminal, windowSize, attrs):
        pass

    def closed(self):
        pass

    def eofReceived(self):
        pass


@implementer(portal.IRealm)
class Realm(object):
    def requestAvatar(self, avatarId, mind, *interfaces):
        return interfaces[0], Session(avatarId), lambda: None


class SSHUserPasswordLogger(userauth.SSHUserAuthServer):
    interfaceToMethod = {
        credentials.IUsernamePassword: b'password',
    }
    def serviceStarted(self):
        self.fp = open('auth.json','a')
        userauth.SSHUserAuthServer.serviceStarted(self)


    def auth_password(self, packet):
        password = getNS(packet[1:])[0]
        self.fp.writelines(json.dumps({
            'timestamp':time.time(),
            'host':self.transport.transport.getPeer().host,
            'port':self.transport.transport.getPeer().port,
            'username':self.user,
            'password':password
        }))
        self.fp.flush()
        return userauth.SSHUserAuthServer.auth_password(self, packet)

    def serviceStopped(self):
        self.fp.close()
        userauth.SSHUserAuthServer.serviceStopped(self)


class SSHServer(factory.SSHFactory):
    services = {
        b'ssh-userauth': SSHUserPasswordLogger,
        b'ssh-connection': connection.SSHConnection
    }

    def __init__(self):
        self.primes = primes.parseModuliFile("moduli")
        self.publicKeys = {
            'ssh-rsa': keys.Key.fromFile("rsa.key.pub"),
            'ssh-dss': keys.Key.fromFile("dsa.key.pub")
        }
        self.privateKeys = {
            'ssh-rsa': keys.Key.fromFile("rsa.key"),
            'ssh-dss': keys.Key.fromFile("dsa.key")
        }

    def startFactory(self):
        factory.SSHFactory.startFactory(self)

    def buildProtocol(self, addr):
        t = transport.SSHServerTransport()
        t.ourVersionString = "SSH-2.0-OpenSSH_7.3p1"
        t.supportedPublicKeys = ['ssh-rsa','ssh-dss']
        t.factory = self
        return t

portal = portal.Portal(Realm())
portal.registerChecker(InMemoryUsernamePasswordDatabaseDontUse())
SSHServer.portal = portal

if __name__ == '__main__':
    server = SSHServer()
    endpoint4 = TCP4ServerEndpoint(reactor, 5022)
    endpoint6 = TCP6ServerEndpoint(reactor, 5022)
    endpoint4.listen(server)
    endpoint6.listen(server)
    reactor.run()