ITflow.de

Da mein Verschlüsselungtool im Moment nur auf Java basiert, aber ich auch eine Windowsimplementation wollte,
habe ich nun angefangen in C# das ganze Tool nochmal neu zu programmieren.
Die Dateiverschlüsselung ist noch nicht implementiert und Multithreading Support auch noch nicht.
Leider hab ich noch ein paar Problemchen wenn die Parameter zu Hoch sind,
das sollte sich aber beheben lassen.

Hier ein Screenshot der aktuellen Version:

Da ich mehrmals gefragt wurde auf was die Verschlüsselung basiert, hier die Antwort.

Auf Elliptische Kurven. Hierzu gibt es ein sehr gutes Buch Rational Points on Elliptic Curves von Joseph H. Silverman und John Tate . Das Buch ist leider nicht ganz einfach zu verstehen,
deshalb sind gute Grundkenntnisse in Mathematik wohl unumgänglich.

Die Datenbanktabelle sieht so aus:

Und der Java-Code welcher den Baum in einem JPanel darstellt, sieht so aus:

import java.awt.*;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

import javax.swing.*;
import javax.swing.tree.*;

import de.logger.Logger;

/**
* This Class generates a JTree structure out of a Database Table.
*/
public class Tree extends JPanel{

	private JTree tree = null;

	public Tree() {
	      setLayout(new BorderLayout());  

	      DefaultMutableTreeNode root = new DefaultMutableTreeNode("RootNode");
	      this.add(root,1);
	      this.tree = new JTree(root);
	      this.add(new JScrollPane(tree));

	 }

     /**
	 * Select the nodes which has the given ID as parent.
	 * @param parentId
	 * @return ArrayList with an ArrayLists
     *  of nodes (DefaultMutableTreeNode) and
	 *  an ArrayList of ID´s (Integer)
	 */
	private ArrayList<ArrayList> getChields(int parentId){
		ResultSet rs = DBQuery.select("select name,id from tree where parent = "+parentId);

		ArrayList<DefaultMutableTreeNode> nodes = new ArrayList<DefaultMutableTreeNode>();
		ArrayList<Integer> ids = new ArrayList<Integer>();
		try {
			while(rs.next()){
				String nodeName = rs.getString("name");

				DefaultMutableTreeNode node = new DefaultMutableTreeNode(nodeName);
				Integer id = Integer.valueOf(rs.getString("id")).intValue();

				nodes.add(node);
				ids.add(id);

			}
		} catch (NumberFormatException e) {
			Logger.log(this, e.getMessage());
		} catch (SQLException e) {
			Logger.log(this, e.getMessage());
		}

		ArrayList<ArrayList> array = new ArrayList<ArrayList>();

		array.add(nodes);
		array.add(ids);

		return array;
	}

     /**
	 * Searches recursiv the chield nodes of the given ID and
     * add them to the given node
	 * @param node The node where the found chield nodes should be added
	 * @param id The  id of the root node.
	 */
	private void add(DefaultMutableTreeNode node, int id){

		ArrayList<ArrayList> list = this.getChields(id);
		ArrayList<DefaultMutableTreeNode> nodes = list.get(0);

		for (DefaultMutableTreeNode defaultMutableTreeNode : nodes) {
			node.add(defaultMutableTreeNode);
		}

		ArrayList<Integer> ids = list.get(1);
		int current = 0;

		for (Integer integer : ids) {
			this.add(nodes.get(current), integer);
			current ++;
		}
	}

}

Sollte nur ein kurzes Beispiel sein, für die, die vielleicht eine Anregung suchen, wie man eine Baumstruktur in Java aus einer DB Tabelle machen könnte.

Da ich mich gerade mit Verschlüsselungen und Verschlüsselungsverfahren beschäftige, habe ich eine kleinen Algorythmus entwickelt, mit dem man Texte verschlüsseln kann. Dieser basiert nicht auf einem vorgefertigten RSA Packet, sondern ist komplett selbst enwickelt. Ich verwende auch keinen Schlüssel (diese unhandlichen random Zeichenkette) im eigentlichen Sinn, sondern der Algrythmus braucht lediglich nur 3 Parameter. Dabei ist der Output wieder komplett entschlüsselbar (also keine einmal Hashes zum Passwort überprüfen). Ob er sicher ist, kann ich nicht sagen. Jedenfalls kommt sieht der Output bei einem kurzen Satz so aus:

1-8208594559064800739623273309071596298502425718925022691059203131
923231328983912310429703532974984723103784660114174251194981393423
18758092129168959506311993600000000000000000000000000000000000000-
110588010031845232186591320969436783465935457602184333476769819971
743533182144374182177950374801877519592654448760403106376832661395
7215763007352626001559213600000000000000000000000000000000000000-1
231289183859720110943490996360739444775363857838753403658880469788
484699347586846564455529946247708465567699017126137679247209013478
137138193753439259467990400000000000000000000000000000000000000-12
312891838597201109434909963607394447753638578387534036588804697884
846993475868465644555299462477084655676990171261376792472090134781
37138193753439259467990400000000000000000000000000000000000000-126
549166118915678069192130181520442935245729833427433153829381617149
816321835314785791262800031014481183346843426853039255963148607475
2058699135479238897656800000000000000000000000000000000000000

15-129388366398397600-151384388686125192

24-2741332262500-2659092294625-1206186195500

3-20471559019408598161167557369633785885927085204031410000000000000
00-1985741224882634021633253064854477230934927264791046770000000000
000-235422928723198878853426909750788537688161479846361215000000000
0000

12-15403305431081465625-16870286900708271875-17016985047670952500

4-50681193624325293855788601341644989432630705078125000-51188005560
568546794346487355061439326957012128906250-577765607317308349955990
05529475287953199003789062500

9-702799034490075913650000-648737570298531612600000-696792205135459
880200000-630717082234683512250000-654744399653147646050000-5826624
47397755244650000-696792205135459880200000-630717082234683512250000
-708805863844691947100000-606689764816219378450000

5-11661816443187755500712795166726170265888768-14021945961451944113
952289426658847581604352-159655820353165700307377552877798759592524
80-16104413183449757596222431420717092271941632

Wer das korrekt entschlüsselt, bekommt eine Packung Gummibären.
Kleiner Tipp: Der Satz besteht aus acht Wörtern.
Wird sich aber keiner die Mühe machen oder doch ?

Update 24.10.2009:

Da das Programm bisher nur Strings verschlüsseln konnte, hab ich das jetzt auf Files ausgeweitet. Leider war das Programm selbst bei einer kleinen Datei (500kb) schon mehrere Minuten beschäftig, je nach stärke der Verschlüsselung (lässt sich durch Parameter einstellen). Deshalb hab ich das Programm komplett Multicore fähig gemacht mit Threads und Concurrent Programming (java.util.concurrent) . Dabei hat die Geschwindigkeit um ca 30% zugenommen.  Leider hab ich noch Java Heap Probleme beim Verschlüsseln von Files welche > 50mb sind bei sehr starker Einstellung des Algorithmus. Das sollte sich aber durch temporäre Auslagerung von Zwischenergebnissen beheben lassen. (Dabei ist natürlich nicht zu vergessen, das temporär gespeicherte Zwischenergebnisse bei falscher Handhabung ein Sicherheitsrisiko sind. )

Im Moment, bin ich gerade an einer Überlegung zur Sicherheit meines Taskclusters dran. Mein Konzept ist, dass der Client sich auf dem Authentifizierungsserver einloggt und seine Tasks zum Zertifizieren dort hin schickt. Was das positive ist, dass alle Tasks, die nicht eine gültige Zertifizierung beinhalten und an den Cluster geschickt/weitergeleitet werden, einfach ignoriert werden. Dadurch fällt auch die Authentifizierung auf dem Cluster weg. Außerdem ist es nicht mehr von Bedeutung, wo der Task abgearbeitet wird, da man nicht mehr an die Authentifizierung auf einem Cluster gebunden ist. Mal schauen wann ich dazu komme, dass ganze in die Tat umzusetzen, da die Zeit dafür, neben dem Beruf und den anderen Hobbies nicht gerade üppig ist.

Durch Zufall hab ich Project Euler endeckt. Hierbei handelt es ich um eine Seite, welche im Moment ca. 250 “mathematische Augaben” beinhaltet, die dann mit einer beliebigen Programmiersprache gelöst werden können.
Generell sollten alle Algorythmen die gestellte Aufgabe in unter einer Minute lösen.
Wenn man sich registriert hat, kann man die Antwort eingeben und falls diese richtig ist, wird das vermerkt. Man kann sich verschiedene Statistiken anschauen, z.b. wieviele Leute ein Problem schon gelöst haben, bzw mit welcher Programmiersprache. Auch gibt es 6 Level die man erreichen kann. Level 6 (fast alle Aufgaben gelöst) haben z.b. im Moment nur < 100 Personen.

Hier mal die ersten 4 Lösungen in Java. Wer die Augaben noch nicht selber gelöst hat und noch lösen will, schaut bitte nicht hin

Augabe 1:

long time = System.currentTimeMillis();

int sum = 0;

		for (int i = 999; i > 0; i–) {
					if(i%3 == 0){
						sum += i;
					}
					else if(i%5 == 0){
						sum += i;
					}

		}

System.out.println("Euler1: "+(System.currentTimeMillis()-time)+" ms ->"+sum);

Aufgabe 2

long time = System.currentTimeMillis();
long sum = 0;

int last = 0;
int current = 1;
int next = 0;	

		while(true) {

			next = current + last;
			last = current;
			current = next;	

			if(current%2==0){
				if(current < 4000000){
					sum += current;
				}else{
					break;
				}
			}

		}

System.out.println("Euler2: "+(System.currentTimeMillis()-time)+" ms ->"+sum);

Aufgabe 3:

long time = System.currentTimeMillis();
long erg = Long.valueOf("600851475143");
ArrayList<Long> primes = new ArrayList<Long>();	

		for(long xt = 0; xt < 100000; xt++){

			if(!(xt%2 == 0)){

				boolean prime = true;

				for(long back = ((xt-1)/2); back > 1; back--){
					if(xt%back==0){
						prime = false;
					}
				}
				if(prime){
					if(erg % xt == 0){
						primes.add(xt);
					}
				}
			}
		}

System.out.println("Euler3: "+(System.currentTimeMillis()-time)+" ms ->"+primes.get(primes.size()-1));

Aufgabe 4:

long time = System.currentTimeMillis();
ArrayList<Integer> palindrome = new ArrayList<Integer>();

		for(int i = 100; i < 1000; i++){
			for(int v = 100; v < 1000; v++){

				int erg = i*v;

				String number = String.valueOf(erg);

				char[] chars = number.toCharArray();

				if(chars.length%2==0){

					boolean same = true;

					for(int x = 0; x < chars.length/2; x++){

						int y = (chars.length-1)-x;

							int ch1 = Integer.valueOf(String.valueOf(chars[x]));
							int ch2 = Integer.valueOf(String.valueOf(chars[y]));

							if(!(ch1 == ch2)){
								same = false;
							}
					}

					if(same){
						palindrome.add(Integer.valueOf(number));
					}
				}

			}
		}

		int finalNumber = 0;
		for (int i = 1; i < palindrome.size(); i++) {
			if(finalNumber < palindrome.get(i).intValue()){
				finalNumber = palindrome.get(i).intValue();
			}
		}

System.out.println("Euler4: "+(System.currentTimeMillis()-time)+" ms ->"+finalNumber);

Auf der Suche nach einer kostenlosen Alternative, zum lösen und darstellen von Funktionen, zu Mathematica bzw. www.wolframalpha.com, bin ich auf Maxima, a Computer Algebra System gestoßen. Hätte nicht gedacht, das es eine so super Alternative als Open-Source gibt.

Hier ein paar Beispiele:

@Schueler: Hausaufgaben lösen kann man damit, aber was bringt einem die Lösung, wenn man es nicht selbst rechnen kann

Der Anfang:

Die anfänglich Idee war eigentlich einen Webcrawler zu programmieren welcher Seiten indiziert.
Allerdings stellte ich schnell fest, das ein Rechner mit 2x 3Ghz und 4GB Ram schon mit dem parrallelen Scannen von mehreren hundert Seiten komplett ausgelastet war. Deshalb kam mir die Idee, den Webcrawler auf verschiedenen Hosts zu verteilen, da es bei der Anzahl der Webseiten welche es gibt, (weiß nicht genau wie viele) wohl nicht ausreicht ein paar hundert auf einmal zu Indexieren.
Da aber ein Clustersoftware, welche man nur für den Webcrawler programmiert, etwas sinnlos erschien, könnte man es so programmieren das man es später vielleicht auch für andere Aufgaben benutzen kann.

Das System:

So programmierte ich ein kleines Task basiertes Cluster System. Mir stellte sich sich
gleich die Frage wie definiert man einen Task (zu deutsch Aufgabe). Ein Task hat einen Startpunkt und einen Endpunkt an dem die Aufgabe erledigt ist. Wie ich das gelöst hab verrate ich noch nicht, es gibt aber eine simple Lösung wo genau die zwei Kriterien zutreffen.
Die Archietektur ist so aufgebaut, das es eine X Anzahl von Hosts gibt. Die Knotenserver, welche die Aufgaben an die Hosts zur Abarbeitung weitergeben,können Baumstrukturartig aufgebaut werden. Dabei ist es auch möglich, dass ein Host von mehreren Knotenservern Aufgaben erhält. Außerdem hab ich darauf geachtet, das sowohl die Clients als auch die Knotenserver, einen Puffer haben, in welchem Sie Aufgaben ablegen können, wenn gerade die maximale Anzahl der parallel abzuarbeitenden Aufgaben erreicht ist.

Theorie und Praxis:

Da ich leider nur 2 Rechner und 2 Server habe, konnte ich trotz einiger auf KVM virtualisierten Hosts noch nicht wirklich abschätzen wie skalierbar das ganze wirklich ist. Außerdem wurde beim Webcrawler Test, das ganze durch meine DSL-Anbindung limitiert. Jedenfalls klappte das Verteilen und Abarbeiten von Aufgaben mit 10 Hosts und 2 Knotenserver jedenfalls problemlos.

Monitoring:

Um etwas den Überblick zu haben, was auf welchem System gerade abgearbeitet wird, hab ich eine ziemlich einfache Webmonitoringoberfläche gemacht. Leider funktioniert der Serverseitige push/refresh noch nicht richtig, deshalb gibt es noch einen Refresh Button.

Anbei folgt ein Screenshot davon:

Zur Zukunft:

Leider ist das ganze alles noch ewtas rudimentär.Außerdem hab ich noch unzählige Ideen wie ich das ganze noch Verbessern und Ausbauen könnte.

Da ich das ganze privat Programmiere und ich neben dem Beruf nicht soviel vor dem Rechner sitzen will, gerade im Sommer bei schönem Wetter, wird sich zeigen wie sich das ganze weiter entwickelt. Wenn es etwas ausgereifter ist, gibt es das ganze evtl als Open Source.

Es gibt wieder mal einen kurzen Beitrag von mir.

Ich hab mich in den letzten Wochen mal so umgeschaut was es an neuen Frameworks gibt neben dem altbekannten wie MyFaces, Struts und Hibernate. Was mir besonders gut gefallen hat ist, das Google Web Toolkit. Für Anfänger gibt es ItMill welches teilweise auf dem GWT basiert,  aber sehr einfach zu konfigurieren und zu erlernen ist. Das Gute ist, man schreibt alles bis auf das CSS und custom Html in Java Code, ähnlich wie eine Swing Application.

Und noch was: Vor kurzem hat Google ihr Waves vorgestellt. War echt beindruckt als ich das gesehen hab. Chat und Email in einem. Ein wichtiger Schritt für mich ist , dass man das System später anscheinend selber Hosten darf, was es also auch für Leute/Unternehmen interresant macht, die ihre Daten/Email´s nicht bei Google lagern wollen.

Da ich bisher immer XP auf dem NC 10 hatte und das teilweise doch etwas zäh wirkte, hab ich nun einmal Ubuntu installiert.

Version

Ich habe mich für die Desktop Version entschieden.

Installation

Da dass NC10 kein CD laufwerk hat, muss man das Ubuntu auf einen USB Stick bekommen. Dazu lud ich mir die das Ubuntu ISO Image und Transformierte es mit Unetbootin auf den USB Stick. Da man nach dem Boot direkt auf dem Desktop landet, kann man auch gleich sehen welche Hartware funktioniert. Die Installation ansich war erstaunlicherweise in 15 Minuten abgeschlossen.

Hardware Kompatibilität

Von Beginn an wurde jede Hartware erkannt. WLan wurde problemlos erkannt. Die Funktionstasten funktinieren auch alle bis auf die des Wlan´s. 2 Probleme hab ich allerdings gefunden. Der Standby Modus tut nicht und der Ath5k Wlan Modul stürt manchmal ab, was sich aber durch einen Shutdown wieder beheben lässt. Einen Patch bzw. Tip der zur Lösung des Problems führt, konnte ich bisher nicht finden.

Geschwindigkeit

Eines der großen Pluspunkte von Ubuntu auf dem NC10, ist die Geschwindigkeit. Sowohl Boot als auch Reaktionszeit (z.b. beim Fensteröffnen) sind gefühlt 1/3 schneller als bei XP. Während man bei XP immer das Gefühl hatte, es ist alles etwas träge, geht es beim Ubuntu richtig zügig. So öffnet sich Firefox meiner Meinung nach fast doppelt so schnell wie unter XP

Ich werde nun vorestmal bei Ubuntu bleiben, da ich keine Nachteile sehe,  mal abgesehen von dem Open Office, mit welchem ich mich immernoch nicht richtig anfreunden kann. Mal schauen, ob es Microsoft schafft, mich mit Windows 7 wieder umzustimmen.

Aus aktuellem Anlass, sollte jeder Internetnutzer überlegen, ob er den DNS Server seines Providers (vorallem bei den großen) noch benutzen will. Es gibt mehrer unabhängige DNS Server welche nicht zensiert oder mit sonstigen Umleitungen versehen werden (manche enthalten leider Werbung bei Fehlerhafter URL Eingabe).

Hier ein paar Organisationen welche zur Zeit auf ihren Webseiten ( Zeitpunkt des Blogeintags) IP´s zu unabhängigen DNS Servern anbieten.

German Privacy Foundation

OpenDns

Chaos Computer Club

So ändert man unter XP den DNS Server:

Start

-> Systemsteuerungen

-> Netzwerkverbindungen

-> Netzwerk Adapter

-> LAN oder WLan etc..

-> Rechtsklick -> Eigenschaften

-> TCP / IP Einstellungen

-> Benutze folgenden DNS Server

-> dort die IP des DNS Servers eintragen.