tnblog
首页
视频
资源
登录
转

.net Aspose.Words破解指南

3899人阅读 2024/7/16 16:13 总访问：3467559 评论：0 收藏：1 手机
分类: .net后台框架

.netcore

.net Aspose.Words破解指南

Aspose.Words破解流程


感谢壹佰大佬提供的技术指导。
核心代码由壹佰大佬提供。

安装Crane.MethodHook包


首先安装Crane.MethodHook包。

破解方式


主要通过过期的序列证书，篡改系统的验证License的时间，只要让Aspose.Word命名空间下的文件获取当前时间时改成未到期时候的时间就可以了。
方法肯定还是通过Hook的方式，下面是提供参考的证书。


定义一个HookManager类。

  1. namespace Aspose.Hook
  2. {
  3.     [Flags]
  4.     public enum HookMethods
  5.     {
  6.         Invoke = 1,
  7.         ParseExact = 2,
  8.         DateTimeOpGreaterThan = 4,
  9.         StringCompare = 8,
  10.         StringIndexOf = 16,
  11.         XmlElementInnerText = 32
  12.     }
  14.     public class NewHookMethods
  15.     {
  16.         //将过期日期修改为
  17.         private static readonly string DATE_CHANGED_TO = (DateTime.Today.Year + 1).ToString() + "1230";
  19.         #region New hook methods
  21.         public static object NewMethodInvoke(MethodBase method, object obj, object[] parameters)
  22.         {
  23.             if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "ParseExact" && parameters.Length > 0 && parameters[0].ToString().Contains("0827"))
  24.             {
  25.                 var ret = DateTime.ParseExact(DATE_CHANGED_TO, "yyyyMMdd", System.Globalization.CultureInfo.InvariantCulture);
  26.                 ShowLog(method, ret, obj, parameters, true);
  27.                 return ret;
  28.             }
  29.             else if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "ParseExact" && parameters.Length > 0 && System.Text.RegularExpressions.Regex.Match(parameters[0].ToString(), @"^\d{4}\.\d{2}\.\d{2}$").Success)
  30.             {
  31.                 var ret = DateTime.ParseExact("20200501", "yyyyMMdd", System.Globalization.CultureInfo.InvariantCulture);
  32.                 ShowLog(method, ret, obj, parameters, true);
  33.                 return ret;
  34.             }
  35.             else if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "get_InnerText" && obj is XmlElement && (obj as XmlElement).Name == "SubscriptionExpiry")
  36.             {
  37.                 ////这里不能用，否则会出错。
  38.                 //ShowLog(method, DATE_CHANGED_TO, obj, parameters, true);
  39.                 //return DATE_CHANGED_TO;
  40.             }
  41.             else if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "get_Ticks" && obj is DateTime && ((DateTime)obj).ToString("MMdd") == "0827")
  42.             {
  43.                 var ret = DateTime.ParseExact(DATE_CHANGED_TO, "yyyyMMdd", System.Globalization.CultureInfo.InvariantCulture).Ticks;
  44.                 ShowLog(method, ret, obj, parameters, true);
  45.                 return ret;
  46.             }
  47.             else if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.DeclaringType != null && method.DeclaringType.Name == "String" && method.Name == "Compare")
  48.             {
  49.                 if (parameters.Length == 2)
  50.                 {
  51.                     if (parameters[0].ToString() == "20200827")
  52.                     {
  53.                         var ret = 1;
  54.                         ShowLog(method, ret, obj, parameters, true);
  55.                         return ret;
  56.                     }
  57.                     else if (parameters[1].ToString() == "20200827")
  58.                     {
  59.                         var ret = -1;
  60.                         ShowLog(method, ret, obj, parameters, true);
  61.                         return ret;
  62.                     }
  63.                 }
  64.             }
  65.             else if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "op_GreaterThan" && parameters.Length == 2 && parameters[1] is DateTime && ((DateTime)parameters[1]).ToString("MMdd") == "0827")
  66.             {
  67.                 ShowLog(method, false, obj, parameters, true);
  68.                 return false;
  69.             }
  70.             else if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "IndexOf" && parameters.Length > 0 && parameters[0].ToString().Contains("0827"))
  71.             {
  72.                 ShowLog(method, 580, obj, parameters, true);
  73.                 return 580;
  74.             }
  75.             else if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "Split" && System.Text.RegularExpressions.Regex.Match(obj.ToString(), @"^\d{4}\.\d{2}\.\d{2}$").Success
  76.                      && obj != null && obj.ToString().Substring(0, 4) == DateTime.Now.Year.ToString())
  77.             {
  78.                 var ret = new string[] { "2019", "08", "27" };
  79.                 ShowLog(method, ret, obj, parameters, true);
  80.                 return ret;
  81.             }
  82.             else if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && method.Name == "get_Now")
  83.             {
  84.                 var ret = DateTime.ParseExact("20200518", "yyyyMMdd", System.Globalization.CultureInfo.InvariantCulture);
  85.                 ShowLog(method, ret, obj, parameters, true);
  86.                 return ret;
  87.             }
  89.             var hook = MethodHookManager.Instance.GetHook(System.Reflection.MethodBase.GetCurrentMethod());
  90.             var result = hook.InvokeOriginal<object>(method, obj, parameters?.ToArray());
  91.             ShowLog(method, result, obj, parameters);
  92.             return result;
  93.         }
  94.         /// <summary>
  95.         /// 获取类型
  96.         /// </summary>
  97.         /// <param name="obj"></param>
  98.         /// <returns></returns>
  99.         private static string Serialize(object obj)
  100.         {
  101.             if (obj is string) return obj?.ToString();
  102.             if (obj is byte[])
  103.             {
  104.                 return "byte[]";
  105.             }
  107.             if (obj is Stream)
  108.             {
  109.                 return "<STREAM>...";
  110.             }
  112.             if (obj is IEnumerable<object>)
  113.             {
  114.                 var arr = obj as IEnumerable<object>;
  115.                 if (arr.Any())
  116.                 {
  117.                     return "[" + (arr.Aggregate("", (a, b) => (a == "" ? "" : Serialize(a) + ",") + Serialize(b))) + "]";
  118.                 }
  119.                 else
  120.                 {
  121.                     return "[]";
  122.                 }
  123.             }
  124.             else if (obj is char[])
  125.             {
  126.                 return string.Join(",", obj as char[]);
  127.             }
  128.             else
  129.             {
  130.                 return obj?.ToString();
  131.             }
  132.         }
  135.         /// <summary>
  136.         /// 输出日志
  137.         /// </summary>
  138.         /// <param name="method"></param>
  139.         /// <param name="ret"></param>
  140.         /// <param name="obj"></param>
  141.         /// <param name="parameters"></param>
  142.         /// <param name="isImportant"></param>
  143.         public static void ShowLog(MethodBase method, object ret, object obj, object[] parameters, bool isImportant = false)
  144.         {
  145.             try
  146.             {
  147.                 if (isImportant == false)
  148.                 {
  149.                     // 只拦截字符串类型的和时间类型的元素
  150.                     if ((method.DeclaringType?.Name.Contains("DateTime") == false
  151.                          && method.DeclaringType?.Name.Contains("String.") == false)
  152.                         || method.Name.Contains("ToCharArray")
  153.                         || method.Name.Contains("IndexOf")
  154.                         || method.Name.Contains("get_Length")
  155.                         || method.Name.Contains("op_Equality")
  156.                         || method.Name.Contains("ToLower"))
  157.                     {
  158.                         //Utils.LogWriteLine($"Bob Is Not Important {method.DeclaringType?.Name}.{method.Name}", ConsoleColor.White);
  159.                         return;
  160.                     }
  161.                 }
  164.                 var paras = string.Empty;
  165.                 try
  166.                 {
  167.                     paras = Serialize(obj) + "," + Serialize(parameters);
  168.                 }
  169.                 catch (Exception)
  170.                 {
  171.                     paras = obj + "," + parameters;
  172.                 }
  174.                 var returns = string.Empty;
  175.                 try
  176.                 {
  177.                     returns = Serialize(ret);
  178.                 }
  179.                 catch (Exception)
  180.                 {
  181.                     returns = ret?.ToString();
  182.                 }
  184.                 Utils.LogWriteLine($"INVOKE method {method.DeclaringType?.Name}.{method.Name}({paras}) RETURN=> {returns}", isImportant ? ConsoleColor.Blue : ConsoleColor.DarkGray);
  185.             }
  186.             catch (Exception e)
  187.             {
  188.                 Utils.LogWrite("Error:" + e.Message);
  189.             }
  190.         }
  193.         public static int NewCompare(string s1, string s2)
  194.         {
  195.             if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && s2 == "20200827")
  196.             {
  197.                 Utils.LogWriteLine($"HOOK SUCCESS: From {Assembly.GetCallingAssembly().GetName().Name} String.Compare({s1},{s2}) return -1;", ConsoleColor.Green);
  198.                 return -1;
  199.             }
  200.             else
  201.             {
  202.                 var hook = MethodHookManager.Instance.GetHook(MethodBase.GetCurrentMethod());
  203.                 var ret = hook.InvokeOriginal<int>(null, s1, s2);
  204.                 Utils.LogWriteLine($"NOT Aspose Call: From {Assembly.GetCallingAssembly().GetName().Name} String.Compare({s1},{s2}) return {ret};", ConsoleColor.DarkRed);
  205.                 return ret;
  206.             }
  207.         }
  209.         public static bool NewGreaterThan(DateTime t1, DateTime t2)
  210.         {
  211.             if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && t2.ToString("yyyyMMdd") == "20200827")
  212.             {
  213.                 Utils.LogWriteLine($"HOOK SUCCESS: From {Assembly.GetCallingAssembly().GetName().Name} DateTime ({t1}>{t2}) return false;", ConsoleColor.Green);
  214.                 return false;
  215.             }
  216.             else
  217.             {
  218.                 var hook = MethodHookManager.Instance.GetHook(MethodBase.GetCurrentMethod());
  219.                 var ret = hook.InvokeOriginal<bool>(null, t1, t2);
  220.                 return ret;
  221.             }
  222.         }
  224.         public static DateTime NewParseExact(string s, string format, IFormatProvider provider)
  225.         {
  226.             if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && s == "20200827")
  227.             {
  228.                 Utils.LogWriteLine($"HOOK SUCCESS: From {Assembly.GetCallingAssembly().GetName().Name} DateTime.ParseExact({s},{format},{provider}) return {DATE_CHANGED_TO};", ConsoleColor.Green);
  229.                 var hook = MethodHookManager.Instance.GetHook(System.Reflection.MethodBase.GetCurrentMethod());
  230.                 return hook.InvokeOriginal<DateTime>(null, DATE_CHANGED_TO, format, provider);
  231.             }
  232.             else
  233.             {
  234.                 var hook = MethodHookManager.Instance.GetHook(System.Reflection.MethodBase.GetCurrentMethod());
  235.                 return hook.InvokeOriginal<DateTime>(null, s, format, provider);
  236.             }
  237.         }
  239.         public static string NewInnerText(XmlElement element)
  240.         {
  241.             if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.Words") == false && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.Hook") == false && element.Name == "SubscriptionExpiry")
  242.             {
  243.                 Utils.LogWriteLine($"HOOK SUCCESS: From {Assembly.GetCallingAssembly().GetName().Name} XmlElement.InnerText ({element.Name},{element.InnerXml}) return {DATE_CHANGED_TO};", ConsoleColor.Green);
  244.                 return DATE_CHANGED_TO;
  245.             }
  246.             else
  247.             {
  248.                 var hook = MethodHookManager.Instance.GetHook(System.Reflection.MethodBase.GetCurrentMethod());
  249.                 return hook.InvokeOriginal<string>(element);
  250.             }
  251.         }
  253.         public static int NewIndexOf(string v1, string v2)
  254.         {
  255.             if (Assembly.GetCallingAssembly() != null && Assembly.GetCallingAssembly().FullName.StartsWith("Aspose.") && v2 == DATE_CHANGED_TO)
  256.             {
  257.                 Utils.LogWriteLine($"HOOK SUCCESS: From {Assembly.GetCallingAssembly().GetName().Name} {v1.ToString().Substring(0, 9) + "..."}.IndexOf({v2}) return 580;", ConsoleColor.Green);
  258.                 return 580;
  259.             }
  260.             else
  261.             {
  262.                 var hook = MethodHookManager.Instance.GetHook(System.Reflection.MethodBase.GetCurrentMethod());
  263.                 var ret = hook.InvokeOriginal<int>(v1, v2);
  264.                 return ret;
  265.             }
  266.         }
  268.         #endregion
  269.     }
  271.     public static class HookManager
  272.     {
  273.         private class HookItem
  274.         {
  275.             public HookMethods Method { get; set; }
  276.             public MethodHook Hook { get; set; }
  277.             public bool Enabled { get; set; }
  278.         }
  280.         //所有的license都只需要设置一次
  281.         private static List<string> mAssembliesLicenseSetted = new List<string>();
  284.         //将于20200827过期的Aspose.Total开发版序列号
  285.         private const string LICENSE_STRING = "PExpY2Vuc2U+CiAgPERhdGE+CiAgICA8TGljZW5zZWRUbz5TdXpob3UgQXVuYm94IFNvZnR3YXJlIENvLiwgT" +
  286.                                               "HRkLjwvTGljZW5zZWRUbz4KICAgIDxFbWFpbFRvPnNhbGVzQGF1bnRlYy5jb208L0VtYWlsVG8+CiAgICA8TG" +
  287.                                               "ljZW5zZVR5cGU+RGV2ZWxvcGVyIE9FTTwvTGljZW5zZVR5cGU+CiAgICA8TGljZW5zZU5vdGU+TGltaXRlZCB" +
  288.                                               "0byAxIGRldmVsb3BlciwgdW5saW1pdGVkIHBoeXNpY2FsIGxvY2F0aW9uczwvTGljZW5zZU5vdGU+CiAgICA8" +
  289.                                               "T3JkZXJJRD4xOTA4MjYwODA3NTM8L09yZGVySUQ+CiAgICA8VXNlcklEPjEzNDk3NjAwNjwvVXNlcklEPgogI" +
  290.                                               "CAgPE9FTT5UaGlzIGlzIGEgcmVkaXN0cmlidXRhYmxlIGxpY2Vuc2U8L09FTT4KICAgIDxQcm9kdWN0cz4KIC" +
  291.                                               "AgICAgPFByb2R1Y3Q+QXNwb3NlLlRvdGFsIGZvciAuTkVUPC9Qcm9kdWN0PgogICAgPC9Qcm9kdWN0cz4KICA" +
  292.                                               "gIDxFZGl0aW9uVHlwZT5FbnRlcnByaXNlPC9FZGl0aW9uVHlwZT4KICAgIDxTZXJpYWxOdW1iZXI+M2U0NGRl" +
  293.                                               "MzAtZmNkMi00MTA2LWIzNWQtNDZjNmEzNzE1ZmMyPC9TZXJpYWxOdW1iZXI+CiAgICA8U3Vic2NyaXB0aW9uR" +
  294.                                               "XhwaXJ5PjIwMjAwODI3PC9TdWJzY3JpcHRpb25FeHBpcnk+CiAgICA8TGljZW5zZVZlcnNpb24+My4wPC9MaW" +
  295.                                               "NlbnNlVmVyc2lvbj4KICAgIDxMaWNlbnNlSW5zdHJ1Y3Rpb25zPmh0dHBzOi8vcHVyY2hhc2UuYXNwb3NlLmN" +
  296.                                               "vbS9wb2xpY2llcy91c2UtbGljZW5zZTwvTGljZW5zZUluc3RydWN0aW9ucz4KICA8L0RhdGE+CiAgPFNpZ25h" +
  297.                                               "dHVyZT53UGJtNUt3ZTYvRFZXWFNIY1o4d2FiVEFQQXlSR0pEOGI3L00zVkV4YWZpQnd5U2h3YWtrNGI5N2c2e" +
  298.                                               "GtnTjhtbUFGY3J0c0cwd1ZDcnp6MytVYk9iQjRYUndTZWxsTFdXeXNDL0haTDNpN01SMC9jZUFxaVZFOU0rWn" +
  299.                                               "dOQkR4RnlRbE9uYTFQajhQMzhzR1grQ3ZsemJLZFZPZXk1S3A2dDN5c0dqYWtaL1E9PC9TaWduYXR1cmU+CjwvTGljZW5zZT4=";
  301.         private static List<HookItem> mHookStatus = new List<HookItem>();
  302.         private static bool mHookStarted = false;
  304.         static HookManager()
  305.         {
  306.         }
  308.         static void InitializeHookList()
  309.         {
  310.             if (mHookStatus.Count == 0)
  311.             {
  312.                 mHookStatus.Add(new HookItem
  313.                 {
  314.                     Method = HookMethods.Invoke,
  315.                     Hook = new MethodHook(
  316.                         typeof(MethodBase).GetMethod("Invoke", BindingFlags.Public | BindingFlags.Instance, null, new[] { typeof(object), typeof(object[]) }, null),
  317.                         typeof(NewHookMethods).GetMethod(nameof(NewHookMethods.NewMethodInvoke), BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(MethodBase), typeof(object), typeof(object[]) }, null)
  318.                     ),
  319.                     Enabled = true
  320.                 });
  321.                 mHookStatus.Add(new HookItem
  322.                 {
  323.                     Method = HookMethods.ParseExact,
  324.                     Hook = new MethodHook(
  325.                         typeof(DateTime).GetMethod("ParseExact", BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(string), typeof(string), typeof(IFormatProvider) }, null),
  326.                         typeof(NewHookMethods).GetMethod(nameof(NewHookMethods.NewParseExact), BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(string), typeof(string), typeof(IFormatProvider) }, null)
  327.                     ),
  328.                     Enabled = true
  329.                 });
  330.                 mHookStatus.Add(new HookItem
  331.                 {
  332.                     Method = HookMethods.DateTimeOpGreaterThan,
  333.                     Hook = new MethodHook(
  334.                         typeof(DateTime).GetMethod("op_GreaterThan", BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(DateTime), typeof(DateTime) }, null),
  335.                         typeof(NewHookMethods).GetMethod(nameof(NewHookMethods.NewGreaterThan), BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(DateTime), typeof(DateTime) }, null)
  336.                     ),
  337.                     Enabled = true
  338.                 });
  339.                 mHookStatus.Add(new HookItem
  340.                 {
  341.                     Method = HookMethods.StringCompare,
  342.                     Hook = new MethodHook(
  343.                         typeof(string).GetMethod("Compare", BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(string), typeof(string) }, null),
  344.                         typeof(NewHookMethods).GetMethod(nameof(NewHookMethods.NewCompare), BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(string), typeof(string) }, null)
  345.                     ),
  346.                     Enabled = true
  347.                 });
  348.                 mHookStatus.Add(new HookItem
  349.                 {
  350.                     Method = HookMethods.StringIndexOf,
  351.                     Hook = new MethodHook(
  352.                         typeof(string).GetMethod("IndexOf", BindingFlags.Instance | BindingFlags.Public, null, new[] { typeof(string) }, null),
  353.                         typeof(NewHookMethods).GetMethod(nameof(NewHookMethods.NewIndexOf), BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(string), typeof(string) }, null)
  354.                     ),
  355.                     Enabled = true
  356.                 });
  357.                 mHookStatus.Add(new HookItem
  358.                 {
  359.                     Method = HookMethods.XmlElementInnerText,
  360. #if NET40
  361.                     Hook = new MethodHook(
  362.                         typeof(XmlElement).GetProperty("InnerText", BindingFlags.Public | BindingFlags.Instance).GetGetMethod(true),
  363.                         typeof(NewHookMethods).GetMethod(nameof(NewHookMethods.NewInnerText), BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(XmlElement) }, null)
  364.                     ),
  365. #else
  366.                     Hook = new MethodHook(
  367.                         typeof(XmlElement).GetProperty("InnerText", BindingFlags.Public | BindingFlags.Instance).GetMethod,
  368.                         typeof(NewHookMethods).GetMethod(nameof(NewHookMethods.NewInnerText), BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(XmlElement) }, null)
  369.                     ),
  370. #endif
  371.                     Enabled = true
  372.                 });
  374.                 foreach (var item in mHookStatus)
  375.                 {
  376.                     if (item.Enabled)
  377.                     {
  378.                         MethodHookManager.Instance.AddHook(item.Hook);
  379.                     }
  380.                 }
  381.             }
  382.         }
  384.         /// <summary>
  385.         /// 设置需要启用的方法清单（默认已启用了所有）
  386.         /// </summary>
  387.         /// <param name="methods"></param>
  388.         public static void SetHookMethods(HookMethods methods)
  389.         {
  390.             InitializeHookList();
  392.             MethodHookManager.Instance.StopHook();
  393.             MethodHookManager.Instance.RemoveAllHook();
  395.             foreach (var item in mHookStatus)
  396.             {
  397.                 if (methods.HasFlag(item.Method))
  398.                 {
  399.                     item.Enabled = true;
  400.                     MethodHookManager.Instance.AddHook(item.Hook);
  401.                 }
  402.                 else
  403.                 {
  404.                     item.Enabled = false;
  405.                 }
  406.             }
  408.             if (mHookStarted)
  409.             {
  410.                 MethodHookManager.Instance.StartHook();
  411.             }
  412.         }
  415.         /// <summary>
  416.         /// 是否显示详细的HOOK明细
  417.         /// </summary>
  418.         /// <param name="show"></param>
  419.         public static void ShowHookDetails(bool show)
  420.         {
  421.             if (show)
  422.             {
  423.                 Utils.EnableLog();
  424.             }
  425.             else
  426.             {
  427.                 Utils.DisableLog();
  428.             }
  429.         }
  431.         /// <summary>
  432.         /// 启用hook
  433.         /// </summary>
  434.         public static void StartHook()
  435.         {
  436.             if (mHookStarted)
  437.             {
  438.                 return;
  439.             }
  441.             try
  442.             {
  443.                 InitializeHookList();
  445.                 MethodHookManager.Instance.StartHook();
  448.                 //所有库的License都只需要设置一次就可以了。
  449.                 var assemblies = Assembly.GetCallingAssembly()?.GetReferencedAssemblies().Union(Assembly.GetEntryAssembly()?.GetReferencedAssemblies() ?? new AssemblyName[] { })
  450.                     .GroupBy(assembly => assembly.Name).Select(item => item.FirstOrDefault())
  451.                     .Where(assembly => assembly.Name.StartsWith("Aspose") && assembly.Name.StartsWith("Aspose.Hook") == false);
  453.                 if (assemblies != null)
  454.                 {
  455.                     foreach (var assembly in assemblies)
  456.                     {
  457.                         if (mAssembliesLicenseSetted.Contains(assembly.FullName))
  458.                         {
  459.                             continue;
  460.                         }
  461.                         else
  462.                         {
  463.                             var type = Assembly.Load(assembly).GetType(assembly.Name + ".License");
  464.                             if (type == null)
  465.                             {
  466.                                 type = Assembly.Load(assembly).GetType(System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(assembly.Name.ToLower()) + ".License");
  467.                             }
  469.                             if (type != null)
  470.                             {
  471.                                 Utils.LogWriteLine($"\nSETTING...{type.FullName}", ConsoleColor.Yellow);
  472.                                 var instance = Activator.CreateInstance(type);
  473.                                 type.GetMethod("SetLicense", new[] { typeof(Stream) }).Invoke(instance, BindingFlags.Public | BindingFlags.Instance, null, new[] { new MemoryStream(Convert.FromBase64String(LICENSE_STRING)) }, null);
  474.                                 Utils.LogWriteLine($"{type.FullName} SET SUCCESSFULLY.", ConsoleColor.Yellow);
  475.                                 mAssembliesLicenseSetted.Add(assembly.FullName);
  476.                             }
  477.                         }
  478.                     }
  479.                 }
  480.             }
  481.             catch (Exception e)
  482.             {
  483.                 var exception = e;
  484.                 while (exception.InnerException != null)
  485.                 {
  486.                     exception = exception.InnerException;
  487.                 }
  489.                 Utils.LogWriteLine($"start hook failed because of {exception.Message}.", ConsoleColor.Red);
  490.             }
  492.             mHookStarted = true;
  493.         }
  495.         /// <summary>
  496.         /// 停用Hook
  497.         /// </summary>
  498.         public static void StopHook()
  499.         {
  500.             if (mHookStarted == false)
  501.             {
  502.                 return;
  503.             }
  505.             MethodHookManager.Instance.StopHook();
  506.             mHookStarted = false;
  507.         }
  508.     }
  509. }


示例代码：

  1. HookManager.ShowHookDetails(true);
  2. HookManager.StartHook();
  3. Document doc = new Document("E:\\outparcket\\asposenetpojie\\file\\nh.docx");
  4. // 将文档保存为 PDF 格式
  5. doc.Save("E:\\outparcket\\asposenetpojie\\file\\nh.pdf", SaveFormat.Pdf);


发现并没有水印破解成功。

参考


参考链接：https://www.52hb.com/thread-57858-1-1.html


欢迎加群讨论技术，1群：677373950(满了，可以加，但通过不了)，2群：656732739

评价

net core 使用 EF Code First
下面这些内容很老了看这篇：https://www.tnblog.net/aojiancc2/article/details/5365 项目使用多层，把数据库访问...

cAPS.net 保存base64位格式的图片
publicvoidUpload() { //取出图片对应的base64位字符 stringimgBase=Request[&quot;imgBase&quot;]; //c#里边的base6...

Quartz.net实例动态改变周期调度。misfire、Cron
Quartz：Java编写的开源的任务调度作业框架 类似Timer之类定时执行的功能，但是更强大Quartz.NET：是把Quartz转成C# NuGet...

.net Windows服务发布、安装、卸载、监听脚本。服务调试
一、脚本 为方便不用每次都去写安装卸载的脚本1.安装脚本@echooff @echo开始安装【服务】 %SystemRoot%\Microsoft.NET\Fr...

c、VB.net中全角半角转换方法
///&lt;summary&gt; ///转全角的函数(SBCcase) ///&lt;/summary&gt; ///&lt;paramname=&quot;input&quot;&gt;任意字符串...

.net mvc分部页，.net core分部页
.net分部页的三种方式第一种：@Html.Partial(&quot;_分部页&quot;)第二种：@{ Html.RenderPartial(&quot;分部页&quot;);}...

C.net 配合小程序实现经过第三方服务器中转文件
某些时候，微信小程序前段上传文件的时候需要经过第三方服务器再将文件上传到客户的服务器；操作如下：1:(小程序内向中端服...

.net实现QQ邮箱发送邮件功能
1、微软已经帮我们封装好了发送邮件的类MailMessage,MailMessage类构造一些邮件信息，然后通过SmtpClient进行邮件发送。Mai...

StackExchange.Redis操作redis(net core支持)
官方git开源地址https://github.com/StackExchange/StackExchange.Redis官方文档在docs里边都是官方的文档通过nuget命令下...

windows 自带的netsh进行端口映射
使用netsh 把本地任意ip的25566端口 映射到192.168.81.234的25565端口netshinterfaceportproxyaddv4tov4listenaddress=0.0....

确保.net程序始终以管理员身份运行
usingSystem; usingSystem.Collections.Generic; usingSystem.Linq; usingSystem.Text; usingSystem.Threading.Tasks; ...

ASP.net Timer细节处理
Timer的用法：1：本人称之为计时器，是asp.net官方的一种。用法即是计时所用 2：关于计时有很多中方式，本人学识有限，暂...

.net core 使用session
tip:net core 2.2后可以直接启用session了，不用在自己添加一次session依赖，本身就添加了使用nuget添加引用Microsoft.AspN...

通俗易懂，什么是.net?什么是.net Framework？什么是.net core?
朋友圈@蓝羽 看到一篇文章写的太详细太通俗了，搬过来细细看完，保证你对.NET有个新的认识理解原文地址：https://www.cnblo...

asp.net core2.0 依赖注入 AddTransient与AddScoped的区别
asp.net core主要提供了三种依赖注入的方式其中AddTransient与AddSingleton比较好区别AddTransient瞬时模式：每次都获取一...
这一世以无限游戏为使命！
博主信息
排名
2
文章
634
粉丝
44
评论
93
文章类别
最新文章
最新评价
docker中Sware集群与service
尘叶心繁 : 想学呀！我教你呀
一个bug让程序员走上法庭 索赔金额达400亿日元
叼着奶瓶逛酒吧 : 所以说做程序员也要懂点法律知识
.net core 塑形资源
剑轩 : 收藏收藏
映射AutoMapper
剑轩 : 好是好，这个对效率影响大不大哇,效率高不高
ASP.NET Core 服务注册生命周期
剑轩 : http://www.tnblog.net/aojiancc2/article/details/167
关于我们
ICP备案 ：渝ICP备18016597号-1
网站信息：2018-2025TNBLOG.NET
技术交流：群号656732739
联系我们：contact@tnblog.net
公网安备：50010702506256
欢迎加群
欢迎加群交流技术