diff --git a/WebRaid.Node.Raid.Tests/RaidNodeTests.cs b/WebRaid.Node.Raid.Tests/RaidNodeTests.cs new file mode 100644 index 0000000..849aa47 --- /dev/null +++ b/WebRaid.Node.Raid.Tests/RaidNodeTests.cs @@ -0,0 +1,253 @@ +using System; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using FluentAssertions; +using Microsoft.Extensions.Logging; +using NUnit.Framework; +using Test.Extensions.Logging; + +namespace WebRaid.Node.Raid.Tests +{ + public class RaidNodeTests : BasisTestKlasse + { + private const int Segment = 64; + private static readonly byte[] Schluessel = Enumerable.Range(1, 32).Select(i => (byte)i).ToArray(); + + private TestKnoten[] knoten; + + public RaidNodeTests() : base(LogLevel.Debug) { } + + private RaidNode UnterTest(int k = 3, int m = 2, int anzahl = 5, byte[] schluessel = null) + { + knoten ??= Enumerable.Range(1, anzahl).Select(i => new TestKnoten($"K{i}")).ToArray(); + return new RaidNode("Raid", knoten, + new RaidOptionen { DatenBloecke = k, ParitaetsBloecke = m, SegmentGroesse = Segment }, + new FesterSchluessel(schluessel ?? Schluessel), Lf.Logger()); + } + + [SetUp] + public void SetUp() => knoten = null; + + private static byte[] Daten(int laenge, int saat = 1) + { + var daten = new byte[laenge]; + new Random(saat).NextBytes(daten); + return daten; + } + + private static async Task Lesen(Stream stream) + { + using (var kopie = new MemoryStream()) + { + await stream.CopyToAsync(kopie); + return kopie.ToArray(); + } + } + + [TestCase(0)] + [TestCase(1)] + [TestCase(Segment - 1)] + [TestCase(Segment)] + [TestCase(Segment + 1)] + [TestCase(3 * Segment + 17)] + public async Task Write_DannGet_GibtDenInhalt(int laenge) + { + var unterTest = UnterTest(); + var daten = Daten(laenge); + + (await unterTest.Write("datei", new MemoryStream(daten))).Should().BeTrue(); + + (await Lesen(await unterTest.Get("datei"))).Should().Equal(daten); + } + + [Test] + public async Task Get_BisZuMKnotenAusgefallen_GibtDenInhalt() + { + var unterTest = UnterTest(k: 3, m: 2, anzahl: 5); + var daten = Daten(5 * Segment + 3); + await unterTest.Write("datei", new MemoryStream(daten)); + + for (var a = 0; a < 5; a++) + for (var b = a + 1; b < 5; b++) + { + foreach (var kn in knoten) kn.Ausgefallen = false; + knoten[a].Ausgefallen = true; + knoten[b].Ausgefallen = true; + + (await Lesen(await unterTest.Get("datei"))).Should().Equal(daten, $"Ausfall von K{a + 1} und K{b + 1}"); + } + } + + [Test] + public async Task Get_MehrAlsMKnotenAusgefallen_WirftIOException() + { + var unterTest = UnterTest(k: 3, m: 2, anzahl: 5); + await unterTest.Write("datei", new MemoryStream(Daten(100))); + knoten[0].Ausgefallen = knoten[1].Ausgefallen = knoten[2].Ausgefallen = true; + + Func aktion = () => unterTest.Get("datei"); + + await aktion.Should().ThrowAsync(); + } + + [Test] + public async Task Get_KnotenLiefertVerfaelschteDaten_WirdErkanntUndKorrigiert() + { + var unterTest = UnterTest(k: 3, m: 2, anzahl: 5); + var daten = Daten(4 * Segment); + await unterTest.Write("datei", new MemoryStream(daten)); + knoten[1].Verfaelscht = true; + knoten[3].Verfaelscht = true; + + (await Lesen(await unterTest.Get("datei"))).Should().Equal(daten); + } + + [Test] + public async Task Get_NurNochZweiKnoten_MetadatenUndDatenBeiK2Lesbar() + { + var unterTest = UnterTest(k: 2, m: 3, anzahl: 5); + var daten = Daten(3 * Segment); + await unterTest.Write("datei", new MemoryStream(daten)); + knoten[0].Ausgefallen = knoten[2].Ausgefallen = knoten[4].Ausgefallen = true; + + (await Lesen(await unterTest.Get("datei"))).Should().Equal(daten); + } + + [Test] + public async Task Anbieter_SiehtWederInhaltNochDateinamen() + { + var unterTest = UnterTest(); + var klartext = Encoding.UTF8.GetBytes(string.Concat(Enumerable.Repeat("GeheimerInhalt ", 30))); + + await unterTest.Write("Steuererklaerung.pdf", new MemoryStream(klartext)); + + var muster = Encoding.UTF8.GetBytes("GeheimerInhalt"); + foreach (var kn in knoten) + { + kn.Inhalt.Keys.Should().NotContain(a => a.Contains("Steuer")); + foreach (var block in kn.Inhalt.Values) + { + block.AsSpan().IndexOf(muster).Should().Be(-1, $"auf {kn.Name} darf kein Klartext liegen"); + } + } + } + + [Test] + public async Task Get_FalscherHauptschluessel_FindetDateiNicht() + { + await UnterTest().Write("datei", new MemoryStream(Daten(100))); + var andererSchluessel = Enumerable.Repeat((byte)7, 32).ToArray(); + + // Mit anderem Schlüssel ergibt sich eine andere Manifest-Adresse: die Datei ist schlicht nicht da + (await UnterTest(schluessel: andererSchluessel).Get("datei")).Should().BeNull(); + } + + [Test] + public async Task Get_ManifestAufAllenKnotenBeschaedigt_WirftInvalidDataException() + { + var unterTest = UnterTest(); + await unterTest.Write("datei", new MemoryStream(Daten(100))); + foreach (var kn in knoten) + foreach (var adresse in kn.Inhalt.Keys.Where(a => a.StartsWith("m/")).ToList()) + { + var teil = kn.Inhalt[adresse]; + teil[^1] ^= 0x01; + } + + Func aktion = () => unterTest.Get("datei"); + + await aktion.Should().ThrowAsync(); + } + + [Test] + public async Task Write_Ueberschreiben_EntferntAlteBloecke() + { + var unterTest = UnterTest(); + await unterTest.Write("datei", new MemoryStream(Daten(3 * Segment, 1))); + var vorher = knoten.SelectMany(k => k.Inhalt.Keys.Where(a => a.StartsWith("b/"))).ToHashSet(); + var neu = Daten(2 * Segment, 2); + + await unterTest.Write("datei", new MemoryStream(neu)); + + var nachher = knoten.SelectMany(k => k.Inhalt.Keys.Where(a => a.StartsWith("b/"))).ToHashSet(); + nachher.Should().NotIntersectWith(vorher); + nachher.Should().HaveCount(2 * 5); + (await Lesen(await unterTest.Get("datei"))).Should().Equal(neu); + } + + [Test] + public async Task Write_EinKnotenAusgefallen_GelingtMitEingeschraenkterRedundanz() + { + var unterTest = UnterTest(k: 3, m: 2, anzahl: 5); + var daten = Daten(2 * Segment); + knoten[4].Ausgefallen = true; + + (await unterTest.Write("datei", new MemoryStream(daten))).Should().BeTrue(); + + knoten[4].Ausgefallen = false; + knoten[0].Ausgefallen = true; + (await Lesen(await unterTest.Get("datei"))).Should().Equal(daten); + } + + [Test] + public async Task Write_ZuVieleKnotenAusgefallen_GibtFalseUndBehaeltAlteVersion() + { + var unterTest = UnterTest(k: 3, m: 2, anzahl: 5); + var alt = Daten(100, 1); + await unterTest.Write("datei", new MemoryStream(alt)); + knoten[0].Ausgefallen = knoten[1].Ausgefallen = knoten[2].Ausgefallen = true; + + (await unterTest.Write("datei", new MemoryStream(Daten(100, 2)))).Should().BeFalse(); + + foreach (var kn in knoten) kn.Ausgefallen = false; + (await Lesen(await unterTest.Get("datei"))).Should().Equal(alt); + } + + [Test] + public async Task Write_ManifestTeilweiseAlt_LiestDieNeuesteVersion() + { + var unterTest = UnterTest(k: 2, m: 1, anzahl: 3); + await unterTest.Write("datei", new MemoryStream(Daten(100, 1))); + var neu = Daten(100, 2); + knoten[2].Ausgefallen = true; + await unterTest.Write("datei", new MemoryStream(neu)); + + // K3 hat noch das alte Manifest, K1 und K2 das neue + knoten[2].Ausgefallen = false; + + (await Lesen(await unterTest.Get("datei"))).Should().Equal(neu); + } + + [Test] + public async Task Del_EntferntAllesVonAllenKnoten() + { + var unterTest = UnterTest(); + await unterTest.Write("datei", new MemoryStream(Daten(3 * Segment))); + + (await unterTest.Del("datei")).Should().BeTrue(); + + foreach (var kn in knoten) kn.Inhalt.Should().BeEmpty(); + (await unterTest.Get("datei")).Should().BeNull(); + } + + [Test] + public void Konstruktor_ZuWenigeKnotenFuerKPlusM_WirftAusnahme() + { + Action aktion = () => UnterTest(k: 3, m: 2, anzahl: 4); + + aktion.Should().Throw().WithMessage("*k + m*"); + } + + [Test] + public void Konstruktor_DoppelteKnotennamen_WirftAusnahme() + { + knoten = new[] { new TestKnoten("A"), new TestKnoten("A"), new TestKnoten("B") }; + + Action aktion = () => UnterTest(k: 2, m: 1); + + aktion.Should().Throw().WithMessage("*eindeutige*"); + } + } +} diff --git a/WebRaid.Node.Raid.Tests/RaidNodeVertragTests.cs b/WebRaid.Node.Raid.Tests/RaidNodeVertragTests.cs new file mode 100644 index 0000000..079ba35 --- /dev/null +++ b/WebRaid.Node.Raid.Tests/RaidNodeVertragTests.cs @@ -0,0 +1,23 @@ +using System.Linq; +using FluentAssertions; +using WebRaid.Node.TestsBase; + +namespace WebRaid.Node.Raid.Tests +{ + public class RaidNodeVertragTests : NodeTests + { + protected override RaidNode GetNode() => + new RaidNode(configuration["Name"], Enumerable.Range(1, 3).Select(i => new TestKnoten($"K{i}")), + new RaidOptionen { DatenBloecke = 2, ParitaetsBloecke = 1 }, + new FesterSchluessel(new byte[32]), Lf.Logger()); + + protected override void AddTestDaten(RaidNode node, string key, string daten) => + node.Write(key, GenerateStreamFromString(daten)).GetAwaiter().GetResult().Should().BeTrue(); + + protected override void ContainKey(RaidNode node, string key) => + node.Get(key).GetAwaiter().GetResult().Should().NotBeNull(); + + protected override void NotContainKey(RaidNode node, string key) => + node.Get(key).GetAwaiter().GetResult().Should().BeNull(); + } +} diff --git a/WebRaid.Node.Raid.Tests/ReedSolomonTests.cs b/WebRaid.Node.Raid.Tests/ReedSolomonTests.cs new file mode 100644 index 0000000..04f4d55 --- /dev/null +++ b/WebRaid.Node.Raid.Tests/ReedSolomonTests.cs @@ -0,0 +1,83 @@ +using System; +using System.Linq; +using FluentAssertions; +using NUnit.Framework; + +namespace WebRaid.Node.Raid.Tests +{ + public class ReedSolomonTests + { + [TestCase(1, 0)] + [TestCase(1, 2)] + [TestCase(2, 1)] + [TestCase(3, 2)] + [TestCase(4, 4)] + [TestCase(10, 4)] + public void Wiederherstellen_JedeAuswahlBisMAusfaelle_ErgibtDieDaten(int k, int m) + { + var code = new ReedSolomon(k, m); + var zufall = new Random(k * 100 + m); + var original = Enumerable.Range(0, k + m).Select(_ => new byte[37]).ToArray(); + for (var i = 0; i < k; i++) zufall.NextBytes(original[i]); + code.Kodieren(original); + + foreach (var ausfaelle in Teilmengen(k + m, m)) + { + var bloecke = original.Select(b => (byte[])b.Clone()).ToArray(); + var vorhanden = Enumerable.Repeat(true, k + m).ToArray(); + foreach (var a in ausfaelle) + { + vorhanden[a] = false; + zufall.NextBytes(bloecke[a]); + } + + code.Wiederherstellen(bloecke, vorhanden); + + for (var i = 0; i < k + m; i++) bloecke[i].Should().Equal(original[i], $"Block {i} bei Ausfall von {string.Join(",", ausfaelle)}"); + } + } + + [Test] + public void Kodieren_LaesstDatenBloeckeUnveraendert() + { + var code = new ReedSolomon(3, 2); + var bloecke = Enumerable.Range(0, 5).Select(i => Enumerable.Repeat((byte)(i + 1), 8).ToArray()).ToArray(); + + code.Kodieren(bloecke); + + bloecke[0].Should().OnlyContain(b => b == 1); + bloecke[1].Should().OnlyContain(b => b == 2); + bloecke[2].Should().OnlyContain(b => b == 3); + } + + [Test] + public void Wiederherstellen_ZuVieleAusfaelle_WirftAusnahme() + { + var code = new ReedSolomon(3, 2); + var bloecke = Enumerable.Range(0, 5).Select(_ => new byte[4]).ToArray(); + + Action aktion = () => code.Wiederherstellen(bloecke, new[] { true, false, true, false, false }); + + aktion.Should().Throw(); + } + + [TestCase(0, 1)] + [TestCase(1, -1)] + [TestCase(200, 56)] + public void Konstruktor_UngueltigeParameter_WirftAusnahme(int k, int m) + { + Action aktion = () => new ReedSolomon(k, m); + + aktion.Should().Throw(); + } + + /// Alle Teilmengen von {0..n-1} mit genau Elementen + private static int[][] Teilmengen(int n, int groesse) + { + if (groesse == 0) return new[] { Array.Empty() }; + return Enumerable.Range(0, n) + .SelectMany(erstes => Teilmengen(n, groesse - 1).Where(rest => rest.All(r => r > erstes)).Select(rest => new[] { erstes }.Concat(rest).ToArray())) + .ToArray(); + } + } +} diff --git a/WebRaid.Node.Raid.Tests/TestKnoten.cs b/WebRaid.Node.Raid.Tests/TestKnoten.cs new file mode 100644 index 0000000..8f75500 --- /dev/null +++ b/WebRaid.Node.Raid.Tests/TestKnoten.cs @@ -0,0 +1,63 @@ +using System; +using System.Collections.Concurrent; +using System.IO; +using System.Threading.Tasks; +using WebRaid.Abstraction.Speicher; + +namespace WebRaid.Node.Raid.Tests +{ + /// + /// Ein Speicher im Arbeitsspeicher, der sich ausschalten und manipulieren lässt + /// + internal sealed class TestKnoten : IRawNode + { + public ConcurrentDictionary Inhalt { get; } = new ConcurrentDictionary(); + + /// Jeder Zugriff wirft eine Ausnahme, wie bei einem nicht erreichbaren Server + public bool Ausgefallen { get; set; } + + /// Gelesene Daten werden verändert, wie bei einem manipulierenden Anbieter + public bool Verfaelscht { get; set; } + + public TestKnoten(string name) + { + Name = name; + } + + public string Name { get; } + + public Task Get(string adresse) + { + Pruefen(); + if (!Inhalt.TryGetValue(adresse, out var daten)) return Task.FromResult(null); + if (Verfaelscht) + { + daten = (byte[])daten.Clone(); + daten[daten.Length - 1] ^= 0xFF; + } + return Task.FromResult(new MemoryStream(daten, false)); + } + + public async Task Write(string adresse, Stream input) + { + Pruefen(); + using (var kopie = new MemoryStream()) + { + await input.CopyToAsync(kopie); + Inhalt[adresse] = kopie.ToArray(); + } + return true; + } + + public Task Del(string adresse) + { + Pruefen(); + return Task.FromResult(Inhalt.TryRemove(adresse, out _)); + } + + private void Pruefen() + { + if (Ausgefallen) throw new IOException($"{Name} ist nicht erreichbar"); + } + } +} diff --git a/WebRaid.Node.Raid.Tests/WebRaid.Node.Raid.Tests.csproj b/WebRaid.Node.Raid.Tests/WebRaid.Node.Raid.Tests.csproj new file mode 100644 index 0000000..7c69b37 --- /dev/null +++ b/WebRaid.Node.Raid.Tests/WebRaid.Node.Raid.Tests.csproj @@ -0,0 +1,23 @@ + + + + net10.0 + + false + + + + + + + + + + + + + + + + + diff --git a/WebRaid.Node.Raid/ISchluesselQuelle.cs b/WebRaid.Node.Raid/ISchluesselQuelle.cs new file mode 100644 index 0000000..ee0ee4c --- /dev/null +++ b/WebRaid.Node.Raid/ISchluesselQuelle.cs @@ -0,0 +1,36 @@ +using System; + +namespace WebRaid.Node.Raid +{ + /// + /// Liefert den Hauptschlüssel eines RAIDs. + /// Woher er kommt (DPAPI, Passphrase, ...) entscheidet die Implementierung. + /// + public interface ISchluesselQuelle + { + /// + /// Der Hauptschlüssel, 32 Byte + /// + ReadOnlyMemory Hauptschluessel { get; } + } + + /// + /// Ein fest übergebener Hauptschlüssel, z.B. für Tests + /// + public sealed class FesterSchluessel : ISchluesselQuelle + { + private readonly byte[] schluessel; + + /// + /// Übernimmt (32 Byte) + /// + public FesterSchluessel(byte[] schluessel) + { + if (schluessel == null || schluessel.Length != 32) throw new ArgumentException("Der Hauptschlüssel muss 32 Byte lang sein", nameof(schluessel)); + this.schluessel = (byte[])schluessel.Clone(); + } + + /// + public ReadOnlyMemory Hauptschluessel => schluessel; + } +} diff --git a/WebRaid.Node.Raid/Manifest.cs b/WebRaid.Node.Raid/Manifest.cs new file mode 100644 index 0000000..a62710a --- /dev/null +++ b/WebRaid.Node.Raid/Manifest.cs @@ -0,0 +1,45 @@ +using System.Collections.Generic; + +namespace WebRaid.Node.Raid +{ + /// + /// Beschreibt eine gespeicherte Datei: Schlüssel, Aufteilung und Ablageort aller Blöcke. + /// Wird selbst verschlüsselt und auf allen Knoten verteilt abgelegt. + /// + internal sealed class Manifest + { + public int Format { get; set; } = 1; + + /// Wird bei jedem Schreiben hochgezählt (Grundlage für den Rollback-Schutz) + public long Version { get; set; } + + /// Länge des Klartexts in Byte + public long Laenge { get; set; } + + public int DatenBloecke { get; set; } + public int ParitaetsBloecke { get; set; } + + /// Schlüssel nur für diese Version der Datei + public byte[] Schluessel { get; set; } + + /// Zufällige Kennung dieser Version, aus der die Blockadressen abgeleitet werden + public byte[] Kennung { get; set; } + + public List Segmente { get; set; } = new List(); + } + + internal sealed class Segment + { + /// Länge des verschlüsselten Segments (Klartext + 16 Byte Prüfwert) + public int Laenge { get; set; } + + /// Je Block der Knoten und der SHA-256-Wert; , wenn das Schreiben fehlschlug + public List Bloecke { get; set; } = new List(); + } + + internal sealed class Block + { + public string Knoten { get; set; } + public byte[] Hash { get; set; } + } +} diff --git a/WebRaid.Node.Raid/RaidNode.cs b/WebRaid.Node.Raid/RaidNode.cs new file mode 100644 index 0000000..4a94516 --- /dev/null +++ b/WebRaid.Node.Raid/RaidNode.cs @@ -0,0 +1,542 @@ +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Security.Cryptography; +using System.Text; +using System.Text.Json; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using WebRaid.Abstraction.Speicher; + +namespace WebRaid.Node.Raid +{ + /// + /// Einstellungen eines + /// + public sealed class RaidOptionen + { + /// Anzahl der Datenblöcke je Segment (k) + public int DatenBloecke { get; set; } = 2; + + /// Anzahl der Paritätsblöcke je Segment (m) = verkraftbare Ausfälle + public int ParitaetsBloecke { get; set; } = 1; + + /// Größe der Klartext-Segmente in Byte + public int SegmentGroesse { get; set; } = 1024 * 1024; + } + + /// + /// Fasst mehrere zu einem ausfallsicheren, verschlüsselten Speicher zusammen. + /// + /// Jede Datei wird in Segmente geteilt, jedes Segment mit ChaCha20-Poly1305 und einem Schlüssel nur für + /// diese Dateiversion verschlüsselt und per Reed-Solomon in k Daten- und m Paritätsblöcke zerlegt. + /// Jeder Block landet auf einem anderen Knoten; bis zu m Knoten dürfen ausfallen oder falsche Daten liefern. + /// + /// + /// Die Beschreibung der Datei (Manifest) wird mit dem Hauptschlüssel verschlüsselt und so auf alle Knoten + /// verteilt, dass zwei beliebige Knoten genügen, um sie zu lesen. Kein einzelner Knoten sieht Dateinamen, + /// Inhalte oder den Zusammenhang der Blöcke. + /// + /// + public class RaidNode : INode + { + private const int NonceLaenge = 12; + private const int TagLaenge = 16; + private const int KopfLaenge = 3; + + private readonly IReadOnlyList knoten; + private readonly Dictionary knotenNachName; + private readonly ReedSolomon datenCode; + private readonly ReedSolomon metaCode; + private readonly int segmentGroesse; + private readonly byte[] manifestSchluessel; + private readonly byte[] adressSchluessel; + private readonly ILogger logger; + + /// + /// Erstellt einen RAID-Knoten über + /// + /// Eindeutiger Name + /// Die zugrundeliegenden Speicher, mindestens k + m, alle mit verschiedenem Namen + /// k, m und Segmentgröße + /// Quelle des Hauptschlüssels + /// Logger, um dem Speicherknoten auf die Finger schauen zu können ;-) + public RaidNode(string name, IEnumerable knoten, RaidOptionen optionen, ISchluesselQuelle schluessel, ILogger logger) + { + this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); + if (optionen == null) throw new ArgumentNullException(nameof(optionen)); + if (schluessel == null) throw new ArgumentNullException(nameof(schluessel)); + this.knoten = knoten?.ToList() ?? throw new ArgumentNullException(nameof(knoten)); + Name = name; + + if (this.knoten.Count == 0) throw new ArgumentException("Mindestens ein Knoten wird benötigt", nameof(knoten)); + if (this.knoten.Count > 255) throw new ArgumentException("Höchstens 255 Knoten", nameof(knoten)); + if (this.knoten.Select(k => k.Name).Distinct().Count() != this.knoten.Count) throw new ArgumentException("Die Knoten brauchen eindeutige Namen", nameof(knoten)); + if (optionen.SegmentGroesse < 1) throw new ArgumentOutOfRangeException(nameof(optionen), "SegmentGroesse muss positiv sein"); + if (optionen.DatenBloecke + optionen.ParitaetsBloecke > this.knoten.Count) + { + throw new ArgumentException($"k + m = {optionen.DatenBloecke + optionen.ParitaetsBloecke} Blöcke brauchen mindestens so viele Knoten, vorhanden: {this.knoten.Count}", nameof(knoten)); + } + knotenNachName = this.knoten.ToDictionary(k => k.Name); + + datenCode = new ReedSolomon(optionen.DatenBloecke, optionen.ParitaetsBloecke); + var metaDaten = Math.Min(2, this.knoten.Count); + metaCode = new ReedSolomon(metaDaten, this.knoten.Count - metaDaten); + segmentGroesse = optionen.SegmentGroesse; + + var haupt = schluessel.Hauptschluessel.Span; + if (haupt.Length != 32) throw new ArgumentException("Der Hauptschlüssel muss 32 Byte lang sein", nameof(schluessel)); + manifestSchluessel = HKDF.DeriveKey(HashAlgorithmName.SHA256, haupt.ToArray(), 32, Array.Empty(), Encoding.UTF8.GetBytes("WebRaid/Manifest")); + adressSchluessel = HKDF.DeriveKey(HashAlgorithmName.SHA256, haupt.ToArray(), 32, Array.Empty(), Encoding.UTF8.GetBytes("WebRaid/Adresse")); + + logger.LogDebug($"New RaidNode({Name}, k={datenCode.DatenBloecke}, m={datenCode.ParitaetsBloecke}, Knoten={string.Join(",", knotenNachName.Keys)})"); + } + + /// + public string Name { get; } + + /// + /// Wenn zu viele Blöcke fehlen oder beschädigt sind + /// Wenn die Daten nicht entschlüsselt werden können (falscher Schlüssel oder Manipulation) + public async Task Get(string adresse) + { + logger.LogDebug($"Get({adresse})"); + Adresse.Pruefen(adresse); + + var manifest = await ManifestLaden(adresse).ConfigureAwait(false); + if (manifest == null) + { + logger.LogWarning($"'{adresse}' nicht gefunden!"); + return null; + } + + var code = manifest.DatenBloecke == datenCode.DatenBloecke && manifest.ParitaetsBloecke == datenCode.ParitaetsBloecke + ? datenCode + : new ReedSolomon(manifest.DatenBloecke, manifest.ParitaetsBloecke); + + var ausgabe = new MemoryStream(); + using (var aead = new ChaCha20Poly1305(manifest.Schluessel)) + { + for (var s = 0; s < manifest.Segmente.Count; s++) + { + var chiffrat = await SegmentLesen(manifest, code, s).ConfigureAwait(false); + var klartext = new byte[chiffrat.Length - TagLaenge]; + try + { + aead.Decrypt(SegmentNonce(s), chiffrat.AsSpan(0, klartext.Length), chiffrat.AsSpan(klartext.Length), klartext, SegmentDaten(manifest.Kennung, s)); + } + catch (CryptographicException e) + { + throw new InvalidDataException($"'{adresse}': Segment {s} lässt sich nicht entschlüsseln", e); + } + ausgabe.Write(klartext); + } + } + + ausgabe.Position = 0; + return ausgabe; + } + + /// + /// + /// , wenn jedes Segment auf mindestens k Knoten und das Manifest auf mindestens zwei Knoten liegt + /// Sonst ; eine vorherige Version bleibt dann erhalten + /// + public async Task Write(string adresse, Stream input) + { + logger.LogDebug($"Write({adresse})"); + Adresse.Pruefen(adresse); + if (input == null) throw new ArgumentNullException(nameof(input)); + + Manifest alt; + try + { + alt = await ManifestLaden(adresse).ConfigureAwait(false); + } + catch (InvalidDataException e) + { + logger.LogWarning(e, $"Write({adresse}): Vorherige Version nicht lesbar, sie wird ersetzt"); + alt = null; + } + + var manifest = new Manifest + { + Version = (alt?.Version ?? 0) + 1, + DatenBloecke = datenCode.DatenBloecke, + ParitaetsBloecke = datenCode.ParitaetsBloecke, + Schluessel = RandomNumberGenerator.GetBytes(32), + Kennung = RandomNumberGenerator.GetBytes(16) + }; + + using (var aead = new ChaCha20Poly1305(manifest.Schluessel)) + { + var puffer = new byte[segmentGroesse]; + var gelesen = await Fuellen(input, puffer).ConfigureAwait(false); + for (var s = 0; gelesen > 0; s++) + { + var chiffrat = new byte[gelesen + TagLaenge]; + aead.Encrypt(SegmentNonce(s), puffer.AsSpan(0, gelesen), chiffrat.AsSpan(0, gelesen), chiffrat.AsSpan(gelesen), SegmentDaten(manifest.Kennung, s)); + + var segment = await SegmentSchreiben(manifest.Kennung, s, chiffrat).ConfigureAwait(false); + manifest.Segmente.Add(segment); + manifest.Laenge += gelesen; + + var geschrieben = segment.Bloecke.Count(b => b != null); + if (geschrieben < datenCode.DatenBloecke) + { + logger.LogWarning($"Write({adresse}): Segment {s} nur auf {geschrieben} von mindestens {datenCode.DatenBloecke} Knoten geschrieben"); + await BloeckeLoeschen(manifest).ConfigureAwait(false); + return false; + } + if (geschrieben < datenCode.Bloecke) + { + logger.LogWarning($"Write({adresse}): Segment {s} nur auf {geschrieben} von {datenCode.Bloecke} Knoten, Redundanz eingeschränkt"); + } + + gelesen = await Fuellen(input, puffer).ConfigureAwait(false); + } + } + + if (!await ManifestSchreiben(adresse, manifest).ConfigureAwait(false)) + { + await BloeckeLoeschen(manifest).ConfigureAwait(false); + return false; + } + + if (alt != null) await BloeckeLoeschen(alt).ConfigureAwait(false); + return true; + } + + /// + public async Task Del(string adresse) + { + logger.LogDebug($"Del({adresse})"); + Adresse.Pruefen(adresse); + + var manifest = await ManifestLaden(adresse).ConfigureAwait(false); + if (manifest == null) + { + logger.LogWarning($"'{adresse}' nicht gefunden!"); + return false; + } + + await BloeckeLoeschen(manifest).ConfigureAwait(false); + var manifestAdresse = ManifestAdresse(adresse); + await Task.WhenAll(knoten.Select(k => Sicher(() => k.Del(manifestAdresse), $"Del({manifestAdresse}) auf {k.Name}"))).ConfigureAwait(false); + return true; + } + + #region Segmente + + private IRawNode KnotenFuer(int segment, int block) => knoten[(block + segment) % knoten.Count]; + + private async Task SegmentSchreiben(byte[] kennung, int s, byte[] chiffrat) + { + var bloecke = Zerlegen(chiffrat, datenCode); + datenCode.Kodieren(bloecke); + + var ergebnisse = await Task.WhenAll(Enumerable.Range(0, datenCode.Bloecke).Select(async j => + { + var ziel = KnotenFuer(s, j); + var ok = await Sicher(() => ziel.Write(BlockAdresse(kennung, s, j), new MemoryStream(bloecke[j], false)), + $"Write(Segment {s}, Block {j}) auf {ziel.Name}").ConfigureAwait(false); + return ok ? new Block { Knoten = ziel.Name, Hash = SHA256.HashData(bloecke[j]) } : null; + })).ConfigureAwait(false); + + return new Segment { Laenge = chiffrat.Length, Bloecke = ergebnisse.ToList() }; + } + + private async Task SegmentLesen(Manifest manifest, ReedSolomon code, int s) + { + var segment = manifest.Segmente[s]; + var blockLaenge = BlockLaenge(segment.Laenge, code.DatenBloecke); + var bloecke = new byte[code.Bloecke][]; + var vorhanden = new bool[code.Bloecke]; + + await Task.WhenAll(Enumerable.Range(0, code.Bloecke).Select(async j => + { + bloecke[j] = new byte[blockLaenge]; + var block = segment.Bloecke[j]; + if (block == null || !knotenNachName.TryGetValue(block.Knoten, out var quelle)) return; + + var daten = await Lesen(quelle, BlockAdresse(manifest.Kennung, s, j)).ConfigureAwait(false); + if (daten == null) return; + if (daten.Length != blockLaenge || !SHA256.HashData(daten).AsSpan().SequenceEqual(block.Hash)) + { + logger.LogWarning($"Segment {s}, Block {j} auf {quelle.Name} ist beschädigt"); + return; + } + bloecke[j] = daten; + vorhanden[j] = true; + })).ConfigureAwait(false); + + var anzahl = vorhanden.Count(v => v); + if (anzahl < code.DatenBloecke) + { + throw new IOException($"Segment {s}: nur {anzahl} von mindestens {code.DatenBloecke} Blöcken lesbar"); + } + if (anzahl < code.Bloecke) + { + logger.LogWarning($"Segment {s}: {code.Bloecke - anzahl} Block/Blöcke fehlen, werden rekonstruiert"); + } + if (vorhanden.Take(code.DatenBloecke).Any(v => !v)) code.Wiederherstellen(bloecke, vorhanden, nurDaten: true); + + return Zusammensetzen(bloecke, code.DatenBloecke, segment.Laenge); + } + + private Task BloeckeLoeschen(Manifest manifest) + { + var aufgaben = new List(); + for (var s = 0; s < manifest.Segmente.Count; s++) + { + for (var j = 0; j < manifest.Segmente[s].Bloecke.Count; j++) + { + var block = manifest.Segmente[s].Bloecke[j]; + var ziel = block != null && knotenNachName.TryGetValue(block.Knoten, out var k) ? k : KnotenFuer(s, j); + var adresse = BlockAdresse(manifest.Kennung, s, j); + aufgaben.Add(Sicher(() => ziel.Del(adresse), $"Del({adresse}) auf {ziel.Name}")); + } + } + return Task.WhenAll(aufgaben); + } + + private static byte[] SegmentNonce(long segment) + { + var nonce = new byte[NonceLaenge]; + BinaryPrimitives.WriteInt64BigEndian(nonce.AsSpan(4), segment); + return nonce; + } + + private static byte[] SegmentDaten(byte[] kennung, long segment) + { + var daten = new byte[kennung.Length + 8]; + kennung.CopyTo(daten, 0); + BinaryPrimitives.WriteInt64BigEndian(daten.AsSpan(kennung.Length), segment); + return daten; + } + + private static string BlockAdresse(byte[] kennung, int segment, int block) + { + var daten = new byte[kennung.Length + 8]; + kennung.CopyTo(daten, 0); + BinaryPrimitives.WriteInt32BigEndian(daten.AsSpan(kennung.Length), segment); + BinaryPrimitives.WriteInt32BigEndian(daten.AsSpan(kennung.Length + 4), block); + return "b/" + Convert.ToHexStringLower(SHA256.HashData(daten), 0, 16); + } + + #endregion + + #region Manifest + + private string ManifestAdresse(string adresse) => + "m/" + Convert.ToHexStringLower(HMACSHA256.HashData(adressSchluessel, Encoding.UTF8.GetBytes(adresse)), 0, 16); + + private async Task ManifestSchreiben(string adresse, Manifest manifest) + { + var manifestAdresse = ManifestAdresse(adresse); + var json = JsonSerializer.SerializeToUtf8Bytes(manifest); + + // Länge | Nonce | Chiffrat | Prüfwert + var nutzlast = new byte[4 + NonceLaenge + json.Length + TagLaenge]; + BinaryPrimitives.WriteInt32BigEndian(nutzlast, nutzlast.Length - 4); + var nonce = nutzlast.AsSpan(4, NonceLaenge); + RandomNumberGenerator.Fill(nonce); + using (var aead = new ChaCha20Poly1305(manifestSchluessel)) + { + aead.Encrypt(nonce, json, nutzlast.AsSpan(4 + NonceLaenge, json.Length), nutzlast.AsSpan(4 + NonceLaenge + json.Length), Encoding.UTF8.GetBytes(manifestAdresse)); + } + + var bloecke = Zerlegen(nutzlast, metaCode); + metaCode.Kodieren(bloecke); + + var ergebnisse = await Task.WhenAll(knoten.Select((ziel, i) => + { + // Kopf: Index, k, Anzahl - damit bleibt das Manifest lesbar, auch wenn sich die Knotenliste ändert + var teil = new byte[KopfLaenge + bloecke[i].Length]; + teil[0] = (byte)i; + teil[1] = (byte)metaCode.DatenBloecke; + teil[2] = (byte)metaCode.Bloecke; + bloecke[i].CopyTo(teil, KopfLaenge); + return Sicher(() => ziel.Write(manifestAdresse, new MemoryStream(teil, false)), $"Write({manifestAdresse}) auf {ziel.Name}"); + })).ConfigureAwait(false); + + var geschrieben = ergebnisse.Count(e => e); + if (geschrieben < metaCode.DatenBloecke) + { + logger.LogWarning($"Write({adresse}): Manifest nur auf {geschrieben} Knoten geschrieben"); + return false; + } + if (geschrieben < metaCode.Bloecke) + { + logger.LogWarning($"Write({adresse}): Manifest nur auf {geschrieben} von {metaCode.Bloecke} Knoten"); + } + return true; + } + + /// Das neueste lesbare Manifest, oder , wenn kein Knoten eines hat + private async Task ManifestLaden(string adresse) + { + var manifestAdresse = ManifestAdresse(adresse); + var teile = (await Task.WhenAll(knoten.Select(k => Lesen(k, manifestAdresse))).ConfigureAwait(false)) + .Where(t => t != null && t.Length > KopfLaenge && t[1] >= 1 && t[2] >= t[1] && t[0] < t[2]) + .ToList(); + if (teile.Count == 0) return null; + + Manifest neuestes = null; + foreach (var auswahl in Auswahlen(teile)) + { + var manifest = ManifestEntschluesseln(auswahl, manifestAdresse); + if (manifest != null && (neuestes == null || manifest.Version > neuestes.Version)) neuestes = manifest; + } + + if (neuestes == null) + { + throw new InvalidDataException($"Die Metadaten zu '{adresse}' lassen sich nicht lesen (falscher Schlüssel oder beschädigt)"); + } + return neuestes; + } + + /// Alle Kombinationen aus k Teilen mit passendem Kopf und verschiedenem Index + private static IEnumerable Auswahlen(List teile) + { + foreach (var gruppe in teile.GroupBy(t => (k: t[1], n: t[2], laenge: t.Length))) + { + var liste = gruppe.GroupBy(t => t[0]).Select(g => g.First()).ToList(); + var k = gruppe.Key.k; + if (liste.Count < k) continue; + if (k == 1) + { + foreach (var t in liste) yield return new[] { t }; + } + else + { + for (var a = 0; a < liste.Count; a++) + for (var b = a + 1; b < liste.Count; b++) + { + if (k == 2) yield return new[] { liste[a], liste[b] }; + } + } + } + } + + private Manifest ManifestEntschluesseln(byte[][] auswahl, string manifestAdresse) + { + try + { + var k = auswahl[0][1]; + var n = auswahl[0][2]; + var code = new ReedSolomon(k, n - k); + var blockLaenge = auswahl[0].Length - KopfLaenge; + var bloecke = Enumerable.Range(0, n).Select(_ => new byte[blockLaenge]).ToArray(); + var vorhanden = new bool[n]; + foreach (var t in auswahl) + { + t.AsSpan(KopfLaenge).CopyTo(bloecke[t[0]]); + vorhanden[t[0]] = true; + } + code.Wiederherstellen(bloecke, vorhanden, nurDaten: true); + + var nutzlast = Zusammensetzen(bloecke, k, k * blockLaenge); + var laenge = BinaryPrimitives.ReadInt32BigEndian(nutzlast); + if (laenge < NonceLaenge + TagLaenge || laenge > nutzlast.Length - 4) return null; + + var nonce = nutzlast.AsSpan(4, NonceLaenge); + var chiffratLaenge = laenge - NonceLaenge - TagLaenge; + var json = new byte[chiffratLaenge]; + using (var aead = new ChaCha20Poly1305(manifestSchluessel)) + { + aead.Decrypt(nonce, nutzlast.AsSpan(4 + NonceLaenge, chiffratLaenge), nutzlast.AsSpan(4 + NonceLaenge + chiffratLaenge, TagLaenge), json, Encoding.UTF8.GetBytes(manifestAdresse)); + } + return JsonSerializer.Deserialize(json); + } + catch (CryptographicException) + { + return null; + } + } + + #endregion + + #region Hilfen + + private static int BlockLaenge(int laenge, int k) => Math.Max(1, (laenge + k - 1) / k); + + private static byte[][] Zerlegen(byte[] daten, ReedSolomon code) + { + var blockLaenge = BlockLaenge(daten.Length, code.DatenBloecke); + var bloecke = new byte[code.Bloecke][]; + for (var i = 0; i < code.Bloecke; i++) + { + bloecke[i] = new byte[blockLaenge]; + if (i >= code.DatenBloecke) continue; + var start = i * blockLaenge; + if (start < daten.Length) daten.AsSpan(start, Math.Min(blockLaenge, daten.Length - start)).CopyTo(bloecke[i]); + } + return bloecke; + } + + private static byte[] Zusammensetzen(byte[][] bloecke, int k, int laenge) + { + var daten = new byte[laenge]; + var blockLaenge = bloecke[0].Length; + for (var i = 0; i < k; i++) + { + var start = i * blockLaenge; + if (start >= laenge) break; + bloecke[i].AsSpan(0, Math.Min(blockLaenge, laenge - start)).CopyTo(daten.AsSpan(start)); + } + return daten; + } + + private static async Task Fuellen(Stream input, byte[] puffer) + { + var gelesen = 0; + while (gelesen < puffer.Length) + { + var n = await input.ReadAsync(puffer.AsMemory(gelesen)).ConfigureAwait(false); + if (n == 0) break; + gelesen += n; + } + return gelesen; + } + + /// Den Inhalt, oder , wenn nicht vorhanden oder der Knoten nicht erreichbar ist + private async Task Lesen(IRawNode quelle, string adresse) + { + try + { + var stream = await quelle.Get(adresse).ConfigureAwait(false); + if (stream == null) return null; + using (stream) + using (var kopie = new MemoryStream()) + { + await stream.CopyToAsync(kopie).ConfigureAwait(false); + return kopie.ToArray(); + } + } + catch (Exception e) when (e is not ArgumentException) + { + logger.LogWarning(e, $"Get({adresse}) auf {quelle.Name} fehlgeschlagen"); + return null; + } + } + + /// Ein ausgefallener Knoten ist ein erwarteter Fall, keine Ausnahme + private async Task Sicher(Func> aktion, string beschreibung) + { + try + { + return await aktion().ConfigureAwait(false); + } + catch (Exception e) when (e is not ArgumentException) + { + logger.LogWarning(e, $"{beschreibung} fehlgeschlagen"); + return false; + } + } + + #endregion + } +} diff --git a/WebRaid.Node.Raid/ReedSolomon.cs b/WebRaid.Node.Raid/ReedSolomon.cs new file mode 100644 index 0000000..f85c203 --- /dev/null +++ b/WebRaid.Node.Raid/ReedSolomon.cs @@ -0,0 +1,248 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace WebRaid.Node.Raid +{ + /// + /// Systematischer Reed-Solomon-Code über GF(2^8). + /// Aus Datenblöcken werden Paritätsblöcke berechnet; + /// aus beliebigen der insgesamt + + /// Blöcke lässt sich alles wiederherstellen. + /// + public sealed class ReedSolomon + { + private readonly byte[,] matrix; + + /// Anzahl der Datenblöcke (k) + public int DatenBloecke { get; } + + /// Anzahl der Paritätsblöcke (m), also der verkraftbaren Ausfälle + public int ParitaetsBloecke { get; } + + /// Gesamtzahl der Blöcke (k + m) + public int Bloecke => DatenBloecke + ParitaetsBloecke; + + /// + /// Erstellt einen Code für + Blöcke + /// + public ReedSolomon(int datenBloecke, int paritaetsBloecke) + { + if (datenBloecke < 1) throw new ArgumentOutOfRangeException(nameof(datenBloecke), "Mindestens ein Datenblock"); + if (paritaetsBloecke < 0) throw new ArgumentOutOfRangeException(nameof(paritaetsBloecke), "Nicht negativ"); + if (datenBloecke + paritaetsBloecke > 255) throw new ArgumentOutOfRangeException(nameof(paritaetsBloecke), "Höchstens 255 Blöcke insgesamt"); + + DatenBloecke = datenBloecke; + ParitaetsBloecke = paritaetsBloecke; + matrix = KodierMatrix(datenBloecke, Bloecke); + } + + /// + /// Berechnet die Paritätsblöcke. + /// + /// Alle k + m Blöcke gleicher Länge; die ersten k enthalten die Daten, die übrigen werden überschrieben + public void Kodieren(byte[][] bloecke) + { + Pruefen(bloecke); + for (var p = 0; p < ParitaetsBloecke; p++) + { + var ziel = bloecke[DatenBloecke + p]; + Array.Clear(ziel); + for (var d = 0; d < DatenBloecke; d++) + { + Galois.MultiplizierenUndAddieren(matrix[DatenBloecke + p, d], bloecke[d], ziel); + } + } + } + + /// + /// Stellt fehlende Blöcke wieder her. + /// + /// Alle k + m Blöcke gleicher Länge; fehlende werden neu berechnet + /// Welche Blöcke gültig sind + /// Nur die Datenblöcke wiederherstellen (reicht zum Lesen) + /// Wenn weniger als k Blöcke vorhanden sind + public void Wiederherstellen(byte[][] bloecke, bool[] vorhanden, bool nurDaten = false) + { + Pruefen(bloecke); + if (vorhanden == null || vorhanden.Length != Bloecke) throw new ArgumentException($"Es werden {Bloecke} Einträge erwartet", nameof(vorhanden)); + + var gueltig = Enumerable.Range(0, Bloecke).Where(i => vorhanden[i]).Take(DatenBloecke).ToArray(); + if (gueltig.Length < DatenBloecke) + { + throw new InvalidOperationException($"Nur {gueltig.Length} von mindestens {DatenBloecke} Blöcken vorhanden"); + } + + var fehlendeDaten = Enumerable.Range(0, DatenBloecke).Where(i => !vorhanden[i]).ToList(); + if (fehlendeDaten.Count > 0) + { + // Zeilen der vorhandenen Blöcke bilden ein invertierbares k x k-System + var teil = new byte[DatenBloecke, DatenBloecke]; + for (var z = 0; z < DatenBloecke; z++) + for (var s = 0; s < DatenBloecke; s++) + teil[z, s] = matrix[gueltig[z], s]; + var inverse = Galois.Invertieren(teil); + + foreach (var d in fehlendeDaten) + { + var ziel = bloecke[d]; + Array.Clear(ziel); + for (var z = 0; z < DatenBloecke; z++) + { + Galois.MultiplizierenUndAddieren(inverse[d, z], bloecke[gueltig[z]], ziel); + } + } + } + + if (nurDaten) return; + for (var p = 0; p < ParitaetsBloecke; p++) + { + if (vorhanden[DatenBloecke + p]) continue; + var ziel = bloecke[DatenBloecke + p]; + Array.Clear(ziel); + for (var d = 0; d < DatenBloecke; d++) + { + Galois.MultiplizierenUndAddieren(matrix[DatenBloecke + p, d], bloecke[d], ziel); + } + } + } + + private void Pruefen(IReadOnlyList bloecke) + { + if (bloecke == null || bloecke.Count != Bloecke) throw new ArgumentException($"Es werden {Bloecke} Blöcke erwartet", nameof(bloecke)); + var laenge = bloecke[0]?.Length ?? throw new ArgumentException("Block 0 fehlt", nameof(bloecke)); + if (bloecke.Any(b => b == null || b.Length != laenge)) throw new ArgumentException("Alle Blöcke müssen gleich lang sein", nameof(bloecke)); + } + + /// + /// Vandermonde-Matrix, so umgeformt, dass die oberen k Zeilen die Einheitsmatrix sind. + /// Damit bleiben die Datenblöcke unverändert und jede Auswahl von k Zeilen ist invertierbar. + /// + private static byte[,] KodierMatrix(int k, int n) + { + var vandermonde = new byte[n, k]; + for (var z = 0; z < n; z++) + for (var s = 0; s < k; s++) + vandermonde[z, s] = Galois.Potenz((byte)z, s); + + var oben = new byte[k, k]; + for (var z = 0; z < k; z++) + for (var s = 0; s < k; s++) + oben[z, s] = vandermonde[z, s]; + + return Galois.Multiplizieren(vandermonde, Galois.Invertieren(oben)); + } + } + + /// + /// Arithmetik im Galois-Feld GF(2^8) mit dem Polynom x^8 + x^4 + x^3 + x^2 + 1 (0x11D) + /// + internal static class Galois + { + private static readonly byte[] Exp = new byte[512]; + private static readonly byte[] Log = new byte[256]; + private static readonly byte[] MulTabelle = new byte[256 * 256]; + + static Galois() + { + var x = 1; + for (var i = 0; i < 255; i++) + { + Exp[i] = (byte)x; + Log[x] = (byte)i; + x <<= 1; + if ((x & 0x100) != 0) x ^= 0x11D; + } + for (var i = 255; i < Exp.Length; i++) Exp[i] = Exp[i - 255]; + + for (var a = 0; a < 256; a++) + for (var b = 0; b < 256; b++) + MulTabelle[a * 256 + b] = Mal((byte)a, (byte)b); + } + + public static byte Mal(byte a, byte b) => a == 0 || b == 0 ? (byte)0 : Exp[Log[a] + Log[b]]; + + public static byte Inverses(byte a) + { + if (a == 0) throw new DivideByZeroException(); + return Exp[255 - Log[a]]; + } + + public static byte Potenz(byte a, int n) + { + if (n == 0) return 1; + if (a == 0) return 0; + return Exp[Log[a] * n % 255]; + } + + /// ziel ^= faktor * quelle + public static void MultiplizierenUndAddieren(byte faktor, byte[] quelle, byte[] ziel) + { + if (faktor == 0) return; + if (faktor == 1) + { + for (var i = 0; i < quelle.Length; i++) ziel[i] ^= quelle[i]; + return; + } + var zeile = new ReadOnlySpan(MulTabelle, faktor * 256, 256); + for (var i = 0; i < quelle.Length; i++) ziel[i] ^= zeile[quelle[i]]; + } + + public static byte[,] Multiplizieren(byte[,] a, byte[,] b) + { + int zeilen = a.GetLength(0), mitte = a.GetLength(1), spalten = b.GetLength(1); + var ergebnis = new byte[zeilen, spalten]; + for (var z = 0; z < zeilen; z++) + for (var s = 0; s < spalten; s++) + { + byte summe = 0; + for (var i = 0; i < mitte; i++) summe ^= Mal(a[z, i], b[i, s]); + ergebnis[z, s] = summe; + } + return ergebnis; + } + + /// Gauß-Jordan-Elimination + public static byte[,] Invertieren(byte[,] matrix) + { + var n = matrix.GetLength(0); + var a = (byte[,])matrix.Clone(); + var inv = new byte[n, n]; + for (var i = 0; i < n; i++) inv[i, i] = 1; + + for (var spalte = 0; spalte < n; spalte++) + { + var pivot = spalte; + while (pivot < n && a[pivot, spalte] == 0) pivot++; + if (pivot == n) throw new InvalidOperationException("Matrix ist nicht invertierbar"); + if (pivot != spalte) + { + for (var s = 0; s < n; s++) + { + (a[spalte, s], a[pivot, s]) = (a[pivot, s], a[spalte, s]); + (inv[spalte, s], inv[pivot, s]) = (inv[pivot, s], inv[spalte, s]); + } + } + + var faktor = Inverses(a[spalte, spalte]); + for (var s = 0; s < n; s++) + { + a[spalte, s] = Mal(a[spalte, s], faktor); + inv[spalte, s] = Mal(inv[spalte, s], faktor); + } + + for (var z = 0; z < n; z++) + { + if (z == spalte || a[z, spalte] == 0) continue; + var f = a[z, spalte]; + for (var s = 0; s < n; s++) + { + a[z, s] ^= Mal(f, a[spalte, s]); + inv[z, s] ^= Mal(f, inv[spalte, s]); + } + } + } + return inv; + } + } +} diff --git a/WebRaid.Node.Raid/WebRaid.Node.Raid.csproj b/WebRaid.Node.Raid/WebRaid.Node.Raid.csproj new file mode 100644 index 0000000..85f4ab9 --- /dev/null +++ b/WebRaid.Node.Raid/WebRaid.Node.Raid.csproj @@ -0,0 +1,13 @@ + + + + net10.0 + 0.1.0 + true + + + + + + + diff --git a/WebRaid.sln b/WebRaid.sln index 2b61d03..b3b0361 100644 --- a/WebRaid.sln +++ b/WebRaid.sln @@ -65,6 +65,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebRaid.Node.WebDav.Tests", EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebRaid.Node.TestsBase", "WebRaid.Node.TestsBase\WebRaid.Node.TestsBase.csproj", "{51A484BF-6CA7-449D-82E7-C981339CA929}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebRaid.Node.Raid", "WebRaid.Node.Raid\WebRaid.Node.Raid.csproj", "{17C3423A-6D2C-4234-86F4-602621A69313}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebRaid.Node.Raid.Tests", "WebRaid.Node.Raid.Tests\WebRaid.Node.Raid.Tests.csproj", "{405173B3-15B5-467F-8A34-BE20BE2B2D55}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -303,6 +307,30 @@ Global {51A484BF-6CA7-449D-82E7-C981339CA929}.Release|x64.Build.0 = Release|Any CPU {51A484BF-6CA7-449D-82E7-C981339CA929}.Release|x86.ActiveCfg = Release|Any CPU {51A484BF-6CA7-449D-82E7-C981339CA929}.Release|x86.Build.0 = Release|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Debug|Any CPU.Build.0 = Debug|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Debug|x64.ActiveCfg = Debug|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Debug|x64.Build.0 = Debug|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Debug|x86.ActiveCfg = Debug|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Debug|x86.Build.0 = Debug|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Release|Any CPU.ActiveCfg = Release|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Release|Any CPU.Build.0 = Release|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Release|x64.ActiveCfg = Release|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Release|x64.Build.0 = Release|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Release|x86.ActiveCfg = Release|Any CPU + {17C3423A-6D2C-4234-86F4-602621A69313}.Release|x86.Build.0 = Release|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Debug|Any CPU.Build.0 = Debug|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Debug|x64.ActiveCfg = Debug|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Debug|x64.Build.0 = Debug|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Debug|x86.ActiveCfg = Debug|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Debug|x86.Build.0 = Debug|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Release|Any CPU.ActiveCfg = Release|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Release|Any CPU.Build.0 = Release|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Release|x64.ActiveCfg = Release|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Release|x64.Build.0 = Release|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Release|x86.ActiveCfg = Release|Any CPU + {405173B3-15B5-467F-8A34-BE20BE2B2D55}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE