PARAMETRISIERBARES DISPERSIONSMODUL FÜR DEN EINSATZ IN EINER CLOUD-SPEICHERDIENST- INTEGRATION

Fakultät Informatik Institut für Systemarchitektur, Professur Rechnernetze PARAMETRISIERBARES DISPERSIONSMODUL FÜR DEN EINSATZ IN EINER CLOUD-SPEICHERDIENST- INTEGRATION Maximilian Quellmalz Matrikelnummer 3320166 BELEGARBEIT Betreuer Dr.-Ing. Josef Spillner Betreuender Hochschullehrer Prof. Dr. rer. nat. habil. Dr. h. c. Alexander Schill Eingereicht am 14. November 2013

3

SELBSTSTÄNDIGKEITSERKLÄRUNG Hiermit erkläre ich, dass ich die vorliegende Belegarbeit mit dem Titel Parametrisierbares Dispersionsmodul für den Einsatz in einer Cloud-Speicherdienst-Integration selbstständig verfasst habe. Es wurden keine anderen als die in der Arbeit angegebenen Quellen und Hilfsmittel benutzt. Die wörtlichen oder sinngemäß übernommenen Zitate habe ich als solche kenntlich gemacht. Dresden, 14. November 2013 Maximilian Quellmalz 5

INHALTSVERZEICHNIS 1. Einleitung 15 2. Hintergrund 17 2.1. Die verwendete Notation........................ 17 2.2. Begriffe zur Datenverteilung....................... 18 2.2.1. Replikation............................ 18 2.2.2. Partitionierung.......................... 18 2.2.3. Forward Error Correction.................... 18 2.2.4. Erasure-Codes.......................... 19 2.2.5. Information Dispersal Algorithmus............... 19 2.2.6. Secret-Sharing.......................... 20 2.3. Codierungsverfahren........................... 20 2.3.1. Erasure-Codes.......................... 20 2.3.2. Secret-Sharing Algorithmen................... 22 2.4. Vergleich frei verfügbarer Datendispersionsbibliotheken....... 23 2.4.1. Jerasure 1.2............................ 24 2.4.2. Jerasure 2.0........................... 25 2.4.3. GF-Complete........................... 25 2.4.4. JigDFS.............................. 26 2.4.5. Schifra............................... 26 2.4.6. Cleversafe dsnet......................... 27 2.4.7. Crypto++............................. 27 2.4.8. IDA (Java)............................. 28 2.4.9. zfec................................ 28 2.4.10. JSharing.............................. 28 2.4.11. Gibraltar.............................. 29 2.4.12. StorageCORE - Cross-Object Redundancy........... 29 2.4.13. CORE - Concurrent Recovery.................. 30 2.4.14. Zusammenfassung........................ 30 3. Konzept 33 3.1. Datenverarbeitung............................ 33 3.1.1. Daten aus dem Speicher.................... 34 7

Inhaltsverzeichnis 3.1.2. Dateien verarbeiten....................... 34 3.2. Architektur................................ 35 3.2.1. Splitter.............................. 36 3.2.2. Plugins.............................. 38 3.2.3. Codecs.............................. 38 3.3. Datenstrukturen............................. 38 3.3.1. Pluginbeschreibung (PluginDescription)............ 39 3.3.2. Codecbeschreibung (CodecDescription)............ 39 3.3.3. Codecparameter......................... 40 3.3.4. Metadaten............................ 40 3.3.5. Codierungsauftrag (CodingTask)................. 41 3.4. Interfaces................................. 43 3.4.1. Splitter Interface......................... 44 3.4.2. Plugin Interface.......................... 45 3.4.3. Codec Interface......................... 45 3.4.4. Callback Interface........................ 46 3.5. Verwendung des Splitter-NG....................... 46 4. Implementierung 49 4.1. Implementierung des Splitter-NG.................... 49 4.1.1. Umsetzung von Multithreading und Warteschlange...... 49 4.1.2. Umsetzung des asynchronen Interfaces............ 50 4.1.3. Umsetzung des Plugin-Konzeptes............... 50 4.2. Erweitern des Splitter-NG durch eigene Plugins............ 51 4.2.1. Plugins erstellen......................... 51 4.2.2. Codecs erstellen......................... 52 4.2.3. Plugin als JAR-Datei Exportieren................ 53 4.2.4. Verwendung von nicht-java Bibliotheken in Plugins...... 53 4.3. Implementierung der JSharing Bibliothek als Splitter-NG Plugin... 53 4.4. Implementierung von Jerasure 1.2A als Splitter-NG Plugin...... 54 4.5. Implementierung einer Testanwendung................ 55 4.5.1. Parametrisierung der implementierten Plugins und Codecs. 57 4.5.2. Zusammenhang der Projekte.................. 59 5. Analyse der Implementierung 61 5.1. Verbesserungen............................. 61 5.2. Aufwandsabschätzung für die Pluginentwicklung........... 62 5.3. Differenzen zum Konzept........................ 62 5.4. Quantitativer Geschwindigkeitsvergleich der implementierten Codecs 63 6. Zusammenfassung und Ausblick 65 6.1. Zusammenfassung............................ 65 6.2. Ausblick.................................. 65 A. Quellcode des Beispiel-Plugins für RAID-1 67 A.1. SplitterPluginRaid1.java.......................... 68 A.2. CodecRaid1.java............................. 69 8

ABBILDUNGSVERZEICHNIS 2.1. Codierung mit Erasure-Codes...................... 19 3.1. Mögliche Datenverarbeitungswege................... 34 3.2. Verarbeitung großer Datenblöcke in Chunks.............. 35 3.3. Splitter-NG Pluginschnittstelle...................... 36 3.4. Splitter-NG Pluginschnittstelle...................... 37 3.5. EncodingTask und DecodingTask erben von der Klasse CodingTask. 42 3.6. Auslesen der Informationen über Plugins und Codecs........ 47 3.7. Verwendung des Splitter-NG durch eine Anwendung......... 48 4.1. Die Plugins sind nach dem Entwurfsmuster Abstract Factory implementiert.................................. 51 4.2. Textausgabe der Testanwendung.................... 55 4.3. Zusammenhang der implementierten Projekte............ 59 9

TABELLENVERZEICHNIS 2.1. Vorgaben der Parameterwahl für verschiedene Codierungsverfahren 22 2.2. Zusammenfassung zu Jerasure 1.2................... 25 2.3. Zusammenfassung zu Jerasure 2.0................... 25 2.4. Zusammenfassung zu GF-Complete.................. 26 2.5. Zusammenfassung zu JigDFS...................... 26 2.6. Zusammenfassung zu Schifra...................... 27 2.7. Zusammenfassung zu Cleversafe dsnet................ 27 2.8. Zusammenfassung zu Crypto++.................... 27 2.9. Zusammenfassung zu IDA (Java).................... 28 2.10. Zusammenfassung zu zfec....................... 28 2.11. Zusammenfassung zu JSharing..................... 29 2.12. Zusammenfassung zu Gibraltar..................... 29 2.13. Zusammenfassung zu StorageCORE.................. 29 2.14. Zusammenfassung zu CORE...................... 30 2.15. Vergleich des Funktionsumfangs und der Aktualität der Bibliotheken 31 3.1. Beispiel für Metadaten nach dem Encodieren............. 41 4.1. Befehle zur Bedienung der Testanwendung.............. 56 4.2. Parameter für die Codecs aus dem Jerasure-Plugin.......... 58 5.1. Implementierungsgrad der Verfahren und Bibliotheken als Plugins. 62 11

LISTINGS 3.1. Methoden der Klasse PluginDescription................ 39 3.2. Methoden der Klasse CodecDescription................ 40 3.3. Das Splitter-NG Interface zur Einbindung in eine Anwendung.... 44 3.4. Das Plugin Interface zur Einbindung von Plugins in den Splitter-NG. 45 3.5. Das Interface eines Codecs zur Einbindung in ein Plugin....... 45 3.6. Callback Interface............................. 46 4.1. Änderungen im JNI Makefile der Jerasure Bibliothek......... 54 4.2. Start-Script für die Test-Anwendung splittertest.jar bei Verwendung des Jerasure-Plugins........................... 55 4.3. Initialisierung des Splitter-NG mit dem RAID-1-Codec im Quelltext der Testanwendung........................... 57 5.1. Quantitativer Geschwindigkeitsvergleich ausgewählter Codecs... 64 A.1. Quellcode des Raid-1 Plugins...................... 68 A.2. Quellcode des Raid-1 Codecs für das Raid-1 Plugin.......... 69 13

1. EINLEITUNG Dispersion von Daten ist seit Jahren als Standard etabliert, wenn es um die Erhöhung der Datenverfügbarkeit bei Ausfall einzelner Festplatten in Computersystemen geht. Bei diesen RAID-Systemen (Redundant Array of Independent Disks) werden zu den Festplatten, die die relevanten Daten enthalten, weitere hinzugefügt, auf die redundante Daten geschrieben werden. Mit Hilfe dieser Redundanz bleiben die Informationen im Falle eines Festplattenausfalls weiterhin verfügbar. Auf diese Weise kann, je nach Konfiguration, der Ausfall einer oder mehrerer Festplatten toleriert werde. Es können dabei unterschiedliche Verfahren eingesetzt werden. Die Möglichkeiten reichen von einfachem Spiegeln der Daten auf weitere Festplatten (RAID-1), bis zu komplexen Verfahren unter Verwendung von Erasure-Codes, die den Ausfall mehrerer Festplatten abfangen können. So kann ein RAID-6-System bis zu zwei gleichzeitige Festplattenausfälle kompensieren. Die Grundidee, wichtigen Daten redundante Informationen hinzuzufügen, ist auch für andere Anwendungen, wie Cloud-Speicher, interessant. Mit Hilfe von Erasure- Codes kann eine Datei in Fragmente geteilt werden, die neben den relevanten Daten auch redundante Informationen enthalten. Diese Fragmente können dann auf mehrere Speicheranbieter verteilt werden. Dadurch kann sichergestellt werden, dass die Daten komplett verfügbar sind, auch wenn nicht alle Anbieter erreichbar sein sollten. Im Gegensatz zu RAID-Systemen können die Dateifragmente auch geographisch getrennt gespeichert werden. Weiterhin kann eine Dispersion mit speziellen Verfahren wie Secret-Sharing und All or Nothing Transformation dazu genutzt werden, die Vertraulichkeit der Information zu gewährleisten. Es sind dabei mehrere Fragmente notwendig um Rückschlüsse auf die Originaldatei zuzulassen. Werden diese nicht alle bei einem Provider gespeichert, ist das Risiko, dass die Daten für Unbefugte zugänglich sind auch dann gering, wenn ein Speicheranbieter kompromittiert wird, oder die Daten durch interne Fehlfunktionen frei zugänglich sind, wie es 2011 bei Dropbox geschehen ist [Hei11]. 15

1. Einleitung Es existieren bereits einige Anwendungen, die das Konzept der Datendispersion auf Cloud-Storage anwenden. Sie haben jedoch alle gemeinsam, dass die Dispersionsverfahren fest implementiert sind. So werden zum Beispiel vom Cloud-Storage- Controller NubiSave direkt die Java-Klassen von JigDFS verwendet. Allgemein bietet eine solche feste Einbindung kaum Flexibilität. Bei NubiSave wäre ein Wechsel zu einer anderen Dispersionsbibliothek nicht ohne größeren Aufwand möglich. Ziel dieser Arbeit ist es ein flexibles Modul Splitter-Next-Generation (Splitter-NG) zu entwickeln, das die Datendispersion kapselt und in unterschiedlichen Cloud- Storage-Controllern verwendet werden kann. Damit sollen verschiedene Verfahren und Bibliotheken über eine einheitliche Schnittstelle nutzbar gemacht werden. Die Einbindung eines Dispersionsalgorithmus soll nicht immer wieder reimplementiert werden müssen. 16

2. HINTERGRUND In diesem Kapitel wird zunächst auf die in dieser Arbeit verwendete Notation eingegangen. Anschließend werden wichtige Begriffe kurz erläutert und einige Erasure- Codierungsverfahren vorgestellt. Außerdem werden mehrere frei verfügbare Bibliotheken, die verschiedene Codierungsverfahren anbieten, verglichen. 2.1. DIE VERWENDETE NOTATION Die verwendeten Begriffe und Abkürzungen im Bereich der Datendispersion sind je nach Literatur unterschiedlich. Im Folgenden wird hier die von [PSS08] verwendete Notation benutzt. Wird eine Datei codiert, so wird sie in n = k + m Fragmente geteilt. Dabei ist m die Anzahl redundanter Fragmente und k die Anzahl der originalen Fragmente. Die redundanten Fragmente werden dabei so berechnet, dass eine beliebige Teilmenge aus mindestens k Fragmenten benötigt wird, um die Datei erfolgreich zu decodieren (Siehe Abbildung 2.1). Weiterhin verwenden einige Verfahren die Wortlänge w. Durch Anpassung der Wortlänge kann oft die Effizienz der Berechnung beeinflusst werden. Wird w {8, 16, 32} gewählt, kann zum Beispiel direkt auf Byte beziehungsweise 16 oder 32 Bit Integer gerechnet werden. Bei XOR-Vergleichen kann so die Rechnerhardware optimal ausgenutzt werden. Zweidimensionale Array-Codes, wie EVENODD und RDP, berechnen jedes codierte Bit c i,j als bitweise XOR-Verknüpfung anderer Bits aus dem Array der Datenbits d i,j. Hier beschreibt k die Anzahl der Spalten und w die Anzahl der Reihen des Arrays. Zur Verbesserung der Performance wird dabei zusätzlich die Paketgröße angege- 17

2. Hintergrund ben, die ein Vielfaches eines Datenwortes sein muss. Die XOR-Operationen werden dann nicht mehr auf einzelnen Bits ausgeführt, sondern auf diesen Paketen. Außerdem kann zum Lesen und Schreiben von Dateien die Puffergröße angegeben werden. Ist eine Datei größer als der Puffer, wird sie in mehreren Schritten eingelesen. 2.2. BEGRIFFE ZUR DATENVERTEILUNG 2.2.1. REPLIKATION Um die Datensicherheit durch Verteilen zu erhöhen, ist eine Replikation der einfachste Weg. Die Daten werden an zwei oder mehreren Orten identisch gespeichert. Oft werden dafür auch die Begriffe Spiegelung oder Mirroring verwendet. Ein Beispiel für Replikation sind RAID-1-Systeme. Sie fassen zwei Festplatten zu einer Virtuellen zusammen, indem alle Datenblöcke identisch auf beide Platten geschrieben werden. Dadurch ist sichergestellt, dass auch beim Ausfall einer Platte die Daten verfügbar bleiben. 2.2.2. PARTITIONIERUNG Eine weitere triviale Methode Daten zu verteilen ist die Partitionierung. Dabei wird ein Datenblock in mehrere kleinere geteilt und anschließend verteilt. Dieses Verfahren dient nicht der Verbesserung der Datensicherheit, da es keine redundanten Informationen hinzufügt. Es kann aber zum Beispiel dazu genutzt werden, mehrere Speicher zu einem größeren zusammenzufassen, wie es bei RAID-0 der Fall ist. Dabei werden die Datenblöcke eines virtuellen Datenträgers über mehrere reale Datenträger verteilt werden. Oft werden auch die Begriffe Striping oder Slicing synonym verwendet. Es sind auch Kombinationen aus Partitionierung und Replikation möglich, um die Eigenschaften beider Verfahren zu nutzen. Dies ist bei Raid-10 der Fall. Hier wird RAID-0 auf mit RAID-1 gespiegelte Festplatten angewendet. 2.2.3. FORWARD ERROR CORRECTION Forward Error Correction oder Vorwärtsfehlerkorrektur (FEC) ist ein Verfahren zur Fehlerkorrektur durch Rekonstruktion. Es wird oft bei der sicheren Speicherung von 18

2.2. Begriffe zur Datenverteilung Daten und bei der Kanalcodierung auf störanfälligen Übertragungsstrecken verwendet. Durch Hinzufügen redundanter Informationen ist es möglich, eventuell auftretende Fehler zu korrigieren. 2.2.4. ERASURE-CODES Erasure-Codes sind FEC-Codes. Sie zählen zu den Block-Codes, da sie mit Datenblöcken (Symbolen) fester Größe arbeiten. Während in der Codierungstheorie ein Symbol normalerweise ein Bit bezeichnet, bezieht es sich bei Speicheranwendungen auf Datenblöcke einer bestimmten Größe. Das können zum Beispiel die Blöcke einer Festplatte sein.[glw10] Bei Erasure-Codes werden aus k Datenblöcken m Datenblöcke so berechnet, dass die Originaldaten aus beliebigen k der n = k + m rekonstruiert werden können. Von diesen n Blöcken, enthalten die ersten k die aufgeteilten Originaldaten und die berechneten m Datenblöcke die codierte Redundanz.[PSS08] Der Name Erasure-Code leitet sich davon ab, dass hier bis zu m Datenblöcke gelöscht werden können und die Daten trotzdem wieder hergestellt werden können. Die Abbildung 2.1 veranschaulicht dieses Verfahren. Sind weniger als k Wörter vorhanden, können unter Umständen auch noch Teile der Information lesbar sein, da sie in den ersten k Blöcken lediglich aufgeteilt und nicht verändert wird. Die codierten m Blöcke sind dagegen dann unbrauchbar. (a) Fragmente encodieren (b) Fragmente decodieren Abbildung 2.1.: Beim encodieren werden aus dem Inhalt der k Dateifragmente m redundante Fragmente berechnet. Beim Decodieren wird eine Teilmenge mit mindestens k Fragmenten benötigt, um die k originalen Fragmente zu rekonstruieren.[pss08] 2.2.5. INFORMATION DISPERSAL ALGORITHMUS Der Begriff des Information Dispersal Algorithmus (IDA) [Rab89] wurde 1989 von Rabin definiert. Es handelt sich um einen Algorithmus um eine Datei F, der Größe L = F, so in n Fragmente der Größe F n = L/k zu zerlegen, dass jede Teilmenge mit k Fragmenten ausreicht, um die Datei wieder herzustellen.[rab89] Dieses Verfahren ermöglicht die fehlertolerante Speicherung von Dateien. Werden die Frag- 19

2. Hintergrund mente auf n Festplatten verteilt, können bis zu m = n k davon ausfallen, ohne das es zu Datenverlusten kommt. 2.2.6. SECRET-SHARING Secret-Sharing bezeichnet ein Verfahren um ein Geheimnis zu schützen, indem es geteilt wird. Dafür wird es durch einen Algorithmus in n Fragmente geteilt. Um es rekonstruieren zu können sind mindestens k n Fragmente nötig. Sind weniger Fragmente vorhanden, lassen sich keine Rückschlüsse auf das Geheimnis ziehen. Die ursprüngliche Idee war es damit zum Beispiel kryptographische Schlüssel vor dem Zugriff durch eine einzelne Person zu schützen.[sha79, Bla79] 2.3. CODIERUNGSVERFAHREN In diesem Abschnitt werden einige Codierungsverfahren vorgestellt. Tabelle 2.1 gibt einen Überblick über die Vorgaben bei der Parametrisierung der verschiedenen Verfahren, die im Anschluss kurz erläutert werden. 2.3.1. ERASURE-CODES REED-SOLOMON Die Reed-Solomon (RS) Codierung [RS60] ist eine sehr häufig verwendete und leistungsfähige Codierungstechnik. Sie gehört zu den Erasure-Codes und wird zum Beispiel bei der Fehlerkorrektur von Audio-CDs verwendet. Bei der Codierung werden w-bit Wörter verwendet. Über Galois-Feld-Berechnungen mit einer Vandermonde-Matrix und Berechnungen in GF (2 w ) werden jeweils aus k Wörtern m codierte Wörter berechnet. Von diesen n = k + m Wörtern, enthalten k Wörter die Originaldaten und m Wörter die codierte Redundanz. Für die Rekonstruktion der Originaldaten werden mindestens k beliebige Wörter benötigt.[pss08] Sind weniger als k Wörter vorhanden, können unter Umständen noch Teile der Information lesbar sein, da sie in den Datenwörtern lediglich aufgeteilt und nicht verändert werden. Die Inhalte der codierten Teile sind dagegen nicht direkt brauchbar. 20

2.3. Codierungsverfahren CAUCHY REED-SOLOMON Um die aufwändigen Berechnungen in GF (2 w ) zu umgehen, wird bei der Cauchy- Reed-Solomon (CRS) Codierung [BKK + 95] die Verteilungsmatrix in eine Bitmatrix konvertiert. Dadurch kann die Berechnung auf reine XOR Vergleiche reduziert werden. [PSS08] AONT-RS Unter dem Gesichtspunkt der Vertraulichkeit sind RS- und CRS-Codierung nicht optimal. Die k Datenwörter werden nicht verändert, wodurch Teile der Daten ausgelesen werden können ohne alle k Teile zu besitzen. Um das zu umgehen, kombiniert AONT-RS [RP11] die klassische RS-Codierung mit dem All-Or-Nothing-Verfahren von Rivest [Riv97]. Damit bleibt die Information solange vollständig verschlüsselt, bis die zur Decodierung notwendigen k Wörter vorhanden sind. EVENODD EVENODD handelt es sich um einen Paritäts-Test-Code.[BBBM95] Er kommt besonders bei RAID6 Systemen zum Einsatz. EVENODD arbeitet mit einer zweidimensionalen Struktur von Datenwörtern und berechnet daraus die m = 2 Paritätswörter durch XOR Vergleiche.[GLW10] Bei EVENODD muss die Wortlänge w so gewählt werden, dass w + 1 k und w + 1 eine Primzahl ist. Es besteht daher die Möglichkeit für ein bestimmten Wert für k aus mehreren Wortlängen zu wählen. Dabei ist die Codierung für kürzere Wortlängen effizienter als für lange. [Pla07] ROW-DIAGONAL-PARITY Sehr ähnlich zu EVENODD ist die Row-Diagonal-Parity (RDP) [CEG + 04]. Hier sind für die Parameter die folgenden Bedingungen nötig: Für die Wortlänge w muss gelten, dass w + 1 eine Primzahl ist. Weiterhin muss w + 1 > k sein, nicht wie bei EVENODD k. Die Redundanz ist ebenfalls auf m = 2 festgelegt.[pla07] MINIMUM DENSITY CODES Minimum Density RAID-6 Codes arbeiten mit Bitmatrizen. Die Anzahl redundanter Blöcke ist m = 2. Es ist eine minimal-dichte Matrix, wenn sie die geringste mögliche Anzahl von 2kw + k 1 Einsen enthält. Die Kosten für die Codierung sind dabei genau k 1 + (k 1) 2w XOR Operationen. Dies liegt sehr nahe an der optimalen Codierung, für die k 1 XOR Operationen nötig sind. Besonders interessant ist, 21

2. Hintergrund dass der Faktor 1+ 1 2w, um den die Berechnungen über dem Optimum liegen, nicht mehr von k abhängt, sondern ausschließlich von der Wortlänge w.[pla09] Sie kann bei den hier im folgenden betrachteten Codes nicht beliebig gewählt werden. Blaum-Roth Codierung Die Blaum-Roth-Codierung [BR99] benötigt eine Wortlänge w, so dass w + 1 prim ist. Um eine gute Performance zu erreichen, eignen sich besonders w = 4 und w = 16. Die XOR Operationen können dann auf ganzen Datenwörtern ausgeführt werden. Liberation Codierung Bei der Liberation-Codierung [Pla08] gibt es keine derart günstigen Wortlängen, da hier die w ein Primzahl sein muss. Längere Wörter liefern eine bessere Performance als kürzere [Pla07]. Liber8tion Codierung Die Liber8tion Codierung [Pla09] schließt eine Lücke, die von den anderen Minimum-Density-Codes nicht abgedeckt wird. Hier wird die Wortlänge w = 8 verwendet. Das bietet Vorteile bei der Berechnung und Speicherung in Computersystemen. Tabelle 2.1.: Vorgaben der Parameterwahl für verschiedene Codierungsverfahren Verfahren k m w Reed-Solomon beliebig beliebig beliebig Cauchy Reed-Solomon beliebig beliebig beliebig AONT-RS beliebig beliebig beliebig EVENODD beliebig 2 w + 1 k und w + 1 prim RDP beliebig beliebig w + 1 > k und w + 1 prim Secret Sharing beliebig beliebig beliebig liberation w 2 > 2, prim liber8tion w 2 8 Blaum-Roth w 2 > 2, w + 1 prim 2.3.2. SECRET-SHARING ALGORITHMEN Zwei der bekanntesten Secret-Sharing Verfahren wurden fast parallel von G. R. Blakley und Adi Shamir im Jahr 1979 entwickelt. 22

2.4. Vergleich frei verfügbarer Datendispersionsbibliotheken BLAKLEY SECRET-SHARING Das Blakley Secret Sharing war eines der ersten Verfahren, mit dem ein Geheimnis durch Teilen geschützt werden konnte. Es wurde von G. R. Blakley an der Texas A&M University entwickelt. [Bla79] Das Verfahren arbeitet auf geometrischer Basis. Dabei wird das Geheimnis als Punkt S in einem k-dimensionalen Vektorraum als Schnittpunkt der Hyperebenen dargestellt. Jeder zu verteilende Geheimnisteil stellt dann einen k 1-dimensionalen Untervektorraum dar, in dem der Punkt S enthalten ist. Um den Punkt S eindeutig zu bestimmen, sind mindestens k Teile notwendig. Das Verfahren ist jedoch nicht perfekt im Sinne des Secret-Sharing.Das heißt, dass mit Kenntnis jedes weiteren Geheimnisteils die möglichen Punkte für S stark reduziert werden, was das Erraten des Geheimnisses erleichtert.[pla99] SHAMIR SECRET-SHARING Im gleichen Jahr wie Blakleys Algorithmus wurde auch Shamir s Secret-Sharing Algorithmus veröffentlicht. [Sha79] Er basiert auf Polynom-Interpolation. Dabei wird ein Polynom vom Grad k 1 definiert, dessen konstanter Teil das zu schützende Geheimnis darstellt. Nun können n, n k Stützstellen des Polynoms berechnet und verteilt werden. Um das Polynom eindeutig berechnen zu können sind mindestens k der n berechneten Stützstellen notwendig. Sind weniger als k vorhanden, bleibt das Geheimnis geschützt. Dieses Verfahren ist auch perfekt im Sinne des Secret- Sharing. Das heißt, dass selbst durch Kenntnis von k 1 Teilen, immer noch keine Rückschlüsse auf das Geheimnis gezogen werden können.[pla99] Außerdem ist es laut [Sha79] auch effizienter als das Verfahren von Blakley. 2.4. VERGLEICH FREI VERFÜGBARER DATENDISPERSIONSBIBLIOTHEKEN In diesem Abschnitt werden im Internet verfügbare Datendispersionsbibliotheken systematisch verglichen. Dabei werden folgende Aspekte berücksichtigt. Die Programmiersprache, in der die Bibliothek geschrieben wurde, ist mit Blick auf die Performance und die Einbindung in eigene Projekte interessant. Wichtig ist hier auch unter welcher Lizenz die Bibliothek veröffentlicht ist. Weiterhin werden der Funktionsumfang und die unterstützten Codierungsverfahren betrachtet. Außerdem werden Projekte genannt, die die Bibliothek verwenden und betrachtet, ob sie aktuell weiterentwickelt wird. 23

2. Hintergrund Nicht zu allen Verfahren, die in Abschnitt 2.3 erläutert wurden, sind auch Implementierungen verfügbar. So existiert zur Zeit keine öffentlich verfügbare Umsetzung von AONT-RS. Auch EVENODD und RDP finden sich in keiner der betrachteten Bibliotheken. 2.4.1. JERASURE 1.2 Jerasure ist eine C/C++ Bibliothek, die speziell für den Einsatz von Erasure-Codes in Speicheranwendungen entwickelt wurde. Sie soll den Einsatz verschiedener Codierungen ermöglichen und wurde von James S. Plank an der University of Tennessee entwickelt.[pss08] Erstmals wurde Jerasure im September 2007 unter der GNU Lesser General Public License 2.1 veröffentlicht. Version 1.2, die einige Verbesserungen enthält, ist aus dem August 2008. Version 1.2A kam im Mai 2011 heraus. Sie enthält jedoch keine Neuerungen, sondern ist lediglich unter einer anderen Lizenz herausgegeben, der New BSD License. Für diese Version ist auf GitHub eine inoffizielle Version mit Java JNI Wrapper zu finden. 1 2 Jerasure hat einen großen Funktionsumfang und ist sehr flexibel einsetzbar. Laut dem Bericht [PSS08] zur Bibliothek, werden klassische Reed-Solomon Codierung, Cauchy Reed-Solomon Codierung sowie Minimal Density RAID-6 Codierungen unterstützt. Bei der klassischen Reed-Solomon Codierung kann zwischen der Verwendung von Vandermonde-Matrizen und speziellen, für RAID-6 optimierten Prozeduren, bei denen die Anzahl redundanter Blöcke m = 2 vorgegeben ist, gewählt werden. Bei der Cauchy Reed-Solomon Codierung kann zwischen der Verwendung der originalen Cauchy-Matrizen und optimierten Matrizen gewählt werden. Es ist außerdem eine Heuristik enthalten, mit der Matrizen optimiert werden können, damit weniger Berechnungen durchgeführt werden müssen. Aus der Kategorie Minimal-Density RAID-6 Codierungen werden Liberation-, Liber8tion- und Blaum- Roth-Codierung unterstützt. Außerdem bietet Jerasure die Möglichkeit Bitmatrizen zu erzeugen, die alle bei der Codierung notwendigen Operationen in XOR Operationen transformieren. Dies bringt schon einen erheblichen Performancegewinn. Darüber hinaus kann aus einer Bitmatrix ein sogenanntes schedule erzeugt werden, in dem nur noch die wirklich zu berechnenden Operationen enthalten sind. Es muss also bei der Codierung nicht jedes mal die Bitmatrix nach Einsen durchsucht werden, was einen weiteren Performancegewinn darstellt. Der Prototyp des Projektes CORE [LLL13] bindet die Jerasure Bibliothek ein. Er wird seit 2013 an der Chinese University of Hong Kong entwickelt und verwendet die von Jerasure implementierten Codes und Bitmatrixoptimierungen. 1 Webseite zu Jerasure http://web.eecs.utk.edu/~plank/plank/papers/cs-08-627.html 2 Git Repository: Jerasure mit Java JNI Wrapper https://github.com/jvandertil/jerasure 24

2.4. Vergleich frei verfügbarer Datendispersionsbibliotheken Tabelle 2.2.: Zusammenfassung zu Jerasure 1.2 Sprache Funktionalität Stand gepflegt Lizenz C++, viele Verfahren 2011 nein New BSD License / (Java Wrapper) LGPL 2.4.2. JERASURE 2.0 Mitte 2011 wurde von Deshmukh, Maginnis und Chandler ein Design-Dokument zur Weiterentwicklung von Jerasure veröffentlicht [DMC11]. Es beschreibt, wie die bestehende Jerasure Bibliothek an den Stand der Technik angepasst werden sollte. Ein offizielles Update der Bibliothek ist nicht veröffentlicht worden. Laut [PH13] war es für August 2013 geplant und sollte eine neue Bibliothek für die Galois-Feld Berechnungen verwenden, Multithreading unterstützen sowie weitere Codierungsverfahren implementieren. Leider ist das Update bis zur Fertigstellung dieser Arbeit noch nicht veröffentlicht worden. Auf Google Project Hosting ist die Bibliothek bereits zu finden.[goo11] Laut der dazugehörigen Dokumentation 3 soll diese Version objektorientiert geschrieben sein. Auch sollen, neben den aus Jerasure 1.2 bekannten Verfahren, bereits EVENODD und RDP Codierung unterstützt werden. Außerdem soll Multithreading implementiert worden sein. Inwiefern weitere Vorschläge aus dem Design-Dokument umgesetzt wurden, ist nicht bekannt. Jerasure 2.0 ist wie die Vorgängerversion unter der New BSD License veröffentlicht. Seit August 2011 wurde das Projekte nicht weiter gepflegt. Tabelle 2.3.: Zusammenfassung zu Jerasure 2.0 Sprache Funktionalität Stand gepflegt Lizenz C++ große Auswahl an Verfahren 2011 nein New BSD License 2.4.3. GF-COMPLETE Die GF-Complete Bibliothek [PMH13] implementiert selbst keine Codierungsverfahren. Sie soll hier aber dennoch erwähnt werden, da sie auf Prozessoren mit Intel SSE3 Erweiterung sehr schnelle Galois-Feld Arithmetik zur Verfügung stellt. Dadurch können, entsprechende Prozessoren vorausgesetzt, andere Bibliotheken, wie zum Beispiel Jerasure, erheblich beschleunigt werden. GF-Complete wurde unter anderem von James S. Plank an der University of Tennessee entwickeln. Hier wird noch die Version 0.1 betrachten. Version 1 sollte im 3 [Goo11] als PDF im Unterverzeichnis trunk/jerasure3/documentation/paper.pdf 25

2. Hintergrund Juni 2013 veröffentlicht werden. Bis zur Fertigstellung dieser Arbeit ist sie jedoch noch nicht veröffentlicht worden. Tabelle 2.4.: Zusammenfassung zu GF-Complete Sprache Funktionalität Stand gepflegt Lizenz C++ Galois-Feld Arithmetik 2013 ja New BSD License 2.4.4. JIGDFS Das Jigsaw Distributed File System (JigDFS) [BS09] ist ein Projekt für ein sicheres, verteiltes Dateisystem auf P2P Basis. JigDFS verwendet eine Java-Implementierung des Cauchy Reed-Solomon Codes und verschlüsselt die Dateien zusätzlich. Entwickelt wurde JigDFS von Jiang Bian an der University of Arkansas at Little Rock. Es wurde unter der GNU General Public License v3 publiziert. Seit der Veröffentlichung im Jahr 2009 wurde das Projekt nicht weiterentwickelt. Die Java Klassen aus JigDFS werden im aktuellen Splitter des NubiSave Prototyps verwendet.[sbm + 11][Mü12] Tabelle 2.5.: Zusammenfassung zu JigDFS Sprache Funktionalität Stand gepflegt Lizenz Java Cauchy Reed-Solomon 2009 nein GNU GPLv3 2.4.5. SCHIFRA Schifra [Par00] von Arash Partow implementiert die Reed-Solomon in C++ und VHDL. Schifra ist flexibel und gut optimiert. Es werden viele Reed-Solomon Varianten unterstützt, wie sie unter anderem bei Intelsat 1-4, DVB-S/T und WiMAX IEEE 802.16d zum Einsatz kommen. Außerdem werden optimierte Encoder und Decoder für SSE1-3 angeboten. Für die private und nicht kommerzielle Nutzung ist Schifra unter der GNU General Public License (Version 2) veröffentlicht. Zum freien Download steht Version 0.0.1 als C++ Version vom Juli 2000 bereit. Für die kommerzielle Nutzung gilt die Schifra General User License. Die Dokumentation und anscheinend auch die VHDL Implementierung sind nur gegen Bezahlung unter dieser Lizenz verfügbar. [Par00] Plank et al. [PLS + 09] haben die Open-Source Variante von Schifra in ihrer Performanceanalyse nicht betrachtet, da sie keinen Encoder und Decoder implementieren konnten, der ausreichende Vergleichbarkeit mit den anderen betrachten Bibliotheken bot. 26