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.

Enumerationen unter Java mit Eigenschaften ausstatten

Im Gegensatz zu vielen anderen Programmiersprachen sind Enumerationen unter Java ein wenig anders gestrickt. Wird eine Enumerationen dort kompiliert entsteht als Ergebnis eine Klasse. Dieser Umstand kann für interessante Dinge genutzt werden. Während in C# der Enum:

public enum Unit {
    PASCAL,
    PSI
}

eine reine Enumeration, mit zwei Werten, darstellt, kann die Enumeration unter Java mit zusätzlicher Funktionalität ausgestattet werden:

public enum Unit {

    PASCAL("Pascal", 1),
    PSI("Pound-force per square inch", 6.895);

    Unit(String name, double conversionFactor) {
        this.name = name;
        this.conversionFactor = conversionFactor;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getConversionFactor() {
        return conversionFactor;
    }

    public void setConversionFactor(double conversionFactor) {
        this.conversionFactor = conversionFactor;
    }

    private String name;
    private double conversionFactor;
}

In diesem Fall erhält die Enumeration zwei zusätzliche Eigenschaften, einen Namen und einen Faktor zur Umrechnung in Pascal. Bei der Definition der einzelnen Werte der Enumeration werden diese zusätzlichen Eigenschaften über den Konstruktor übergeben. In der Nutzung sieht das Ganze dann wie folgt aus:

Unit unit = Unit.PSI;

System.out.println(unit.getName());
System.out.println("Conversion factor to Pascal: " + unit.getConversionFactor());

Mit dieser Herangehensweise lassen sich Enumerationen unter Java einfach mit dazugehörigen Metadaten bzw. zusätzlichen Informationen anreichern.

Enums unter JavaScript

Enums gibt es unter JavaScript nicht. Damit könnte der Artikel an dieser Stelle vorbei sein. Allerdings gibt es viele Wege um in JavaScript ein Verhalten oder die Strukturen zu simulieren, die am Ende gewünscht sind. Bei einem Enum würde dies so aussehen:

var DayOfTheWeek = {
  Monday: 1,
  Tuesday: 2,
  Wednesday: 3,
  Thursday: 4,
  Friday: 5,
  Saturday: 6,
  Sunday: 7
};

Genutzt wird das ganze dann so:

var dayOfTheWeek = DayOfTheWeek.Thursday;

Wer mehr über die Hintergründe rund um Enums unter JavaScript erfahren möchte dem sei der ausgezeichnete Blogbeitrag Enums in Javascript empfohlen.

JavaScript Integer in Enum umwandeln

In JavaScript ist es durchaus möglich Enums anzulegen:

var Protocol =
{ 
  PAMSG_REGISTER:0x0000, // D version, S username, S password, S email, S captcha response
  APMSG_REGISTER_RESPONSE:0x0002, // B error, S updatehost, S Client data URL, B Character slots
  PAMSG_UNREGISTER:0x0003, // S username, S password
}

Interessant wird es nun, wenn man versucht aus einer Zahl in diesem Beispiel der „2“ wieder einen Enum („APMSG_REGISTER_RESPONSE“) zu erzeugen. Hierbei hilft die Funktion „getEnumFromInteger“ welche wie folgt aussieht:

function getEnumFromInteger(enumWithValues, integer)
{
  var keys = Object.keys(enumWithValues);
    
  for (var i=0; i<keys.length; i++)
  {
    if(enumWithValues[keys[i]]==integer) return keys[i];
  }
    
  return null;
}

Damit wird der Enum durchiteriert und der entsprechende Schlüssel, welcher dem Integer entspricht, zurückgegeben.

Enums in Strings verwandeln

Wenn man in C# einen Enum definiert hat:

public enum CultivationArea
{
    Burgenland,
    Steiermark,
    Wachau,
    Weinviertel
}

und aus diesem Enum ein paar Strings eine Stringliste machen möchte so stellt man schnell fest das es nicht so einfach ist. Mit ein paar Verrenkungen geht das ganze dann zum Glück doch:

List Values = new List();
foreach (CultivationArea i in Enum.GetValues(typeof(CultivationArea)))
{
    Values.Add(i.ToString());
}