Einfacher Passwort-Generator unter Java

Das Ausdenken von Passwörtern ist prinzipiell eine schlechte Idee; besser ist es, wenn diese automatisch generiert werden. Ein solcher Generator kann problemlos selbst geschrieben werden. In diesem Fall in Java:

public class PasswordGenerator {

    private static final SecureRandom secureRandom = new SecureRandom();

    private static final String alpha = "abcdefghijklmnopqrstuvwxyz";
    private static final String alphaCaps = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String numeric = "0123456789";
    private static final String specials = "!§$%&/()=?.:,;+*#<>";

    public enum CharacterSet {
        Alpha,
        AlphaCaps,
        AlphaBoth,
        Numeric,
        AlphaNumeric,
        Special,
        All
    }

    private static String getCharacters(CharacterSet characterSet) {

        switch (characterSet) {
            case Alpha:
                return alpha;
            case AlphaCaps:
                return alphaCaps;
            case AlphaBoth:
                return alpha + alphaCaps;
            case Numeric:
                return numeric;
            case AlphaNumeric:
                return alpha + alphaCaps + numeric;
            case Special:
                return specials;
            case All:
                return alpha + alphaCaps + numeric + specials;
        }

        return alpha;
    }

    public static String generatePassword(int length, CharacterSet characterSet) {

        String characters = getCharacters(characterSet);
        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < length; i++) {
            stringBuilder.append(characters.charAt(secureRandom.nextInt(characters.length())));
        }

        return stringBuilder.toString();
    }
}

Der Generator funktioniert im Groben so, das aus einem bestimmten Zeichenvorrat zufällig Zeichen gewählt und aus diesen das Passwort erzeugt wird. Als Zufallsquelle kommt nicht die gebräuchliche Klasse Random zum Einsatz, sondern die Klasse SecureRandom. Diese von Random abgeleitete Klasse erzeugt aus kryptografischer Sicht starke Zufallszahlen, was die Sicherheit des Generators erhöht. Als kleines Gimmick lässt sich der gewünschte Zeichensatz, aus welchem das Passwort generiert werden soll, über einen Enum auswählen:

String s = PasswordGenerator.generatePassword(64, PasswordGenerator.CharacterSet.All);
System.out.println(s);

Damit würde auf der Konsole ein Passwort mit 64 Zeichen ausgegeben werden, welches den kompletten Zeichenvorrat der Generator-Klasse nutzt.

Java Cheat Sheet für Einsteiger

Für eine Veranstaltung war ich auf der Suche nach einem zweiseitigen Java Cheat Sheet für Einsteiger. Da ich nichts Passendes gefunden habe, habe ich auf die Schnelle ein solches Cheat Sheet für Java erstellt.

Die erste Seite des Cheat Sheets

Es behandelt dabei wirklich nur die grundlegenden Begriffe und richtet sich von der Zielgruppe her an Jugendliche und Kinder. Der Cheat Sheet kann als PDF herunterladen werden.

MQTT-Broker in Java einbinden

Zur Nutzung des MQTT-Protokolls wird ein MQTT-Broker benötigt. Dieser kann separat betrieben oder aber in eine Anwendung eingebettet werden. Ein MQTT-Broker, welcher sich für die Einbettung unter Java eignet, ist Moquette. Zur Einbindung von Moquette muss es den Abhängigkeiten des Projektes hinzugefügt werden:

<dependency>
	<groupId>io.moquette</groupId>
	<artifactId>moquette-broker</artifactId>
	<version>0.12.1</version>
</dependency>

Die Funktionalitäten zum Start und Stop des MQTT-Brokers werden in diesem Beispiel in der Klasse Broker gekapselt. In der Klasse wird eine Instanz vom Typ Server angelegt und über die Methode startServer kann der MQTT-Broker gestartet werden. Beim Start wird in diesem Beispiel das Topic /exit angelegt. Weitere Topics können über die Methode pushTopic angelegt werden. Mittels der Methode stopServer kann der Broker wieder gestoppt werden.

public final class Broker {

    private static Logger log = LoggerFactory.getLogger(new Exception().fillInStackTrace().getStackTrace()[0].getClassName());

    final Server mqttBroker = new Server();

    public void startServer() {

        // Load class path for configuration
        IResourceLoader classpathLoader = new ClasspathResourceLoader();
        final IConfig classPathConfig = new ResourceLoaderConfig(classpathLoader);

        // Start MQTT broker
        log.info("Start MQTT broker...");
        List userHandlers = Collections.singletonList(new PublisherListener());

        try {
            mqttBroker.startServer(classPathConfig, userHandlers);
        } catch (IOException e) {
            log.error("MQTT broker start failed...");
        }

        // Wait before publish topics
        log.info("Wait before topics are pushed...");

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            log.warn("Pause for publishing topics interupted.");
        }

        // Publishing topics
        log.info("Pushing topics...");

        pushTopic("/exit");

        log.info("Topics pushed...");
    }

    public void stopServer() {
        mqttBroker.stopServer();
    }

    public void pushTopic(String topic) {

        MqttPublishMessage message = MqttMessageBuilders.publish()
                .topicName(topic)
                .retained(true)
                .qos(MqttQoS.EXACTLY_ONCE)
                .payload(Unpooled.copiedBuffer("{}".getBytes(UTF_8)))
                .build();

        mqttBroker.internalPublish(message, "INTRLPUB");
    }
}

Beim Start des Servers wird eine Konfigurationsdatei mit dem Namen moquette.conf aus dem Ordner resources/config geladen. Diese könnte beispielhaft wie folgt aussehen:

##############################################
#  Moquette configuration file. 
#
#  The syntax is equals to mosquitto.conf
# 
##############################################

port 1883

#websocket_port 8080

host 0.0.0.0

#Password file
#password_file password_file.conf

#ssl_port 8883
#jks_path serverkeystore.jks
#key_store_password passw0rdsrv
#key_manager_password passw0rdsrv

allow_anonymous true

Beim Start des MQTT-Brokers wird ein Handler vom Typ PublisherListener registriert. Diese Handler muss natürlich vorher definiert werden:

public class PublisherListener extends AbstractInterceptHandler {

    private static Logger log = LoggerFactory.getLogger(new Exception().fillInStackTrace().getStackTrace()[0].getClassName());

    @Override
    public String getID() {
        return "PublishListener";
    }

    @Override
    public void onPublish(InterceptPublishMessage msg) {

        // Create array for payload
        int readableBytes = msg.getPayload().readableBytes();
        byte[] payload = new byte[readableBytes];

        // Read bytes from payload
        for (int i = 0; i < readableBytes; i++) {
            payload[i] = msg.getPayload().readByte();
        }

        // Create string from payload
        String decodedPayload = new String(payload, UTF_8);
        log.debug("Received on topic: " + msg.getTopicName() + " content: " + decodedPayload);
    }
}

Der Handler wertet alle Publish-Nachrichten aus und loggt diese mittels des Loggers. Nun kann der Broker gestartet werden:

// Start broker
Broker broker = new Broker();
broker.startServer();

// Bind a shutdown hook
Runtime.getRuntime().addShutdownHook(new Thread(() -> {

	log.info("Stopping MQTT broker...");
	broker.stopServer();
}));

Über den registrierten Shutdown-Hook kann der Server anschließend wieder beendet werden. Damit ist die beispielhafte Einbindung von Moquette in eine Java-Applikation abgeschlossen. Der Quelltext von Moquette kann über GitHub bezogen werden. Lizenziert ist das Projekt unter der Apache License in Version 2 und damit freie Software.

Deeplearning4j

Bibliotheken für die Entwicklung von Deep Learning-Anwendungen bzw. zur Nutzung von maschinellem Lernen, sind meistens für Python verfügbar. Entsprechende Bibliotheken für Java sind dagegen spärlich gesät. Eine dieser Bibliotheken für Java ist Deeplearning4j. Neben der klassischen Kost, wie der Unterstützung unterschiedlicher neuronaler Netze, verfügt Deeplearning4j über eine Schnittstelle zu Python, mit deren Hilfe die entsprechenden Bibliotheken aus der Python-Welt angebunden werden können.

deeplearning4j.org

Der Quelltext der Bibliothek ist auf GitHub zu finden. Lizenziert ist die Bibliothek unter der Apache License in der Version 2 und damit freie Software. Die offizielle Projektseite kann unter deeplearning4j.org besucht werden.

Exception-Hierarchie unter Java

Java nutzt, wie viele andere Sprachen, Exceptions zur Fehlersignalisierung und Fehlerbehandlung. Folgender Code würde hierbei dem Anschein nach alle Exceptions fangen:

try {
  // Do something wrong
} catch(Exception e) {
  // Gotta Catch 'Em All
}

An dieser Stelle trügt der Schein nicht. Allerdings werden nur einige Fehlerklassen gefangen, nämlich nur solche vom Typ Exception. Die Hierarchie der Fehlerklassen ist unter Java ein wenig differenzierter. In Java erbt jede Klasse implizit von der Klasse Object und so erbt auch die Klasse Throwable von dieser und implementiert das Interface Serializable.

Die Hierarchie der Klassen, welche für Fehlersignalisierung zuständig sind

Von der Klasse Throwable wiederum erben die Klassen Error und Exception. Fehler vom Typ Error stellen laut Definition immer Fehler innerhalb der JVM da, während Exceptions gewöhnliche Fehler des Programmes bzw. des Entwicklers sind. Sollen nun alle Fehlerklassen gefangen werden, so müsste der Quellcode wie folgt aussehen:

try {
  // Do something wrong
} catch(Throwable t) {
  // Gotta Catch 'Em All
}

Das Beispiel sollte nur als solches betrachtet werden, da es sich immer empfiehlt spezielle Fehler zu fangen und zu behandeln. Ein solch allgemeiner Fehlerhandler eignet sich nur für Spezialfälle wie z.B. das Logging nicht behandelter Fehler. Die Hierarchie verästelt sich anschließend noch weiter, so erben unterschiedlichste Klassen von der Klasse Error. Bei der Klasse Exception sieht dies ähnlich aus, allerdings existiert hier eine Besonderheit, die Klasse RuntimeException. Normalerweise muss eine Methode Exceptions, die sie wirft im Methodenkopf bekannt geben, wenn sie nicht in der Methode behandelt werden:

public static void example() throws Exception {
  throw new Exception();
}

Bei Klassen die von der Klasse RuntimeException erben muss diese Bekanntmachung im Methodenkopf nicht erfolgen. Sie werden trotzdem nach oben durchgereicht bis sie gefangen werden oder sich das Programm beendet, wenn die Behandlung der Exception nicht durchgeführt wurde.