.NET托管非托管区别和引申

于 2024-01-12 08:01:51 发布
阅读量226 收藏
点赞数
文章标签： .net java c# 开发语言
原文链接：https://mp.weixin.qq.com/s?__biz=MzAwNTMxMzg1MA==&mid=2654098680&idx=8&sn=953d17a238b883a4f3a6d84ac7331b78&chksm=815cde4ccc5a1a8f9d1b2089a73dded706b5aeed0d4893caa618aad973bb246b03b876b71d08&scene=126&sessionid=0
版权

点击上方蓝字 江湖评谈设为关注

5d7591eec1a0f202846e36fbfde36497.png

区别

一般的简单点来说，托管就是C#语言写的代码，非托管就是C++语言写的代码。离了C++，C#完全无法运行。本质上来说，C#和C++是不分家的。那么更确切一点以最常用的win平台为例，C#语言生成的PE文件托管DLL和C++非托管DLL，区别在于有无.NET头结构体IMAGE_COR20_HEADER。

托管加固

一些加密软件，为了对托管DLL的逆向难度进行增强。来回的在托管和非托管中切换，理论上来说托管的函数都遵循CLR/JIT的规则。一个托管函数的编译过程本身就是极其复杂的工程，即使是一个最简单的托管函数，比如以下简单的C#代码:

static void ABC()
{
    Console.WriteLine("Call ABC");
}

ABC函数需要经过Roslyn构建MSIL，经过CLR加载，经过IR变形，经过JIT优化以及生成机器码。这个中间的过程，辗转了整个runtime的几百万行代码的亲密接触，经历了二进制，汇编，C/C++,以及最上层的C#的各种骚操，形成了最后的那简单的几行汇编代码，存放在内存里，用即时编译器运行出来。

中间的过程是难点，最后的结果更是难点。即时编译的结果是存放在内存里的，内存里的东西运行的时候可以更改，但是程序结束了，它又恢复了原样,且地址亦不固定。所以这里需要从非托管作为切入口对它进行hook以及一些其它工作。

以上面的ABC函数为例，它里面只是调用了System.Console.dll库里面的函数Console.WriteLine打印出字符串Call ABC。这个看似简单的过程，可以通过加密软件把这个ABC函数的MSIL进行重新构建。它原有的MSIL如下：

IL_0000  00                nop
IL_0001  28 06 00 00 06    call         0x6000006
IL_0006  00                nop
IL_0007  28 07 00 00 06    call         0x6000007
IL_000c  00                nop
IL_000d  72 25 00 00 70    ldstr        0x70000025
IL_0012  28 10 00 00 0a    call         0xA000010
IL_0017  00                nop
IL_0018  28 11 00 00 0a    call         0xA000011
IL_001d  26                pop
IL_001e  2a                ret

被加密之后的MSIL如下：

IL to import:
IL_0000  28 c7 00 00 0a    call         0xA0000C7
IL_0005  6f c8 00 00 0a    callvirt     0xA0000C8
IL_000a  2b 18             br.s         24 (IL_0024)
IL_000c  06                ldloc.0
IL_000d  04                ldarg.2
IL_000e  16                ldc.i4.0
IL_000f  0b                stloc.1
IL_0010  38 5e 00 00 00    br           94 (IL_0073)
IL_0015  06                ldloc.0
IL_0016  07                ldloc.1
IL_0017  9a                ldelem.ref
IL_0018  2b 13             br.s         19 (IL_002d)
IL_001a  17                ldc.i4.1
IL_001b  2d 02             brtrue.s     2 (IL_001f)
IL_001d  18                ldc.i4.2
IL_001e  26                pop
IL_001f  0a                stloc.0
IL_0020  2b ec             br.s         -20 (IL_000e)
IL_0022  2b 09             br.s         9 (IL_002d)
IL_0024  17                ldc.i4.1
IL_0025  2d 02             brtrue.s     2 (IL_0029)
IL_0027  1b                ldc.i4.5
IL_0028  26                pop
IL_0029  2b ef             br.s         -17 (IL_001a)
IL_002b  2b df             br.s         -33 (IL_000c)
IL_002d  0c                stloc.2
IL_002e  08                ldloc.2
IL_002f  2b 08             br.s         8 (IL_0039)
IL_0031  6f 5e 00 00 0a    callvirt     0xA00005E
IL_0036  0d                stloc.3
IL_0037  de 44             leave.s      68 (IL_007d)
IL_0039  16                ldc.i4.0
IL_003a  2c 02             brfalse.s    2 (IL_003e)
IL_003c  1e                ldc.i4.8
IL_003d  26                pop
IL_003e  2b 05             br.s         5 (IL_0045)
IL_0040  18                ldc.i4.2
IL_0041  2b 0b             br.s         11 (IL_004e)
IL_0043  4e                ldind.r4
IL_0044  56                stind.r4
IL_0045  16                ldc.i4.0
IL_0046  2c 02             brfalse.s    2 (IL_004a)
IL_0048  1c                ldc.i4.6
IL_0049  26                pop
IL_004a  2b 0b             br.s         11 (IL_0057)
IL_004c  2b f3             br.s         -13 (IL_0041)
IL_004e  17                ldc.i4.1
IL_004f  2d 02             brtrue.s     2 (IL_0053)
IL_0051  1b                ldc.i4.5
IL_0052  26                pop
IL_0053  2b dc             br.s         -36 (IL_0031)
IL_0055  2b ee             br.s         -18 (IL_0045)
IL_0057  17                ldc.i4.1
IL_0058  2d 02             brtrue.s     2 (IL_005c)
IL_005a  1c                ldc.i4.6
IL_005b  26                pop
IL_005c  02                ldarg.0
IL_005d  2b ed             br.s         -19 (IL_004c)
IL_005f  2b 04             br.s         4 (IL_0065)
IL_0061  02                ldarg.0
IL_0062  03                ldarg.1
IL_0063  de 08             leave.s      8 (IL_006d)
IL_0065  17                ldc.i4.1
IL_0066  2d 02             brtrue.s     2 (IL_006a)
IL_0068  17                ldc.i4.1
IL_0069  26                pop
IL_006a  26                pop
IL_006b  2b f6             br.s         -10 (IL_0063)
IL_006d  07                ldloc.1
IL_006e  17                ldc.i4.1
IL_006f  58                add
IL_0070  2b 0d             br.s         13 (IL_007f)
IL_0072  0c                stloc.2
IL_0073  07                ldloc.1
IL_0074  06                ldloc.0
IL_0075  8e                ldlen
IL_0076  69                conv.i4
IL_0077  2b 0e             br.s         14 (IL_0087)
IL_0079  4e                ldind.r4
IL_007a  53                stind.i2
IL_007b  14                ldnull
IL_007c  2a                ret
IL_007d  09                ldloc.3
IL_007e  2a                ret
IL_007f  17                ldc.i4.1
IL_0080  2d 02             brtrue.s     2 (IL_0084)
IL_0082  18                ldc.i4.2
IL_0083  26                pop
IL_0084  0b                stloc.1
IL_0085  2b ec             br.s         -20 (IL_0073)
IL_0087  17                ldc.i4.1
IL_0088  2d 02             brtrue.s     2 (IL_008c)
IL_008a  15                ldc.i4.m1
IL_008b  26                pop
IL_008c  3f 84 ff ff ff    blt          -124 (IL_0015)
IL_0091  2b e8             br.s         -24 (IL_007b)

以上是一个逆向的实例，这里面包含了大量的跳转br.s，brtrue.s这种东西。不说它在JIT里面的IR变形和优化，也不说变成机器码之后的程序结果。只看当前就非常艰涩。它某些跳转里面包含了一些函数的调用，这些函数的调用里面又包含了十几个跳转。这些十几个跳转里面又包含了几个函数，每个函数里面再包函十几个跳转，这些跳转从托管到非托管，然后跳转回来，来来回回往复循环。耗尽耐心之后，防护加固就成功了。这是托管层面的，下面看下非托管层面的加固模式。为了解决这个困惑，可以在JIT的PreStubworker上入手，查看其汇编结果，逐步推导。

非托管加固

非托管里面的实质是，可以通过加密软件加密的托管代码，调用一些非托管库函数，然后运行这些非托管库函数，比如zlibc这种压缩库。一般的来说，在.NET里面压缩它是有intel特别定制的库文件，比如System.IO.Compression.Native.dll，它一共导出了如下函数

CompressionNative_Crc32
CompressionNative_Deflate
CompressionNative_DeflateEnd
CompressionNative_DeflateInit2_
CompressionNative_DeflateReset
CompressionNative_Inflate
CompressionNative_InflateEnd
CompressionNative_InflateInit2
CompressionNative_InflateReset
等函数，还有一些没写出来

它里面进行了代码的压缩以及解压，这个过程非常复杂。基本上在耗尽耐心。虽然它看似足够牛逼，为了解决这个非托管困惑。这里依然有足够宽松的切入点，那就上面所说的非托管DLL。

今天的分享大致就这么多。关于更多的知识点，可以加入知识星球，里面的硬核知识，骚操技术，你难以想象，持续性分享。

往期精彩回顾

.NET8 JIT核心:分层编译的原理

新版.Net性能有没有达到C++90%?

欢迎加入C#12.NET8技术交流群

面试官问.Net对象赋值为null,就会被GC回收吗?

79d63b37bd0300fbbfb0f02db376ec49.jpeg

dotNET跨平台
关注
.net托管与非托管以及GC(垃圾回收)
liuyongjie1992的博客
01-04 1673
官方解释 .NET Framework的核心是其运行库的执行环境，称为公共语言运行库(CLR)或.NET运行库。通常将在CLR的控制下运行的代码称为托管代码(managed code)。 运行库环境（而不是直接由操作系统）执行的代码。托管代码应用程序可以获得公共语言运行库服务，例如自动垃圾回收、运行库类型检查和安全支持等。这些服务帮助提供独立于平台和语言的、统一的托管代码应用程序行为。 托管代码是可以使用20多种支持Microsoft .NET Framework的高级语言编写的代码，它们包括：C.
.net中的托管、非托管
10-31 855
1、托管代码Managed Code 托管代码是编译器创建，被编译成中间语言（IL），IL被保存在程序集（描述代码的类、方法它和属性的元数据文件）中。 托管代码运行在CLR中； 托管代码独立于平台和语言，能更好的实现不同语言平台之间的兼容； 托管类型是可以被垃圾回收器所回收的。他们必须要用关键字new来创建； .Net程序被加载入内存以后，当某段IL代码被第一次运行的时候，JIT编译器就会将这段IL代码，全部编译成本地代码，然后再执行。 2、非托管代码Unmanaged Code 非托管代
.Net 中的托管与非托管 （CLR）
realmagician的专栏
11-25 1841
CLR(公共语言运行时)          .Net Framework是由彼此独立又相关的两部分组成:CLR和类库,   CLR是它为我们提供的服务，类库是它实现的功能. .NET的大部分特性----垃圾收集，版本控制,线程管理等（这些程序员是无法干预的），都使用了CLR提供的服务          当你为.NET Framework编译源代码的时候，得到的目标代码不是CPU能识别的机器指令
.net 托管非托管资源
sina_itxie的博客
07-30 168
1、托管资源：很多程序创建的对象，可以通过GC回收机制进行回收的资源称为托管资源，由CRL自动调用垃圾回收，通过GC自动回收释放。 2、非托管资源：很多是操作系统资源的对象，如文件句柄，数据库连接等。.net 提供Object.Finalize()方法，让GC回收，不过Finalize方法不执行任何操作，所以必须要重写此方法，而实际编程中无法覆盖实现此方法，只能通过析构函数自动生成Finalize方法，来实现资源的回收。 这些非托管资源的释放，需要继承IDispoable，手动调用Dispose及时
.NET 托管vs非托管
a_codecat的博客
11-08 744
.net托管vs非托管
Unity3D教程：Unity加载和内存管理
小小姑娘
12-13 393
由此可以解释另一个之前有人提过的话题：为什么第一次Instantiate一个Prefab的时候都会卡一下，因为在你第一次Instantiate之前，相应的Asset对象还没有被创建，要加载系统内置的AssetBundle并创建Assets,第一次以后你虽然Destroy了，但Prefab的Assets对象都还在内存里，所以就很快了。系统在加载新场景时，所有的内存对象都会被自动销毁，包括你用AssetBundle.Load加载的对象和Instaniate克隆的。最后CG.Collect();
为什么 C# 的 string.Empty 是一个静态只读字段，而不是一个常量呢？
walterlv - 吕毅
04-06 766
使用 C# 语言编写字符串常量的时候，你可能会发现可以使用 "" 而不能使用 string.Empty。进一步可以发现 string.Empty 实际上是一个静态只读字段，而不是一个常量。 为什么这个看起来最适合是常量的 string.Empty，竟然使用静态只读字段呢？ 本文内容string.EmptyIntrinsic 特性JIT 编译器总结：为什么 string.Empty 需要是一个静态...
【Unity3D】中如何分配内存占用（解决内存占用过大问题）
天生爱赞美的博客
02-10 9901
最近网友通过网站搜索Unity3D在手机及其他平台下占用内存太大. 这里写下关于Unity3D对于内存的管理与优化. Unity3D 里有两种动态加载机制：一个是Resources.Load，另外一个通过AssetBundle,其实两者区别不大。 Resources.Load就是从一个缺省打进程序包里的AssetBundle里加载资源，而一般AssetBundle文件需要你自己创建，运行时
COM、DLL、ActiveX、OLE，CLR之间的区别
世界瞭望塔
11-28 549
COM、DLL、ActiveX、OLE之间的区别 COM的最核心的思想，说白了就是要做个跨语言的 “class” “object” “function” 。 因为所有OOP语言，这三个都是核心，如果能做到这三个语言要素就可以跨语言，所有语言不都是可以互通了，程序员可以很用自己喜欢的语言编程了，这是目的。 COM是OO技术的巅峰之作，COM之后的OO都是COM的子集而已 COM的意图...
关于权限"android.permission.GLOBAL_SEARCH"
@甘道夫@的专栏
03-24 2559
此前有一篇文章说明如何将自己的app作为一个外部数据源提供给android系统搜索： http://blog.csdn.net/zhanglianyu00/article/details/61196900 里面提到安卓提供了一个权限android.permission.GLOBAL_SEARCH，供数据源提供方使用，来作为数据的保护机制。android官方文档对于此权限的说明较少，只有
.net中托管代码和非托管代码的互操作
weixin_30925411的博客
03-25 182
引言 这几天在做一个应用的时候，遇到用C#调用c++编译的动态链接库文件中函数的问题。于是研究了一下.net framework内托管代码和非托管代码之间的相互调用问题。在msdn中对托管代码的定义为[1]：在运行时控制下执行的代码。反之则为非托管代码。非托管代码主要有com组件，ActiveX，Win32API以及各种在.net framework之外编译的二进制代码...
.net中的托管资源与非托管资源，如何避免内存泄露
路在远方
03-30 2502
托管资源与非托管资源 “非托管资源”指的是不受.net垃圾回收器控制的资源。比如打开一个数据库连接，所访问的数据库资源来源于服务器而不受.net控制。或者是客户机上其他非.net资源，资源的提供者不是通过托管代码编写的。 这就是为什么对于数据库连接，需要写在一个using中 using (var connection = new SqlConnection("connection_string_here")) { connection.open(); //..do something
【转】.Net 托管代码和非托管代码的区别
weixin_30361753的博客
06-18 251
什么是托管代码(managed code)？ 托管代码是一microsoft的中间语言(IL)，他主要的作用是在.NET FRAMEWORK的公共语言运行库(CLR)执行代码前去编译源代码，也就是说托管代码充当着翻译的作用，源代码在运行时分为两个阶段： 1.源代码编译为托管代码,（所以源代码可以有很多种，如VB,C#,J#) 2.托管代码编译为micros...
C#探索之路(4)：浅析C#中的托管、非托管堆栈与垃圾回收
qq_1628941121的博客
10-30 3944
执行回收时，垃圾回收器会在托管堆中检查应用程序不再使用的对象，然后执行必要的操作来回收其内存。但是当我回过头来了解这个垃圾回收机制的时候，我发现了一个很有意思的事情，当我去查询相关的资料的时候我发现，这其中的原理真的是一环扣一环，还环环不一样，我的内心：(TM*燃起来了！，讲述的挺好的，那我不经发出了疑问，那是不是有的Unity的C#的热更方案就有用到这个托管代码的互操作性呢？但是，请务必注意，如果采取这种方法，当代码越过运行时的边界时，实际的执行管理将再次交接到托管代码，因而需要遵守相同的限制。
1.2：.NET基础托管代码和非托管代码（课程共5100字，4段代码举例）
最新发布
小兔子平安
08-04 115
总而言之，通过本课程，我们建立了对.NET框架中托管代码和非托管代码的全面理解。我们学会了如何编写和执行托管代码，了解了非托管代码的特点和用途，并掌握了托管代码和非托管代码之间的互操作技术。同时，我们也意识到在实际开发中需要对细微之处保持警觉，并持续学习和探索.NET框架的发展。这将使我们能够更好地应对.NET应用程序开发中的挑战，并提高开发效率和代码质量。
关于Dll、Com组件、托管dll和非托管dll
511遇见
07-27 7935
Com组件和dll区别： 1.普通dll不能通过regsvr32.exe来注册，而Com组件能通过regsvr32.exe注册。 2.Com组件是微软的一个协议，满足com组件协议的dll文件就是com组件，这种协议为了跨语言、跨平台使用，dll组件需要编译后使用，而Com组件注册后即可使用。 而dll是动态链接库，是一个可以导出函数的集合。 3.Com组件可以是exe也可以是dll文件。 托管dll/Com组件和非托管dll/Com组件： 1.非托管Com组件是用非运行库代码编写的，如C++，
C# 托管资源和非托管资源
热门推荐
zlwzlwzlw的专栏
08-29 3万+
托管资源指的是.NET可以自动进行回收的资源，主要是指托管堆上分配的内存资源。托管资源的回收工作是不需要人工干预的，有.NET运行库在合适调用垃圾回收器进行回收。          非托管资源指的是.NET不知道如何回收的资源，最常见的一类非托管资源是包装操作系统资源的对象，例如文件，窗口，网络连接，数据库连接，画刷，图标等。这类资源，垃圾回收器在清理的时候会调用Object.Finalize(
C#的三大难点之二：托管与非托管
游子的博客
05-24 1万+
转载自:http://blog.sina.com.cn/s/blog_3e51bb390102vv6b.html 托管代码与非托管代码 众所周知，我们正常编程所用的高级语言，是无法被计算机识别的。需要先将高级语言翻译为机器语言，才能被机器理解和运行。 在标准C/C++中，编译过程是这样的： 源代码首先经过预处理器，对头文件以及宏进行解析，然后经过编译器，生成汇编代码，接
.Net 中的托管资源和非托管资源
weixin_30237281的博客
07-27 729
.NET中的所有类型都是（直接或间接）从System.Object类型派生的。 　　CTS中的类型被分成两大类——引用类型（reference type，又叫托管类型[managed type]），分配在内存堆上；值类型（value type），分配在堆栈上。如图： 首先说下在栈和堆在window中的区别，栈是向低地址扩展的数据结构，是一块连续的内存区域，先进后出的。而堆是向高地址扩展的数...
非托管代码调用.NET托管代码示例
"本文将探讨如何使用非托管代码（如C++）来访问和调用由.NET Framework生成的托管代码（如C#编写的类库）。通过实例展示了一个C++程序调用C#动态链接库（DLL）中的方法，演示了非托管与托管代码之间的交互过程。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值