叫我安不理

几张图带你了解.NET 8中的 String

简介

string作为一种特殊的引用类型,是迄今为止.NET程序中使用最多的类型。其本质就是unicode格式的char[] 分配在托管堆上

因此在分析dump的时候,大量的string,char[]是很常见的现象

String的内存布局

https://github.com/dotnet/runtime/blob/main/src/coreclr/nativeaot/Runtime.Base/src/System/String.cs

从源码中看到,String对象内存布局应该如下
image

眼见为实

        static void Main(string[] args)
        {
            string name = "Lewis";
            Console.WriteLine(name);
            Debugger.Break();
        }

image

Strig的池化

.NET Rumtime内部有一个string interning 机制
当两个字符串一模一样的时候,不需要在内存中存两份。只保留一份即可

但字符串暂存有个限制,默认情况下是只暂存静态创建的字符串的。也就是静态值才会被暂存起来.由JIT来判断是否暂存

举个例子
        static void Main(string[] args)
        {
            var s1 = "hello world";
            var s2 = "hello ";
            var s3 = "world";

            Console.WriteLine(string.ReferenceEquals(global,s1));  //True ,两者一致,只保留一个变量
            Console.WriteLine(string.ReferenceEquals(s1, s2 + s3));//False s2+s3是动态的,不暂存

            Console.ReadLine();
        }

究其原因是因为这样做开销巨大,创建一个新字符串时,runtime需要动态的检测它是否已被暂存。如果被检测的字符串相当庞大或数量特别多,那么花销同样也很大

FCL提供了显式API string.IsInterned/string.Intern 来让我们可以主动暂存字符串。

眼见为实

示例代码
        static void Main(string[] args)
        {
            string str1 = "asdfghjkl";
            string str2 = "asdfghjkl";
            string str3 = "asdfghjkl";
            string str4 = "asdfghjkl";
            string str5 = "asdfghjkl";

            Console.WriteLine("done");
            Debugger.Break();
        }

示例一

点击查看代码
	IL_0001: ldstr "asdfghjkl"
	IL_0006: stloc.0
	// string text2 = "asdfghjkl";
	IL_0007: ldstr "asdfghjkl"
	IL_000c: stloc.1
	// string text3 = "asdfghjkl";
	IL_000d: ldstr "asdfghjkl"
	IL_0012: stloc.2
	// string text4 = "asdfghjkl";
	IL_0013: ldstr "asdfghjkl"
	IL_0018: stloc.3
	// string text5 = "asdfghjkl";
	IL_0019: ldstr "asdfghjkl"
	IL_001e: stloc.s 4
	// Console.WriteLine("done");
	IL_0020: ldstr "done"
	IL_0025: call void [System.Console]System.Console::WriteLine(string)

熟悉IL代码的人都知道,IL在创建引用类型的实例的时候,都是使用newobj命令。但是面对string,使用的ldstr命令。

示例二

image
在windbg中也是引用同一个内存地址

字符串被池化在哪里?

https://github.com/dotnet/runtime/blob/main/src/coreclr/vm/stringliteralmap.cpp

这时大家可以思考一下,暂存的字符串跟静态变量有什么区别? 都是永远不会被释放的对象
因此可以猜到。字符串应该是被暂存在AppDomain中。与高频堆应该相邻在一起.

在.NET内部Appdomain中,有一个私有堆叫String Literal Map的对象,内部存储着字符串的hash与一个内存地址。
内存地址指向另外一个数据结构LargeHeapHandleTable .位于LOH堆中,LargeHeapHandleTable内部包含了对字符串实例的引用
image

在正常情况下,只有>85000字节的才会被分配到LOH堆中,LargeHeapHandleTable就是一个典型的例外。一些不会被回收/很难被回收的对象即使没有超过85000也会分配在LOH堆中。因为这样可以减少GC的工作量(不会升代,不会压缩)

眼见为实

image
可以看到,被暂存的字符串有一个gc根引用着它,并且还是一个固定句柄

.NET 8中的极致优化

在.NET 8中,新增了一个堆,叫Non-GC Heap。简单来说,在.NET 8 之前。string被作为固定句柄。虽然内存地址不会变,但依旧受到GC管理,并且固定句柄还会导致代降级。因此还是有一定开销。在.NET 8之后,直接将编译期间就能确定的数据放置到Non-GC Heap中,完全不受GC管理。极大提高性能
image

眼见为实

同一段代码string name = "Lewis";
在.net 8中的汇编


00007FFD54B37773  mov         rcx,21018006808h 
00007FFD54B3777D  mov         qword ptr [rbp+28h],rcx  

在.net 6中的汇编

00007FFD5D0558B3  mov         rcx,21018006808h  
00007FFD5D0558BD  mov         rcx,qword ptr [rcx]  
00007FFD5D0558C0  mov         qword ptr [rbp+28h],rcx  

可以看到,在.net 8中。直接跳过了间接寻址操作,将rcx寄存器的值直接推入栈中

String的不可变性

string作为引用类型,那就意味是可以变化的.但在.NET中,它们默认不可变,也就是说行为类似值类型,实际上是引用类型的特殊情况。
image
这会带来一种情况,对字符串的任何操作,修改/追加都会导致重新创建一个新的string对象。而且因为动态创建的。所以存放在托管堆中。

但是,"字符串具有不可变性"仅在.NET平台下成立,只是因为在BCL(Basic Class Library)中并未提供改变string内容的方法而已。
在C/C++/F# 中,是可以改变的。因此,我们完全可以在底层实现修改字符串内容

眼见为实

示例1

示例代码
        static void Main(string[] args)
        {
            var teststr = "aaa";
            Debugger.Break();
            Console.WriteLine(teststr);
            Console.ReadLine();
        }

image
可以看到,string的值为aaa

image
通过算法:address + 0x10 + 2 * sizeof(char) ,我们直接修改内存的内容

image

可以看到,同一个内存地址,里面的值已经从"aaa"变成了"aab".

示例2

点击查看代码
        static void Main(string[] args)
        {
            var str1 = "aaa";
            ref var c0 = ref MemoryMarshal.GetReference<char>(str1.AsSpan(0));
            c0 = '0';
            ref var c1 = ref MemoryMarshal.GetReference<char>(str1.AsSpan(1));
            c1 = '1';

            Console.WriteLine(str1);//从aaa变成了01a
        }

字符串的可变行为

那么在日常使用中,我们需要大量字符串拼接的时候。如何改进呢?
最常见的办法就是使用Stringbuilder.

Stringbuilder源码解析

 public sealed partial class StringBuilder : ISerializable
 {
 		//存储字符串的char[]
        internal char[] m_ChunkChars;

		//StringBuilder之间使用链表来关联
        internal StringBuilder? m_ChunkPrevious;
		
        public StringBuilder(string? value, int startIndex, int length, int capacity)
        {
            ArgumentOutOfRangeException.ThrowIfNegative(capacity);
            ArgumentOutOfRangeException.ThrowIfNegative(length);
            ArgumentOutOfRangeException.ThrowIfNegative(startIndex);

            value ??= string.Empty;

            if (startIndex > value.Length - length)
            {
                throw new ArgumentOutOfRangeException(nameof(length), SR.ArgumentOutOfRange_IndexLength);
            }

            m_MaxCapacity = int.MaxValue;
            if (capacity == 0)
            {
                capacity = DefaultCapacity;
            }
            capacity = Math.Max(capacity, length);

            m_ChunkChars = GC.AllocateUninitializedArray<char>(capacity);
            m_ChunkLength = length;

            value.AsSpan(startIndex, length).CopyTo(m_ChunkChars);
        }
		public StringBuilder Append(char value, int repeatCount)
        {
            if (repeatCount == 0)
            {
                return this;
            }

            char[] chunkChars = m_ChunkChars;
            int chunkLength = m_ChunkLength;


    		// 尝试在当前块中放入所有重复字符
    		// 使用与 Span<T>.Slice 相同的检查,以便在 64 位系统中进行折叠
    		// 因为 repeatCount 不能为负数,所以在 32 位系统中不会溢出
            if (((nuint)(uint)chunkLength + (nuint)(uint)repeatCount) <= (nuint)(uint)chunkChars.Length)
            {
				//使用Span高性能填充char[]
                chunkChars.AsSpan(chunkLength, repeatCount).Fill(value);
                m_ChunkLength += repeatCount;
            }
            else
            {
				//如果空间不足,则进行扩容
                AppendWithExpansion(value, repeatCount);
            }
            return this;
        }
		public override string ToString()
        {
			// 分配一个新的字符串用于存储结果
            string result = string.FastAllocateString(Length);
            StringBuilder? chunk = this;
            do
            {
                if (chunk.m_ChunkLength > 0)
                {
                   // 将这些值复制到局部变量中,以确保在多线程环境下的稳定性
                    char[] sourceArray = chunk.m_ChunkChars;
                    int chunkOffset = chunk.m_ChunkOffset;
                    int chunkLength = chunk.m_ChunkLength;

					// 使用内存移动复制数据到result中
                    Buffer.Memmove(
                        ref Unsafe.Add(ref result.GetRawStringData(), chunkOffset),
                        ref MemoryMarshal.GetArrayDataReference(sourceArray),
                        (nuint)chunkLength);
                }
				//移动到上一个StringBuilder中,链表式读取
                chunk = chunk.m_ChunkPrevious;
            }
            while (chunk != null);

            return result;
        }
 }

在Stringbuilder的内部,内部使用char[] m_ChunkChars将文本保存。并且使用Span方式直接高性能操作内存。
image

避免对象分配是改进代码性能的最常见方法
string.format/string.join/$"name={name}" 等常见函数均已在内部实现Stringbuilder

字符串为什么不可变?

那么既然string的反直觉,那么为什么要这么设计呢?原因有如下几点

  1. 安全性
    string的使用范围太广了,比如new Dictionary<string, string>(),用户token,文件路径。它们的用途都代表一个key,如果这个key能被程序随意修改。那么将毫无安全性可言。
  2. 并发性
    正因为string使用范围大,所以很多场景都可能存在并发访问,如果可变,那么需要承担额外的同步开销。

为什么string不是一个结构?

上面说了这么多,结构完美满足了不可变/并发安全 这两个条件,那为什么不把string定义为结构?
其核心原因在于,结构的传值语义会导致频繁复制字符串
而复制大字符串的开销太大了,因此使用传引用语义要高效得多

JSON 的序列化/反序列化就是一个典型的例子

安全字符串

在使用string的过程中,可能包含敏感对象。比如Password.
String对象内部使用char[]来承载。因此携带敏感信息的string。被执行了unsafe或者非托管代码的时候。就有可能被扫描内存。
只有对象被GC回收后,才是安全的。但是中间的时间差足够被扫描N次了。

为了解决此问题,在FCL中添加了SecureString类。作为上位替代

  1. 内部使用UnmanagedBuffer来代替char[]
public sealed partial class SecureString : IDisposable
{
		private readonly object _methodLock = new object();//同步锁
        private UnmanagedBuffer? _buffer; //使用UnmanagedBuffer代替char[]
		public SecureString()
        {
			_buffer = UnmanagedBuffer.Allocate(GetAlignedByteSize(value.Length));
            _decryptedLength = value.Length;

            SafeBuffer? bufferToRelease = null;
            try
            {
                Span<char> span = AcquireSpan(ref bufferToRelease);
                value.CopyTo(span);
            }
            finally
            {
                ProtectMemory();
                bufferToRelease?.DangerousRelease();
            }
        }

		
		public void AppendChar(char c)
        {
            lock (_methodLock)
            {
                EnsureNotDisposed();
                EnsureNotReadOnly();

                Debug.Assert(_buffer != null);

                SafeBuffer? bufferToRelease = null;

                try
                {
				    //解密内存以便进行修改
                    UnprotectMemory();

                    EnsureCapacity(_decryptedLength + 1);

                    Span<char> span = AcquireSpan(ref bufferToRelease);
                    span[_decryptedLength] = c;
                    _decryptedLength++;
                }
                finally
                {
					//重新加密
                    ProtectMemory();
                    bufferToRelease?.DangerousRelease();
                }
            }
        }
}
  1. 实现了IDisposable接口,开发可以手动执行Dispose().对内存缓冲区直接清零,确保恶意代码无法获得敏感信息

        public void Dispose()
        {
            lock (_methodLock)
            {
                if (_buffer != null)
                {
                    _buffer.Dispose();
                    _buffer = null;
                }
            }
        }

安全字符串真的安全吗?

SecureString的目的是避免在进程中使用纯文本存储机密信息
SecureString的底层本质上也是一段未加密的char[],由FCL进行数据加密/解密。
因此只有.NET Framework 中,内部的char[]由windows提供支持,是加密的
但在.NET Core中,其他平台并未提供系统层面的支持

https://github.com/dotnet/platform-compat/blob/master/docs/DE0001.md

因此,个人认为真正的"银弹". 是数据本身就是加密的。比如从数据库中存储就是加密内容,或者配置文件中本身就是加密的。因为操作系统没有安全字符串的概念。

恶意代码只要能读内存,且内存本身未加密。那么在CLR层上就是裸奔

posted on 2024-10-25 15:50  叫我安不理  阅读(1064)  评论(4编辑  收藏  举报

导航