Schlagwort: Informatik

Base64-Kodierung mit C# 👍 👎

Zur verlustfreien Speicherung und Übertragung von Binärdateien als Text kommt häufig die Base64-Kodierung zum Einsatz. C# unterstützt die (De-)Kodierung dieser Daten in ihrer üblichen Darstellungsform als Zeichenkette sehr komfortabel über die beiden Methoden Convert.ToBase64String und Convert.FromBase64String:
Base64-Konvertierung
01020304
byte[] input = Encoding.UTF8.GetBytes("Hällö!");   // [72, 195, 164, 108, 108, 195, 182, 33]
string base64 = Convert.ToBase64String(input); // "SMOkbGzDtiE="byte[] output = Convert.FromBase64String(base64); // [72, 195, 164, 108, 108, 195, 182, 33]
Die verbreitete Darstellung mit Zeilenumbrüchen nach jeweils 76 Zeichen wird durch die Option Base64FormattingOptions.InsertLineBreaks ermöglicht.

Spannender als mit einer einfachen Zeichenkette ist dieses Vorgehen natürlich bei komplexen Dateien, wie sie beispielsweise im Zusammenhang mit X.509-Zertifikaten auftreten. Praktisch ist dies, da die kodierte Zeichenkette nur noch aus lesbaren ASCII-Zeichen besteht und folglich keine Probleme mit Zeichensätzen zu erwarten sind. Darüber hinaus können derart kodierte Grafiken beispielsweise direkt in Webseiten eingebettet werden.

Offensichtlich sollte dieses Verfahren jedoch nicht zur "Verschlüsselung" sensibler Daten verwendet werden.

(De-)Kompression mit C# 👍 👎

Zwar ist Speicher heutzutage üblicherweise keine Mangelware mehr, dennoch kann sich die Komprimierung großer Datenmengen, beispielsweise zur Übertragung, lohnen. C# bietet dazu einige Möglichkeiten, so unter anderem zur Arbeit mit ZIP-Archiven. Zu diesen möchte ich jedoch in einem separaten Beitrag kommen und stattdessen zeigen, wie sich mit der DeflateStream-Klasse beliebige Daten(-ströme) (de-)komprimieren lassen:
(De-)Komprimierung von Rohdaten
01020304050607080910111213141516171819202122232425
  // Daten komprimierenpublic static byte[] Compress(byte[] data) {    using(MemoryStream inStream = new MemoryStream(data)) {        using(MemoryStream outStream = new MemoryStream()) {            using(DeflateStream deflate = new DeflateStream(outStream, CompressionMode.Compress)) {                inStream.CopyTo(deflate);            }
return outStream.ToArray(); } }}
// Daten dekomprimierenpublic static byte[] Decompress(byte[] data) { using(MemoryStream inStream = new MemoryStream(data)) { using(MemoryStream outStream = new MemoryStream()) { using(DeflateStream deflate = new DeflateStream(inStream, CompressionMode.Decompress)) { deflate.CopyTo(outStream); }
return outStream.ToArray(); } }}
Um beispielsweise komplette Dateien effizient zu (de-)komprimieren, kann wie folgt vorgegangen werden:
(De-)Komprimierung von Dateien
010203040506070809101112131415161718192021
  // Datei komprimierenpublic static void CompressFile(string inputPath, string outputPath) {    using(FileStream inStream = File.OpenRead(inputPath)) {        using(FileStream outStream = File.OpenWrite(outputPath)) {            using(DeflateStream deflate = new DeflateStream(outStream, CompressionMode.Compress)) {                inStream.CopyTo(deflate);            }        }    }}
// Datei dekomprimierenpublic static void DecompressFile(string inputPath, string outputPath) { using(FileStream inStream = File.OpenRead(inputPath)) { using(FileStream outStream = File.OpenWrite(outputPath)) { using(DeflateStream deflate = new DeflateStream(inStream, CompressionMode.Decompress)) { deflate.CopyTo(outStream); } } }}
Sofern zusätzlich verschlüsselt werden soll, worauf ich in einem separaten Beitrag näher eingehen möchte, ist eine sinnvolle Reihenfolge zu beachten. Diese trägt zwar, abgesehen von kleineren Umständen bei unberechtigten Entschlüsselungsversuchen, nicht wesentlich zur Sicherheit an sich bei – wohl aber zur erzielbaren Kompression.

Die (verlustfreie) Datenkompression basiert hauptsächlich auf Redundanzreduktion. Es werden also Muster der Eingabe erkannt und kompakter kodiert. Derartige Muster sollten nach einer ordnungsgemäßen Verschlüsselung jedoch nicht auftreten, d. h. die Ausgabe wirkt ohne Schlüssel weitestgehend zufällig. Verschlüsselte Daten lassen sich entsprechend schlecht komprimieren und so lässt sich sogar recht einfach prüfen, ob eine Verschlüsselung grobe Fehler aufweist – nämlich genau dann, wenn eine signifikante Kompression des Chiffrats möglich ist.

Konkret bedeutet dies also für die Praxis üblicherweise, zuerst zu komprimieren und danach zu verschlüsseln.

Schaltjahr ermitteln 👍 👎

Viele Beispiele ermitteln ein Schaltjahr über eine Prüfung darauf, ob das fragliche Jahr durch vier teilbar ist. Diese einfache Prüfung, die bereits im julianischen Kalender Anwendung findet, ist jedoch nur eine von drei Regeln des gregorianischen Kalenders. Für eine vollständige Prüfung müssen folgende drei Bedingungen überprüft werden:
  • Ist das Jahr durch 4 teilbar, ist es potentiell ein Schaltjahr. (2016 ist ein Schaltjahr)
  • Ist das Jahr durch 100 teilbar, ist es grundsätzlich kein Schaltjahr. (2100 ist kein Schaltjahr)
  • Ist das Jahr durch 400 teilbar, ist es generell ein Schaltjahr. (2000 ist ein Schaltjahr)
Dies lässt sich in C# nun beispielsweise wie folgt als statische Methode umsetzen:
Schaltjahr-Prüfung implementieren und verwenden
01020304050607
public static bool IsLeapYear(int year) {    return (((year % 2 == 0) && (year % 100 != 0)) || (year % 400 == 0));}
bool isLeapYear = IsLeapYear(2016); // trueisLeapYear = IsLeapYear(2100); // falseisLeapYear = IsLeapYear(2000); // true
Besonders spannend ist diese Methode jedoch nicht, das .NET-Framework bietet mit DateTime.IsLeapYear(…) nämlich bereits eine entsprechende Implementierung an. Es gilt jedoch den Hinweis der Dokumentation zu beachten, dass die Prüfung dabei immer im Rahmen des gregorianischen Kalenders erfolgt, was für manche – beispielsweise historische – Anwendungen unpässlich sein kann. Das Framework bietet im Namensraum System.Globalization jedoch weitere Kalender-Implementierungen an, welche jeweils eine entsprechende Umsetzung der IsLeapYear(…)-Methode zur Verfügung stellen.

UNIX Timestamps and C# 👍 👎

In einem älteren Beitrag zum Thema Erweiterungsmethoden in C# hatte ich eine kleine Methode zur Arbeit mit UNIX-Zeitstempeln als Beispiel verwendet. Dieser Beitrag wird auch heute noch relativ häufig aufgerufen, weswegen ich zu diesem konkreten Beispiel anmerken möchte, dass das .NET-Framework seit Version 4.6 Funktionalität zur Arbeit mit entsprechenden Zeitstempeln auf der DateTimeOffset-Struktur bereithält:
Die Verwendung gestaltet sich wie üblich sehr einfach:
Konvertierung von UNIX-Zeitstempeln
010203040506070809
  // UNIX-Zeitstempel für aktuelles Datum und aktuelle Uhrzeit ermittelnlong unixTimestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
// bestimmtes Datum um 0:00 Uhr verwendenunixTimestamp = (new DateTimeOffset(new DateTime(1988, 1, 29))).ToUnixTimeSeconds();

// DateTime-Objekt lokaler Zeit aus UNIX-Zeitstempel erzeugenDateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(unixTimestamp).LocalDateTime;
Eigene Implementierungen sollten für die aktuelle Praxis daher nicht mehr nötig sein.

Check against DNS blacklists with C# 👍 👎

Im früheren Beitrag zur DNS-Auflösung mit C# haben wir eine grundlegende Möglichkeit kennengelernt, IP-Adressen zu Domains zu ermitteln. Dies möchten wir uns zu Nutze machen, um DNS-Blacklisten abzufragen, welche von vielen eMail-Systemen genutzt werden, um potentiellen Spam zu erkennen (und ggf. abzuweisen).

Zu den bekannten Anbietern entsprechender Dienste gehören beispielsweise: Diese setze ich auch selbst ein und habe jeweils gute Erfahrungen damit gemacht. Bitte informiert euch jedoch vor einem Einsatz beim jeweiligen Anbieter über die genauen Konditionen, der kommerzielle Einsatz ist beispielsweise oftmals kostenpflichtig. Ebenso verhält es sich je nach Anbieter ab einem gewissen Abfragevolumen.

Um nun eine IP-Adresse gegen die entsprechenden Dienste prüfen zu können, müssen wir diese dem oben angegebenen Hostnamen in umgekehrter Reihenfolge voranstellen und eine Namensauflösung durchführen.

Konkret fragen wir also beispielsweise bei einer Prüfung der IP-Adresse 217.160.176.125 auf Spam-Aktivität laut Spamhaus das Ergebnis der Domain 125.176.160.217.zen.spamhaus.org ab (welches hoffentlich negativ beschieden werden sollte). Per C# könnte man dies nun beispielsweise (durchaus verbesserungsfähig) wie folgt durchführen:
IP-Adresse auf Blacklisting prüfen
010203040506070809101112131415161718192021222324
public static bool CheckBlacklisting(IPAddress ipAddress, string blacklist = "zen.spamhaus.org") {    string ipAddressReversed = String.Join(".", ipAddress.GetAddressBytes().Reverse());    string hostName = String.Concat(ipAddressReversed, ".", blacklist);
try { foreach(IPAddress hostAddress in Dns.GetHostAddresses(hostName)) { /** * Achtung: Diese Implementierung ist naiv und sollte nicht direkt * übernommen werden. Je nach Anbieter, so beispielsweise auch bei * Spamhaus, gilt nicht der gesamte Loopback-Adressbereich als Spam. * Daher bitte vorher beim Anbieter informieren und konkretisieren! **/ if(IPAddress.IsLoopback(hostAddress)) { return true; } }
return false; } catch { return false; }}
bool checkResult = CheckBlacklisting(IPAddress.Parse("217.160.176.125")); // false
Das Ergebnis der Namensauflösung, also die erhaltene IP-Adresse, gibt darüber hinaus Aufschluss über den genaueren Status. Spamhaus liefert dazu beispielsweise in ihren FAQ weiterführende Informationen.

Project links

Categories / Archive  |  Übersicht RSS feed

Tags

Search