v1.1.0

+ Added support for DxO PhotoLab
+ Added directory permission check
* Refactored code

Signed-off-by: Still Hsu <dev@stillu.cc>

Author: Still34

.idea/.idea.AffinityPatcher/.idea/vcs.xml

@@ -11,12 +11,15 @@
         <SelfContained>true</SelfContained>
         <PublishSingleFile>true</PublishSingleFile>
         <PublishTrimmed>true</PublishTrimmed>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <Deterministic>true</Deterministic>
+        <Version>1.1.0</Version>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="dnlib" Version="4.4.0" />
-      <PackageReference Include="Humanizer.Core" Version="3.0.0-beta.13" />
-      <PackageReference Include="Spectre.Console" Version="0.49.1-preview.0.2" />
+      <PackageReference Include="dnlib" Version="4.5.0" />
+      <PackageReference Include="Humanizer.Core" Version="3.0.0-beta.96" />
+      <PackageReference Include="Spectre.Console" Version="0.50.0" />
       <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
     </ItemGroup>
 

AffinityPatcher/AffinityPatcher.csproj

@@ -0,0 +1,14 @@
+namespace AffinityPatcher.Enums
+{
+    public enum CrashReportUploadPolicy
+    {
+        // Token: 0x04009C1F RID: 39967
+        User,
+
+        // Token: 0x04009C20 RID: 39968
+        Always,
+
+        // Token: 0x04009C21 RID: 39969
+        Never
+    }
+}

AffinityPatcher/Enums/CrashReportUploadPolicy.cs

@@ -0,0 +1,8 @@
+namespace AffinityPatcher.Enums
+{
+    public enum PatcherMode
+    {
+        Affinity,
+        DxO
+    }
+}

AffinityPatcher/Enums/PatcherMode.cs

@@ -1,7 +1,8 @@
 using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.Security.Cryptography;
+using System.Runtime.InteropServices;
 using System.Text;
+using AffinityPatcher.Enums;
+using AffinityPatcher.Utils;
 using dnlib.DotNet;
 using dnlib.DotNet.Emit;
 using dnlib.DotNet.Writer;
@@ -12,81 +13,109 @@ namespace AffinityPatcher
 {
     internal class Program
     {
-        // Token: 0x02000502 RID: 1282
-        public enum CrashReportUploadPolicy
-        {
-            // Token: 0x04009C1F RID: 39967
-            User,
-
-            // Token: 0x04009C20 RID: 39968
-            Always,
-
-            // Token: 0x04009C21 RID: 39969
-            Never
-        }
-
         static async Task<int> Main(string[] args)
         {
             var rootCommand =
-                new RootCommand("Simple application for patching license activation amongst Affinity v2.x/v1.x products.");
+                new RootCommand("Universal application patcher for Affinity v2.x/v1.x products and DxO PhotoLab.");
 
             var inputOptions = new Option<DirectoryInfo?>("--input",
-                    description: "Target Affinity directory (i.e., path containing Photo/Designer.exe).")
-                { IsRequired = true };
+                    description: "Target application directory (i.e., path containing the main executable).")
+            { IsRequired = true };
+
+            var modeOptions = new Option<PatcherMode>("--mode",
+                    description: "Select which application to patch.")
+            { IsRequired = false };
+            modeOptions.SetDefaultValue(PatcherMode.Affinity);
+
             var verboseOptions = new Option<bool>("--verbose", description: "Enable verbose logging.");
             var backupOptions = new Option<bool>("--keep", description: "Backup original assembly.");
 
             rootCommand.AddOption(inputOptions);
+            rootCommand.AddOption(modeOptions);
             rootCommand.AddOption(verboseOptions);
             rootCommand.AddOption(backupOptions);
 
-            rootCommand.SetHandler((di, shouldVerbose, shouldBackup) =>
+            rootCommand.SetHandler((di, mode, shouldVerbose, shouldBackup) =>
             {
                 if (di is not { Exists: true })
-                {
-                    throw new DirectoryNotFoundException("Cannot find the target Affinity directory.");
-                }
+                    throw new DirectoryNotFoundException($"Cannot find the target {mode} directory.");
+
+                bool hasWriteAccess = DirectoryAccessGeneric.HasWriteAccess(di.FullName);
+                if (shouldVerbose)
+                    AnsiConsole.MarkupLine($"[grey]Checking write access to {di.FullName}: {hasWriteAccess}[/]");
+                if (!hasWriteAccess)
+                    throw new AccessViolationException("Target directory does not have write access. You may need to re-run this application as administrator.");
 
-                var personaAssembly = FindPersonaAssembly(di);
-                if (personaAssembly == null)
+                AnsiConsole.MarkupLine(
+                    $"[grey]Patching product \"{mode}\" - if this is incorrect, make sure you have selected the desired product via the \"--mode\" switch.[/]");
+                switch (mode)
                 {
-                    throw new FileNotFoundException("Cannot find the required assembly.");
+                    case PatcherMode.Affinity:
+                        PatchAffinity(di, shouldVerbose, shouldBackup);
+                        break;
+                    case PatcherMode.DxO:
+                        PatchDxO(di, shouldVerbose, shouldBackup);
+                        break;
+                    default:
+                        throw new ArgumentException("Invalid patcher mode specified.");
                 }
+            }, inputOptions, modeOptions, verboseOptions, backupOptions);
 
-                PatchPersonaAssembly(personaAssembly.FullName, verbose: shouldVerbose, keepOriginal: shouldBackup);
-            }, inputOptions, verboseOptions, backupOptions);
+            return await rootCommand.InvokeAsync(args);
+        }
 
+        private static void PatchAffinity(DirectoryInfo directoryInfo, bool verbose, bool keepOriginal)
+        {
+            AnsiConsole.MarkupLine("[blue]Starting Affinity patching process...[/]");
 
-            return await rootCommand.InvokeAsync(args);
+            var personaAssembly = FindAssembly("Serif.Interop.Persona.dll",directoryInfo);
+            if (personaAssembly == null)
+                throw new FileNotFoundException("Cannot find the required Affinity assembly (Serif.Interop.Persona.dll).");
+
+            PatchAffinityAssembly(personaAssembly.FullName, verbose: verbose, keepOriginal: keepOriginal);
+        }
+
+        private static void PatchDxO(DirectoryInfo directoryInfo, bool verbose, bool keepOriginal)
+        {
+            AnsiConsole.MarkupLine("[blue]Starting DxO PhotoLab patching process...[/]");
+
+            var activationAssembly = FindAssembly("DxO.PhotoLab.Activation.dll", directoryInfo);
+            var activationInteropAssembly = FindAssembly("DxO.PhotoLab.Activation.Interop.dll", directoryInfo);
+
+            if (activationAssembly == null || activationInteropAssembly == null)
+                throw new FileNotFoundException("Cannot find the required DxO assemblies.");
+
+            PatchDxOAssembly(activationAssembly.FullName, verbose: verbose, keepOriginal: keepOriginal);
+            PatchDxOAssembly(activationInteropAssembly.FullName, verbose: verbose, keepOriginal: keepOriginal);
         }
 
-        static FileInfo? FindPersonaAssembly(DirectoryInfo? directoryInfo)
+        private static FileInfo? FindAssembly(string dllName, DirectoryInfo? directoryInfo)
         {
-            var targetPath = Path.Join(directoryInfo?.FullName, "Serif.Interop.Persona.dll");
-            var fi = new FileInfo(targetPath);
-            if (fi.Exists) return fi;
             // use the backup file if one exists
-            targetPath = Path.Join(directoryInfo?.FullName, "Serif.Interop.Persona.dll.bak");
-            fi = new FileInfo(targetPath);
-            return fi.Exists ? fi : null;
+            var expectedPath = Path.Join(directoryInfo?.FullName, dllName);
+            var expectedFi = new FileInfo(expectedPath);
+            return expectedFi.Exists ? expectedFi : null;
         }
 
-        static void PatchPersonaAssembly(string targetFile, bool verbose, bool keepOriginal)
+        private static void PatchAffinityAssembly(string targetFile, bool verbose, bool keepOriginal)
         {
             if (keepOriginal)
             {
                 File.Copy(targetFile, targetFile + ".bak", overwrite: true);
-                AnsiConsole.MarkupLine("[green]Backed up original assembly.[/]");
+                AnsiConsole.MarkupLine("[green]Backed up original Affinity assembly.[/]");
             }
 
             var moduleContext = ModuleDef.CreateModuleContext();
             var tempOutput = Path.GetTempFileName();
+
             using (var module = ModuleDefMD.Load(targetFile, moduleContext))
             {
                 var patchedList = new List<string>();
                 var application = module.Types.FirstOrDefault(x => x.FullName == "Serif.Interop.Persona.Application");
+
                 var methodsToPatchToTrue = application?.Methods.Where(x =>
                     x.Name == "HasEntitlementToRun" || x.Name == "CheckEula" || x.Name == "CheckAnalytics");
+
                 if (methodsToPatchToTrue != null)
                 {
                     foreach (var method in methodsToPatchToTrue)
@@ -97,15 +126,14 @@ static void PatchPersonaAssembly(string targetFile, bool verbose, bool keepOrigi
                                 $"Located [grey]{method.FullName}[/], patching with [grey]\"return true\"[/].");
                         }
 
-                        PatchWithLdcRet(method.Body, 1);
+                        Patcher.PatchWithLdcRet(method.Body, 1);
                         patchedList.Add(method.FullName);
                     }
                 }
 
                 var methodsToPatchToFalse = application?.Methods.Where(x => x.Name == "get_AllowsOptInAnalytics");
                 if (methodsToPatchToFalse != null)
                 {
-                    
                     foreach (var method in methodsToPatchToFalse)
                     {
                         if (verbose)
@@ -114,7 +142,7 @@ static void PatchPersonaAssembly(string targetFile, bool verbose, bool keepOrigi
                                 $"Located [grey]{method.FullName}[/], patching with [grey]\"return false\"[/].");
                         }
 
-                        PatchWithLdcRet(method.Body, 0);
+                        Patcher.PatchWithLdcRet(method.Body, 0);
                         patchedList.Add(method.FullName);
                     }
                 }
@@ -128,53 +156,128 @@ static void PatchPersonaAssembly(string targetFile, bool verbose, bool keepOrigi
                             $"Located [grey]{crashPolicy.FullName}[/], patching as [grey]{CrashReportUploadPolicy.Never.Humanize()}.[/]");
                     }
 
-                    PatchWithLdcRet(crashPolicy.Body, (int)CrashReportUploadPolicy.Never);
+                    Patcher.PatchWithLdcRet(crashPolicy.Body, (int)CrashReportUploadPolicy.Never);
                     patchedList.Add(crashPolicy.FullName);
                 }
 
-                AnsiConsole.Status().Spinner(Spinner.Known.Aesthetic)
-                    .Start("Saving assembly...", x =>
+                SaveAssembly(module, tempOutput, patchedList, "Affinity");
+            }
+
+            FinalizeAssembly(targetFile, tempOutput);
+        }
+
+        private static void PatchDxOAssembly(string targetFile, bool verbose, bool keepOriginal)
+        {
+            if (keepOriginal)
+            {
+                var backupPath = targetFile + ".bak";
+                File.Copy(targetFile, backupPath, overwrite: true);
+                AnsiConsole.MarkupLine($"[green]Backed up original DxO assembly as \"{backupPath}\".[/]");
+            }
+
+            var moduleContext = ModuleDef.CreateModuleContext();
+            var tempOutput = Path.GetTempFileName();
+
+            using (var module = ModuleDefMD.Load(targetFile, moduleContext))
+            {
+                var patchedList = new List<string>();
+                var features = module.Types.Where(x => x.FullName.Contains("DxO.PhotoLab.Activation.Feature") || x.FullName.Contains("DxOActivation"));
+
+                foreach (var feature in features)
+                {
+                    var methodsToPatchToTrue = feature?.Methods.Where(x => x.HasBody).Where(x =>
+                        x.Name.EndsWith("IsValid") || x.Name.EndsWith("HasAnyLicense") ||
+                        x.Name.EndsWith("IsActivated") || x.Name.EndsWith("IsElite"));
+
+                    if (methodsToPatchToTrue != null)
                     {
-                        if (module.IsILOnly)
+                        foreach (var method in methodsToPatchToTrue)
                         {
-                            module.Write(tempOutput);
+                            Patcher.PatchWithLdcRetVerbose(method.FullName, method.Body, 1, verbose);
+                            patchedList.Add(method.FullName);
                         }
-                        else
+                    }
+
+                    var methodsToPatchToFalse = feature?.Methods.Where(x => x.HasBody).Where(x =>
+                        x.Name.EndsWith("IsExpired") || x.Name.EndsWith("IsDemo") ||
+                        x.Name.EndsWith("IsTemporary") || x.Name == "Check");
+
+                    if (methodsToPatchToFalse != null)
+                    {
+                        foreach (var method in methodsToPatchToFalse)
                         {
-                            var writerOptions = new NativeModuleWriterOptions(module, false);
-                            module.NativeWrite(tempOutput, writerOptions);
+                            Patcher.PatchWithLdcRetVerbose(method.FullName, method.Body, 0, verbose);
+                            patchedList.Add(method.FullName);
                         }
-                    });
+                    }
 
-                var sb = new StringBuilder();
-                foreach (var patched in patchedList)
-                {
-                    sb.AppendLine($"- [green]{patched}[/]");
+                    var methodsToPatchToTwo = feature?.Methods.Where(x => x.HasBody).Where(x => x.Name.EndsWith("DemoType"));
+                    if (methodsToPatchToTwo != null)
+                    {
+                        foreach (var method in methodsToPatchToTwo)
+                        {
+                            Patcher.PatchWithLdcRetVerbose(method.FullName, method.Body, 2, verbose);
+                            patchedList.Add(method.FullName);
+                        }
+                    }
+
+                    var methodsToPatchToSpecifiedAmount = feature?.Methods.Where(x => x.HasBody).Where(x =>
+                        x.Name.EndsWith("RemainingDays") || x.Name == "RemainingOfflineDays");
+
+                    if (methodsToPatchToSpecifiedAmount != null)
+                    {
+                        foreach (var method in methodsToPatchToSpecifiedAmount)
+                        {
+                            Patcher.PatchWithLdcRetVerbose(method.FullName, method.Body, 99, verbose);
+                            patchedList.Add(method.FullName);
+                        }
+                    }
                 }
 
-                var panel = new Panel(sb.ToString());
-                panel.Padding = new Padding(1, 1);
-                panel.Header("Patched");
-                AnsiConsole.Write(panel);
+                SaveAssembly(module, tempOutput, patchedList, "DxO");
             }
 
-            if (targetFile.EndsWith(".bak"))
+            FinalizeAssembly(targetFile, tempOutput);
+        }
+
+        private static void SaveAssembly(ModuleDefMD module, string tempOutput, List<string> patchedList, string appName)
+        {
+            AnsiConsole.Status().Spinner(Spinner.Known.Aesthetic)
+                .Start($"Saving {appName} assembly...", _ =>
+                {
+                    if (module.IsILOnly)
+                    {
+                        module.Write(tempOutput);
+                    }
+                    else
+                    {
+                        var writerOptions = new NativeModuleWriterOptions(module, false);
+                        module.NativeWrite(tempOutput, writerOptions);
+                    }
+                });
+
+            var sb = new StringBuilder();
+            foreach (var patched in patchedList)
             {
-                targetFile = targetFile.Replace(".bak", "");
+                sb.AppendLine($"- [green]{patched}[/]");
             }
-            File.Move(tempOutput, targetFile, overwrite: true);
 
-            AnsiConsole.MarkupLine(
-                $"[green]Assembly saved as {targetFile}[/] with file size [bold]{new FileInfo(targetFile).Length.Bytes().Humanize()}[/].");
+            var panel = new Panel(sb.ToString())
+            {
+                Padding = new Padding(1, 1)
+            };
+            panel.Header($"Patched ({appName})");
+            AnsiConsole.Write(panel);
         }
 
-        static void PatchWithLdcRet(CilBody cilBody, int ldcValue)
+        private static void FinalizeAssembly(string targetFile, string tempOutput)
         {
-            cilBody.Instructions.Clear();
-            cilBody.ExceptionHandlers.Clear();
-            cilBody.Variables.Clear();
-            cilBody.Instructions.Add(Instruction.CreateLdcI4(ldcValue));
-            cilBody.Instructions.Add(Instruction.Create(OpCodes.Ret));
+            if (targetFile.EndsWith(".bak")) targetFile = targetFile.Replace(".bak", "");
+
+            File.Move(tempOutput, targetFile, overwrite: true);
+
+            AnsiConsole.MarkupLine(
+                $"[green]Assembly saved as {targetFile}[/] with file size [bold]{new FileInfo(targetFile).Length.Bytes().Humanize()}[/].");
         }
     }
-}
+}