axios全局使用 react
2018-06-13 16:13:29 shujudeliu 阅读数 8138

.net reactor的使用

.NET Reactor 是一款强大的 .NET 代码混淆加密保护工具,常用于防止对 .NET 程序的反编译破解等场景。

本文以.net reactor加密dll为示例:

1.新建一个类库项目,并创建一个类,本文以对称加密算法为示例

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace PP.Encrypt
{
    //密码生成:https://suijimimashengcheng.51240.com/
    public class SymmetricMethod
    {
        private SymmetricAlgorithm mobjCryptoService;
        private string Key;
        /// <summary>   
        /// 对称加密类的构造函数   
        /// </summary>   
        public SymmetricMethod()
        {
            mobjCryptoService = new RijndaelManaged();
            Key = "FefZ$@pAedzg#HjT!QcM7JQqwOcAkCm7x2pZjBUMSocM9v6#%AP9HZg7OZ^ogG!x";
        }
        /// <summary>   
        /// 获得密钥   
        /// </summary>   
        /// <returns>密钥</returns>   
        private byte[] GetLegalKey()
        {
            string sTemp = Key;
            mobjCryptoService.GenerateKey();
            byte[] bytTemp = mobjCryptoService.Key;
            int KeyLength = bytTemp.Length;
            if (sTemp.Length > KeyLength)
                sTemp = sTemp.Substring(0, KeyLength);
            else if (sTemp.Length < KeyLength)
                sTemp = sTemp.PadRight(KeyLength, ' ');
            return ASCIIEncoding.ASCII.GetBytes(sTemp);
        }
        /// <summary>   
        /// 获得初始向量IV   
        /// </summary>   
        /// <returns>初试向量IV</returns>   
        private byte[] GetLegalIV()
        {
            string sTemp = "XUYXqW8QF2fqyytf0ZwU6Vv1cbNI3qU!zVzohQ0ptAug#&uJ3b^rEKkrckH1LE3i";
            mobjCryptoService.GenerateIV();
            byte[] bytTemp = mobjCryptoService.IV;
            int IVLength = bytTemp.Length;
            if (sTemp.Length > IVLength)
                sTemp = sTemp.Substring(0, IVLength);
            else if (sTemp.Length < IVLength)
                sTemp = sTemp.PadRight(IVLength, ' ');
            return ASCIIEncoding.ASCII.GetBytes(sTemp);
        }
        /// <summary>   
        /// 加密方法   
        /// </summary>   
        /// <param name="Source">待加密的串</param>   
        /// <returns>经过加密的串</returns>   
        public string Encrypto(string Source)
        {
            byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source);
            MemoryStream ms = new MemoryStream();
            mobjCryptoService.Key = GetLegalKey();
            mobjCryptoService.IV = GetLegalIV();
            ICryptoTransform encrypto = mobjCryptoService.CreateEncryptor();
            CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
            cs.Write(bytIn, 0, bytIn.Length);
            cs.FlushFinalBlock();
            ms.Close();
            byte[] bytOut = ms.ToArray();
            return Convert.ToBase64String(bytOut);
        }
        /// <summary>   
        /// 解密方法   
        /// </summary>   
        /// <param name="Source">待解密的串</param>   
        /// <returns>经过解密的串</returns>   
        public string Decrypto(string Source)
        {
            byte[] bytIn = Convert.FromBase64String(Source);
            MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);
            mobjCryptoService.Key = GetLegalKey();
            mobjCryptoService.IV = GetLegalIV();
            ICryptoTransform encrypto = mobjCryptoService.CreateDecryptor();
            CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
            StreamReader sr = new StreamReader(cs);
            return sr.ReadToEnd();
        }
    }
}

2.安装.net reactor5.0

如果要单独加密某个dll,单击“open”选择要加密的dll,然后在下边"Quick Settings"里边选择加密的选项即可,使用菜单里的“Protection Presets”可以快速设定"Quick Settings"里的选项,本例使用类库强加密,如图:

然后切换到Protection选项卡,点击“Protect”按钮即可生成加密后的dll

执行加密保护操作以后,默认会在原dll文件夹下创建一个后缀名_Secure的文件夹,里边就是加密以后的dll了。

此时使用.net reflector反编译工具查看生成的dll,即可发现无法直接看到相关方法信息了,如图:

3.在VS项目中配置自动加密

这种手动加密的方法固然可以,不过实际使用中却不是很方便,毕竟需要手动加密的。.net reactor强大的地方在于可以在VS项目生成的时候自动加密。

打开.Net Reactor 5.0,单击Help菜单,选择开发使用的VS版本,这个操作会在VS中安装.net reactor插件

打开VS,点击“工具”菜单,可以看到.net reactor插件已安装

点击上图中的.Net Reactor

随后点击生成项目,会跳出加密的画面:

这个加密画面只有修改了.net reactor插件中的配置后第一次生成时候可以明显看到,随后再执行生成都是一闪而过,几乎感觉不到,可以说是非常便捷的。

.net reactor功能非常强大,还可以用于将站点、服务、类库文件打包成一个文件等等,本文只是介绍了简单的使用。

 

此外,混淆加壳和逆向脱壳破解,本身就是矛和盾之争,安全的概念只是相对的。比如一款叫de4dot的逆向工具,就可以对大部分.net reactor加密的程序进行脱壳破解(当然需要懂一些逆向的知识),大家使用时候自己有所衡量就可以了。

 

2015-09-23 21:10:44 u012333307 阅读数 449

1 RingBufferDispather

   机制:

   使用RingBuffer作为任务的存放容器,等待策略使用阻塞模式。

   使用单线程执行任务。

   使用场景:

         由于采用单线程执行,因此任务的执行必须快,不能阻塞,否则当大批量的任务提交时,必然阻塞提交任务的线程。

        BlockingWaitStrategy策略机制采用ReentrantLock重入锁和显示条件队进行等待。当大量的任务阻塞提交时,必然导致线程的上线文切换频繁,导致过高的cpu。

     

  避免使用场景:

      生产者生产的速度远高于消费者消费的速度。reactor的消费者有阻塞操作。

2019-01-11 16:29:49 stableboy 阅读数 128

https://blog.csdn.net/shujudeliu/article/details/80679951

 

 

.net reactor的使用
.NET Reactor 是一款强大的 .NET 代码混淆加密保护工具,常用于防止对 .NET 程序的反编译破解等场景。

本文以.net reactor加密dll为示例:

1.新建一个类库项目,并创建一个类,本文以对称加密算法为示例


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
 
namespace PP.Encrypt
{
    //密码生成:https://suijimimashengcheng.51240.com/
    public class SymmetricMethod
    {
        private SymmetricAlgorithm mobjCryptoService;
        private string Key;
        /// <summary>   
        /// 对称加密类的构造函数   
        /// </summary>   
        public SymmetricMethod()
        {
            mobjCryptoService = new RijndaelManaged();
            Key = "FefZ$@pAedzg#HjT!QcM7JQqwOcAkCm7x2pZjBUMSocM9v6#%AP9HZg7OZ^ogG!x";
        }
        /// <summary>   
        /// 获得密钥   
        /// </summary>   
        /// <returns>密钥</returns>   
        private byte[] GetLegalKey()
        {
            string sTemp = Key;
            mobjCryptoService.GenerateKey();
            byte[] bytTemp = mobjCryptoService.Key;
            int KeyLength = bytTemp.Length;
            if (sTemp.Length > KeyLength)
                sTemp = sTemp.Substring(0, KeyLength);
            else if (sTemp.Length < KeyLength)
                sTemp = sTemp.PadRight(KeyLength, ' ');
            return ASCIIEncoding.ASCII.GetBytes(sTemp);
        }
        /// <summary>   
        /// 获得初始向量IV   
        /// </summary>   
        /// <returns>初试向量IV</returns>   
        private byte[] GetLegalIV()
        {
            string sTemp = "XUYXqW8QF2fqyytf0ZwU6Vv1cbNI3qU!zVzohQ0ptAug#&uJ3b^rEKkrckH1LE3i";
            mobjCryptoService.GenerateIV();
            byte[] bytTemp = mobjCryptoService.IV;
            int IVLength = bytTemp.Length;
            if (sTemp.Length > IVLength)
                sTemp = sTemp.Substring(0, IVLength);
            else if (sTemp.Length < IVLength)
                sTemp = sTemp.PadRight(IVLength, ' ');
            return ASCIIEncoding.ASCII.GetBytes(sTemp);
        }
        /// <summary>   
        /// 加密方法   
        /// </summary>   
        /// <param name="Source">待加密的串</param>   
        /// <returns>经过加密的串</returns>   
        public string Encrypto(string Source)
        {
            byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source);
            MemoryStream ms = new MemoryStream();
            mobjCryptoService.Key = GetLegalKey();
            mobjCryptoService.IV = GetLegalIV();
            ICryptoTransform encrypto = mobjCryptoService.CreateEncryptor();
            CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
            cs.Write(bytIn, 0, bytIn.Length);
            cs.FlushFinalBlock();
            ms.Close();
            byte[] bytOut = ms.ToArray();
            return Convert.ToBase64String(bytOut);
        }
        /// <summary>   
        /// 解密方法   
        /// </summary>   
        /// <param name="Source">待解密的串</param>   
        /// <returns>经过解密的串</returns>   
        public string Decrypto(string Source)
        {
            byte[] bytIn = Convert.FromBase64String(Source);
            MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);
            mobjCryptoService.Key = GetLegalKey();
            mobjCryptoService.IV = GetLegalIV();
            ICryptoTransform encrypto = mobjCryptoService.CreateDecryptor();
            CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
            StreamReader sr = new StreamReader(cs);
            return sr.ReadToEnd();
        }
    }
}
2.安装.net reactor5.0


如果要单独加密某个dll,单击“open”选择要加密的dll,然后在下边"Quick Settings"里边选择加密的选项即可,使用菜单里的“Protection Presets”可以快速设定"Quick Settings"里的选项,本例使用类库强加密,如图:

然后切换到Protection选项卡,点击“Protect”按钮即可生成加密后的dll

执行加密保护操作以后,默认会在原dll文件夹下创建一个后缀名_Secure的文件夹,里边就是加密以后的dll了。

此时使用.net reflector反编译工具查看生成的dll,即可发现无法直接看到相关方法信息了,如图:

3.在VS项目中配置自动加密
这种手动加密的方法固然可以,不过实际使用中却不是很方便,毕竟需要手动加密的。.net reactor强大的地方在于可以在VS项目生成的时候自动加密。

打开.Net Reactor 5.0,单击Help菜单,选择开发使用的VS版本,这个操作会在VS中安装.net reactor插件

打开VS,点击“工具”菜单,可以看到.net reactor插件已安装

点击上图中的.Net Reactor

随后点击生成项目,会跳出加密的画面:

这个加密画面只有修改了.net reactor插件中的配置后第一次生成时候可以明显看到,随后再执行生成都是一闪而过,几乎感觉不到,可以说是非常便捷的。

.net reactor功能非常强大,还可以用于将站点、服务、类库文件打包成一个文件等等,本文只是介绍了简单的使用。

 

此外,混淆加壳和逆向脱壳破解,本身就是矛和盾之争,安全的概念只是相对的。比如一款叫de4dot的逆向工具,就可以对大部分.net reactor加密的程序进行脱壳破解(当然需要懂一些逆向的知识),大家使用时候自己有所衡量就可以了。

 
--------------------- 
作者:数据的流 
来源:CSDN 
原文:https://blog.csdn.net/shujudeliu/article/details/80679951 
版权声明:本文为博主原创文章,转载请附上博文链接!

2004-12-11 17:12:00 bluecrest 阅读数 2617

使用ACE Reactor框架编程

高歌

代码下载

按照我的理解,我大致讲一下windows平台下的原理。在windows平台下ACE_Reactor的实现类是ACE_WMFO_Reactor,事件的多路分离是通过WaitForMultiObject和WSAEventSelect着两个函数来实现的。WaitForMultiObject的功能是等待一组(64)handle中的一个或者所有被操作系统激活,程序返回,具体使用看msdn,WSAEventSelect的功能是指定一个事件对象event object与 某个SOCKET的FD_XXX网络事件关联。ACE_WMFO_Reactor对象构造成功后,我们调用run_event_loop(),事件的多路分离线程就开始了,

int
ACE_Reactor::run_reactor_event_loop (REACTOR_EVENT_HOOK eh)
{
  ACE_TRACE ("ACE_Reactor::run_reactor_event_loop");

  if (this->reactor_event_loop_done ())
    return 0;

  while (1)
  {
    int result = this->implementation_->handle_events ();//循环调用实现类的handle_events;

    if (eh != 0 && (*eh)(this))
      continue;
    else if (result == -1 && this->implementation_->deactivated ())
      return 0;
    else if (result == -1)
    return -1;
  }

  ACE_NOTREACHED (return 0;)
}

下面是handle_events调用过程

ACE_WFMO_Reactor::handle_events (ACE_Time_Value *how_long)
-ACE_WFMO_Reactor::event_handling (ACE_Time_Value *max_wait_time,int alertable)
--ACE_WFMO_Reactor::ok_to_wait (ACE_Time_Value *max_wait_time,int alertable)
--ACE_WFMO_Reactor::ok_to_wait (ACE_Time_Value *max_wait_time,int alertable)
--ACE_WFMO_Reactor::calculate_timeout (ACE_Time_Value *max_wait_time)
--ACE_WFMO_Reactor::calculate_timeout (ACE_Time_Value *max_wait_time)
--ACE_WFMO_Reactor::wait_for_multiple_events (int timeout,int alertable)

上面那个函数就是关键的多路分离函数。Reactor是如何知道应该调用那个事件处理器呢(event_handler),请看下面那个函数,

ACE_WFMO_Reactor::register_handler (ACE_Event_Handler *event_handler,ACE_Reactor_Mask mask)这是一个简单的事件处理器的注册函数,没有提供IO句柄,因为我们可以从ACE_Event_Handler派生一个类,,并在这个类中重载get_handle()这个函数提供IO句柄。如下

class Server_Acceptor : public ACE_Event_Handler
{
public:
  virtual int open (const ACE_INET_Addr &local_addr);
  virtual ACE_HANDLE get_handle (void) const {return acceptor_.get_handle (); };
  virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE,ACE_Reactor_Mask = 0);
  virtual int handle_input (ACE_HANDLE = ACE_INVALID_HANDLE);

protected:
  ACE_SOCK_Acceptor acceptor_;

};

这个注册过程最终是通过register_handler_i这个成员函数进行的,

int
ACE_WFMO_Reactor::register_handler_i (ACE_HANDLE event_handle,
ACE_HANDLE io_handle,
ACE_Event_Handler *event_handler,
ACE_Reactor_Mask new_masks)
{
  // If this is a Winsock 1 system, the underlying event assignment will
  // not work, so don't try. Winsock 1 must use ACE_Select_Reactor for
  // reacting to socket activity.

#if !defined (ACE_HAS_WINSOCK2) || (ACE_HAS_WINSOCK2 == 0)

ACE_UNUSED_ARG (event_handle);
ACE_UNUSED_ARG (io_handle);
ACE_UNUSED_ARG (event_handler);
ACE_UNUSED_ARG (new_masks);
ACE_NOTSUP_RETURN (-1);

#else

  // Make sure that the <handle> is valid
  if (io_handle == ACE_INVALID_HANDLE)
  io_handle = event_handler->get_handle ();

  if (this->handler_rep_.invalid_handle (io_handle))
  {
    errno = ERROR_INVALID_HANDLE;
    return -1;
  }

  long new_network_events = 0;
  int delete_event = 0;
  auto_ptr <ACE_Auto_Event> event;

  // Look up the repository to see if the <event_handler> is already
  // there.
  ACE_Reactor_Mask old_masks;
  int found = this->handler_rep_.modify_network_events_i (io_handle,
  new_masks,
  old_masks,
  new_network_events,
  event_handle,
  delete_event,
  ACE_Reactor::ADD_MASK);

  // Check to see if the user passed us a valid event; If not then we
  // need to create one
  if (event_handle == ACE_INVALID_HANDLE)
  {
    // Note: don't change this since some C++ compilers have
    // <auto_ptr>s that don't work properly...
    auto_ptr<ACE_Auto_Event> tmp (new ACE_Auto_Event);
    event = tmp;
    event_handle = event->handle ();
    delete_event = 1;
  }

  int result = ::WSAEventSelect ((SOCKET) io_handle,
  event_handle,
  new_network_events);

  // If we had found the <Event_Handler> there is nothing more to do
  if (found)
    return result;
  else if (result != SOCKET_ERROR &&
  this->handler_rep_.bind_i (1,
    event_handler,
    new_network_events,
    io_handle,
    event_handle,
    delete_event) != -1)
  {
    // The <event_handler> was not found in the repository, add to
    // the repository.
    if (delete_event)
    {
       // Clear out the handle in the ACE_Auto_Event so that when
       // it is destroyed, the handle isn't closed out from under
       // the reactor. After setting it, running down the event
       // (via auto_ptr<> event, above) at function return will
       // cause an error because it'll try to close an invalid handle.
       // To avoid that smashing the errno value, save the errno
       // here, explicitly remove the event so the dtor won't do it
       // again, then restore errno.
       ACE_Errno_Guard guard (errno);
       event->handle (ACE_INVALID_HANDLE);
       event->remove ();
    }
    return 0;
  }
  else
    return -1;

#endif /* ACE_HAS_WINSOCK2 || ACE_HAS_WINSOCK2 == 0 */

}

这个函数先调用WSAEventSelect进行Event_Handler的注册,然后调用handler_rep_.bind_i来修改句柄相关的信息。handler_rep是ACE_WFMO_Reactor的一个句柄仓库。

在使用ACE_WFMO_Reactor时也遇到个这么几个问题,

如何安全的结束run_event_loop线程?

定义入下一个类

class Quit_Handler : public ACE_Event_Handler {
friend class ace_dewarn_gplusplus;
public:
Quit_Handler (ACE_Reactor *r) : ACE_Event_Handler (r) {}

virtual int handle_exception (ACE_HANDLE) {
reactor ()->end_reactor_event_loop ();
return -1; // Trigger call to handle_close() method.
}

virtual int handle_close (ACE_HANDLE, ACE_Reactor_Mask)
{ delete this; return 0; }

private:

// Private destructor ensures dynamic allocation.
virtual ~Quit_Handler () {}
};

然后调用

Quit_Handler *quit_handler_;
ACE_Reactor *r = ACE_Reactor::instance();
quit_handler_ = new Quit_Handler (r);
r->notify (quit_handler_);

 

如何安全的删除事件处理器?

ACE_Reactor::instance()->remove_handler(acceptor_.get_handle(),ACE_Event_Handler::READ_MASK);

不要直接调用handle_close

如何安全的结束工作者,消费者线程?

如果线程使用同步队列的话,可以插入以下消息,结束线程
ACE_Message_Block *shutdown_message = 0;
ACE_NEW_RETURN
(shutdown_message,
ACE_Message_Block (0, ACE_Message_Block::MB_STOP), -1);
if( my_card_queue.enqueue_tail (shutdown_message) == -1)
shutdown_message->release();

MFC中如何使用ACE编程?

在程序开始运行是调用ACE::init(),结束前调用ACE:fini()。

Reactor存在的问题是WaitForMultiObject只能 传入64个局柄,这个问题会在前摄式框架中解决。

我也是初学者,只能写这么点。

bluecrest.nease.net

2017-11-15 13:00:00 weixin_34356555 阅读数 26

.NET Reactor 是个好东西,只不过这家伙升级的速度非常快,加密算法经常变化,而且越来越厉害,实在懒得 "跟" 了。这类工具通常在 "壳" 上做了大量的工作,诸如什么 JIT Hook、native loader 之类的。而我通常只使用它的混淆功能,所以用另外一种方法 "绕" 过去,即便不注册,也可以使用最新版本。

  首先,我们准备一个简单一点的 DLL,用于分析 .NET Reactor 混淆后的限制。test.dll

namespace MyLibrary
{
    public class MyClass
    {
        public void Test()
        {
            Console.WriteLine("MyClass.Test...");
        }
    }
}

namespace MyLibrary.Test
{
    public class MyClass2
    {
        public void TestXXX()
        {
            Console.WriteLine("MyClass2.Test...");
        }
    }
}

  我们使用 .NET Reactor 对该 DLL 进行混淆后,调用时会出现如下提示。

  OK! 接下来,我们把这个东西给去掉。

  打开 Reflector,我们会发现每个 .cctor 中都增加了如下代码 (可能不同加密结果名称有所不同)。

.method private hidebysig specialname rtspecialname static void .cctor() cil managed
{
    .maxstack 8
    L_0000: call void <PrivateImplementationDetails>{B4838DC1-AC79-43d1-949F-41B518B904A8}::CS$0$0006()
    L_0005: ret 
}

  很显然,<PrivateImplementationDetails>{B4838DC1-AC79-43d1-949F-41B518B904A8} 类型是 .NET Reactor 注入进去的,顺藤摸瓜进入 CS$0$0006()。

.method assembly hidebysig static void CS$0$0006() cil managed
{
    .maxstack 8
    L_0000: br L_0007
    L_0005: pop 
    L_0006: ldc.i4.0 
    L_0007: ldsfld bool <PrivateImplementationDetails>{B4838DC1-AC79-43d1-949F-41B518B904A8}::CS$0$0004
    L_000c: brtrue.s L_002f
    L_000e: ldc.i4.1 
    L_000f: stsfld bool <PrivateImplementationDetails>{B4838DC1-AC79-43d1-949F-41B518B904A8}::CS$0$0004
    L_0014: ldstr "This assembly is protected by an unregistered version of \".NET Reactor\". Copyright @ Eziriz, www.eziriz.com"
    L_0019: ldstr "Lock System"
    L_001e: call valuetype [System.Windows.Forms]System.Windows.Forms.DialogResult 
    [System.Windows.Forms]System.Windows.Forms.MessageBox::Show(string, string)
    L_0023: pop 
    L_0024: leave L_002f
    L_0029: pop 
    L_002a: leave L_002f
    L_002f: ret 
    .try L_0014 to L_0029 catch object handler L_0029 to L_002f
}

  那行字符串符合我们通缉目标的特征,接下来怎么做?当然是把这个方法内部代码删除掉了。(如果你愿意,也可以将所有 .cctor 中的那行代码给批量替换掉)

d:\temp> ildasm test.dll /out=test.il
Protected module -- cannot disassemble

  不好意思,Suppress ILDASM 是最基本的手段。我们换一个 ILDASM.exe (可从网上找该修改版本,剔除了 SuppressIldasmAttribute 特性限制)。

d:\temp> d:\program\tools\ILDasm\ILDasm.exe test.dll /out=test.il
// WARNING: Created Win32 resource file test.res

  打开编辑器,搜索 CS$0$0006,然后将该方法体删除,只保留 ret。(如果有 publickey,注意删除)

.method assembly hidebysig static void CS$0$0006() cil managed
{
    .maxstack 8
    ret 
}

保存,重新编译该 IL 代码 (如果有 Public Key,注意使用 /key=...)。

d:\temp> ilasm /dll test.il /out=test2.dll

...
Emitting fields and methods:
Global  Methods: 1;
Class 1 Fields: 4;      Methods: 8;
Class 2 Methods: 3;
Class 3 Methods: 3;
Resolving local member refs: 9 -> 9 defs, 0 refs, 0 unresolved

Emitting events and properties:
Global
Class 1
Class 2
Class 3
Resolving local member refs: 0 -> 0 defs, 0 refs, 0 unresolved
Writing PE file
Signing file with strong name
Operation completed successfully

  我们试试这个 test2.dll,那个讨厌的对话框已经消失了,不见了……

  结束了?等等……

  我们给 MyClass2 添加一个私有方法。

namespace MyLibrary.Test
{
    public class MyClass2
    {
        public void TestXXX()
        {
            Test2();
        }

        private void Test2()
        {
            Console.WriteLine("MyClass2 Private Test...");
        }
    }
}

  用 .NET Reactor 混淆后,可能你会发现上面写的那个 <PrivateImplementationDetails>{B4838DC1-AC79-43d1-949F-41B518B904A8} 不见了,.cctor 里面也没有注入额外的代码。所不同的是出现了一个名字古里古怪的家伙,就像下面这样。

.namespace AKEtMeX)o
{
    .class private auto ansi beforefieldinit AAxshPnXX
        extends [mscorlib]System.Object
    {
        .method private hidebysig specialname rtspecialname static void .cctor() cil managed
        {
        }

        .method assembly hidebysig static pinvokeimpl("nr_native_lib.dll" as "nr_nli" ansi winapi) bool AAxshPnXX(string marshal(bstr), int32) cil managed preservesig
        {
        }

        .method assembly hidebysig static pinvokeimpl("Learn.Library_nat.dll" as "nr_nli" ansi winapi) bool ABy2LSAxY(string marshal(bstr), int32) cil managed preservesig
        {
        }

        .method assembly hidebysig static pinvokeimpl("Learn.Library_nat.dll" as "nr_startup" ansi winapi) void ACiuCWtbY(string marshal(bstr)) cil managed preservesig
        {
        }

        .method assembly hidebysig static void ADxAfYIbq() cil managed
        {
        }

        .method assembly hidebysig static void AER(Ib2WO(bool) cil managed
        {
        }

        .method assembly hidebysig static string AFxcDdVK8(string) cil managed
        {
        }

        .method assembly hidebysig static string AGEdqxnDQ(string) cil managed
        {
        }

        .method assembly hidebysig static void AHrgRGDAh() cil managed
        {
        }

        .method assembly hidebysig static int32 AI0mY6Kel() cil managed
        {
        }

        .method assembly hidebysig static object AJM2IfMnl() cil managed
        {
        }

        .method assembly hidebysig static void AKEtMeX)o() cil managed
        {
        }

        .method assembly hidebysig static void ALJw(16JK() cil managed
        {
        }

        .field private static bool AAxshPnXX

        .field private static bool ABy2LSAxY

        .field private static bool ACiuCWtbY

        .field private static bool ADxAfYIbq

    }
}

  我们翻看其内部方法,很显然下面这个就是我们要修改的目标。

.method assembly hidebysig static void AHrgRGDAh() cil managed
{
    .maxstack 4
    L_0000: br L_0007
    L_0005: pop 
    L_0006: ldc.i4.0 
    L_0007: ldsfld bool AKEtMeX)o.AAxshPnXX::AAxshPnXX
    L_000c: brtrue.s L_002f
    L_000e: ldc.i4.1 
    L_000f: stsfld bool AKEtMeX)o.AAxshPnXX::AAxshPnXX
    L_0014: ldstr ""
    L_0019: ldstr "Lock System"
    L_001e: call valuetype [System.Windows.Forms]System.Windows.Forms.DialogResult 
    [System.Windows.Forms]System.Windows.Forms.MessageBox::Show(string, string)
    L_0023: pop 
    L_0024: leave L_002f
    L_0029: pop 
    L_002a: leave L_002f
    L_002f: ret 
    .try L_0014 to L_0029 catch object handler L_0029 to L_002f
}

  至于后面怎么做,无需我多言了。(其实在这个例子中,根本没有调用该方法,也就是说不会出现弹出框……)

-------------------------------

附:如果你希望加密 EXE,那么还是老老实实进行脱壳,然后修复,再然后……










本文转自 h2appy  51CTO博客,原文链接:http://blog.51cto.com/h2appy/1174565,如需转载请自行联系原作者
没有更多推荐了,返回首页