Remove constants from code

NDecrypt/Data/Constants.cs

@@ -1,9 +1,14 @@
-using System.Numerics;
+using System.IO;
+using System.Linq;
+using System.Numerics;
+using System.Reflection;
 
 namespace NDecrypt.Data
 {
-    public static class Constants
+    public class Constants
     {
+        #region NDS
+
         public static byte[] NDSEncryptionData = new byte[]
         {
             0x99,0xD5,0x20,0x5F,0x57,0x44,0xF5,0xB9,0x6E,0x19,0xA4,0xD9,0x9E,0x6A,0x5A,0x94,
@@ -269,66 +274,102 @@ namespace NDecrypt.Data
             0x96,0xE7,0xC4,0x18,0x5F,0xAD,0xF5,0x19,
         };
 
+        // ARM9 decryption check values
+        public const uint MAGIC30 = 0x72636E65;
+        public const uint MAGIC34 = 0x6A624F79;
+
+        #endregion
+
+        #region 3DS
+
         // Setup Keys and IVs
         public static byte[] PlainCounter = new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
         public static byte[] ExefsCounter = new byte[] { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
         public static byte[] RomfsCounter = new byte[] { 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
-        // Note: BigInteger requires the 0x00 at the end of each string in order to preserve the sign value
-        // Note: BigInteger requires that the values be in little endian format, the values in 
-
-        // Big Endian - 0x1F, 0xF9, 0xE9, 0xAA, 0xC5, 0xFE, 0x04, 0x08, 0x02, 0x45, 0x91, 0xDC, 0x5D, 0x52, 0x76, 0x8A
-        // Little Endian - 0x8A, 0x76, 0x52, 0x5D, 0xDC, 0x91, 0x45, 0x02, 0x08, 0x04, 0xFE, 0xC5, 0xAA, 0xE9, 0xF9, 0x1F
-        public static BigInteger AESHardwareConstant = new BigInteger(new byte[] { 0x8A, 0x76, 0x52, 0x5D, 0xDC, 0x91, 0x45, 0x02, 0x08, 0x04, 0xFE, 0xC5, 0xAA, 0xE9, 0xF9, 0x1F });
+        public static BigInteger AESHardwareConstant { get; private set; }
 
         #region Retail 3DS keys
 
         // KeyX 0x18 (New 3DS 9.3)
-        // Big Endian - 0x82, 0xE9, 0xC9, 0xBE, 0xBF, 0xB8, 0xBD, 0xB8, 0x75, 0xEC, 0xC0, 0xA0, 0x7D, 0x47, 0x43, 0x74
-        // Little Endian - 0x74, 0x43, 0x47, 0x7D, 0xA0, 0xC0, 0xEC, 0x75, 0xB8, 0xBD, 0xB8, 0xBF, 0xBE, 0xC9, 0xE9, 0x82
-        public static BigInteger KeyX0x18 = new BigInteger(new byte[] { 0x74, 0x43, 0x47, 0x7D, 0xA0, 0xC0, 0xEC, 0x75, 0xB8, 0xBD, 0xB8, 0xBF, 0xBE, 0xC9, 0xE9, 0x82, 0x00 });
+        public static BigInteger KeyX0x18 { get; private set; }
 
         // KeyX 0x1B (New 3DS 9.6)
-        // Big Endian - 0x45, 0xAD, 0x04, 0x95, 0x39, 0x92, 0xC7, 0xC8, 0x93, 0x72, 0x4A, 0x9A, 0x7B, 0xCE, 0x61, 0x82
-        // Little Endian - 0x82, 0x61, 0xCE, 0x7B, 0x9A, 0x4A, 0x72, 0x93, 0xC8, 0xC7, 0x92, 0x39, 0x95, 0x04, 0xAD, 0x45
-        public static BigInteger KeyX0x1B = new BigInteger(new byte[] { 0x82, 0x61, 0xCE, 0x7B, 0x9A, 0x4A, 0x72, 0x93, 0xC8, 0xC7, 0x92, 0x39, 0x95, 0x04, 0xAD, 0x45, 0x00 });
+        public static BigInteger KeyX0x1B { get; private set; }
 
         // KeyX 0x25 (> 7.x)
-        // Big Endian - 0xCE, 0xE7, 0xD8, 0xAB, 0x30, 0xC0, 0x0D, 0xAE, 0x85, 0x0E, 0xF5, 0xE3, 0x82, 0xAC, 0x5A, 0xF3
-        // Little Endian - 0xF3, 0x5A, 0xAC, 0x82, 0xE3, 0xF5, 0x0E, 0x85, 0xAE, 0x0D, 0xC0, 0x30, 0xAB, 0xD8, 0xE7, 0xCE
-        public static BigInteger KeyX0x25 = new BigInteger(new byte[] { 0xF3, 0x5A, 0xAC, 0x82, 0xE3, 0xF5, 0x0E, 0x85, 0xAE, 0x0D, 0xC0, 0x30, 0xAB, 0xD8, 0xE7, 0xCE, 0x00 });
+        public static BigInteger KeyX0x25 { get; private set; }
 
         // Dev KeyX 0x2C (< 6.x)
-        // Big Endian - 0xB9, 0x8E, 0x95, 0xCE, 0xCA, 0x3E, 0x4D, 0x17, 0x1F, 0x76, 0xA9, 0x4D, 0xE9, 0x34, 0xC0, 0x53
-        // Little Endian - 0x53, 0xC0, 0x34, 0xE9, 0x4D, 0xA9, 0x76, 0x1F, 0x17, 0x4D, 0x3E, 0xCA, 0xCE, 0x95, 0x8E, 0xB9
-        public static BigInteger KeyX0x2C = new BigInteger(new byte[] { 0x53, 0xC0, 0x34, 0xE9, 0x4D, 0xA9, 0x76, 0x1F, 0x17, 0x4D, 0x3E, 0xCA, 0xCE, 0x95, 0x8E, 0xB9, 0x00 });
+        public static BigInteger KeyX0x2C { get; private set; }
 
         #endregion
 
         #region Dev 3DS Keys
 
         // Dev KeyX 0x18 (New 3DS 9.3)
-        // Big Endian - 0x30, 0x4B, 0xF1, 0x46, 0x83, 0x72, 0xEE, 0x64, 0x11, 0x5E, 0xBD, 0x40, 0x93, 0xD8, 0x42, 0x76
-        // Little Endian - 0x76, 0x42, 0xD8, 0x93, 0x40, 0xBD, 0x5E, 0x11, 0x64, 0xEE, 0x72, 0x83, 0x46, 0xF1, 0x4B, 0x30
-        public static BigInteger DevKeyX0x18 = new BigInteger(new byte[] { 0x76, 0x42, 0xD8, 0x93, 0x40, 0xBD, 0x5E, 0x11, 0x64, 0xEE, 0x72, 0x83, 0x46, 0xF1, 0x4B, 0x30, 0x00 });
+        public static BigInteger DevKeyX0x18 { get; private set; }
 
         // Dev KeyX 0x1B New 3DS 9.6)
-        // Big Endian - 0x6C, 0x8B, 0x29, 0x44, 0xA0, 0x72, 0x60, 0x35, 0xF9, 0x41, 0xDF, 0xC0, 0x18, 0x52, 0x4F, 0xB6
-        // Little Endian - 0xB6, 0x4F, 0x52, 0x18, 0xC0, 0xDF, 0x41, 0xF9, 0x35, 0x60, 0x72, 0xA0, 0x44, 0x29, 0x8B, 0x6C
-        public static BigInteger DevKeyX0x1B = new BigInteger(new byte[] { 0xB6, 0x4F, 0x52, 0x18, 0xC0, 0xDF, 0x41, 0xF9, 0x35, 0x60, 0x72, 0xA0, 0x44, 0x29, 0x8B, 0x6C, 0x00 });
+        public static BigInteger DevKeyX0x1B { get; private set; }
 
         // Dev KeyX 0x25 (> 7.x)
-        // Big Endian - 0x81, 0x90, 0x7A, 0x4B, 0x6F, 0x1B, 0x47, 0x32, 0x3A, 0x67, 0x79, 0x74, 0xCE, 0x4A, 0xD7, 0x1B
-        // Little Endian - 0x1B, 0xD7, 0x4A, 0xCE, 0x74, 0x79, 0x67, 0x3A, 0x32, 0x47, 0x1B, 0x6F, 0x4B, 0x7A, 0x90, 0x81
-        public static BigInteger DevKeyX0x25 = new BigInteger(new byte[] { 0x1B, 0xD7, 0x4A, 0xCE, 0x74, 0x79, 0x67, 0x3A, 0x32, 0x47, 0x1B, 0x6F, 0x4B, 0x7A, 0x90, 0x81, 0x00 });
+        public static BigInteger DevKeyX0x25 { get; private set; }
 
         // Dev KeyX 0x2C (< 6.x)
-        // Big Endian - 0x51, 0x02, 0x07, 0x51, 0x55, 0x07, 0xCB, 0xB1, 0x8E, 0x24, 0x3D, 0xCB, 0x85, 0xE2, 0x3A, 0x1D
-        // Little Endian - 0x1D, 0x3A, 0xE2, 0x85, 0xCB, 0x3D, 0x24, 0x8E, 0xB1, 0xCB, 0x07, 0x55, 0x51, 0x07, 0x02, 0x51
-        public static BigInteger DevKeyX0x2C = new BigInteger(new byte[] { 0x1D, 0x3A, 0xE2, 0x85, 0xCB, 0x3D, 0x24, 0x8E, 0xB1, 0xCB, 0x07, 0x55, 0x51, 0x07, 0x02, 0x51, 0x00 });
+        public static BigInteger DevKeyX0x2C { get; private set; }
 
         #endregion
 
         public const int CXTExtendedDataHeaderLength = 0x800;
+
+        public static bool IsReady { get; private set; }
+
+        /// <summary>
+        /// Setup all of the necessary constants
+        /// </summary>
+        /// <remarks>keys.bin should be in little endian format</remarks>
+        static Constants()
+        {
+            string keyfile = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "keys.bin");
+            if (!File.Exists(keyfile))
+            {
+                IsReady = false;
+                return;
+            }
+
+            try
+            {
+                using (BinaryReader reader = new BinaryReader(File.Open(keyfile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
+                {
+                    // This is required to preserve sign for BigInteger
+                    byte[] signByte = new byte[] { 0x00 };
+
+                    // Hardware constant
+                    AESHardwareConstant = new BigInteger(reader.ReadBytes(16));
+
+                    // Retail keys
+                    KeyX0x18 = new BigInteger(reader.ReadBytes(16).Concat(signByte).ToArray());
+                    KeyX0x1B = new BigInteger(reader.ReadBytes(16).Concat(signByte).ToArray());
+                    KeyX0x25 = new BigInteger(reader.ReadBytes(16).Concat(signByte).ToArray());
+                    KeyX0x2C = new BigInteger(reader.ReadBytes(16).Concat(signByte).ToArray());
+
+                    // Development keys
+                    DevKeyX0x18 = new BigInteger(reader.ReadBytes(16).Concat(signByte).ToArray());
+                    DevKeyX0x1B = new BigInteger(reader.ReadBytes(16).Concat(signByte).ToArray());
+                    DevKeyX0x25 = new BigInteger(reader.ReadBytes(16).Concat(signByte).ToArray());
+                    DevKeyX0x2C = new BigInteger(reader.ReadBytes(16).Concat(signByte).ToArray());
+                }
+            }
+            catch
+            {
+                IsReady = false;
+                return;
+            }
+
+            IsReady = true;
+        }
+
+        #endregion
     }
 }

NDecrypt/Headers/NDSHeader.cs

@@ -12,10 +12,6 @@ namespace NDecrypt.Headers
         private uint[] cardHash = new uint[0x412];
         private uint[] arg2 = new uint[3];
 
-        // ARM9 decryption check values
-        private const uint MAGIC30 = 0x72636E65;
-        private const uint MAGIC34 = 0x6A624F79;
-
         #endregion
 
         #region Common to all NDS files
@@ -674,7 +670,7 @@ namespace NDecrypt.Headers
             if (!encrypt)
             {
                 Decrypt(ref p1, ref p0);
-                if (p0 == MAGIC30 && p1 == MAGIC34)
+                if (p0 == Constants.MAGIC30 && p1 == Constants.MAGIC34)
                 {
                     p0 = 0xE7FFDEFF;
                     p1 = 0xE7FFDEFF;
@@ -717,8 +713,8 @@ namespace NDecrypt.Headers
 
                 if (p0 == 0xE7FFDEFF && p1 == 0xE7FFDEFF)
                 {
-                    p0 = MAGIC30;
-                    p1 = MAGIC34;
+                    p0 = Constants.MAGIC30;
+                    p1 = Constants.MAGIC34;
                 }
 
                 Encrypt(ref p1, ref p0);

NDecrypt/Program.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using NDecrypt.Data;
 
 namespace NDecrypt
 {
@@ -14,11 +15,11 @@ namespace NDecrypt
             }
 
             bool? encrypt = null;
-            if (args[0] == "decrypt")
+            if (args[0] == "decrypt" || args[0] == "d")
             {
                 encrypt = false;
             }
-            else if (args[0] == "encrypt")
+            else if (args[0] == "encrypt" || args[0] == "e")
             {
                 encrypt = true;
             }
@@ -36,6 +37,14 @@ namespace NDecrypt
                 start = 2;
             }
 
+            // Ensure the constants are all set
+            new Constants();
+            if (!Constants.IsReady)
+            {
+                Console.WriteLine("Could not read keys from keys.bin. Please make sure the file exists and try again");
+                return;
+            }
+
             for (int i = start; i < args.Length; i++)
             {
                 if (File.Exists(args[i]))
@@ -59,6 +68,10 @@ namespace NDecrypt
             Console.Read();
         }
 
+        /// <summary>
+        /// Display a basic help text
+        /// </summary>
+        /// <param name="err">Additional error text to display, can be null to ignore</param>
         private static void DisplayHelp(string err = null)
         {
             if (!string.IsNullOrWhiteSpace(err))
@@ -75,6 +88,35 @@ namespace NDecrypt
             N3DS,
         }
 
+        /// <summary>
+        /// Derive the encryption tool to be used for the given file
+        /// </summary>
+        /// <param name="filename">Filename to derive the tool from</param>
+        /// <param name="encrypt">True if we are encrypting the file, false otherwise</param>
+        /// <param name="development">rue if we are using development keys, false otherwise</param>
+        /// <returns></returns>
+        private static ITool DeriveTool(string filename, bool encrypt, bool development)
+        {
+            RomType type = DetermineRomType(filename);
+            switch(type)
+            {
+                case RomType.NDS:
+                case RomType.NDSi:
+                    return new DSTool(filename, encrypt);
+                case RomType.N3DS:
+                    return new ThreeDSTool(filename, development, encrypt);
+                case RomType.NULL:
+                default:
+                    Console.WriteLine($"Unrecognized file format for {filename}. Expected *.nds, *.srl, *.dsi, *.3ds");
+                    return null;
+            }
+        }
+
+        /// <summary>
+        /// Determine the rom type from the filename extension
+        /// </summary>
+        /// <param name="filename">Filename to derive the type from</param>
+        /// <returns>RomType value, if possible</returns>
         private static RomType DetermineRomType(string filename)
         {
             if (filename.EndsWith(".nds", StringComparison.OrdinalIgnoreCase)
@@ -89,22 +131,5 @@ namespace NDecrypt
 
             return RomType.NULL;
         }
-
-        private static ITool DeriveTool(string filename, bool encrypt, bool development)
-        {
-            RomType type = DetermineRomType(filename);
-            switch(type)
-            {
-                case RomType.NDS:
-                case RomType.NDSi:
-                    return new DSTool(filename, encrypt);
-                case RomType.N3DS:
-                    return new ThreeDSTool(filename, development, encrypt);
-                case RomType.NULL:
-                default:
-                    Console.WriteLine($"Unrecognized file format for {filename}. Expected *.nds, *.dsi, *.3ds");
-                    return null;
-            }
-        }
     }
 }