Bitcoin und SHA

Das Bitcoin-Protokoll gilt als sicher. Zu verdanken hat das Protokoll diese Eigenschaft unter anderem einem speziellen Algorithmus. Bitcoin verwendet für den Miningprozess, das Kreieren von Adressen und der Verifikation von Transaktionen eine Sha-256 Funktion. Das Bitcoin-Protokoll nutzt eine doppelte SHA-256 Funktion, was bedeutet, die Funktion wird auf die Ausgabe der Funktion angewandt. SHA-256 findet jedoch auch Anwendung in manchen der meistgenutzten Authentifizierung und Sicherheitsprotokollen wie SSL, TLS, IPsec, SSH und PGP. Auch in Unix und Linux wird der Algorithmus zum hashen von Passwörtern genutzt. Wie der Name vermuten lässt, ist der Output der Funktion 256 Bits lang.

Eine kurze Historie zu SHA-256

SHA-256 wurde 2002 als Reaktion auf erfolgreiche Angriffe auf die SHA-1 Hashfunktionen von der NSA entwickelt und vorgestellt. Auf einer National Institute of Standards and Technology (NIST) Konferenz im Jahr 2005 wurde die Umstellung von SHA-1 auf SHA-2 empfohlen und als Standard etabliert. Im Jahr 2012 wurde Keccak zum SHA-3 Algorithmus gewählt. SHA-256 sowie einige andere Algorithmen der SHA-2 Familie werden vom Bundesamt für Sicherheit in der Informationstechnik (BSI) jedoch immer noch als sicher eingestuft.

Die Eigenschaften von SHA-256

Es gibt 3 Eigenschaften welche den Grundstein des SHA-256 Algorithmus und seiner Sicherheit liefern. Um die nachfolgenden Eigenschaften einzuordnen, hilft es sich zu verdeutlichen, dass 2²⁵⁶ mehr ist als die Anzahl der Atome in dem uns bekannten Universum.

1. Es ist nahezu unmöglich die ursprünglichen Daten aus dem Hashwert zu rekonstruieren. Angenommen dies wäre das Ziel eines Angreifers, so müsste dieser mit einer Exhaustionsmethode (Bute-Force Attack) 2²⁵⁶ Versuche durchführen. Die Anzahl der benötigten Versuche ist schier zu groß, um dies überhaupt in Erwägung zu ziehen.
2. Es ist äußerst unwahrscheinlich zweimal denselben Hashwert zu erhalten, da es 2²⁵⁶ verschiedene Möglichkeiten gibt.
3. Eine minimale Veränderung der Daten verändert den Hashwert so, dass nicht ersichtlich ist, dass der neue Hashwert aus einem ähnlichen Datensatz kreiert wurde.

Beispiel Output der SHA-256 Funktion

Um die Funktionsweise und Punkt 3 zu verdeutlichen ein Nehmen wir die Wörter „Beispiel“ und „Beispiele“.

Der Output der SHA-256 Funktion als Hexadezimal von „Beispiel“ ist: 2071c7736acd16f6cea3727d3b7ecde53f4c2e97b421f3550248e19d7309c636

Der Output der SHA-256 Funktion als Hexadezimal von „Beispiele“ ist: 147790983143d584d88c22ad1a14f128c3d55e3dea3d92ec400e930a04031fb9

Es lässt sich offensichtlich, anhand der Hashwerte, kein Rückschluss auf die Daten ziehen.

SHA Funktionen bilden das Fundament einer Vielzahl von Authentifizierung und Sicherheitsprotokollen.

Auch Blockchain Protokolle wie z.B. Bitcoin nutzen diese und ähnliche Algorithmen, um Sicherheit Ihrer Transaktionen und des Miningprozesses zu gewährleisten. Die SHA-256 Funktion bietet eine optimale Balance zwischen Kollisionsresistenz und Effizienz für das Bitcoin Protokoll. Die Länge der Daten welche gehasht werden ist für die Länge des Outputs irrelevant. Dieser beträgt immer 256 bits. Der 64 Zeichen lange Hexadezimalwert, welcher z.B. einen Block der Bitcoin Blockchain repräsentiert eignet sich somit optimal um zu gewährleisten das die Daten eines Blocks unverändert sind. Jeder Knotenpunkt (Node) kann somit die Integrität eines Blockes validieren. Da eine Blockchain neue Blöcke chronologisch ankettet und der Hash des aktuellen Blocks auf dem vorhergehenden Block basiert, sind Daten unveränderbar auf der Blockchain gespeichert.

Hat Euch dieser Beitrag gefallen? Lasst uns und dem Auto Stable Blocks ein Like da und kommentiert was das Zeug hält!

Der Beitrag SHA-256 und Bitcoin – feat. Stableblocks erschien zuerst auf Informatik Guru.

Falls Ihr zu den Menschen gehört die in Euren Firmen die Mail-Server administrieren, oder Ihr einfach neugierig seid, welcher interessante Fehlerteufel sich am 01.01.2022 beim Microsoft Exchange Server eingeschlichen hat, dürfte Euch unsere kleine Zusammenfassung interessieren!

Seit dem 01.01.2022 um 0:00 Uhr hat ein Großteil der on premise gehosteten Microsoft Exchange Server ein Problem mit dem Mailverkehr. Daran ist jedoch zur Abwechslung mal nicht der Transport Agent schuld, sondern der Schadsoftwarefilter.

Der Virenscanner FIP-FS Scan Engine meldet einen Fehler mit dem Text „Can’t Convert ‚2201010001‘ to long“.
Der „größte“ Long ist 2.147.483.647, Datumsangaben im Jahr 2022 haben jedoch einen Mindestwert von 2.201.010.001.

Dieser Fehler hat außerordentlich viele Systeme betroffen, da die FIP-FS Anti-Spam- und Anti-Malware-Scan-Engine seitens Microsoft seit dem Exchange Server 2013 standardmäßig aktiviert ist.

Malware Agent deaktivieren – Exchange Management Shell

Zum Glück lässt sich der Fehler schnell kurzfristig umgehen, allerdings leider nur in dem der Malware Agent deaktiviert wird. Zur Behebung des Problems könnt ihr mit den folgenden beiden Zeilen in der Exchange Management Shell den Malware Agent deaktivieren und anschließend den Transport Service neu starten, wonach Euer Microsoft Exchange Server auch im Jahr 2022 wieder ordnungsgemäß arbeiten sollte:

 
Powershell-Befehl Get-Transportagent "Malware Agent" | Disable-Transportagent
Restart-Service MSExchangeTransport

Wenn das sauber funktioniert hat, so seht Ihr bei der nachfolgenden Überprüfung folgende Ausgabe:

In einigen Fällen kann es sein, dass der MSExchangeTransport beim Neustarten Schwierigkeiten hat, in diesem Fall könnt Ihr den Dienst auch über die GUI neu starten, oder den ganzen Server rebooten.

MSExchangeTransport über die GUI neu starten:

Hier sucht Ihr nun den Microsoft Exchange-Transport Dienst heraus und startet diesen neu:

Nun sollte Euer Microsoft Exchange Mailserver wieder funktionieren und gut für 2022 gewappnet sein 😉

Wenn Euch dieser Beitrag gefallen hat schreibt uns oder besucht uns auf einem unserer Social Media Kanäle und lasst einen Like oder Kommentar da!

Der Beitrag MS Exchange 2022 Bug erschien zuerst auf Informatik Guru.

Im folgenden möchte ich Euch Step-by-Step näher bringen, wie ihr PDFs automatisiert auslesen, filtern und verarbeiten könnt. Ziel ist es eine Funktion in PowerShell zu haben, welche Ihr ganz einfach in Eure bestehenden Ideen oder Abläufe einbinden könnt.

Hierfür verwenden wir im folgenden iTextSharp. iTextSharp könnt ihr hier herunterladen:
iTextSharp Download

iTextSharp einbinden

Um iTextSharp nun innerhalb unseres PowerShell Scripts zu verwenden um PDFs automatisiert auszulesen müssen die es zunächst einbinden.
Dies geschieht so:

Nun stehen uns im weiteren Verlauf Objekte und Methoden hieraus zur Verfügung.

Reader initialisieren

Zunächst beginnen wir mit einem Reader, der uns die jeweilige Datei erst einmal lesend zur Verfügung stellt. Hier kommt es darauf an ob wir von einem Datei-Objekt oder einem Pfad ausgehen. Wenn wir also bspw. in der Variable $filepath den Pfad zur Datei stehen haben legen wir so los:

Im Prinzip haben wir hier eine Dopplung und innerhalb des Reader-Aufrufs könnten wir auch einfach $filepath verwenden, auf die hier gezeigte Weise haben wir allerdings noch die Möglichkeit $filepath mit einem Wildcard zu übergeben(Kunde1234*.pdf).

Seitenweiser Durchlauf der PDF

Nun empfiehlt es sich meines Erachtens die Datei seitenweise zu durchlaufen. Bevor wir die weiteren Schritte erarbeiten sollten wir uns auch Gedanken darüber machen wie unsere entsprechende Datei strukturiert ist. Also welche wiederkehrenden Zeilen wir auslesen möchten und auf welchen Seiten diese sich befinden. In unserem Beispiel durchlaufen wir immer die ersten beiden Seiten einer Datei.

Zeilenweise durchlaufen

Innerhalb des seitenweisen Durchlaufs lesen wir jetzt jeweils den Inhalt der aktuell zu verarbeitenden Seite zeilenweise in ein String-Array. Um das fehlerfrei tun zu können müssen wir das Zeichen kennen, welches als Zeilenumbruch verwendet wird. Hier liegt nicht unbedingt ein Carriage Return oder ein Newline vor, je nach Quelle der PDF-Datei und somit ihrem Aufbau kann das Zeilen-Trennzeichen unterschiedlich sein. In unserem Fall ist es der Character 0x000A.

Zeilen identifizieren

Die Zeilen prüfe wir mit einem regulären Ausdruck auf einen Match unserer Wahl.
Nehmen wir als Beispiel eine PDF-Datei welche immer an einer beliebigen Position die Zeile „Kunden-Nr.:<unterschiedlich viel Whitespace>123456“ enthält.
Wir möchten also die 123456, bzw. in der Praxis natürlich echte Kundennummern auslesen.
Hierfür überprüfen wir zunächst ob die Zeile mit dem String „Kunden-Nr.:“ beginnt und verwenden vorangestellt den Anker ^. Dann trennen wir die Zeile mit .split anhand unseres Trennzeichens „:“ und wählen das zweile zurückgelieferte Element [1], woraufhin wir uns noch von überflüssigem Whitespace verabschieden mit -replace ‚\s‘,“.
Anschließend steht in unserer Variable $Kundennummer lediglich die gewünschte 123456.

Somit haben wir unsere PDF-Datei ausgelesen und übrig bleibt nur den Reader zu schließen mit $reader.close().

Zusammenfassung

Das Ganze lässt sich nun sehr einfach in eine wieder verwendbare Subfunktion wrappen.
Hier stellt sich dann nur die Frage, was wir als Parameter verwenden möchten.
Wollen wir bspw. die Anzahl Seiten die zu prüfen sind beim Aufruf direkt mit angeben?
Den regulären Ausdruck anhand dessen die Zeile identifiziert werden soll?
Das Trennzeichen?
Den Dateinamen sowie den gewünschten Rückgabewert benötigen wir in jedem Fall.
Zusammengefasst könnte die Funktion zum automatisierten Auslesen einer Kundennummer aus einer PDF in PowerShell bspw. so aussehen:

Diese Technik zum automatisierten Auslesen von PDF-Dateien lässt sich recht einfach auf den jeweiligen Anwendungsfall adaptieren und spart je nach Büroumgebung oder Auftrag im EDI-Kontext viel händische Arbeit.

Hat Euch dieser Beitrag gefallen?
Lasst uns gerne Feedback, Ideen oder Kritik zukommen.
Gerne könnt Ihr diesen Beitrag auch teilen und uns einen Besuch auf einem unserer Social Media Kanäle abstatten und wenn Ihr möchtet ein Herzchen oder einen Daumen nach oben da lassen.

Wenn Ihr Euch für mehr PowerShell- oder iTextSharp-Content interessiert schreibt uns!

Der Beitrag PDF-Dateien auslesen mit Powershell erschien zuerst auf Informatik Guru.

Heute befassen wir uns mal mit einem Goodie für die kreativen unter uns.
Die meisten, die bereits im beruflichen Umfeld mit Adobe InDesign gearbeitet haben, kennen das leidige Problem…
Mehrere Indesign-Versionen, mehrere unterschiedliche .indd-Dateien, viele Probleme.
Um den Umgang mit solchen Situationen zu vereinfachen wurde von einem Mitglied unseres Teams in der Vergangenheit untenstehendes Script entwickelt.
Dieses muss per Automator/Skript-Editor unter OS X als Dienst (.scpt) abgespeichert und einem Order als Ordneraktion hinzugefügt werden (Rechtsklick auf den Ordner und dann unter „Dienste“ auf „Ordneraktionen konfigurieren“).
Sobald dies geschehen ist hat man einen selbst gebauten „Hotfolder“, mit welchem es möglich ist, Dateien zu konvertieren.
Hierbei wird das aktuelle CC auf dem eigenen Rechner kurz aufgerufen, mit selbigem wird die Datei, welche man zuvor in den Ordner gelegt hat, geöffnet und als .idml-Datei im selben Verzeichnis wieder gespeichert.
Somit sind alle händischen Konvertierungen und Inkompatiblitätsprobleme hinfällig!

on adding folder items to thisFolder after receiving theItems
     try
         tell application "Finder"
             set theName to name of thisFolder
             set theCount to length of theItems
        repeat with f in theItems
            set work_file to f as alias
            --Den Ordnerpfad des zu verarbeitenden Files finden: 
            set the_container to (container of work_file) as string
            --Den Filename ohne Endung in eine Variable schreiben:
            set the_name to name of work_file
            --Die Endung in eine Variable schreiben:
            set the_extension to name extension of work_file
            --display dialog the_name & the_extension #Debug-Ausgabe um zu testen, ob die Variablen korrekt befuellt sind
            if the_extension is not "" then set the_name to (text 1 thru ((length of the_name) - (length of the_extension) - 1) of the_name)


            if the_extension is not "indd" then exit repeat -- # simulated `continue`




            tell application id "com.adobe.InDesign" -- "Adobe InDesign"
                set «class UIAc» of «class pScr» to «constant elnteNvr»
                open work_file without «class psiw»
                tell document 1
                    «event K2  expt» without «class imot» given «class exft»:«constant eXftidml», «class kfil»:(the_container & the_name & ".idml")
                    «event CoReclos» given «class svop»:no
                end tell
            end tell
        end repeat
    end tell
on error the error_message number the error_number
    set the error_text to "Error: " & the error_number & ". " & the error_message
    -- Im folgende wird eine Subroutine aufgerufen, welche eine Zeile in ein Logfile auf dem Desktop schreibt
    -- Falls das Log bereits existiert, so wird lediglich eine Zeile angefuegt
    my write_error_log(the error_text)
end try

end adding folder items to

on write_error_log(this_error)
    set the error_log to ((path to desktop) as text) & "Script Error Log.txt"
    try
        open for access file the error_log with write permission
        write (this_error & return) to file the error_log starting at eof
        close access file the error_log
    on error
        try
            close access file the error_log
        end try
    end try
end write_error_log

Weitere interessante InDesign Skripte findet Ihr hier: https://indesignscript.de

Falls Euch das Skript genutzt und/oder gefallen hat, so lasst uns doch einen Like auf Facebook, ein Follow auf Instagram oder ein Subscribe für unseren Mail-Newsletter da, um fortwährend über neue, informative und lustige Beiträge vom Informatik-Guru informiert zu werden!

Der Beitrag InDesign-Konvertierung von INDD zu IDML erschien zuerst auf Informatik Guru.

#Script by C. Caspar
#/bin/bash

ZARAFA_ADMIN=which zarafa-admin
AWK=which awk
echo „Achtung – Dieses Script wird automatisch alle verwaisten Stores loeschen!!!“
$ZARAFA_ADMIN –list-orphans | tail -n+4 | $AWK ‚{print $1}‘ |while read STOREID; do
echo „Entferne Store: $STOREID“
$ZARAFA_ADMIN –remove-store $STOREID
done

Hierbei schreiben wir zunächst die Pfade zu den Kommandos „zarafa-admin“ und „awk“ in die jeweiligen Variablen hinein, um diese im Weiteren gesichert und umgebungsunabhängig weiter aufrufen zu können.
Nach einer rein informativen Ausgabe bzgl. dessen was das Script tun wird geht’s ans Eingemachte.
Mit dem vorgegebenen Kommando „$ZARAFA_ADMIN –list-orphans“, was hierbei als Referenz auf das eigentliche Komando „zarafa-admin –list-orphans“ zu verstehen ist, geben wir zunächst alle Stores ohne User aus.
Mit dem „| tail -n+4“ lassen wir hierbei die ersten vier Zeilen aus, da darin ohnehin keine für uns verwertbare Information enthalten ist.
Darauffolgend pipen wir in ein awk „| $AWK ‚{print $1}'“, welches die Aufgabe hat, lediglich die erste Spalte des Kommandos auszugeben, also nur die Store-IDs.
Zu guter letzt starten wir in dieser Zeile unsere Schleife mit:
|while read STOREID; do
Hiernach kommt wieder ein rein informativer echo bzgl. dessen was im Begriff ist zu passieren:
echo „Entferne Store: $STOREID“
Gefolgt von der tatsächlichen Löschung des Stores:
$ZARAFA_ADMIN –remove-store $STOREID

Abschließend kann man sagen, dass grundsätzlich mit der automatischen Löschung von Stores äußerst vorsichtig umgegangen werden sollte, da mit obenstehendem Script ALLE verwaisten Stores gelöscht werden, ohne dass diese vorher überprüft wurden, bspw. ob der Store fälschlicherweise verwaist ist, da er eigentlich einem User angehangen werden müsste oder ähnliches.
Wir übernehmen natürlich keine Haftung für Fehler welche durch Benutzung unseres Scripts entstanden sind, oder Mails die verloren gegangen sind.
Solltet Ihr bzgl. der Vorqualifizierung einer Löschung in einem solchen Fall Fragen haben, so könnt Ihr uns gerne kontaktieren unter senpai@informatik-guru.de.
Ein Mitglied unseres Teams wird Euch in einem solchen Fall gerne beratend zur Seite stehen.

Der Beitrag Zarafa Mail Server – Verwaiste stores löschen erschien zuerst auf Informatik Guru.

In unserem Beispiel wird ein Zarafa-Mail-Server benutzt, welcher ein älteres Produkt ist, das auf Postfix aufsetzt.

Das funktioniert in unserem Beispiel zweistufig.
Zunächst benötigen wir folgendes Script, um einen Überblick über die Postfachauslastung aller Benutzer zu erstellen:

#Script by C. Caspar
#!/bin/bash
_USER_LIST=$(zarafa-admin -l | grep -v „username“ | grep -v „SYSTEM“ | grep -v „User“ | grep -v „–“ | awk -F‘ ‚ ‚{print$1}‘ | sort)

for _USERS in $_USER_LIST
do
_CHECK_SIZE=$(zarafa-admin –details $_USERS –type user | grep „Current store size“ | awk -F‘ ‚ ‚{print$4, $5}‘)

echo „$_USERS storesize: $_CHECK_SIZE“
done

Hierbei erstellen wir uns zunächst ein Array aus Usern, welche alphabetisch sortiert sind.
Alle Zeilen mit den Strings „username“, „SYSTEM“, „User“ und „–“ lassen wir hierbei aufgrund der Struktur des Standard-Outputs des genutzten Befehls nicht in die Ausgabe.
Unser Output sieht hierbei zunächst so aus:

a_user storesize: 277.54 MB
b_user storesize: 14510.95 MB
c_user storesize: 19.72 MB
d_user storesize: 1748.51 MB
e_user storesize: 7758.81 MB
f_user storesize: 490.84 MB

Mit diesem Script in der Hinterhand können wir folgendes Script für das tatsächliche Monitoring ausführen:

#Script by C. Caspar
#!/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root
sh /root/zeige_postfachauslastung.sh > postfachauslastung_recent &
sleep 60

echo -e `cat /root/postfachauslastung_recent |sort -n -r -k3 |grep -E '[0-9]{5}' |awk {'print $1"\011"$3"\n\r"'}` | { read body; echo -e $(echo „Subject: IMAP_Monitoring_Postfachauslastung\r\n“; echo „\r\n\r\nFolgende User haben Postfaecher von mindestens 10 GB:\r\n\r\n“; echo -e „${body}“)| sendmail empfaenger_A@Domain.de empfaenger_B@Domain.de empfaenger_C@Domain.de ;}

Was genau tun wir hier jetzt?
Zunächst geben wir dem Script über die PATH-Variable mit, wo es überall nach den entsprechenden Kommandos zu suchen hat, um nicht immer den vollen Pfad zu den Kommandos angeben zu müssen.
Dann geben wir den Output des cat-Befehls aus, wobei wir die Trennzeichen durch tatsächliche newlines ersetzen.
Das wird danach in die neue Variable „body“ gelesen und weiter verarbeitet.
Im Output des Echo greppen wir bereits per regulärem Ausdruck nach 5-Stelligen Zahlen, da uns alle Postfächer ab 10 GB interessieren.
Im Nachgang wird per echo -e der Aufbau der später mit sendmail versandten Mail zusammengesetzt.
Hierbei est es wichtig, dass wir zeilenumbruchgetrennt „Subject“ und anschließend den Inhalt (${body}) angeben, bevor wir den gesamten Output in ein sendmail pipen.

Folgende Mail kommt hierbei bspw. heraus:

Folgende User haben Postfaecher von mindestens 10 GB:

m_user 17333.92
b_user 17311.53
a_user 17193.89

Das Ganze lässt sich selbstverständlich auch über ein einzelnes Script bewerkstelligen, da ohnehin das erste im zweiten lediglich aufgerufen und in eine temporäre Datei geschrieben wird. Allerdings ist es in unserem Fall so gebaut, da Script Nummer Eins in mehreren Fällen auch anderweitige händische Verwendung findet.

Die Einbindung, damit das auch alles automatisiert und ohne unser Zutun läuft, erfolgt einfach via Eintrag im Crontab des entsprechenden Systems.

In unserem Beispiel ist das wie folgt geschehen:


1 6   * * *   root    /root/postfachauslastung_monitoring.sh

Aus diesem Eintrag geht hervor, dass das Script „postfachauslastung_monitoring.sh“ täglich um 6:01 Uhr morgens ausgeführt werden soll.

Der Beitrag Mail-Server Monitoring in Bash erschien zuerst auf Informatik Guru.

USV (Unterbrechungsfreie Stromversorgung) wird eingesetzt um bei Störungen bzw. Ausfällen im Stromnetz die Versorgung kritischer Systeme zu gewährleisten.

Sie sollen vor allem vor folgenden Arten von Netzstörungen schützen:

1. Stromausfall
2. Unterspannung
3. Überspannung
4. Frequenzänderungen
5. Oberschwingungen

Man unterscheidet zwischen folgenden drei Klassen von USVs:

1. VFI (Voltage and Frequency Independent from main supply, Spannung und Frequenz unabhängig vom Netz)

2. VI (Voltage Independent from main supply, Spannung unabhängig vom Netz)

3. VFD (Voltage and Frequency Dependent on main supply, Spannung und Frequenz abhängig vom Netz)

VFI-USV

Im Folgenden möchte ich auf die 1. Klasse, die VFI-USVs näher eingehen, da diese aufgrund der extrem niedrigen Ausfallzeiten mit am häufigsten angewendet werden.

Auch bekannt als „Online“, „Double-Conversion“ oder „Doppelwandler“.

Bei diesen USVs ist der Eingang direkt auf einen Gleichrichter geführt, der die Akkumulatoren speist.

Der Ausgang wird ausschließlich von einem Wechselrichter versorgt, der im Normalbetrieb, also bei vorhandener Netzspannung am USV-Eingang, die notwendige Energie über den Gleichrichter (GR) bezieht und bei Netzausfall über die Batterieanlage (Akkumulatoren) versorgt wird.

Die Wechselspannung am Ausgang wird in jedem Fall – unabhängig von der Qualität der Eingangsspannung – über einen nachgeschalteten Wechselrichter (WR) aus der Gleichspannung des sogenannten Zwischenkreises erzeugt. Zur Erhöhung der Versorgungssicherheit verfügt eine VFI-USV über eine so genannte Bypass-Schaltung, die parallel zur Gleichrichter/Wechselrichter-Kombi geschaltet ist.

Sollte der USV-Ausgang überlasten oder es zu einem internen Fehler kommen, so wird der Gleichrichter/Wechselrichter-Zweig umgangen und es wird der Bypass-Weg geschaltet.

Die hochwertigen Gleichrichter und Wechselrichter, welche für diese Bauart USV benötigt werden, da diese Teile konstant unter vollem Betriebsstrom stehen, machen die VFI USVs zur teuersten Preisart.

Eine VFI-USV schützt neben den Folgen eines Stromausfalls, Unterspannung und Überspannung auch vor Schwankungen der Frequenz und vor Oberschwingungen. Sie bieten ebenfalls sporadischen Schutz vor Blitzeinwirkungen und Spannungsverzerrungen.

VFI-USVs werden vorrangig in Bereichen eingesetzt, welche eine extrem niedrige Toleranz bzgl. Der Ausfallzeiten haben, wie bspw. Rechenzentren und Systeme in Krankenhäusern.

VFI-USVs haben unter allen Klassen die höchste eigene Leistungsaufnahme.
Man kann in etwa von 5-10 % der Nennleistung ausgehen.

Der Beitrag USV – Strom aus, Server an erschien zuerst auf Informatik Guru.

Grundsätzlich ist ein RAID eine Zusammenfassung von Festplatten unter unterschiedlichen Gesichtspunkten.

Hierbei kann man bspw. an Geschwindigkeit, oder aber an Redundanz, respektive Ausfallsicherheit, gewinnen, wobei man bzgl. dieser beiden Faktoren immer einen Trade-off eingehen muss.
Im folgenden möchte ich die verbreitetsten Basisformen des Raid etwas erläutern.

RAID-Level 0

Beim RAID-Level 0(aka „striping“) werden Datenströme abwechselnd gleichermaßen auf zwei oder mehr Festplatten verteilt. Hierbei hat man 0 Datenredundanz.
Hieraus ergibt sich ein Geschwindigkeitsvorteil gegenüber einer einzelnen Festplatte.
Im Gegenzug dafür hat man allerdings keine Ausfallsicherheit.

RAID-Level 1

Beim RAID-Level 1 (aka „mirroring“) werden Datenströme auf zwei oder mehr Festplatten gespiegelt gespeichert.
Die Geschwindigkeit entspricht hierbei etwa der Geschwindigkeit der einzelnen Festplatten.
Man hat hier in diesem Fall eine volle Datenredundanz und somit einen Nettospeicherplatz von Anzahl Festplatten/2 x Größe der Platten

RAID-Level 5

Beim RAID-Level 5 werden die Daten auf drei oder mehr Festplatten verteilt gespeichert.
Im Gegensatz zum RAID-1 hat man einen wesentlich höheren Nettospeicheranteil.
Dieser ergibt sich aus Anzahl Platten – 1 x Größe der Platten
Die daten werden Chunkwise auf die einzelnen Platten geschrieben.
Der letzte geschriebene Anteil ist immer die Parität.
Die Berechnung des Parity Bits erfolgt u.a. oftmals durch XOR-Verknüpfung der vorangegangenen Bits.

Betrachten wir bei obenstehender Abbildung die erste „Spalte“ so ergibt sich bzgl. Der XOR-Berechnung der Parität folgende Formel:

1 XOR 1 XOR 0 = Parity bit

Übertragen wir dies auf die anderen Spalten so ergibt sich für die in die in der Abbildung schematisch dargestellten Bits die im folgenden grün dargestellte Parität

RAID-Level 6

Bei RAID-Level 6 wird ebenfalls, wie bereits bei RAID 5 mit Sector Striping gearbeitet.
Beim Raid 6 allerdings werden anstatt einer gleich zwei Paritäten bzw. Checksums geschrieben.
Daraus ergibt sich bzgl. Der Nettospeicherkapazität eine Verkleinerung hingegen Raid 5, in der Ausfallsicherheit jedoch liegt Raid 6 mit zwei Platten vorne
Die Nettospeicherkapazität beträgt Anzahl Platten -2 x Plattengröße
Die Art der Implementierung ist hierbei unterschiedlich, wobei man sagen kann, dass zumeist lediglich die Parität die auch schon bei Raid 5 gebildet wird doppelt gespeichert wird, wodurch im Weiteren kein zusätzlicher Rechenaufwand im RAID-Controller entsteht.

RAID-Level 10

Unter Raid 10 versteht man eine Kombination aus Mirroring und Striping.
Hier werden Datenströme gleichermaßen auf zwei gespiegelte Einheiten verteilt.
Hierfür werden mindestens 4 Festplatten benötigt.
Hierdurch hat man die Geschwindigkeitsvorteile des Raid 0 unter Beibehaltung der vollen Redundanz des Raid 1.

Der Beitrag RAID-Systeme Basics erschien zuerst auf Informatik Guru.