PE (Portable Executable) 文件是 Windows 操作系统中可执行文件和动态链接库 (DLL) 的标准格式。在操作系统加载 PE 文件时，它会将文件映射到进程的虚拟地址空间中。PE 文件的基址 (Base Address) 是指操作系统尝试将该文件加载到内存中的首选地址。一般来说，在 Windows 系统中，x86 架构的 EXE 文件默认基址是 0x00400000，而 x64 架构的 EXE 文件默认基址是 0x140000000。

2 ASLR

ASLR (Address Space Layout Randomization) 是一种安全技术，用于随机化进程的内存地址布局，以防止攻击者利用已知的内存地址进行攻击。通过随机化基址，ASLR 使得攻击者难以预测关键数据结构和代码的位置，从而增加了攻击的难度。详见 Wikipedia。

然而，对于逆向分析和调试来说，这一机制导致每次重启调试器时，PE 文件的基址都会发生变化。而一些反编译工具会采用默认基址进行分析，导致对比分析出现不便。

3 关闭 ASLR

3.1 原理

PE 文件格式中，有一个标志位 IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE，用于指示操作系统是否启用 ASLR。如果该标志位被置零，操作系统将不会随机化该 PE 文件的基址，而是使用其默认基址进行加载。

该标志位位于 PE 文件的可选头 (Optional Header) 中的 DllCharacteristics 字段。这个字段是一个 16 位的位掩码，每一位代表不同的特性。可以通过将该 ushort 值与 0x0040 进行按位与操作来检查该标志位是否被设置。

3.2 方法

3.2.1 方法一：修改 PE 文件标志位

使用任何 PE 编辑工具或十六进制编辑器，打开目标 PE 文件，找到并修改 IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE 标志位。

3.2.1.1 使用 010 Editor

1. 打开 010 Editor，加载目标 PE 文件。

2. 运行 EXE.bt 模板，定位到 Optional Header 部分，找到 DllCharacteristics 字段下的 IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE 位。

   

3. 将其改为 0，保存。

3.2.2 方法二：修改调试器设置

在 x64dbg 调试器中，选择 选项 -> 引擎，勾选 禁用 ASLR 选项。

1 原理分析

先来看一下 Huffman 编码和解码的基本原理：

1.1 编码

1. 统计频率

   • 遍历待编码的字符串 / 字节数组，统计每个字符 / 字节出现的频率

2. 构建 Huffman 树

   • 将每个字符和其频率作为节点
   • 使用优先队列 (最小堆) 来构建 Huffman 树。
   • 每次取出频率最小的两个节点，合并成一个新节点，直到只剩下一个节点

3. 生成编码

   • 从根节点开始，遍历树，左子节点为 0，右子节点为 1，直到叶节点
   • 记录每个字符的编码

4. 替换

   • 使用生成的编码替换原字符串中的字符

1.2 解码

1. 构建 Huffman 树

   • 使用编码时生成的树结构

2. 遍历编码

   • 从根节点开始，根据编码的 0 和 1 走左子节点或右子节点
   • 到达叶节点时，将对应字符 / 字节添加到结果中，并返回根节点继续遍历

3. 重复直到遍历完整个编码

2 具体实现

先列举我们需要的几个类：

• BitStream：用于处理位流的类
• HuffmanNode：表示 Huffman 树的节点
• PriorityQueue：优先队列

其中，PriorityQueue 在 .NET 6 及以上版本中已经有了，我们可以直接使用。另外两个类需要我们自己实现。

2.1 BitStream

BitStream 的主要功能是处理位流的读写，通过维护一个 underlying Stream，记录当前缓存的字节、当前位的位置和移位实现。

Huffman 需要的是 MSB (Most Significant Bit) 顺序的位流，我们这里把二者 (MSB、LSB) 都实现了。

BitStream.cs

2.2 HuffmanNode

HuffmanNode 包含以下属性：父节点、左右节点、该节点的值 (字符 / 字节)、该节点的频率、对应的编码 (可选)。

对于编码的表示，思来想去还是 bool[] 最合适。

同时注意到，构造节点有两种情况：

• 通过频率和字符 / 字节构造叶节点
• 通过左右子节点构造非叶节点

因此需要两个构造函数。而且显然，构造时即可确定该节点是否为叶节点，后续无需变动。

HuffmanNode.cs

2.3 PriorityQueue

在高版本 .NET 中，可以直接使用 System.Collections.Generic.PriorityQueue<TElement, TPriority>。

在低版本 .NET 中，我们可以自行用最小堆实现一个简易的优先队列。

此处实现遵循 .NET Framework 4.8 的语法。

PriorityQueue.cs

构造函数中需要传入一个比较器 IComparer<T>，用于比较节点的优先级：

HuffmanNodeComparer.cs

使用独立的比较器而不是让 HuffmanNode 实现 IComparable<HuffmanNode> ，是为了保证 HuffmanNode 在不同版本间的一致性。

2.4 HuffmanCompression

接下来是 Huffman 编码和解码的核心类 HuffmanCompression。

2.4.1 编码

1. 统计频率

   csharp

   int[] freqs = new int[256];
   foreach (byte b in data)
   {
       freqs[b]++;
   }

   freqs 数组的索引是字节值，值是该字节出现的频率。

2. 构建 Huffman 树

   使用内置的 PriorityQueue 来构建 Huffman 树：

   csharp

   private HuffmanNode BuildTree(int[] freqs)
   {
       PriorityQueue<HuffmanNode, int> queue = new();
       for (int i = 0; i < freqs.Length; i++)
       {
           if (freqs[i] > 0)
           {
               queue.Enqueue(new(freqs[i], (byte)i), freqs[i]);
           }
       }
       while (queue.Count > 1)
       {
           HuffmanNode left = queue.Dequeue();
           HuffmanNode right = queue.Dequeue();
           HuffmanNode parent = new(left, right);
           queue.Enqueue(parent, parent.Frequency);
       }
       return queue.Count > 0 ? queue.Dequeue() : null;
   }

   for 循环中构造所有叶节点，并将它们加入优先队列。然后通过不断取出频率最小的两个节点，合并成一个新节点，直到只剩下一个节点。频率的加和与叶节点的判断均在 HuffmanNode 的构造函数中完成。

   使用自定义的 PriorityQueue 大同小异：

   csharp

   private HuffmanNode BuildTree(int[] freqs)
   {
       PriorityQueue<HuffmanNode> queue = new PriorityQueue<HuffmanNode>(new HuffmanNodeComparer());
       for (int i = 0; i < freqs.Length; i++)
       {
           if (freqs[i] > 0)
           {
               queue.Enqueue(new HuffmanNode(freqs[i], (byte)i));
           }
       }
       while (queue.Count > 1)
       {
           HuffmanNode left = queue.Dequeue();
           HuffmanNode right = queue.Dequeue();
           HuffmanNode parent = new HuffmanNode(left, right);
           queue.Enqueue(parent);
       }
       return queue.Count > 0 ? queue.Dequeue() : null;
   }

3. 生成编码

   用一个字典存储字节值和对应的编码。

   如果当前节点是叶节点，则从该节点开始向上遍历，记录路径上的 0 和 1，直到到达根节点。将路径反转即为该字节的编码。

   csharp

   private void GenerateCodes(HuffmanNode node, Dictionary<byte, bool[]> codeTable)
   {
       if (node == null)
       {
           return;
       }
   
       HuffmanNode current;
       if (node.IsLeaf)
       {
           List<bool> code = [];
           current = node;
           while (!current.IsRoot)
           {
               code.Add(current.Bit);
               current = current.Parent;
           }
           code.Reverse();
           codeTable[node.Value] = [.. code];
       }
       else
       {
           if (node.LeftChild != null)
           {
               GenerateCodes(node.LeftChild, codeTable);
           }
           if (node.RightChild != null)
           {
               GenerateCodes(node.RightChild, codeTable);
           }
       }
   }

4. 写入树

   为了在解码时能够重建 Huffman 树，我们需要将树结构序列化到输出流中。可以使用前序遍历的方式来写入树。

   csharp

   private void WriteTree(HuffmanNode node)
   {
       if (node.IsLeaf)
       {
           input.WriteBit(0);
           input.WriteBits(node.Value);
       }
       else
       {
           input.WriteBit(1);
           WriteTree(node.LeftChild);
           WriteTree(node.RightChild);
       }
   }

5. 替换

   这一步就简单了，遍历原数据，将每个字节替换为对应的编码。

   csharp

   foreach (byte b in data)
   {
       if (codeTable.TryGetValue(b, out bool[] code))
       {
           input.WriteBits(code);
       }
       else
       {
           throw new InvalidDataException($"No code found for byte {b}.");
       }
   }

2.4.2 解码

有一个很巧的思路：字节的取值是 0~255，因此我们可以直接拿一个二维数组 ushort[512, 2]：

第一位表示字节值 (<256) 或父节点的索引 (>=256)，第二位表示左右子节点。

1. 读取树

   csharp

   private const ushort MAX = 512;
   private ushort index = 256;
   private readonly ushort[,] children = new ushort[MAX, 2];
   
   private ushort RebuildTree()
   {
       switch (input.ReadBit())
       {
           case 0:
               return (ushort)input.ReadBits(8);
           case 1:
               ushort parent = index++;
               if (parent >= MAX)
               {
                   throw new InvalidDataException("Exceeded huffman tree.");
               }
               children[parent, 0] = RebuildTree();
               children[parent, 1] = RebuildTree();
               return parent;
           default:
               throw new InvalidDataException("Invalid bit.");
       }
   }

2. 解码

   这种表示的好处在于判断是否为叶节点非常简单：如果索引小于 256，则是叶节点，且该值即为字节值；如果索引大于等于 256，则是非叶节点，且可以通过 children 数组获取左右子节点。

   csharp

   public MemoryStream Decompress()
   {
       if (mode != CompressionMode.Decompress)
       {
           throw new InvalidOperationException("Not in decompression mode.");
       }
   
       ushort root = RebuildTree();
       while (output.Length != decompressedLength)
       {
           ushort node = root;
           while (node >= 256)                 // Keep reading bits until we reach a leaf node
           {
               int bit = input.ReadBit();
               if (bit != -1)
               {
                   node = children[node, bit]; // Traverse the tree based on the bit read
               }
           }
           output.WriteByte((byte)node);
       }
       return output;
   }

3 完整代码

见 https://github.com/detached64/Huffman。

1 基本概念

DLL 劫持 (DLL Hijacking) 是一种常见的攻击手段，通过劫持系统 DLL 或自定义 DLL 实现恶意代码的注入。

2 原理

2.1 劫持系统 DLL

当程序加载系统 DLL 时，若未指定 DLL 的完整路径 (这种情况相当常见)，Windows 会大致按照以下顺序搜索 DLL (随 Windows 版本不同可能会有差异)：

• 当前目录
• 系统目录
• Windows 目录
• 环境变量 PATH 中指定的目录

可以看到，当前目录优先级最高，因此可以将恶意 DLL 重命名为程序需要的系统 DLL 并放置在当前目录，从而实现劫持。

注意：在注册表 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs 中列出的 DLL 不会被劫持。

当然，被掉包的 DLL 应该实现原 DLL 的所有导出函数，否则可能会导致程序崩溃。

实现方式见下文。

2.2 劫持自定义 DLL

这一部分就很简单了，我们通过创建一个新的 DLL，重命名为原 DLL 的名称，并在其中实现原 DLL 的所有导出函数。这样，当程序加载这个新的 DLL 时，实际上是加载了我们自己实现的代码。

这个方法也叫做 “DLL 代理”(DLL Proxy)。

3 实现

3.1 劫持系统 DLL

在代码中，我们需要找到目标 DLL 的路径，通过 LoadLibrary 加载该 DLL，之后通过 GetProcAddress 获取真正的函数地址。随后，我们需要导出获取到的真正函数，并且导出的名称必须与原 DLL 对应函数一致。

关键代码如下：(以 version.dll 的 GetFileVersionInfoA 函数为例)

#pragma comment(linker, "/EXPORT:GetFileVersionInfoA=_Redirect_GetFileVersionInfoA,@1")

PVOID Real_GetFileVersionInfoA = NULL;

HMODULE Real_Module = NULL;

FARPROC WINAPI GetAddress(LPCSTR lpProcName)
{
    FARPROC pAddress = GetProcAddress(Real_Module, lpProcName);
    if (pAddress == NULL)
    {
        MessageBoxW(NULL, L"Get address failed", L"version", MB_OK);
        ExitProcess(1);
    }
    return pAddress;
}

EXTERN_C __declspec(naked) void __cdecl Redirect_GetFileVersionInfoA(void)
{
    __asm jmp Real_GetFileVersionInfoA;
}

VOID WINAPI InitHijack()
{
    WCHAR real_dll_path[MAX_PATH];
    GetSystemDirectoryW(real_dll_path, MAX_PATH);
    lstrcatW(real_dll_path, L"\\version.dll");

    Real_Module = LoadLibraryW(real_dll_path);
    if (Real_Module == NULL)
    {
        MessageBoxW(NULL, L"Load original dll failed", L"version", MB_OK);
        ExitProcess(1);
    }

    Real_GetFileVersionInfoA = GetAddress("GetFileVersionInfoA");
}

最后在 DLL 的 DllMain 函数中调用 InitHijack 函数即可。

3.2 劫持自定义 DLL

劫持自定义 DLL 时利用转发函数的方式实现，将调用转发到原 DLL 的对应函数。

如果使用 .h 头文件，那么我们需要使用类似 #pragma comment(linker, "/EXPORT:...") 的语句来导出函数。

#pragma comment(linker, "/EXPORT:GetFileVersionInfoA=version.GetFileVersionInfoA,@1")

如果使用 .def 文件，那么我们需要在 .def 文件中添加 EXPORTS 语句。这种方式仅限 gcc/g++，msvc 不支持。

EXPORTS
GetFileVersionInfoA=version.GetFileVersionInfoA @1

众所周知，BitComet 在中国大陆地区部分功能被封锁，例如种子市场等等。我们可以通过简单的方式绕过这个限制。

1 步骤

1. 用 x64dbg 载入

   注意：此处可能需关闭 ScyllaHide，否则会导致持续出现异常；可能需要隐藏调试器：调试 -> 高级 -> 隐藏调试器。

2. Ctrl + G 或在符号界面断下 GetUserDefaultUILanguage。

3. F9 运行到断点，然后 Alt + F9 执行到用户代码。

   位置大致如下：

   asm

   00007FF7AA71E082 | FF15 28ECB500            | call qword ptr ds:[<GetProcAddress>]           |
   00007FF7AA71E088 | 48:85C0                  | test rax,rax                                   |
   00007FF7AA71E08B | 74 05                    | je bitcomet11.7FF7AA71E092                     |
   00007FF7AA71E08D | FFD0                     | call rax                                       |
   00007FF7AA71E08F | 0FB7D8                   | movzx ebx,ax                                   | 到达这里
   00007FF7AA71E092 | 48:8BCF                  | mov rcx,rdi                                    | rcx:"1\t"
   00007FF7AA71E095 | FF15 75EBB500            | call qword ptr ds:[<FreeLibrary>]              |
   00007FF7AA71E09B | 8BC3                     | mov eax,ebx                                    |
   00007FF7AA71E09D | 48:8B5C24 30             | mov rbx,qword ptr ss:[rsp+30]                  | [rsp+30]:&L"C:\\Program Files\\BitComet\\BitComet.exe"
   00007FF7AA71E0A2 | 48:83C4 20               | add rsp,20                                     |
   00007FF7AA71E0A6 | 5F                       | pop rdi                                        |
   00007FF7AA71E0A7 | C3                       | ret                                            |

4. 修改下面的 mov eax,ebx 为 mov eax,0x409。

   注意

   切记加上 0x 前缀，否则会被当作十进制数处理。

5. Ctrl + P 保存。

6. 打开 BitComet，即可看到语言变成英文，种子市场等功能已经解锁。当然，如果你把语言修改为简体中文，这些功能又隐藏了。

   我们可以通过修改 C:\Program Files\BitComet\lang 目录下的 .mo 文件的名字来解决这个问题：

   • bitcomet-en_US.mo -> bitcomet-en_US.mo.bak

   • bitcomet-zh_CN.mo -> bitcomet-en_US.mo

7. 最终效果如图：

   

   可以看到有小部分仍是英文，可能因为对应字段未存储在 .mo 文件中，或初始化时机与其他字段不同。

2 参考

• x64dbg
• BitComet
• C++ 如何获取 Windows 操作系统的语言

1 字节数组转十六进制字符串

1.1 手动实现

public static string ByteArrayToHexString(byte[] bytes)
{
    StringBuilder sb = new StringBuilder();
    foreach (byte b in bytes)
    {
        sb.Append(b.ToString("x2"));
    }
    return sb.ToString();
}

1.2 手动实现优化

public static string ByteArrayToHexString(byte[] bytes)
{
    char[] c = new char[bytes.Length * 2];
    byte b;
    for (int i = 0; i < bytes.Length; i++)
    {
        b = ((byte)(bytes[i] >> 4));
        c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
        b = ((byte)(bytes[i] & 0xF));
        c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
    }
    return new string(c);
}

1.3 使用 BitConverter

public static string ByteArrayToHexString(byte[] bytes)
{
    return BitConverter.ToString(bytes).Replace("-", "");
}

1.4 使用 Convert.ToHexString (限.NET 5+)

string hex = Convert.ToHexString(bytes);

1.5 使用 SoapHexBinary (限.NET Framework)

string hex = new SoapHexBinary(bytes).ToString();

1.6 性能测试与比较

我们使用 BenchmarkDotNet 在.NET 9.0 和.NET Framework 4.8 上对上述方法进行性能测试。

1.6.1 .NET 9.0

测试代码：

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System.Text;

namespace BenchMarkerNet9
{
    public class Program
    {
        private static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Benchmarker>();
        }
    };

    [MemoryDiagnoser]
    public class Benchmarker
    {
        public byte[] bytes = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };

        [Benchmark]
        public string ByteArrayToHexString1()
        {
            StringBuilder sb = new StringBuilder();
            foreach (byte b in bytes)
            {
                sb.Append(b.ToString("x2"));
            }
            return sb.ToString();
        }

        [Benchmark]
        public string ByteArrayToHexString2()
        {
            char[] c = new char[bytes.Length * 2];
            byte b;
            for (int i = 0; i < bytes.Length; i++)
            {
                b = ((byte)(bytes[i] >> 4));
                c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
                b = ((byte)(bytes[i] & 0xF));
                c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
            }
            return new string(c);
        }

        [Benchmark]
        public string ByteArrayToHexString3()
        {
            return BitConverter.ToString(bytes).Replace("-", string.Empty);
        }

        [Benchmark]
        public string ByteArrayToHexString4()
        {
            return Convert.ToHexString(bytes);
        }
    }
}

测试结果如下：

| Method                | Mean      | Error    | StdDev   | Gen0   | Allocated |
|---------------------- |----------:|---------:|---------:|-------:|----------:|
| ByteArrayToHexString1 | 156.29 ns | 2.677 ns | 4.006 ns | 0.0429 |     808 B |
| ByteArrayToHexString2 |  22.63 ns | 0.475 ns | 0.650 ns | 0.0093 |     176 B |
| ByteArrayToHexString3 | 156.63 ns | 0.864 ns | 0.808 ns | 0.0110 |     208 B |
| ByteArrayToHexString4 |  11.45 ns | 0.262 ns | 0.408 ns | 0.0047 |      88 B |

• Mean : Arithmetic mean of all measurements 平均值
• Error : Half of 99.9% confidence interval 误差
• StdDev : Standard deviation of all measurements 方差
• Gen0 : GC Generation 0 collects per 1000 operations 第 0 代 GC 次数
• Allocated : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B) 分配的内存
• 1 ns : 1 Nanosecond (0.000000001 sec) 纳秒

可见，Convert.ToHexString 是最快的，手动实现优化次之，BitConverter 和手动实现性能很差。

1.6.2 .NET Framework 4.8

测试代码：

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;
using System.Runtime.Remoting.Metadata.W3cXsd2001;
using System.Text;

namespace BenchMarker480
{
    public class Program
    {
        private static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Benchmarker>();
        }
    };

    [MemoryDiagnoser]
    public class Benchmarker
    {
        public byte[] bytes = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };

        [Benchmark]
        public string ByteArrayToHexString1()
        {
            StringBuilder sb = new StringBuilder();
            foreach (byte b in bytes)
            {
                sb.Append(b.ToString("x2"));
            }
            return sb.ToString();
        }

        [Benchmark]
        public string ByteArrayToHexString2()
        {
            char[] c = new char[bytes.Length * 2];
            byte b;
            for (int i = 0; i < bytes.Length; i++)
            {
                b = ((byte)(bytes[i] >> 4));
                c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
                b = ((byte)(bytes[i] & 0xF));
                c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
            }
            return new string(c);
        }

        [Benchmark]
        public string ByteArrayToHexString3()
        {
            return BitConverter.ToString(bytes).Replace("-", string.Empty);
        }

        [Benchmark]
        public string ByteArrayToHexString4()
        {
            return new SoapHexBinary(bytes).ToString();
        }
    }
}

测试结果如下：

| Method                | Mean      | Error     | StdDev    | Median    | Gen0   | Allocated |
|---------------------- |----------:|----------:|----------:|----------:|-------:|----------:|
| ByteArrayToHexString1 | 539.00 ns | 22.907 ns | 67.543 ns | 513.00 ns | 0.1035 |     545 B |
| ByteArrayToHexString2 |  37.79 ns |  0.656 ns |  0.613 ns |  37.91 ns | 0.0297 |     156 B |
| ByteArrayToHexString3 | 194.82 ns |  2.988 ns |  3.557 ns | 194.53 ns | 0.0565 |     296 B |
| ByteArrayToHexString4 | 339.67 ns |  5.352 ns |  4.745 ns | 340.74 ns | 0.1135 |     597 B |

可见，手动实现优化是最快的，BitConverter 次之，SoapHexBinary 和手动实现性能很差。

1.7 结论

• Convert.ToHexString 是最快的，假设你的项目是.NET 5+，推荐使用。
• 如果你的项目是.NET 5 以下，推荐使用手动实现优化。
• 纵向对比会发现，.NET 9 的 StringBuilder 和 BitConverter 性能比.NET framework 4.8 有较大提升。

1.8 注意

• byte 数组有一个扩展方法 ToString()，但是它返回的是 "System.Byte[]"。这是因为 System.Byte 继承自 System.Object，而 System.Object 有一个 ToString() 方法，且 System.Byte 没有重写这个方法。同样，Console.WriteLine(bytes) 也会返回 System.Byte[]。
• 不可以使用 Encoding.xxx.GetString(bytes)，因为这个方法会将字节数组按照指定的编码转换成字符串，而不是转换为十六进制字符串。
• 将 byte 数组写入 json 或其他文本文件时，建议使用 Convert.ToBase64String(bytes)，不建议使用 hex string。

2 十六进制字符串转字节数组

2.1 手动实现

public static byte[] HexStringToByteArray(string hex)
{
    byte[] bytes = new byte[hex.Length / 2];
    for (int i = 0; i < hex.Length; i += 2)
    {
        bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
    }
    return bytes;
}

2.2 基于 Linq 的实现

public static byte[] HexStringToByteArray(string hex)
{
    return Enumerable.Range(0, hex.Length)
                     .Where(x => x % 2 == 0)
                     .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                     .ToArray();
}

2.3 使用 Convert.FromHexString (限.NET 5+)

public static byte[] HexStringToByteArray(string hex)
{
    return Convert.FromHexString(hex);
}

2.4 使用 SoapHexBinary (限.NET Framework)

public static byte[] HexStringToByteArray(string hex)
{
    return new SoapHexBinary(hex).Value;
}

2.5 性能测试与比较

环境同上。

2.5.1 .NET 9.0

测试代码：

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

namespace BenchMarkerNet9
{
    public class Program
    {
        private static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Benchmarker>();
        }
    };

    [MemoryDiagnoser]
    public class Benchmarker
    {
        public string hex = "0102030405060708090A0B0C0D0E0F10";

        [Benchmark]
        public byte[] HexToBytes1()
        {
            byte[] bytes = new byte[hex.Length / 2];
            for (int i = 0; i < hex.Length; i += 2)
            {
                bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
            }
            return bytes;
        }

        [Benchmark]
        public byte[] HexToBytes2()
        {
            return Enumerable.Range(0, hex.Length)
                .Where(x => x % 2 == 0)
                .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                .ToArray();
        }

        [Benchmark]
        public byte[] HexToBytes3()
        {
            return Convert.FromHexString(hex);
        }
    }
}

测试结果如下：

| Method      | Mean       | Error     | StdDev     | Gen0   | Allocated |
|------------ |-----------:|----------:|-----------:|-------:|----------:|
| HexToBytes1 | 172.904 ns | 8.5000 ns | 25.0625 ns | 0.0293 |     552 B |
| HexToBytes2 | 200.896 ns | 3.9337 ns |  5.7660 ns | 0.0410 |     776 B |
| HexToBytes3 |   7.851 ns | 0.1848 ns |  0.2270 ns | 0.0021 |      40 B |

可见，Convert.FromHexString 是最快的，手动实现和基于Linq的实现性能很差。

2.5.2 .NET Framework 4.8

测试代码：

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;
using System.Linq;
using System.Runtime.Remoting.Metadata.W3cXsd2001;

namespace BenchMarker480
{
    public class Program
    {
        private static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Benchmarker>();
        }
    };

    [MemoryDiagnoser]
    public class Benchmarker
    {
        public string hex = "0102030405060708090A0B0C0D0E0F10";

        [Benchmark]
        public byte[] HexToBytes1()
        {
            byte[] bytes = new byte[hex.Length / 2];
            for (int i = 0; i < hex.Length; i += 2)
            {
                bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
            }
            return bytes;
        }

        [Benchmark]
        public byte[] HexToBytes2()
        {
            return Enumerable.Range(0, hex.Length)
                .Where(x => x % 2 == 0)
                .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                .ToArray();
        }

        [Benchmark]
        public byte[] HexToBytes3()
        {
            return SoapHexBinary.Parse(hex).Value;
        }
    }
}

测试结果如下：

| Method      | Mean       | Error    | StdDev   | Gen0   | Allocated |
|------------ |-----------:|---------:|---------:|-------:|----------:|
| HexToBytes1 |   414.5 ns | 13.73 ns | 40.48 ns | 0.0663 |     349 B |
| HexToBytes2 |   586.6 ns |  3.08 ns |  2.57 ns | 0.0992 |     525 B |
| HexToBytes3 | 1,285.0 ns | 18.47 ns | 17.27 ns | 0.3071 |    1610 B |

可见，手动实现是最快的，基于Linq的实现次之，SoapHexBinary 性能很差。

2.6 结论

• Convert.FromHexString 是最快的，假设你的项目是.NET 5+，推荐使用。
• 如果你的项目是.NET 5 以下，推荐使用手动实现。
• 纵向对比会发现，.NET 9 的手动实现性能和 Linq 性能比.NET framework 4.8 有较大提升。

3 参考

• stackoverflow-how-do-you-convert-byte-array-to-hexadecimal-string-and-vice-versa

1 设置用户名和邮箱

git config --global user.name "your name"
git config --global user.email "your email"

--global 表示全局设置，如果只想对当前仓库生效，去掉 --global 即可。

GitHub 等代码托管平台会为用户提供一个匿名邮箱地址。就 GitHub 来说，在 Settings -> Emails 中勾选 Keep my email addresses private，然后就可以看到 GitHub 分配的类似于 123456+user@users.noreply.github.com 的匿名邮箱地址。匿名邮箱地址可以保护个人隐私，同时也能将提交与平台账户关联起来，方便在平台上查看提交历史和贡献记录。

如果不需要关联账户，或代码托管于多个平台，可以使用一个虚假的邮箱地址。

2 初始化本地仓库和远程仓库

1. 初始化本地仓库

   bash

   git init

2. 创建远程空仓库 (如果没有)

   登录 GitHub，点击右上角 +，选择 New repository，填写信息，点击 Create repository。输入仓库名，其余保持默认即可，点击 Create repository。

3. 关联本地仓库和远程仓库

   bash

   git remote add origin <远程仓库地址>

4. 暂存并创建 commit

   bash

   git add .
   git commit -m "message"

5. 将本地仓库内容推送到远程仓库

   bash

   git push --set-upstream origin master

   或

   bash

   git push -u origin master

3 撤销已 commit 的更改

1. 保留更改到暂存区

   bash

   git reset --soft HEAD~1

2. 删除更改

   bash

   git reset --hard HEAD~1

fatal: ambiguous argument 'HEAD~1': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

4 修改某个 commit 的 message

假设修改第 n 个 (以最近的 commit 为 1) commit 的 message：

git rebase -i HEAD~n

在弹出的编辑器中，将需要修改的 commit 前的 pick 改为 reword，保存并关闭编辑器。接着会弹出一个新的编辑器，修改 message 后保存并关闭编辑器。

5 合并多个 commit

假设合并最近的 n 个 commit：

方法一：

git rebase -i HEAD~n

在弹出的编辑器中，将需要合并的 commit 前的 pick 改为 squash，保存并关闭编辑器。接着会弹出一个新的编辑器，修改 message 后保存并关闭编辑器。

方法二：

git reset --soft HEAD~n
git commit -m "new message"

6 强制推送

git push --force

多人协作时不建议使用，必要时可以使用 git push --force-with-lease。它会检查远程仓库是否有新的更改，如果有则拒绝推送。

7 批量修改提交者信息

新建一个.mailmap 文件，格式为以下之一：

Correct Name <correct@email.com> Wrong Name <wrong@email.com>
Correct Name <correct@email.com> <wrong@email.com>
<correct@email.com> <wrong@email.com>

例如：

user1 <1@1.com> user2 <2@2.com>

再执行：

git filter-repo --mailmap .mailmap --force
git push --force

.mailmap 代表该文件的路径，可以手动指定。

8 将原仓库的更改同步到 fork 的仓库

1. 添加上游远程仓库

   bash

   git remote add upstream <原仓库地址>

2. 获取上游远程仓库的更改

   bash

   git fetch upstream

3. 切换到本地的主分支

   bash

   git checkout <主分支名称>

4. 将上游远程仓库的更改应用到本地分支

   • 使用 merge 方法

     bash

     git merge upstream/<主分支名称>

     如果有冲突，你会看到类似如下的信息：

     text

     CONFLICT (content): Merge conflict in <冲突文件路径>

     打开冲突的文件，你会看到类似如下的标记：

     text

     <<<<<<< HEAD
     你的代码
     =======
     上游的代码
     >>>>>>> upstream/main

     你需要手动编辑冲突的文件，并删除所有标记 (<<<<<<<, =======, >>>>>>>)，然后保存文件。

     解决所有冲突后执行：

     bash

     git add .
     git commit -m "Merge upstream changes"

   • 使用 rebase 方法

     bash

     git rebase upstream/<主分支名称>

     冲突处理同上。

     解决冲突后执行：

     bash

     git add <冲突文件路径>
     git rebase --continue

5. 将本地分支的更改推送到 fork 的远程仓库

   bash

   git push origin <主分支名称> --force

9 浅克隆

当只需要获取仓库的最新状态，而不需要完整的提交历史时，可以使用浅克隆来节省时间和存储空间。

git clone --depth 1 <仓库地址>

--depth 1 表示只克隆最近的一次提交，可以根据需要调整深度。

如果需要在浅克隆的基础上获取更多的提交，可以使用以下命令：

git fetch --deepen <深度>

该命令会在当前的基础上再获取更多的提交，<深度> 表示要获取的提交数量。比如原来克隆了最近的 1 次提交，执行 git fetch --deepen 4 后会获取最近的 4 次提交，使本地仓库总共包含最近的 5 次提交。

或者使用以下命令：

git fetch --depth <深度>

该命令会将修改克隆深度。比如原来克隆了最近的 1 次提交，执行 git fetch --depth 4 后就会获取最近的 3 次提交，使本地仓库总共包含最近的 4 次提交。

使用以下命令将浅克隆转换为完整克隆：

git fetch --unshallow

如果要针对特定分支，可以使用以下命令：

git fetch <远程名称> <分支名称> --deepen <深度>
git fetch <远程名称> <分支名称> --depth <深度>
git fetch <远程名称> <分支名称> --unshallow

如果需要设置某个子模块为浅克隆，在 .gitmodules 文件中的对应条目添加 shallow = true 配置即可。