Erster Ansatz

Was macht ein Passwort sicher? Bestimmt nicht die Hinzunahme von Sonderzeichen und Zahlen in Kombination mit Groß- und Kleinschreibung. Das ist mittlerweile ein Standard, den jeder bei einer Bruteforce-Attacke mit einplant. Doch wie verhelfen wir solchen Bruteforce-Attacken zu nicht mehr lohnenswerten Laufzeiten? Viele denken eben hier an eine Kombination von Klein- und Großschreibung sowie Zahlen und Sonderzeichen. Doch halt! Bevor wir unser Passwort unnötig kompliziert machen: Es gibt bessere Methoden!

Grundsicherheit

Die Basis eines jeden Passwortes bildet der Zeichensatz. Haben wir nur Kleinbuchstaben beläuft sich dieser auf 26 Zeichen. Bei Klein- und Großbuchstaben sind es bereits 52 Zeichen und so weiter. Mit der Wahl von Zahlen und Sonderzeichen erhöhen wir diese Basis nur minimal. Wichtig bei der Komplexität von Passwörtern ist der Exponent!

Dieser berechnet sich aus der Länge des Passwortes, also der Formel: Vefügbarer Zeichensatz (hoch) Länge des Passworts. Diese Gegebenheit gehen wir auch gleich noch an Hand eines Beispiels an. Aber erstmal zur erweiterten Sicherheit.

Erweiterte Sicherheit

Wenn wir unser Grundpasswort festgelegt haben, zum Beispiel eine Phrase oder einen ganzen Satz wie “IchHabeAm19.01.1999Geburtstag” und versehen ein solches Passwort noch am Anfang mit dem 2. und 4. Buchstaben, sowie am Ende mit dem 3. und 5. Buchstaben der Website, dann haben wir ein individuelles Passwort für jede Seite. Die ersten und letzten beiden Ziffern lassen sich erst dann entziffern, wenn man mindestens zwei Accounts gehackt hat. Ansonsten wäre dieser “Salt” nur geraten.

Das Ganze lässt sich natürlich nach Belieben ändern, wichtig ist nur, dass man Grundlage und den “Salt”, also die seitenspezifische Kombination geheim hält. Hat man einmal ein solches Verfahren entwickelt, braucht man sich keine Passwörter mehr merken. Ebenso kann das System so erweitert werden, dass man beispielsweise die Anzahl der Konsonanten der URL noch mit einbezieht. Es gibt genug Möglichkeiten, also seid kreativ!

Ein weiteres kreatives Beispiel wäre, aus jedem Passwort einen SHA512 Hash zu generieren. Damit kann das Passwort auch nicht mehr zurückgerechnet werden. Wenn diese Passwörter zu lang sind, kann mal alternativ auch SHA256 oder MD5 nutzen. Allerdings aufpassen bei MD5, dieser Algorithmus zur Berechnung von Hashes hat schon seit geraumer Zeit Schwachstellen. Mit Passwort-Managern lassen sich diese auch gut speichern und wenn man sich mal einloggen möchte, braucht man sein Passwort für die gewünschte Seite nur in einen üblichen Online-Hash-Generator eingeben.

Beispiel

Wir haben einen Zeichensatz von 26 Ziffern und eine Passwortlänge von 6 Zeichen. Zum Vergleich haben wir ein Passwort mit einem Zeichensatz von 52 Ziffern und einer Passwortlänge von ebenfalls 6 Zeichen. Zum Schluss nutzen wir einen Zeichensatz von 26 Zeichen bei einer Passwort Länge von 10 Zeichen. Dadurch erhalten wir folgende Rechnung:

26 ^ 5 = 11881376 Kombinationen
52 ^ 5 = 380204032 Kombinationen
26 ^ 10 = 141167095653376 Kombinationen

Fazit

Wir sehen also, dass eine Erhöhung der Basis durch das Hinzunehmen von Zahlen und Sonderzeichen zwar hilft, aber wir durch ein längeres Passwort eine wesentlich größere Anzahl an Kombinationen erreichen. Diese beiden Eigenschaften stehen in keinerlei Konkurrenz. Bevor ihr also das nächste Mal überlegt, welches Sonderzeichen ihr benutzen könnt, nutzt lieber 5 Zeichen mehr für das Passwort und lasst dem Bruteforce keine Chance!

• Motorola Xoom Tablet
• Nokia Lumia 800
• Xperia Pro
• Samsung Galaxy Tab 7.0
• HTC Radar
• DELL Streak 7
• BlackBerry Curve 9360
• Feature-Phone XCover 2
• AM405 SlimPack Akku
• Bluetooth Headset HS3000

Weiteres könnt ihr hier in Erfahrung bringen. Viel Spaß an alle, die mitmachen!

Die Installation

Eigentlich ist es mit Windows 8 ein Kinderspiel das System selbst aufzusetzen – und das nicht nur für den ambitionierten Windows Tüftler! DVD einlegen, auf den Installationsbildschirm warten und installieren klicken – schon kann es losgehen! Nach der Eingabe der Seriennummer DNJXJ-7XBW8-2378T-X22TX-BKG7J kam man dann auch schon zum Installationsprogress.

Der Windows 8 Installationsvorgang

Dieser brauchte in meiner virtuellen Maschine nicht wirklich lang und kurz darauf gelangt ihr zum Konfigurationsmenü. Dort können nochmal diverse Einstellungen vorgenommen werden, oder aber ihr nutzt den von Windows vorgeschlagenen Standard.

Metro UI

Ja, die Metro UI. Wohl die umstrittenste Neuerung an Windows 8. Diese ersetzt quasi euer Startmenü. Ihr findet hier alle installierten Anwendungen, ähnlich wie bei Windows Mobile als Kacheln angeordnet. Diese könnt ihr natürlich nach belieben sortieren und in der Größe anpassen.

Die neue Metro UI

Fangt ihr in diesem Bildschirm an zu tippen, so öffnet sich eine Suchseite, die euch, ähnlich wie bei der Suche im Startmenü, alle Programme, Funktionen, Einstellungen usw. anzeigt, die zu eurem Suchbegriff passen.

Es gibt auch hier Kritiker, die sich gerade erst mit dem aufgemotzten Windows 7 Startmenü angefreundet haben und nun Gruppierungen u.ä. vermissen. Aber wie bei allem Neuen gilt auch hier, dass man sich mit der Zeit daran gewöhnt und die alten Features vermutlich garnicht mehr vermisst. Auch wenn der Schritt, das Startmenü aus Windows zu verbannen, ein sehr radikaler ist.

Der Windows Store

Er wurde groß und breit angekündigt und auch schon auf der Build Konferenz gezeigt. Richtig nutzen, Erfahrungen sammeln und ausprobieren kann man ihn aber erst mit der Consumer Preview. Ich muss sagen, ich finde den Store sehr schön schlicht, mit Blick auf das Wesentliche – Die Apps.

Der Windows Store mit den ersten Apps

Neben den Apps der Gewinner des Microsoft App-Contest, gibt es auch schon professionelle Applikationen im Store. Und das laut Microsoft im Rahmen der Consumer Preview vorläufig kostenfrei! Da freut sich doch bestimmt der ein oder andere Beta-Tester.

Die Apps

Neben den Programmen, die ihr aus dem Store herunterladen könnt, vermittel uns die Consumer Preview auch schon einen ersten Eindruck, wie Mail, Kalender, Messenger, Reader und SkyDrive auf dem kommenden Windows wohl aussehen könnten. Zwar sind die Apps ganz klar mit “APP-VORSCHAU” gekennzeichnet, aber vielleicht wird das ein oder andere ja doch übernommen. Allerdings sind die Apps aus der Developer Preview auch verschwunden oder wurden optisch überarbeitet.

Der Desktop

Bevor jetzt die ersten schreien “Metro UI? Ich will meinen Desktop” – ich kann euch beruhigen, vom Desktop hat sich Microsoft nicht verabschiedet. Diesen könnt ihr in der Metro UI starten und habt anschließend den gewohnten Windows Desktop vor euch. Gewohnt? Naja, fast. Wie ich ja schon sagte, gibt es kein Startmenü mehr. Die untere linke Ecke hat in der Developer Preview noch ein neues Menü hervorgerufen, mit welchem man den PC herunterfahren oder Einstellungen vornehmen konnte. Doch auch dieses ist in dem neuen Release verschwunden. Stattdessen zeigt sich nur die Metro UI nach einem Klick.

Die Ribbob-Bar die seit der Developer Preview die klassische Datei-Leiste abgelöst hat, wurde auch nochmal etwas überarbeitet. So sind die Bedienungsmöglichkeiten erstmal zugeklappt und erst nach einem Klick auf den gewünschten Tab öffnet sich dann das bereits aus Word und Co. bekannte Ribbon.

Die neue Ribbon Menü Leiste

Wählt man ein Laufwerk, ein Verzeichnis oder eine Datei, so erscheinen die Standard Funktionen im Ribbon. Spezielle Funktionalitäten, zum Beispiel das Freigabe oder Datenträger Menü erscheinen erst bei einem Klick auf ein Verzeichnis bzw. zweiteres nach einem Klick auf ein Laufwerk. Dort sind Funktionen untergebracht, die nur für das aktuell gewählte Element gedacht sind. Diese Funktionen haben auch Fotos, Video und Audio Dateien.

Mein Résumé

Vielleicht ist es an dieser Stelle noch ein wenig zu früh zu sagen, wie viel Potential in dem neuen Betriebssystem aus dem Hause Kleinweich steckt, aber in meinen Augen sind die Redmonder auf dem richtigen Weg. Es scheint als werde endlich das lang ersehnte All-In-One Windows entwickelt, welches auf allen Geräten lauffähig ist und ein einheitliches Design mit sich bringt. Ich konnte zwar noch nicht alles testen, dazu muss ich das OS von meiner VirtualBox auf mein Produktivgerät übertragen (dann wird es auch noch ein Update des Berichtes geben), aber ich fühle mich auf Anhieb wohl – und das ist bei der Vielfalt an Betriebssystemen und Arbeitsumgebungen heutzutage garnicht mal so leicht!

Also viel Spaß beim Testen in einer virtuellen Maschine oder auf einem Echt-Gerät. Ich habe bisher privat übrigens die Windows Developer Preview genutzt und konnte bis auf ein paar Unverträglichkeiten mit meinen HDMI Treibern und einigen Abstürzen im Firefox keine größeren Probleme feststellen und werde daher nun auch die Consumer Preview im Echtbetrieb einsetzen!

Download Windows 8 Server Beta 64 Bit (ISO)
Download Windows 8 Server Beta 64 Bit (VHD, english)
Download Windows 8 Consumer Preview 32 Bit (ISO, deutsch)
Download Windows 8 Consumer Preview 64 Bit (ISO, deutsch)

Wer noch eine Seriennummer braucht, kann diese hier benutzen, solange die Consumer Preview gültig ist: DNJXJ-7XBW8-2378T-X22TX-BKG7J

Nun zeige ich, wie wir mit Hilfe eines Buffers den Upload steuern können und somit die Datei Stück für Stück hochladen. Als erstes brauchen wir eine Funktion, die den Upload-Vorgang mit einem Buffer bereitstellt. Dieser übergeben wir die Adresse zum FTP, sowie den Pfad zur Datei, die wir hochladen möchten.

public void BufferedUpload(string ftpAddress, string file) { }

Der Anfang

Was wir nun noch brauchen, ist ein FtpWebRequest, eine WebResponse und einen Stream. Der FtpRequestStream dient dazu, eine parameterisierte Verbindung zu unserem FTP aufzubauen und liefert uns eine WebResponse zurück, welche wir zur Auswertung nutzen könnten. Ich habe hier allerdings darauf verzichtet. Der Stream ist letztenendes das Objekt, welches wir mit der Funktion GetRequestStream() aus der Klasse FtpWebRequest befüllen.

FtpWebRequest ftpRequest = (FtpWebRequest)WebRequest.Create(new Uri(ftpAddress));
ftpRequest.Method = WebRequestMethods.Ftp.UploadFile;
ftpRequest.Credentials = new NetworkCredential("username", "password");

// Verbindung herstellen
WebResponse ftpResponse = ftpRequest.GetResponse();

// Datei einlesen
byte[] fileContents = File.ReadAllBytes(file);

// Stream zum FTP aufbauen
Stream ftpRequestStream = ftpRequest.GetRequestStream();

Der Buffer

Soweit, so gut! Nun haben wir einen offenen Stream, mit dem wir die Daten nun schon schreiben könnten. Aber wir wollten ja noch einen Buffer implementieren. Dazu brauchen wir neben einer Variable für den Buffer auch noch eine für die aktuelle Position an der sich der Stream gerade befindet. Für den Buffer nutze ich üblicherweise 64 KB. Ich habe die Erfahrung gemacht, dass die Upload-Geschwindigkeit hier noch sehr gut ist und wir genug Rückmeldungen für größere Dateien abfangen können.

int position = 0;
int buffer = 65536;

Weiter geht’s. Der Buffer hat seinen Initialwert erhalten und wir können nun mit Hilfe einer While-Schleife unsere Daten Stück für Stück in die Stream schieben. hierbei müssen wir aber daran denken, dass wir auch die aktuelle Position im Stream erhöhen, da wir unsere Daten sonst immer wieder an die gleiche Stelle schreiben würden:

while (position != fileContents.Length)
{
    ftpRequestStream.Write(fileContents, position, buffer);
    position += buffer;
}

Im Großen und Ganzen wäre es das schon gewesen, oder? Nicht ganz! Was viele Leute bei einem gepufferten Stream vergessen ist, dass das letzte Stück bei einer Dateiübertragung auch kleiner sein kann, also die von uns angegeben 64 KB. Daraus würde folgen, dass wir über das eigentlich Ende der Datei hinausschreiben könnten. Daher müssen wir noch eine kleine Abfrage in unsere While-Schleife integrieren:

while (position != fileContents.Length)
{
    // Prüfen, ob Rest kleiner ist als der Buffer
    if (buffer > fileContents.Length - position)
        buffer = fileContents.Length - position;

    ftpRequestStream.Write(fileContents, position, buffer);
    position += buffer;
}

Das Fazit

Nun haben wir alle Bestandteile unseren gepufferten FTP Uploads zusammen. Durch die While-Schleife haben wir nun die Möglichkeit nach jedem Upload eines Teilstückes Informationen zum Gesamt-Upload auszuwerten. So können wir eine Prozentangabe zeigen oder mit Hilfe der StopWatch-Klasse die aktuelle Upload-Geschwindigkeit ermitteln. Verlagern wir diese Methode nun in einen eigenen Thread, können wir die nach jedem Durchlauf der Schleife unsere GUI mit Informationen aufwerten, ohne dass diese regungslos stehen bleibt und wartet, bis der gesamte Upload fertig ist.

Hier nochmal die gesamte Methode:

///
<summary> /// Lädt eine Datei mit Hilfe eines Buffers hoch. /// </summary>

///FTP Adresse
///Dateiname inklusive Pfad
public void BufferedUpload(string ftpAddress, string file)
{
    // ftpAddress = @"ftp://meinserver.de/pfad/datei.zip";
    // file = @"C:\test.zip";

    int position = 0;
    int buffer = 65536;

    try
    {
        FtpWebRequest ftpRequest = (FtpWebRequest)WebRequest.Create(new Uri(ftpAddress));
        ftpRequest.Method = WebRequestMethods.Ftp.UploadFile;
        ftpRequest.Credentials = new NetworkCredential("username", "password");

        // Verbindung herstellen
        WebResponse ftpResponse = ftpRequest.GetResponse();

        // Datei einlesen
        byte[] fileContents = File.ReadAllBytes(file);

        // Stream zum FTP aufbauen
        Stream ftpRequestStream = ftpRequest.GetRequestStream();

        while (position != fileContents.Length)
        {
            // Prüfen, ob Rest kleiner ist als der Buffer
            if (buffer > fileContents.Length - position)
                buffer = fileContents.Length - position;

            ftpRequestStream.Write(fileContents, position, buffer);
            position += buffer;
        }

        // Verbindungen schließen
        ftpRequestStream.Close();
        ftpResponse.Close();
        ftpRequest.Abort();
    }

    catch (WebException webEx)
    {
        Console.WriteLine("Es ist ein Fehler aufgetreten: " + webEx.Message);
    }
}

Wie immer wünsche ich viel Spaß beim Ausprobieren. Den Code könnt ihr natürlich frei benutzen und verändern!

Es ist oft das gleiche Bild: Man surft auf einen Blog, um eine Meinung einzuholen, eine Antwort auf eine Frage zu finden oder sich einfach über die neusten Trends zu informieren. Leider stolpere ich, neben den unverhältnismäßig langen Ladezeiten durch externe Werbung auch immer wieder über ein AdvertismentOverflow. Soll heißen, dass ich auf einen Blick mehr Shopping-Angebote, Fernstudiengänge oder GoogleAds sehe, als das, weswegen ich eigentlich diesen Blog angesurft habe. Schlimmer noch: Ich sehe nicht mehr das, was als Grundprinzip der Blogs gedacht war.

Natürlich muss und soll es jedem einzelnen möglich sein, seinen Blog und damit auch seine Arbeit die er dort hinein gesteckt hat zu monetarisieren. Das darf aber nicht Hauptaugenmerk werden. Zu den Anfängen der Blogs, habe ich hier auch mal ein GoogleAd platziert, bin aber mittlerweile ohne Werbung glücklich – und ich hoffe meine Leser auch…

Langsam aber sicher wird der Aufschrei laut, sich lieber wieder auf den Inhalt zu besinnen und auf übermäßige Werbung zu verzichten. Im Web lassen sich auch Alternativ-Konzepte finden, darunter natürlich auch die alten Bekannten PayPal und Flattr. Ein gesunder Mittelweg, wodurch sich der Aufwand für den Blog lohnt, die Leser aber gleichzeitig nicht verstimmt werden ist hier genau die richtige Lösung. Doch diesen korrekt einzuschlagen, ist nicht ganz so leicht.

Ich für meinen Teil habe dieses Problem momentan zum Glück nicht – kann aber trotzdem zu einer Maßnahme raten: Schaltet ein A/B Testing und testet parallel, wo sich Werbung am ehesten auszahlt. Vielleicht erhaltet ihr diese Erkenntnis auch schon aus bisherigen Erfahrungen durch Werbung. Wie auch immer: Sucht euch den besten Platz und den besten Inhalt für eure Werbung und beschränkt euch darauf. Das hat den Vorteil, dass eure Besucher wirklich Inhalts-abhängige und gut platzierte Werbung erhalten, ohne dass sie den Überblick über Commercial und Content verlieren!

Die Fassade sollte also immer dann genutzt werden, wenn ein Untersystem viele Klassen enthält, die aber einzeln selten bzw. garnicht verwendet werden. Statt nun für eine gewisse Funktionalität sehr viele kleine Klassen ansprechen zu müssen, verwendet man eine Fassade, die diese Klassen vereint und Funktionalitäten weiter deligiert. Somit kann eine Fassade die Komplexität einer Implementierung erheblich senken, da das benutzte Untersystem nicht direkt sichtbar ist.

Um die Fassade korrekt zu implementieren benötigen wir als allererstes Subklassen. Diese Klassen enthalten jeweils Teil-Strukturen unserer Fassade, hier am Beispiel eines Kunden. Ein Kunde hat bei einer Bank ein Konto, ein Darlehen und eventuell eine Kreditkarte. Nun möchte er eine Hypothek abschließen. Dazu müssen wir prüfen, ob der Kunde kreditwürdig für eine solche Hypothek ist. Zuerst erstellen wir also unseren Kunden. Dazu dient folgende, sehr vereinfachte Klasse:

class Kunde
{
    public string Name { get; set; }
}

Diese dient nur der Veranschaulichung, denn die wichtigen Subklassen erstellen wir jetzt. Dazu gehören die Klassen Konto, Darlehen und Kreditkarte, welche später in der Fassade vereint werden:

class Konto
{
    public bool HatGenugGuthaben(Kunde k, int betrag)
    {
        Console.WriteLine(string.Format("Prüfe Guthaben für Kunde {0} {1}", k.Name));
        return true;
    }
}

class Darlehen
{
    public bool HatDarlehen(Kunde k)
    {
        Console.WriteLine(string.Format("Prüfe Darlehen für Kunde {0} {1}", k.Name));
        return false;
    }
}

class Kreditkarte
{
    public bool HatNichtUeberzogen(Kunde k)
    {
        Console.WriteLine(string.Format("Prüfe Dispo für Kunden {0} {1}", k.Name));
        return true;
    }
}

Nun stellen wir uns die Klasse Hypothek zusammen, welche aus den 3 Subklassen Konto, Darlehen und Kreditkarte besteht, auf die wir aber später von außen nicht mehr zugreifen möchten / brauchen.

class Hypothek
{
    private Konto _konto = new Konto();
    private Darlehen _darlehen = new Darlehen();
    private Kreditkarte _kreditkarte = new Kreditkarte();

    public bool IstGeeignet(Kunde k, int betrag)
    {
        Console.WriteLine("{0} möchte ein Darlehen über {1:C} haben", k.Name, betrag);

        bool geeignet = true;

        // Prüfe kreditwürdigkeit des Kunden
        if (!_konto.HatGenugGuthaben(k, betrag))
        {
            geeignet = false;
        }
        else if (_darlehen.HatDarlehen(k))
        {
            geeignet = false;
        }
        else if (!_kreditkarte.HatNichtUeberzogen(k))
        {
            geeignet = false;
        }

        return geeignet;
    }
}

Diese Fassade kann nun dazu benutzt werden, um die kreditwürdigkeit des Kunden zu prüfen, ohne dabei selbst auf die Subklassen zugreifen zu müssen. Das bietet den immensen Vorteil, dass die Prüfung nun in den jeweiligen Subklassen erweitert werden kann, ohne dass die Fassade oder die explizite Prüfung des Kunden an mehreren Stellen geändert werden muss. So können wir nun prüfen:

static void Main()
{
    var k = new Kunde { Name = "Max Mustermann" };
    var h = new Hypothek();

    bool geeignet = h.IstGeeignet(k, 250000);
    Console.WriteLine(k.Name + " wurde " + (geeignet ? "angenommen" : "abgelehnt"));
}

Und wie immer dürft ihr den Code verwenden und ändern wie ihr lustig seid!

In den meisten Fällen kommt immer dann ein Prototype zum Einsatz, wenn das Erzeugen neuer Instanzen von Klassen sehr kostspielig ist, die Instanzen sich aber grundsätzlich sehr ähnlich sind. Es gibt hier noch eine Reihe von anderen Gründen die ich gerne zitieren möchte:

“Ein Prototyp findet Anwendung, wenn die Erzeugung weiterer Instanzen einer Klasse teuer ist und sich die Objekte ähneln, die zu instanziierenden Klassen erst zur Laufzeit bekannt sind, eine Hierarchie von Fabriken parallel zu einer Hierarchie von Produkten vermieden werden soll oder wenn die Objekte einer Klasse nur wenige Zustandskombinationen annehmen können; oder wenn die Bearbeitung von Vorlagen sehr ähnlich oder gleich der von Objekten ist.” – Quelle: wikipedia.de

Um den Prototype in Aktion sehen zu können, benötigen wir zuerst ein passendes Beispiel, welches wir uns überlegen müssen. Im Internet bin ich häufig über einen Farbenmanager gestolpert, der entweder nicht korrekt implementiert oder schlecht kommentiert wurde, daher möchte in an einem solchen Beispiel einmal die Funktionsweise des Prototypes erklären.

Als Erstes brauchen wir hier eine Klasse, welche von ICloneable abgeleitet ist, damit wir die Clone() Methoden nutzen können. Die Klasse enthält die Grundbausteine einer jeden Farbe, die RGB Werte, sowie die oben bereits genannte Methode.

class Farbe : ICloneable
{
    // Roten Anteil der Farbe holen oder setzen
    public byte R { get; set; }

    // Grünen Anteil der Farbe holen oder setzen
    public byte G { get; set; }

    // Blauen Anteil der Farbe holen oder setzen
    public byte B { get; set; }

    // Die Clone() Methode
    public object Clone()
    {
        return this.MemberwiseClone();
    }
}

Das ist nun zunächst unsere Basis-Klasse, welche die grundlegenden Farbeigenschaften enthält, die wir für jede neue Farbe brauchen. Als Nächstes definieren wir uns eine ENUM, welche bestimmte Farben bereits enthält. Hier einmal die Basis-Farben rot, grün, blau sowie eigene, selbst zu definierene Farben.

enum FarbTyp
{
    Rot,
    Gruen,
    Blau,
    Eigene1,
    Eigene2,
    Eigene3
}

Um das Ganze nun einfacher und sauberer handhaben zu können, basteln wir uns noch eine FarbManager Klasse, welche mit Hilfe eines Dictionary unsere Farbtypen und unsere Farben beinhaltet.

class FarbManager
{
    private Dictionary<FarbTyp, Farbe> _farben = new Dictionary<FarbTyp, Farbe>();

    // Holt oder setzt die Farbe
    public Farbe this[FarbTyp typ]
    {
        get { return _farben[typ]; }
        set { _farben.Add(typ, value); }
    }
}

(Achtung, an dieser Stelle werden < als &lt; und > als &gt; dargestellt!)

Und schon steht unser Grundgerüst für den Prototype! Jetzt können wir in der Main() Methode unseren FarbManager initialisieren und unsere Farbe hinzufügen. Zum Schluss sehen wir, wie wir mit der Clone() Methode einzelne Farben kopieren können.

static void Main()
{
    var farbmanager = new FarbManager();

    // Standardfarben
    farbmanager[FarbTyp.Rot] = new Farbe { R = 255, G = 0, B = 0 };
    farbmanager[FarbTyp.Gruen] = new Farbe { R = 0, G = 255, B = 0 };
    farbmanager[FarbTyp.Blau] = new Farbe { R = 0, G = 0, B = 255 };

    // Eigene Farben
    farbmanager[FarbTyp.Eigene1] = new Farbe { R = 54, G = 90, B = 20 };
    farbmanager[FarbTyp.Eigene2] = new Farbe { R = 128, G = 128, B = 128 };
    farbmanager[FarbTyp.Eigene3] = new Farbe { R = 80, G = 120, B = 230 };

    // Farben aus dem FarbManager benutzen
    var farbe1 = farbmanager[FarbTyp.Rot].Clone() as Farbe;
    var farbe2 = farbmanager[FarbTyp.Eigene2].Clone() as Farbe;
}

Hier haben wir nun in den Objekten farbe1 und farbe2 die Eigenschaften R, G und B. In diesen sind die vorher durch den FarbManager festgelegten Bytes gespeichert, die unsere eigentlichen Farben darstellen. Möchte ich nun im späteren Verlauf meiner Anwendung eine Farbe benutzen, so muss ich diese nicht immer komplett neu implementieren, sondern kann über die Clone() Methode des FarbManagers mir meine Objekte jederzeit definieren. Zusätzlich hat diese Vorgehensweise den Vorteil, dass ich Farben und deren Eigenschaften, zentral an einer Stelle definieren kann ohne jederzeit im gesamten Quellcode nach neuen Farben suchen zu müssen.

Wie immer an dieser Stelle wünsche ich viel Spaß beim Testen und Tüfteln!

Nachdem die LulzSec Mitglieder nun zu Anonymous abgewandert sind, besteht wohl erstmal keine größere Gefahr mehr für den normalen Nutzer. Anonymous hat sich nämlich im Gegensatz zur LulzSec Gruppe eher dem Hacken von Regierungsmaterial verschrieben ist somit Vorreiter der #AntiSec Bewegung. Dennoch kann man rückwirkend sagen, dass die Jungs von LulzSec doch sehr motiviert bei der Sache waren. Hier ein kleiner Überblick über die neusten Hacks:

• 50 Days of Lulz.txt 2.64 KiB
• AOL internal data.txt 63.6 KiB
• AT&T internal data.rar 314.59 MiB
• Battlefield Heroes Beta (550k users).csv 24.67 MiB
• FBI being silly.txt 3.82 KiB
• Hackforums.net (200k users).sql 111.2 MiB
• Nato-bookshop.org (12k users).csv 941.8 KiB
• Office networks of corporations.txt 3.87 KiB
• Private Investigator Emails.txt 2.52 KiB
• Random gaming forums (50k users).txt 6.08 MiB
• Silly routers.txt 67.7 KiB
• navy.mil owned.png 240.51 KiB

Um nun sicherzugehen, dass man selbst nicht in diesen Dokumenten auftaucht, bietet die Seite “Should I Change My Password” einen Check an, der die meisten Dokumente nach E-Mail Adressen oder Nicknames überprüft und euch Bescheid gibt, sofern diese Daten in den Dokumenten bzw. Datenbanken gefunden wurde.

Im gleichen Atemzug hat Gizmodo ebenfalls eine Prüfung online gestellt. Hier werden nochmals andere Dokumente nach E-Mails und Co. durchforstet. Sollten eure E-Mail Adressen bei einem dieser Checks gefunden werden, ist dringend zur Änderung eurer Passwörter zu raten! Ich jedenfalls schien diesmal verschont geblieben zu sein…

Quellen: Liste der Dokumente, <a title="Gizmodo" href="http://gizmodo.com/5815551/find-out-if-your-personal-data-is-part-of-lulzsecs-grand-finale" target="_blank">Gizmodo</a>