Ed25519-SSH-Schlüssel im Terminal generieren

Wer in den letzten Jahren einen SSH-Schlüssel generiert hat, wird meist RSA als kryptografischen Verfahren dafür genutzt haben. Mittlerweile geht die Empfehlung für neue Schlüssel mehrheitlich zu solchen, welche auf elliptische Kurven basieren. Ein solcher Schlüssel kann im Terminal über den Befehl:

ssh-keygen -t ed25519

generiert werden. Alternativ kann eine entsprechende E-Mail-Adresse für den Schlüssel definiert werden:

ssh-keygen -t ed25519 -C ""

Anschließend wird ein entsprechender Schlüssel erzeugt:

The key fingerprint is:
SHA256:1RCIsYVjuj9JUdpkAQEpnHmQEI2n+VsW1hr5dPk/X9w 
The key's randomart image is:
+--[ED25519 256]--+
|o*.=.o+*ooo.     |
|. O o =o=  o     |
| + o =.B .. .    |
|o   * = +.       |
| . . B oS.       |
|  . = o   .    ..|
|   + o .   .    E|
|  .   +     o  . |
|       .     o.  |
+----[SHA256]-----+

Wer sich den öffentlichen Schlüssel anschaut, wird feststellen, das dieser wesentlich kürzer ist:

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDQFUwFRKdr/6xq208X6ME9kQF0pxVWSEmIkMqJXwUZ2 

Die Länge des Schlüssels verglichen mit den RSA-Schlüsseln sagt allerdings direkt nichts über die Sicherheit des Schlüssels aus. Grundsätzlich sind die Ed25519-Schlüssel kürzer als vergleichbare RSA-Schlüssel. Daneben ist das Verfahren schneller und resistenter gegen Kollisionsattacken und sollte daher in Zukunft gewählt werden.

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.

Joplin mit Ende-zu-Ende-Verschlüsselung erschienen

Vor einigen Tagen stelle ich mit Joplin eine freie Evernote-Alternative vor. Joplin befindet sich in in aktiver Entwicklung und so schaffte es die letzten Tage ein Feature mit dem Titel E2EE, was für End-To-End Encryption steht, in die Anwendung. Damit ist eine Ende-zu-Ende-Verschlüsselung der Notizen gemeint. Das bedeutet, dass die Notizen nur noch auf den jeweiligen Endgeräten entschlüsselt werden können. Beginnend mit Version 0.10.41 wird dies unterstützt; auch wenn das ganze im Moment noch als Beta deklariert ist.

Die Einstellungen zur Verschlüsselung in der iOS-App

Unter iOS und Android funktioniert die Ende-zu-Ende-Verschlüsselung noch nicht. Hier existierte noch ein Bug, welcher dafür sorgte, das man das Passwort nicht eingeben konnte. Mittlerweile wurde dieser Fehler behoben und ab dem Release 0.10.42 sollte die Verschlüsselung auf den mobilen Plattformen ebenfalls funktionieren. Joplin kann über die offizielle Projektseite bezogen werden.

Mailverschlüsselung unter Android

Möchte man PGP bzw. GPG unter Android nutzen, so empfielt sich die Nutzung von K-9 Mail. Dabei handelt es sich um eine freie Mailsoftware. Neben K-9 Mail muss auch die App APG installiert werden. APG ist eine GnuPG Implementation für Android.

K-9 Mail beim Verfassen einer Mail

K-9 Mail beim Verfassen einer Mail

Nach der Installation können mittels APG die öffentlichen Schlüssel der Empfänger hinzugefügt werden. Anschließend kann in K-9 Mail eine Mail verfasst werden. Dort kann auch festgelegt werden, ob die Mail nur signiert oder auch verschlüsselt werden soll. In den Einstellungen von K-9 Mail können diese Optionen auch als Standard eingestellt werden (unter Kryptografie).