Gruppe GUI

Aufgabe bis zum 29.1.

• Alexander und Oleg: Die Methoden readHistory und writeHistory funktionieren nun. Baut diese in das GUI ein. Als nächstes brauchen wir eine Schlüsselverwaltung für jedes offene MessageWindow. Dies soll mit Hilfe der Klasse Key bzw. KeyList realisiert werden. Ein neues Objekt vom Typ Key kann man mit den Konstruktoren

  Key(int id, String key);
  Key(int id, String key, long timestamp, boolean selected);
  

  initialisieren. Bei dem ersten Konstruktor wird der timestamp auf die aktuelle Zeit und die Variable selected auf true gesetzt. Das Feld String key enthält den Schlüssel, der z.B. per createKey() erzeugt werden kann. Die Schlüssel werden in Dateien verwaltet. Dazu stehen folgende Methoden aus der Klasse CryptFile zur Verfügung:

  // liest alle abgespeicherten Schlüssel aus der Schlüsseldatei
  KeyList readKeys(String verfahren, int buddyid);
  
  // schreibt einen neuen Schlüssel in die Schlüsseldatei
  boolean writeKey(String verfahren, int buddyid, Key schluessel);
  
  // liest den aktuell selektierten Schlüssel aus der Datei aus
  Key getKey(String verfahren, int buddyid);
  
  // setzt Schlüssel mit der id -keyid- als den aktuellen Schlüssel
  boolean setSelectedKey(String verfahren, int buddid, int keyid);
  

  Die Klasse KeyList benötigen wir erst einmal nicht, sondern wir arbeiten direkt mit der Klasse Key. Mit getKey erhät man den aktuellen Schlüssel. Sind noch keine Schlüssel für das ausgewählte Verfahren und den Buddy gespeichert, so ist der Rückgabewert null! Mit dem so erhaltenen Schlüsselobjekt kann man nun verschlüsseln. Mit k.getKey() erhält man den Schlüsselstring (den man dann per stringToKey() im CryptSystem verankert).

  Wird ein neuer Schlüssel erzeugt, kann man diesen mit der Methode writeKey in die Schlüsseldatei schreiben.

  Natürlich müssen erzeugte Schlüssel an den Buddy gesendet werden. Sprecht euch mit der Netzwerkgruppe ab, wie das genau funktioniert. Vielleicht schafft ihr es bis nächste Woche, die Schlüsselübermittlung zu implementieren. Einkommende Schlüssel müssen per writeKey-Methode gespeichert werden.

  Die Konfiguration zu jedem Buddy kann man übrigens mittlerweile auch speichern/auslesen, und zwar mit den Methoden

  Buddy readBuddy(int);
  boolean writeBuddy(Buddy);
  

  So kann man sich merken, welches Verfahren man zuletzt für diesen Buddy gebraucht hat (kann man im Feld String verfahren des Buddy Objektes festhalten).

• Oliver und Philipp: Überprüft den Code der Klasse CryptFile auf mögliche Fehler, die auftreten könnten. Z.B. könnten Dateien nicht vorhanden oder deren Inhalt falsch formatiert sein. Überlegt euch, wie man dadrauf im einzelnen reagieren sollte.

Aufgabe bis zum 22.1.

• Oliver und Philipp: Für jeden Buddy sollte eine Konfiguration gespeichert werden, und zwar in der Datei data/buddies/config($buddid).xml. Diese enthält folgende Informationen:

  <?xml version="1.0" encoding="utf-8"?>
  <BUDDY>
  	<ID>1</ID>
  	<NAME>Peter</NAME>
  	<IP>192.168.0.107</IP>
  	<VERFAHREN>Vigenere</VERFAHREN>
  </BUDDY>
  

  Ein Buddy-Objekt existiert bereits im package crypto.net, auch mit den entsprechenden Variablen für die vier Felder in der XML-Datei. Wir benötigen nun die zwei Methoden

  public boolean writeBuddy(Buddy b);
  public Buddy readBuddy(int id);
  

  um die Konfigurationen zu Lesen/Schreiben. Um die XML-Daten auszulesen, müßt ihr die Klasse BuddyParser erweitern. Orientiert euch hierbei an der Klasse MessageParser, um die XML-Datei Tag für Tag auszulesen und das Buddy-Objekt mit den entsprechenden Werten zu füllen.

• Alexander und Oleg: Das Lesen/Schreiben der Serverliste soll geändert werden. Anstatt der Methode CryptFile.readServer() soll die Methode CryptFile.readServer1() benutzt werden. Statt eines String-Arrays wird ein Objekt vom Typ "ServerObjectList" zurückgeliefert (ist von ArrayList abgeleitet). Auf die einzelnen Elemente kann man so zugreifen:

  ServerObjectList serverlist;
  ServerObject server;
  
  // liest die Serverliste aus
  serverlist = readServer1();
  
  for (int i = 0; i < serverlist.size(); i++) {
  	// liest das Element mit Index i aus der Liste aus
  	server = (ServerObject) serverlist.get(i);
  }
  

  Mit den Methoden ServerObject.getName() und ServerObject.getIp() kann man dann jeweils den Namen und die IP des Servers herausfinden. In der JComboBox der Klasse NewServer sollen nur die Namen der Server aufgelistet sein. Wenn man mit dem ausgewählten Server eine Verbindung herstellen möchte, muß man dann die IP des zugehörigen ServerObject benutzen.
  Die Liste hat den Vorteil, daß man sehr effektiv Objekte hinzufügen, editieren und löschen kann. Fügt drei neue Buttons "Add Server", "Edit Server" und "Delete Server" hinzu (in der JComboBox). Bei "Add Server" soll ein neues Popup erscheinen, in dem man den Namen und die IP eines neuen Servers eintragen kann. Dazu erstellt man dann ein neues Objekt server vom Typ "ServerObject" (Name per server.setName("Bla"), IP per server.setIp("127.0.0.1") setzen). Mit ServerObjectList.add(server) fügt man den Server der aktuellen Serverliste hinzu und per writeServer(ServerObjectList) schreibt man die neue Liste in eine Datei.
  Bei "Edit Server" soll dasselbe Popup erscheinen, jedoch sind die Felder für Name und IP bereits mit den Werten des aktuell ausgewählten Servers gefüllt. Mit Hilfe der Methode ServerObjectList.set(int index, Server server) überschreibt man in der Liste das Objekt an der Stelle index mit dem neuen Objekt server.
  Beim auslösen des Buttons "Delete Server" soll das aktuell ausgewählte ServerObject aus der Liste gelöscht werden. Das geht mit der Methode ServerObjectList.remove(int index). Am Ende dieser Operationen muß man mit writeServer(ServerObjectList s) aus CryptFile.java die aktuelle Serverliste speichern.

  Das hört sich erst einmal nach einer Menge Arbeit mit geringem Nutzwert an. Jedoch werden wir die History sowie die Schlüssel später auch aus Dateien auslesen und die Ergebnisse in Listen zurückliefern. Schafft euch also über die oben genannte Aufgabe einen Überblick von der Arbeit mit Objekten vom Typ ArrayList.

Aufgabe bis zum 15.1.

• Oliver und Philipp: Ich habe in der Klasse CryptFile mehrere Methoden geschrieben, die das Lesen und Schreiben der Schlüssel in XML Format ermöglichen. Diese neuen Methoden habe ich im Source Code gekennzeichnet. Die Serverdaten haben wir gestern schon auf XML umgestellt, das funktioniert auch so weit.
  Was jetzt noch fehlt, sind XML Dateien für jeden Buddy. Diese sollten im Verzeichnis data/buddies/ liegen, als Datei history($buddyid).xml. Das Format sollte folgendermaßen aussehen:

  <?xml version="1.0" encoding="utf-8"?>
  <MESSAGE ID="1" TIMESTAMP="1073648666934" SEND="true">Dies ist die erste Nachricht, die ich verschickt habe</MESSAGE>
  <MESSAGE ID="2" TIMESTAMP="1073648666955" SEND="false">Dies ist die erste Nachricht, die ich erhalten habe.</MESSAGE>
  <MESSAGE ID="3" TIMESTAMP="1073648666996" SEND="true">Dies ist die zweite Nachricht, die ich verschickt habe.</MESSAGE>
  

  Im Moment soll nur die bisherige Nachrichtenkommunikation in dieser Datei gespeichert werden. Diese soll man auslesen können mit Hilfe der Methode

  MessageObjectList readHistory(int buddyid);
  

  Eine neue Nachricht soll an das Ende der Datei angehängt werden, und zwar per Aufruf der Funktion

  boolean writeHistory(int buddyid, MessageObject m);
  

  Die Klassen MessageObject, MessageObjectList, MessageObjectParser sowie das Gerüst der zwei Methoden (in der Datei CryptFile.java) habe ich schon geschrieben. Beim Rest der Implementierung könnt ihr euch an die bestehenden Methoden der Klasse CryptFile anlehnen, die ich speziell gekennzeichnet habe, z.B. readKeys und writeKeys.

• Alexander und Oleg: Sprecht euch mit der Netzwerkgruppe ab, um die Nachrichtenübermittlung zwischen zwei Clients korrekt zu implementieren. Wäre schön, wenn das bis nächste Woche reibungslos funktioniert.
  Nächste Woche stellen wir dann im GUI die Methoden um, die den Lese-/Schreibzugriff auf Dateien regeln (für die Serverliste, Keys, etc.).

Aufgabe bis zum 18.12.

• Oliver/Philipp: Die Methoden

  boolean writeServer(String[] server);
  String[] readServer();
  String readKey(String verfahren, int buddyid);
  

  funktionieren soweit. Die Methode

  boolean writeKey(String verfahren, int buddyid, String key);
  

  muß noch angepasst werden. Falls zum ersten Mal ein Schlüssel für dieses Verfahren und diesen User angelegt wird, speichert man den Schlüssel wie gehabt in "$buddy_id.key". Falls aber schon ein Schlüssel existiert, muß dieser in der Datei "$buddy_id.old" abgelegt werden, um ihn nachher wieder rekonstruieren zu können. Dabei dürfen noch ältere Schlüssel natürlich nicht überschrieben werden. Am besten den zu speichernden Schlüssel ans Dateiende anfügen.

• Alexander/Oleg: Falls ein Buddy ausgewählt ist, muß mit Hilfe der Methode readKey(String verfahren, int buddyid) und der Methode CryptSystem.stringToKey(String k) der jeweilige Schlüssel im Objekt "CryptSystem" abgespeichert werden. Falls noch kein Schlüssel für dieses Verfahren und diesen Buddy existiert, soll automatisch ein Zufallsschlüssel erzeugt werden (CryptSystem.createKey()).

  Der Schlüsselbutton im Hauptfenster kann in das MessageWindow verlagert werden. Damit soll man dann später die erzeugten Schlüssel seinem Buddy schicken können.

  Wenn eine Nachricht verschickt wird, muß diese mindestens folgende Informationen enthalten:

  • den verschlüsselten Text,
  • welches Verfahren benutzt wurde,
  • wieviele zufällig erzeugte Characters angehängt wurden.

  Der letzte Wert wird nach dem Aufrufen der Methode encrypt in der Variable int attached der Klasse CryptSystem gespeichert. Die ist momentan noch als protected deklariert, das muß die Kryptographiegruppe dann noch ändern. Bzw. getter und setter Methoden definieren.
  Je nachdem, wie gut die Versendung von Nachrichten schon funktioniert, könnt ihr euch überlegen, wie man diese Informationen allesamt verschickt. Am besten mit der Netzwerkgruppe absprechen.

Aufgabe bis zum 11.12.

• Oliver und Philipp: Legt eine neue Klasse CryptFile an. Diese soll das Lesen und Schreiben von Dateien möglich machen. Benötigt werden die Methoden

  public String readKey(String verfahren, int buddyId);
  public boolean writeKey(String verfahren, int buddyId);
  public String readServer();
  public boolean writeServer(String Server);
  

  Die Schlüssel werden in der Datei "data/keys/" + verfahren + "/" + buddyId + ".key" abgelegt.

  Die Serverliste speichern wir in der Datei "data/server/serverlist.txt"

  Beschreibung der Methoden:

  • readKey: Liest den Schlüssel aus der Datei "data/keys/" + verfahren + "/" + buddyId + ".key" aus und gibt diesen zurück.
  • writeKey: Schreibt den Schlüssel in die Datei "data/keys/" + verfahren + "/" + buddyId + ".key" und liefert bei Erfolg ein "true" zurück.
  • readServer: Liest die erste Zeile aus der Datei "data/server/serverlist.txt" aus und gibt sie als String zurück.
  • writeServer: Schreibt den Parameter String in die Datei "data/server/serverlist.txt".

  Dabei ist zu beachten, daß man die entsprechenden Verzeichnisse neu anlegen muß, falls diese noch nicht existieren. Das Überprüfen, ob Verzeichnisse existieren, und das anlegen neuer Verzeichnisse, bewältigt man mit der Klasse "File" in java.io.
  Zum Anlegen, Lesen und Schreiben von Dateien benutzt man die Klasse "FileReader" bzw. "FileWriter". Wie das genau geht, steht in Kapitel 18 im Javabuch beschrieben.

• Oleg und Alexander: Die Logik wann und welche Schlüssel erzeugt werden, müß ein wenig abgeändert werden. Das "Passwort" Feld kann durch einen Button ersetzt werden. Dieser ist nur bei Caesar und Vigenere aktiviert. Wird er gedrückt, erscheint ein Popup, in dem man einen neuen Schlüssel eingeben kann. Dieser wird mit Hilfe der Methode

  crypto.stringToKey(String k);
  

  im Objekt crypto der Klasse CryptSystem gespeichert. Zusätzlich soll es einen Button geben, der einen randomisierten Schlüssel erzeugt. Das geht mit der Methode

  crypto.createKey();
  

  Falls ein Buddy ausgewählt ist, sollte automatisch die Methode

  readKey(String verfahren, int buddyId);
  

  angesprochen werden. Diese wird im Moment von Oliver und Philipp implementiert. Außerdem brauchen wir noch einen Button, der einen erzeugten Schlüssel an einen Buddy schickt.

  Bei dem Connection-Dialog sollte man die Möglichkeit haben, einen neuen Server hinzuzufügen, aus mehreren bereits existierenden Servern auszuwählen, und einzelne Server aus der Liste zu streichen. Hierfür legt man am besten eine neue Klasse (z.B. "ServerObject") an, welche Namen und IP des Servers beinhaltet. Diese ganzen Operationen funktionieren natürlich erst, wenn das Lesen und Schreiben auf der Datei "server.txt" klappt.

  Je nachdem, wie weit die Client-Client Kommunikation schon ist, könnt ihr außerdem versuchen, die Nachrichtenübermittlung zu implementieren. Bei Fragen wendet euch an Pavel und David.

Aufgabe bis zum 4.12.

Die Aufgaben werden auf jeweils 2 Leute verteilt:

• Oleg und Alexander: Die Verbindung zum Server klappt mit der neuesten Version ja schon. Beseitigt noch den Fehler, dass sich das Programm beendet, falls es keinen laufenden Server auf der IP findet.
• Oliver und Philipp: Ihr sollt eine Methode für den neuen Schlüssel-Button schreiben. Diese soll den aktuell gespeicherten Schlüssel für das aktuell ausgewählte Verfahren in einer Datei speichern. Die Datei soll im Verzeichnis "keys/$verfahren/" unter dem Namen "$buddyid.key" angelegt werden. "$verfahren" ist natürlich das zum Schlüssel passende Verfahren und "$buddyid" die ID des Users, der gerade ausgählt ist. Den Schlüssel extrahiert man wie folgt:

  // crypto ist das aktuell ausgewählte CryptSystem-Objekt
  String key = crypto.keyToString();
  // in der Variablen key ist nun der Schluessel gespeichert
  // funktioniert momentan leider nur mit dem Verfahren Caesar...
  // bis Donnerstag ist die Methode keyToString auch fuer die
  // anderen Verfahren implementiert
  

Aufgabe bis zum 27.11.

Erweitert das GUI um eine Buddylist. Beim Anklicken eines Namens (werden zur Zeit noch statisch generiert) soll ein Dialogfenster geöffnet werden, mit dem man Nachrichten verschicken kann. Beim Design könnt ihr euch an ICQ halten.
Im Hauptfenster könnt ihr schon die Kryptographieprotokolle "Caesar" und "Vigenere" benutzen, um Nachrichten zu ver- und entschlüsseln. Dies erreicht man so:

/* im stringarray "verfahren"  der klasse "Kryptosystem" sind die
 *  angebotenen verfahren aufgelistet. im moment
 * funktionieren die verfahren Caesar und vigenere
 * ... hier wird der schluessel automatisch erzeugt
 * falls man einen schluessel mitgeben moechte, geht das so:
 * Kryptosystem k = Kryptosystem.neu("Caesar", "T");
 */
Kryptosystem k = Kryptosystem.neu(Kryptosystem.verfahren[0]);

/* klartext string */
k.klartext = "abc";

// testoutput
System.out.println("Klartext: " + k.klartext);
System.out.println("Schluessel: " + k.schluessel);

// verschluesseln
k.verschluesseln();
System.out.println("Chiffretext: " + k.chiffretext);

// entschluesseln
k.entschluesseln();
System.out.println("Klartext: " + k.klartext); 

Die .java Dateien kann man sich unten herunterladen.

Außerdem könnt ihr euch das Programm CrypTool installieren und dessen Fähigkeiten schon einmal ausprobieren.

Aufgabe bis zum 20.11.

Ihr sollt das bereits bestehende GUI folgendermaßen erweitern:

• Eine Menüleiste mit den drei Menüs "File", "Connections" und "Protocol" wird hinzugefügt.
• Im Menü "File" existiert lediglich ein MenuItem "Quit". Damit soll das Programm beendet werden. Implementiert auch direkt die Kürzel, mit denen die Einträge per Tastatur angesprochen werden können.
• Im Menü "Connections" gibt es einen Eintrag "New Server". Wird dieser ausgewählt (per Maus oder Tastaturkürzel), so öffnet sich ein neues Fenster mit drei Textfeldern und einem Button. Im ersten Fenster soll die Server IP eingegeben werden, im zweiten der Benutzername und im dritten das Passwort. Bei der Passworteingabe werden im GUI nur Sternchen angezeigt. Der Button bekommt das Label "Connect to Server". Nächste Woche stellen Pavel und David dann die Methoden vor, die für einen Verbindungsaufbau nötig sind.
• Das Menü "Protocols" enthält die drei Einträge "Caesar", "Vigenère" und "Hill". Es darf jeweils nur ein Eintrag selektiert sein, beim Programmstart ist dies "Caesar".
• Im Hauptfenster gibt es zwei Textfelder "Plain Text" und "Chiffre Text", ein Textfeld für die Schlüsseleingabe und zusätzlich zwei Buttons "encrypt" und "decrypt". Wird "encrypt" ausgelöst, so wird der Inhalt des Feldes "Plain Text" in das Feld "Chiffre Text" kopiert. Beim Button "decrypt" entsprechend umgekehrt.
• Oleg und Alexander sollten über die keyEvents sicherstellen, dass nur die Characters eingegeben werden dürfen, die erlaubt sind. Die erlaubten ASCII-Codes sind 10 für Zeilenumbruch und 32 bis 126. Ich habe Philipp und Oliver aussen vor gelassen, damit diese Aufgabe nicht doppelt bearbeitet wird. In Zukunft sollten wir uns überlegen, wie man grundsätzlich die Aufgaben besser verteilen kann.

Ich habe extra kein Bild eingefügt, laßt also eurer künstlerischen Freiheit freien Lauf :-)

Die Gruppe Kryptographie wird in 1-2 Wochen die ersten Verschlüsselungsmethoden implementiert haben. Diese werden in etwa so aussehen:

public class Caesar{

	/* verschluesselt einen klartext, schluessel ist ein character */
	public String verschluesseln(String klartext, String schluessel);

	/* entschluesselt einen klartext, schluessel ist ein character
	(string der laenge 1) */
	public String entschluesseln(String chiffretext, String schluessel);

	/* erzeugt einen randomisierten schluessel */
	public String schluesselErzeugen();

	/* erzeugt den schluessel, der als parameter uebergeben wird */
	public String schluesselErzeugen(String schluessel);

}

Diese Methoden werden wir nächste Woche in das GUI integrieren, um eine wirkliche Verschlüsselung durchzuführen.

Viel Spass beim Programmieren!

Aufgabe bis zum 13.11.

Wir wollen eine einfache Swing Oberfläche erstellen. Das Fenster soll zwei Eingabefelder und einen Button enthalten. Im ersten Eingabefeld soll man einen Text eingeben können, im zweiten nur einen einzelnen Charakter. Bei Betätigung des Buttons soll eine Funktion aufgerufen werden, die die Argumente der zwei Textfelder auf der Konsole ausgibt (per System.out.println).
Am besten auch direkt javadoc-konform alles dokumentieren :) Wie das geht steht auf der Hauptseite beschrieben.

Zurück zur Hauptseite