fun generateLoginKeys(): PublicKey {
        val keyGenerator = KeyPairGenerator.getInstance("RSA")
        keyGenerator.initialize(2048)
        val keyPair = keyGenerator.generateKeyPair()
        Gdx.files.local("keys/").mkdirs()

        var output = ObjectOutputStream(FileOutputStream(Gdx.files.local("keys/loginKeyPublic.key").file()))
        output.writeObject(keyPair.public)
        output.close()

        output = ObjectOutputStream(FileOutputStream(Gdx.files.local("keys/loginKeyPrivate.key").file()))
        output.writeObject(keyPair.private)
        output.close()

        return keyPair.public
    }

    fun generateMessageKeys(): PublicKey {
        val keyGenerator = KeyPairGenerator.getInstance("RSA")
        keyGenerator.initialize(2048)
        val keyPair = keyGenerator.generateKeyPair()
        Gdx.files.local("keys/").mkdirs()

        var output = ObjectOutputStream(FileOutputStream(Gdx.files.local("keys/encryptionKeyPublic.key").file()))
        output.writeObject(keyPair.public)
        output.close()

        output = ObjectOutputStream(FileOutputStream(Gdx.files.local("keys/encryptionKeyPrivate.key").file()))
        output.writeObject(keyPair.private)
        output.close()

        return keyPair.public
    }

    fun addScheduledTask(runnable: Runnable) {
        scheduledTasks.put(runnable)
    }

call to send the packet
override fun buttonCallback(button: GuiButton) {
        when (button) {
            checkUsernameButton -> {
                if (textFieldUsername.text.length < 5) {
                    usernameToShort = true
                } else {
                    KentaiCommon.packetHelper.sendPacket(CheckUsernameAvailablePacketToServer(textFieldUsername.text), ConnectionService.socket!!)
                    usernameToShort = false
                }
            }
            registerButton -> {
                val loginKey = KentaiClient.generateLoginKeys()
                val messageKey = KentaiClient.generateMessageKeys()
                KentaiCommon.packetHelper.sendPacket(RegisterPacketToServer(textFieldUsername.text, loginKey, messageKey), ConnectionService.socket!!)
            }
        }
    }

The packet class

class RegisterPacketToServer : IPacket {

    lateinit var username: String
    lateinit var loginPublicKey: PublicKey
    lateinit var messagePublicKey: PublicKey

    constructor(username: String, publicKey: PublicKey, messagePublicKey: PublicKey) {
        this.username = username
        this.loginPublicKey = publicKey
        this.messagePublicKey = messagePublicKey
    }

    constructor()

    override fun write(output: DataOutputStream) {
        output.writeUTF(username)

        var objectOut = ObjectOutputStream(output)
        objectOut.writeObject(loginPublicKey)

        objectOut = ObjectOutputStream(output)
        objectOut.writeObject(messagePublicKey)
    }

    override fun read(input: DataInputStream) {
        username = input.readUTF()
        var objectIn = ObjectInputStream(input)
        loginPublicKey = objectIn.readObject() as PublicKey

        objectIn = ObjectInputStream(input)
        messagePublicKey = objectIn.readObject() as PublicKey
    }
}

//Handling the packet
class RegisterPacketToServerHandler : IPacketHandler {

    override fun handlePacket(packet: IPacket, socketFrom: Socket) {
        packet as RegisterPacketToServer
        if (packet.username.length in 6..19) {
            try {
                DatabaseConnection.ds.connection.use({ connection ->
                    var statement = connection.prepareStatement("SELECT * FROM kentai.login_table WHERE username = ?;")
                    statement.setString(1, packet.username)
                    val query = statement.executeQuery()
                    if (!query.next()) {
                        statement = connection.prepareStatement("INSERT INTO `kentai`.`login_table` (`username`, `public_key`, `message_public_key`) VALUES (?, ?, ?);")
                        statement.setString(1, packet.username)
                        val publicString = Base64.getEncoder().encodeToString(packet.loginPublicKey.encoded)
                        statement.setString(2, publicString)
                        val privateString = Base64.getEncoder().encodeToString(packet.messagePublicKey.encoded)
                        statement.setString(3, privateString)
                        statement.execute()
                        KentaiCommon.packetHelper.sendPacket(RegisterPacketToServerResponseToClient(true, packet.username), socketFrom, null)
                    }
                })
            } catch (e: SQLException) {
                KentaiServer.logger.log(Level.WARNING, "ERROR!", e)
            }
        } else {
            KentaiCommon.packetHelper.sendPacket(RegisterPacketToServerResponseToClient(false, ""), socketFrom)
        }
    }

}