/**
 * Klasse Programm soll die Verwendung von Methoden verdeutlichen.
 */
class Programm {
    /**
     * Methode add addiert zwei uebergebene Parameter und gibt die Summe zurueck
     * @param summand_1 Der erste Summand
     * @param summand_2 Der zweite Summand
     * @return Das Ergebnis der Addition beider  Summanden
     */
    public static int add(int summand_1, int summand_2){
        return summand_1 + summand_2;
    }
 
    /**
     * Methode hallo gibt ihren Namen aus. Welche weitere Methode sie aufgerufen hat und
     * welches Ergebnis sie von der anderen Methode erhalten hat.
     */
    public static void hallo(){
        System.out.println("Ich bin die Methode "hallo"");
        System.out.println("Ich rufe die Methode "add" mit den Parametern 3 und 4 auf");
        int summe = add(3, 4);
        System.out.println("Ich habe als Ergebnis die Summe " + summe + " von "add" erhalten");
    }
    /**
     * Main-Methode wird vom Compiler gesucht und automatisch aufgerufen
     */
    public static void main(String[] args) {
        System.out.println("Das ist ein Beispiel, das die Verwendung von Methoden erklaeren soll");
        hallo();
        System.out.println("Hier endet die main-Methode und damit das Programm");
    }
}

Dieses Programm enthält insgesamt drei Methoden, die wir definiert haben. Zunächst ist da die bereits bekannte main-Methode. Diese wird beim Kompilieren und beim Ausführen des Programms gesucht und automatisch aufgerufen. Sie ermöglicht also der JVM den Einstieg in unser Programm. Ohne ihr würde nichts funktionieren. Wichtig ist, dass ein Programm nur eine main-Methode haben darf, da sonst nicht klar ist, welche dieser Methoden ausgeführt werden sollen.
Die zweite Methode ist die Methode “hallo”. Sie ähnelt in ihrem Methodenkopf sehr stark der main-Methode. Der einzige Unterschied ist, dass unsere hallo-Methode keine Parameter übergeben bekommt. Parameter sind die Elemente, die von der runden öffnenden und schließenden Klammer, die hinter der Bezeichnung der Methode kommt, eingeschlossen werden. Zu erkennen ist, dass die main-Methode einen Parameter mit der Bezeichnung “args” übergeben bekommt. Dieser Parameter ist vom Typ ein String-Array.

Die Methode “hallo” ruft in Zeile 22 eine weitere Methode auf, die wir “add” genannt haben. Das Ergebnis, dass uns die Methode “add” liefert, wird der Variablen “summe” zugewiesen. Der Wert der Variablen wird dann in der drauf folgenden Zeile ausgegeben.
Die Methode “add” addiert die beiden übergebenen Parameter. Das Ergebnis der Addition wird dann zurückgegeben. Das Zurückgeben erfolgt stets mit dem Schlüsselwort “return”. Sobald wir etwas zurückgeben möchten, müssen wir im Methodenkopf notieren welchen Typ die Rückgabe haben wird. Deshalb steht vor der Bezeichnung der add-Methode das Schlüsselwort “int”. Zurückgegeben werden können alle erdenklichen Typen wie int, long, float, double, String, Arrays und Objekte. Da wird in der Methode “hallo” nichts zurückgeben wollen, sondern nur Ausgaben tätigen, muss vor dem Methodennamen das Schlüsselwort “void” stehen. Es heißt soviel wie “Ich geben nichts zurück”. Die main-Methode darf per Konvention nur void sein.

Was ist nun der Sinn hinter Methoden? Methoden dienen dazu, um Code durch Auslagern übersichtlicher und wartungsfreundlicher zu gestalten.

Methoden werden nacheinander wie sie im Programm aufgerufen werden abgearbeitet. Methoden, die andere Methoden aufrufen, werden unterbrochen und fahren erst nachdem die aufgerufene Methode beendet ist, in ihrem Programmfluss fort. In unserem Beispiel wird zunächst du die JVM die main-Methode ausgeführt. In dieser Methode rufen wir die Methode “hallo” auf. Somit wird die Methode main zunächst unterbrochen und die hallo-Methode ausgeführt. Methode “hallo” ruft wiederum die Methode “add” auf, der sie die zwei Parameter 3 und 4 übergibt, um dann den eigenen Programmfluss zu unterbrechen und den Weg für “add” frei zu machen. Nachdem “add” die beiden Parameter addiert hat, kann “hallo” fortfahren und ebenfalls beendet werden. Jetzt wird weiter die Methode “main” ausgeführt, bis diese abgearbeitet wurde und unser Programm schließlich beendet werden kann.
Den Programmfluss soll das nachfolgende Bild darstellen.

Programmfluss der Methoden

In vielen Unix-Systemen sind die MD5-Bibliotheken bereits integriert und können über die Konsole genutzt werden.
Auf einem Mac sieht der Aufruf beispielsweise so aus:

md5 -s "ein string, den ich verschlüsseln will"

Mit dem Ergebnis:

MD5 ("ein string, den ich verschlüsseln will") = fbf50beb87218a44ed02a7cf4dca9868

Wie man erkennt entspricht der String “ein string, den ich verschlüsseln will” dem MD5-Hash fbf50beb87218a44ed02a7cf4dca9868.

Ein Merkmal der MD5-Funktion besteht darin, dass ein Hash-Wert nicht ohne Weiteres wieder entschlüsselt werden kann.
Deswegen wird MD5 oft genutzt um Passwörter verschlüsselt in Datenbanken zu speichern.

Was macht man nun, wenn man aber mal doch diesen Hash entschlüsselt haben möchte? Da das zurückrechnen nicht möglich ist, verwendet man eine besondere Datenstruktur, die sogenannten Rainbow Tables. Im Internet finden sich zahlreiche Seiten, die eine Entschlüsselung von Hashes mittels Rainbow Tables anbieten. Darunter findet man auch die Seite c0llision.net, die u.a mittels einer API ermöglicht auf ihre Dienste zuzugreifen. Wie man diese nutzt, will ich in den folgenden Textabschnitten erklären. Dabei stütze ich mich auf diese Dokumentation: http://www.c0llision.net/rest_api_documentation.

Der Zugriff auf die API erfolgt über die URL http://api.dev.c0llision.net/. Die API unterstützt drei verschiedene Formate, die einem als Ergebnis einer Anfrage geliefert werden. Zur Auswahl stehen dabei JSON, XML und YAML. Ich habe mich hier für JSON entschieden, da später der Zugriff über PHP bequemer ist. Als Algorithmen werden LM, NTLM und wie eingangs erwähnt MD5 unterstützt. Diese Angaben müssen der URL angehängt werden. Dabei erhält man folgendes Muster, um eine Anfrage an die c0llision API absetzen zu können:

http://api.dev.c0llision.net//crack//

Wollen wir nun den MD5-Hash fbf50beb87218a44ed02a7cf4dca9868 entschlüsselt haben und das Ergebnis als JSON zurückgeliefert bekommen, würden wir folgende Anfrage abschicken:

http://api.dev.c0llision.net/json/crack/md5/fbf50beb87218a44ed02a7cf4dca9868

Um diese Anfrage bequem per Skript verarbeiten zu können, habe ich folgendes kleines PHP-Programm geschrieben:

<!--?php
  function crack($algorithm, $hash){
    //Convert algorithm to lowercase
    $algorithm = strtolower($algorithm);
    $pattern = '';
    $url = 'http://api.dev.c0llision.net/json/crack/';
 
    //Check algorithm
    switch($algorithm){
      case 'md5':
        $pattern = '/^([0-9a-f]{32})$/';
        $url .= 'md5/';
      break;
 
      case 'lm':
        $pattern = '/^([0-9a-f]{32}:[0-9a-f]{32})$/';
        $url .= 'lm/';
      break;
 
      case 'ntlm':
        $pattern = '/^([0-9a-f]{32})$/';
        $url .= 'ntlm/';
      break;
 
      default:
        return FALSE;
      break;
    }
 
    //Check hash
    $check = preg_match($pattern, $hash);
    if(0 === $check || FALSE === $check){
      return FALSE;
    }
 
    //Build final URL
    $url .= $hash;
 
    //Initialize CURL and set options
    $curl_handle = curl_init();
    curl_setopt($curl_handle, CURLOPT_URL, $url);
    curl_setopt($curl_handle, CURLOPT_HEADER, 0);
    curl_setopt($curl_handle, CURLOPT_RETURNTRANSFER, TRUE);
    curl_setopt($curl_handle, CURLOPT_TIMEOUT, 4);
 
    //Execute CURL request
    $result = curl_exec($curl_handle);
    curl_close($curl_handle);
 
    return $result;
  }
 
  function crackMD5($hash){
    return crack('md5', $hash);
  }
 
  function crackLM($hash){
    return crack('lm', $hash);
  }
 
  function crackNTLM($hash){
    return crack('ntlm', $hash);
  }
?-->

Das Programm definiert eine Prozedur “crack”, welche die ganze Funktionalität liefert. In ihr wird zunächst ein Teil der URL gespeichert, auf die im weiteren Programmablauf mittels cURL zugegriffen wird. Nachdem die Variable “url” gesetzt wurde, wird überprüft ob ein korrekter Algorithmus gewählt wurde und das Muster des Hashs zum Algorithmus passt. Beispielsweise darf ein MD5-Hash lediglich aus 32 hexadezimalen Zahlen bestehen. Ist ein gültiger Hash übergeben, wird er an die URL gehängt. Diese ist nun vollständig zusammengebaut. Mittels cURL wird nun eine GET-Anfrage abgesetzt, die Antwort in die result-Variable gespeichert und zurückgegeben. Die weiteren Funktionen “crackMD5″, “crackLM” und “crackNTLM” nutzen lediglich “crack”, indem sie ihr die entsprechenden Parameter übergeben.
Die crackMD5-Funktion wollen wir nun nutzen, um den Hash 098f6bcd4621d373cade4e832627b4f6 zu entschlüsseln.
Ein PHP-Skript könnte zum Beispiel so aussehen:

<!--?php
  $hash = '098f6bcd4621d373cade4e832627b4f6';
  $result = crackMD5($hash);
  $json;
  if(FALSE !== $result){
    $json = json_decode($result, true);
 
    // HTTP 200 received
    if(200 !== $json['response']['status']['code']){
        echo 'Server response: ' . $json['response']['status']['code'];
    }
    // Hash already cracked
    elseif(TRUE !== $json['response']['result']['cracked']){
        echo 'Sorry, your hash has not been cracked yet';
    }
    else {
        echo $json['response']['result']['plaintext']['raw'];
    }
}
?-->

Es setzt eine Anfrage durch die Funktion “crackMD5″ an die c0llision API ab und speichert die Antwort in die Variable “result”. Hat “crackMD5″ eine gültige Antwort zurückgegeben, so dekodieren wir den JSON-String mittels der PHP-Funktion “json_decode“. Dann wird geprüft, ob der Server mit einem HTTP-200-Status geantwortet hat und der zu entschlüsselnde Hash bereits gecrackt wurde. Ist dies der Fall, wird der entsprechende Klartext des Hashs ausgegeben.

Java bietet uns drei Möglichkeiten von Kommentaren:

• Zeilenkommentar
• Blockkommentar
• JavaDoc-Kommentar

Ein Zeilenkommentar gilt nur für eine Zeile und wird mit einem // eingeleitet. Möchte man Kommentare über mehrere Zeilen hinweg setzten, so bietet sich das Blockkommentar dafür an. Dieses wird mit einem /* eingeleitet und endet mit */.
Das JavaDoc-Kommentar ist ein besonderes Blockkommentar, das zum Beispiel Beschreibungen von Funktionen und / oder deren Parameter enthält. Beginnt man ein Kommentar mit /** und schließt es mit */ ab, handelt es sich um diesen Typ von Kommentar. Mit dem im JDK mitgelieferten Tool javadoc ist es möglich diese Kommentare zu einer API-Dokumentation zu generieren.

Mit Kommentaren können wir Code auch zum Testen und zur Fehlersuche auskommentieren, um diese vor dem Compiler zu verstecken.

Dieses Beispiel soll uns die Verwendung von Kommentaren in Java verdeutlichen:

/**
 * @author eugen
 * @version 1.0
 */
class RasenMaehen
{
  /*
  * Dieses Programm berechnet, ob man seinen Rasen mähen sollte
  */
  public static void main ( String[] args )
  {
    //Maße in cm
    int aktuelleLaenge = 53;
    int gewuenschteLaenge = 20;
    int maxUeberschuss = 10;
 
    // Wenn Ueberschuss zu groß, muss gemaeht werden
    if( (aktuelleLaenge – gewuenschteLaenge) > maxUeberschuss )
    {
      System.out.println("Rasen muss gemaeht werden");
    }
    else
    {
      System.out.println("Geht noch!");
    }
  }
}

Bei dem ersten Kommentar handelt es sich um einen JavaDoc-Kommentar, der besondere Schlüsselwörter wie @author enthält, die vom javadoc-Tool ausgewertet werden können.
Der zweite Kommentar auf den wir stoßen ist ein Blockkommentar, der sich über drei Zeilen hinzieht.
Bei dem dritten und vierten Kommentar verwenden wir nun den Zeilenkommentar, der wie gesagt nur eine Zeile auskommentiert.

Variablen werden viele schon aus der Mathematik kennen. Schauen wir und beispielsweise eine einfache Gleichung aus der Algebra an.
x² + 2x = 0
Dabei ist x eine Variable, die für verschiedene Zahlen steht. Dass x die Werte 0 und -2 annehmen kann, damit die Gleichung auch korrekt ist, ist hier unwichtig.

Eine Variable in der Programmierung kann man sich als Box vorstellen, in die wir verschiedenste Werte reinstecken und diese dann wieder auslesen oder verändern können.

Die Variable ist eine Box, die den Namen “zahl” trägt. In diese Box können wir nun zum Beispiel eine Zahl “hineinschieben” – hier ist es die 5. Später können wir auf diese gespeicherte 5 zugreifen, indem wir einfach dazu den Namen der Variablen verwenden.

Dies wollen wir nun in Java mit folgendem Code übertragen.

int zahl;
zahl = 5;

In der ersten Zeile sagen wir dem Compiler, dass wir eine Variable zahl in unserem Programm haben werden. In der zweiten Zeile weisen wir der Variablen zahl den Wert 5 zu.
Den obigen Code können wir so auch verkürzt aufschreiben:

int zahl = 5;

Jetzt kann man beim weiteren Programmieren auf diese Variable zugreifen, sie verändern oder mit ihr Rechnungen durchführen. Dazu dieses Beispiel:

class VariablenTutorial
{
  public static void main(String[] args)
  {
    int zahl = 5;
    System.out.println("Ich bin die Variable zahl! Mein Wert ist: " + zahl);
    zahl = 3;
    System.out.println("Ich bin die Variable zahl! Mein Wert ist: " + zahl);
    zahl = zahl + 3;
    System.out.println("Ich bin die Variable zahl! Mein Wert ist: " + zahl);
  }
}

Die Ausgabe dieses Programmes sollte wie folgt aussehen:

Ich bin die Variable zahl! Mein Wert ist: 5
Ich bin die Variable zahl! Mein Wert ist: 3
Ich bin die Variable zahl! Mein Wert ist: 6

Was geschieht nun in unserem Programmablauf?
In der ersten Zeile der main-Methode erstellen wir eine Variable zahl, die den Wert 5 zugewiesen bekommt. Danach rufen wir System.out.println() mit einem Text auf und übergeben unsere Variable. In der dritten Zeile überschreiben wir unsere Variable mit einem neuen Wert und geben wieder eine Meldung auf der Konsole aus. In der fünften Zeile rechnen wir mit dieser Variable. Der Wert der Variable zahl, der jetzt 3 ist, wird mit 3 addiert und das Ergebnis wird wieder in unsere Variable zahl gespeichert. Eine erneute Ausgabe auf der Konsole zeigt uns, dass die Variable zahl jetzt den Wert 6 angenommen hat.
Was dieses “int” da vor der Variable zu suchen hat, klären wir im nächsten Tutorial. Freut euch drauf!

Wie es scheint, ist hier noch einiges zu tun. Die vorläufige ToDo-Liste sieht wie folgt aus.

ToDo:

• eine anständige TLD für dieses Blog bestellen (done – coder-blog.de)
• eigenes Design erstellen
• Artikel aus dem ersten Semester des Informatikstudiums nachschreiben
• bei Google Analytics anmelden (done – Tracking Code eingebunden)
• Keywords SEO – vorteilhaft aussuchen (vorläufige Keywords gefunden)
• eventuell ein wenig Affiliate Marketing betreiben, damit Kosten des Blogs gedeckt werden (Bewerbungsphase)

So, genug Werbung gemacht! XD

Sollten diese Punkte nicht demnächst abgearbeitet worden sein, bin ich entweder noch im Winterschlaf oder die Motivation für das Blog ist dahin. Wahrscheinlicher ist aber, dass ich wegen des Studium keine Zeit habe irgendwelche Artikel zu schreiben.

Aber ich werde mich bemühen mich in den Arsch zu treten und mich darum zu kümmern, denn ein weiterer Nebeneffekt, der nicht zu verachten ist, dass dieses Blog mir auch dazu dienen kann, meinen mehr oder weniger gelernten Stoff besser zu verstehen.

Wir werden sehen …