Add many classes that are used for NCA reading

build/CodeGen/results.csv

@@ -996,10 +996,10 @@ Module,DescriptionStart,DescriptionEnd,Flags,Namespace,Name,Summary
 2,6316,,,,UnsupportedSetSizeForHierarchicalIntegrityVerificationStorage,
 2,6317,,,,UnsupportedOperateRangeForHierarchicalIntegrityVerificationStorage,
 2,6318,,,,UnsupportedSetSizeForIntegrityVerificationStorage,
-2,6319,,,,UnsupportedOperateRangeForNonSaveDataIntegrityVerificationStorage,
+2,6319,,,,UnsupportedOperateRangeForWritableIntegrityVerificationStorage,
 2,6320,,,,UnsupportedOperateRangeForIntegrityVerificationStorage,
 2,6321,,,,UnsupportedSetSizeForBlockCacheBufferedStorage,
-2,6322,,,,UnsupportedOperateRangeForNonSaveDataBlockCacheBufferedStorage,
+2,6322,,,,UnsupportedOperateRangeForWritableBlockCacheBufferedStorage,
 2,6323,,,,UnsupportedOperateRangeForBlockCacheBufferedStorage,
 2,6324,,,,UnsupportedWriteForIndirectStorage,
 2,6325,,,,UnsupportedSetSizeForIndirectStorage,
@@ -1064,6 +1064,9 @@ Module,DescriptionStart,DescriptionEnd,Flags,Namespace,Name,Summary
 2,6386,,,,UnsupportedSetSizeForZeroBitmapHashStorageFile,
 2,6387,,,,UnsupportedWriteForCompressedStorage,
 2,6388,,,,UnsupportedOperateRangeForCompressedStorage,
+2,6395,,,,UnsupportedRollbackOnlyModifiedForApplicationTemporaryFileSystem,
+2,6396,,,,UnsupportedRollbackOnlyModifiedForDirectorySaveDataFileSystem,
+2,6397,,,,UnsupportedOperateRangeForRegionSwitchStorage,
 
 2,6400,6449,,,PermissionDenied,
 2,6403,,,,PermissionDeniedForCreateHostFileSystem,Returned when opening a host FS on a retail device.

src/LibHac/Boot/Package1.cs

@@ -300,7 +300,7 @@ private Result SetPk11Storage()
         return Result.Success;
     }
 
-    private delegate void Decryptor(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
+    private delegate int Decryptor(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
         ReadOnlySpan<byte> iv, bool preferDotNetCrypto = false);
 
     private bool TryFindEristaKeyRevision()

src/LibHac/Common/FixedArrays/Array68.cs

@@ -0,0 +1,31 @@
+#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace LibHac.Common.FixedArrays;
+
+public struct Array68<T>
+{
+    public const int Length = 68;
+
+    private Array64<T> _0;
+    private Array4<T> _64;
+
+    public ref T this[int i] => ref Items[i];
+
+    public Span<T> Items
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
+    }
+
+    public readonly ReadOnlySpan<T> ItemsRo
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator ReadOnlySpan<T>(in Array68<T> value) => value.ItemsRo;
+}

src/LibHac/Common/FixedArrays/Array96.cs

@@ -0,0 +1,31 @@
+#pragma warning disable CS0169, CS0649, IDE0051 // Field is never used, Field is never assigned to, Remove unused private members
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace LibHac.Common.FixedArrays;
+
+public struct Array96<T>
+{
+    public const int Length = 96;
+
+    private Array80<T> _0;
+    private Array16<T> _80;
+
+    public ref T this[int i] => ref Items[i];
+
+    public Span<T> Items
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.Items), Length);
+    }
+
+    public readonly ReadOnlySpan<T> ItemsRo
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => SpanHelpers.CreateSpan(ref MemoryMarshal.GetReference(_0.ItemsRo), Length);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator ReadOnlySpan<T>(in Array96<T> value) => value.ItemsRo;
+}

src/LibHac/Crypto/Aes.cs

@@ -102,140 +102,132 @@ public static ICipherWithIv CreateXtsEncryptor(ReadOnlySpan<byte> key1, ReadOnly
         return new AesXtsEncryptor(key1, key2, iv);
     }
 
-    public static void EncryptEcb128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
+    public static int EncryptEcb128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
         bool preferDotNetCrypto = false)
     {
         if (IsAesNiSupported() && !preferDotNetCrypto)
         {
             Unsafe.SkipInit(out AesEcbModeNi cipherNi);
 
             cipherNi.Initialize(key, false);
-            cipherNi.Encrypt(input, output);
-            return;
+            return cipherNi.Encrypt(input, output);
         }
 
         ICipher cipher = CreateEcbEncryptor(key, preferDotNetCrypto);
 
-        cipher.Transform(input, output);
+        return cipher.Transform(input, output);
     }
 
-    public static void DecryptEcb128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
+    public static int DecryptEcb128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
         bool preferDotNetCrypto = false)
     {
         if (IsAesNiSupported() && !preferDotNetCrypto)
         {
             Unsafe.SkipInit(out AesEcbModeNi cipherNi);
 
             cipherNi.Initialize(key, true);
-            cipherNi.Decrypt(input, output);
-            return;
+            return cipherNi.Decrypt(input, output);
         }
 
         ICipher cipher = CreateEcbDecryptor(key, preferDotNetCrypto);
 
-        cipher.Transform(input, output);
+        return cipher.Transform(input, output);
     }
 
-    public static void EncryptCbc128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
+    public static int EncryptCbc128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
         ReadOnlySpan<byte> iv, bool preferDotNetCrypto = false)
     {
         if (IsAesNiSupported() && !preferDotNetCrypto)
         {
             Unsafe.SkipInit(out AesCbcModeNi cipherNi);
 
             cipherNi.Initialize(key, iv, false);
-            cipherNi.Encrypt(input, output);
-            return;
+            return cipherNi.Encrypt(input, output);
         }
 
         ICipher cipher = CreateCbcEncryptor(key, iv, preferDotNetCrypto);
 
-        cipher.Transform(input, output);
+        return cipher.Transform(input, output);
     }
 
-    public static void DecryptCbc128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
+    public static int DecryptCbc128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
         ReadOnlySpan<byte> iv, bool preferDotNetCrypto = false)
     {
         if (IsAesNiSupported() && !preferDotNetCrypto)
         {
             Unsafe.SkipInit(out AesCbcModeNi cipherNi);
 
             cipherNi.Initialize(key, iv, true);
-            cipherNi.Decrypt(input, output);
-            return;
+            return cipherNi.Decrypt(input, output);
         }
 
         ICipher cipher = CreateCbcDecryptor(key, iv, preferDotNetCrypto);
 
-        cipher.Transform(input, output);
+        return cipher.Transform(input, output);
     }
 
-    public static void EncryptCtr128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
+    public static int EncryptCtr128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
         ReadOnlySpan<byte> iv, bool preferDotNetCrypto = false)
     {
         if (IsAesNiSupported() && !preferDotNetCrypto)
         {
             Unsafe.SkipInit(out AesCtrModeNi cipherNi);
 
             cipherNi.Initialize(key, iv);
-            cipherNi.Transform(input, output);
-            return;
+            return cipherNi.Transform(input, output);
         }
 
         ICipher cipher = CreateCtrEncryptor(key, iv, preferDotNetCrypto);
 
-        cipher.Transform(input, output);
+        return cipher.Transform(input, output);
     }
 
-    public static void DecryptCtr128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
+    public static int DecryptCtr128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key,
         ReadOnlySpan<byte> iv, bool preferDotNetCrypto = false)
     {
         if (IsAesNiSupported() && !preferDotNetCrypto)
         {
             Unsafe.SkipInit(out AesCtrModeNi cipherNi);
 
             cipherNi.Initialize(key, iv);
-            cipherNi.Transform(input, output);
-            return;
+            return cipherNi.Transform(input, output);
         }
 
         ICipher cipher = CreateCtrDecryptor(key, iv, preferDotNetCrypto);
 
-        cipher.Transform(input, output);
+        return cipher.Transform(input, output);
     }
 
-    public static void EncryptXts128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key1,
+    public static int EncryptXts128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key1,
         ReadOnlySpan<byte> key2, ReadOnlySpan<byte> iv, bool preferDotNetCrypto = false)
     {
         if (IsAesNiSupported() && !preferDotNetCrypto)
         {
             Unsafe.SkipInit(out AesXtsModeNi cipherNi);
 
             cipherNi.Initialize(key1, key2, iv, false);
-            cipherNi.Encrypt(input, output);
-            return;
+            return cipherNi.Encrypt(input, output);
         }
 
         ICipher cipher = CreateXtsEncryptor(key1, key2, iv, preferDotNetCrypto);
 
-        cipher.Transform(input, output);
+        return cipher.Transform(input, output);
     }
 
-    public static void DecryptXts128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key1,
+    public static int DecryptXts128(ReadOnlySpan<byte> input, Span<byte> output, ReadOnlySpan<byte> key1,
         ReadOnlySpan<byte> key2, ReadOnlySpan<byte> iv, bool preferDotNetCrypto = false)
     {
         if (IsAesNiSupported() && !preferDotNetCrypto)
         {
             Unsafe.SkipInit(out AesXtsModeNi cipherNi);
 
             cipherNi.Initialize(key1, key2, iv, true);
-            cipherNi.Decrypt(input, output);
-            return;
+            return cipherNi.Decrypt(input, output);
         }
 
         ICipher cipher = CreateXtsDecryptor(key1, key2, iv, preferDotNetCrypto);
 
-        cipher.Transform(input, output);
+        return cipher.Transform(input, output);
     }
 
     /// <summary>
@@ -307,4 +299,4 @@ private static void LeftShiftBytes(ReadOnlySpan<byte> input, Span<byte> output)
             carry = (byte)((b & 0xff00) >> 8);
         }
     }
-}
+}

src/LibHac/Crypto/AesCbcCipher.cs

@@ -13,9 +13,9 @@ public AesCbcEncryptor(ReadOnlySpan<byte> key, ReadOnlySpan<byte> iv)
         _baseCipher.Initialize(key, iv, false);
     }
 
-    public void Transform(ReadOnlySpan<byte> input, Span<byte> output)
+    public int Transform(ReadOnlySpan<byte> input, Span<byte> output)
     {
-        _baseCipher.Encrypt(input, output);
+        return _baseCipher.Encrypt(input, output);
     }
 }
 
@@ -29,8 +29,8 @@ public AesCbcDecryptor(ReadOnlySpan<byte> key, ReadOnlySpan<byte> iv)
         _baseCipher.Initialize(key, iv, true);
     }
 
-    public void Transform(ReadOnlySpan<byte> input, Span<byte> output)
+    public int Transform(ReadOnlySpan<byte> input, Span<byte> output)
     {
-        _baseCipher.Decrypt(input, output);
+        return _baseCipher.Decrypt(input, output);
     }
-}
+}

src/LibHac/Crypto/AesCbcCipherNi.cs

@@ -18,9 +18,9 @@ public AesCbcEncryptorNi(ReadOnlySpan<byte> key, ReadOnlySpan<byte> iv)
         _baseCipher.Initialize(key, iv, false);
     }
 
-    public void Transform(ReadOnlySpan<byte> input, Span<byte> output)
+    public int Transform(ReadOnlySpan<byte> input, Span<byte> output)
     {
-        _baseCipher.Encrypt(input, output);
+        return _baseCipher.Encrypt(input, output);
     }
 }
 
@@ -36,8 +36,8 @@ public AesCbcDecryptorNi(ReadOnlySpan<byte> key, ReadOnlySpan<byte> iv)
         _baseCipher.Initialize(key, iv, true);
     }
 
-    public void Transform(ReadOnlySpan<byte> input, Span<byte> output)
+    public int Transform(ReadOnlySpan<byte> input, Span<byte> output)
     {
-        _baseCipher.Decrypt(input, output);
+        return _baseCipher.Decrypt(input, output);
     }
-}
+}

src/LibHac/Crypto/AesCtrCipher.cs

@@ -16,8 +16,8 @@ public AesCtrCipher(ReadOnlySpan<byte> key, ReadOnlySpan<byte> iv)
         _baseCipher.Initialize(key, iv);
     }
 
-    public void Transform(ReadOnlySpan<byte> input, Span<byte> output)
+    public int Transform(ReadOnlySpan<byte> input, Span<byte> output)
     {
-        _baseCipher.Transform(input, output);
+        return _baseCipher.Transform(input, output);
     }
-}
+}

src/LibHac/Crypto/AesCtrCipherNi.cs

@@ -18,8 +18,8 @@ public AesCtrCipherNi(ReadOnlySpan<byte> key, ReadOnlySpan<byte> iv)
         _baseCipher.Initialize(key, iv);
     }
 
-    public void Transform(ReadOnlySpan<byte> input, Span<byte> output)
+    public int Transform(ReadOnlySpan<byte> input, Span<byte> output)
     {
-        _baseCipher.Transform(input, output);
+        return _baseCipher.Transform(input, output);
     }
-}
+}

src/LibHac/Crypto/AesEcbCipher.cs

@@ -13,9 +13,9 @@ public AesEcbEncryptor(ReadOnlySpan<byte> key)
         _baseCipher.Initialize(key, false);
     }
 
-    public void Transform(ReadOnlySpan<byte> input, Span<byte> output)
+    public int Transform(ReadOnlySpan<byte> input, Span<byte> output)
     {
-        _baseCipher.Encrypt(input, output);
+        return _baseCipher.Encrypt(input, output);
     }
 }
 
@@ -29,8 +29,8 @@ public AesEcbDecryptor(ReadOnlySpan<byte> key)
         _baseCipher.Initialize(key, true);
     }
 
-    public void Transform(ReadOnlySpan<byte> input, Span<byte> output)
+    public int Transform(ReadOnlySpan<byte> input, Span<byte> output)
     {
-        _baseCipher.Decrypt(input, output);
+        return _baseCipher.Decrypt(input, output);
     }
-}
+}

src/LibHac/Crypto/AesEcbCipherNi.cs

@@ -13,9 +13,9 @@ public AesEcbEncryptorNi(ReadOnlySpan<byte> key)
         _baseCipher.Initialize(key, false);
     }
 
-    public void Transform(ReadOnlySpan<byte> input, Span<byte> output)
+    public int Transform(ReadOnlySpan<byte> input, Span<byte> output)
     {
-        _baseCipher.Encrypt(input, output);
+        return _baseCipher.Encrypt(input, output);
     }
 }
 
@@ -29,8 +29,8 @@ public AesEcbDecryptorNi(ReadOnlySpan<byte> key)
         _baseCipher.Initialize(key, true);
     }
 
-    public void Transform(ReadOnlySpan<byte> input, Span<byte> output)
+    public int Transform(ReadOnlySpan<byte> input, Span<byte> output)
     {
-        _baseCipher.Decrypt(input, output);
+        return _baseCipher.Decrypt(input, output);
     }
-}
+}