命令行参数和“字节”数组

Question

So I have a generated byte array in the form of '\\xef\\x00\\xef\\x00' blah blah blah. The program is supposed to take this as an argument, encrypt it, and display the results. The problem is that from command line it is '\\xef\\x00\\xef\\x00' so it doesn't work.

I have tried various encodings (UTF8, Unicode, Default, etc). I have tried different "input" methods, but those are not desirable due to the source of the byte array's in the first place. The different input methods are like 0x00 format for the bytes instead.

I have been googling for hours, but come up with nothing. Most things involving a byte array is "how to pass it to a method" >_<;

static void Main(string[] args)
{
    //string one produces the desired results
    string one = "\xfc\xe8\x82\x00\x00";
    //args[0] is the same thing as string one..just command line
    //it IS never the same as strong one once "loaded"
    byte[] bytes = Encoding.GetEncoding(1252).GetBytes(args[0]);
    //various messing around trying to figure it out....
    string two = Encoding.UTF8.GetString(bytes);
    byte[] oneb = StrToByteArray(one);
    byte[] twob = StrToByteArray(two);
    Console.ReadKey();
}

public static byte[] StrToByteArray(string str)
{
    if (str != string.Empty)
    {
        byte[] sc = new byte[str.Length];

        for (int i = 0; i < str.Length; i++)
        {
            sc[i] = Convert.ToByte(str[i]);
        }

        return sc;
    }
    return null;
}

At the end...oneb and twob should be the same size, containing the same stuff.

Answer 1

As the parameter is passed in, the string is being escaped, which is why you don't get it as a literal string.

You can use Regex.Unescape to turn the escaped string back into an un-escapaed one, then convert to an array if you need.

static void Main(string[] args)
{
    {
        string str = System.Text.RegularExpressions.Regex.Unescape(args[0]);

        var bytes = str.Select(c => (byte)c).ToArray();

        Console.WriteLine(str);
        Console.WriteLine(BitConverter.ToString(bytes));

        Console.ReadKey();
    }
}

Results:-

C:\Temp>ConsoleApp.exe \xfc\xe8\x82\x00\x00
üè?
FC-E8-82-00-00

Answer 2

I did find a temporary work around, but it isn't exactly what I would consider the "best" solution. Anything that would work better I'm all ears.

        public static byte[] StringToBytes2(string str)
        {
            string[] parts = str.Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries);
            byte[] bytes = new byte[parts.Length];

            for (int i = 0; i < parts.Length; i++)
            {
                if (parts[i] != "")
                {
                    string temp = String.Format("0{0}", parts[i]);
                    bytes[i] = Convert.ToByte(temp, 16);
                }
            }
            return bytes;
        }

Answer 3

First, there's probably no convenient encoding scheme that will give you the raw bytes you're expecting. You can get the correct values out by converting each character in the string to a byte using LINQ:

string one = "\xfc\xe8\x82\x00\x00";
string oneBytes = one.Select(c => (byte)c).ToArray();

This works because the string constant in your program is transformed during compilation to be a string 5 characters long with the hex values as code points.

Now let's assume that you run your program and provide the same quoted string as an argument:

YourProgram.exe "\xfc\xe8\x82\x00\x00"

Now if you examine arg[0] in your program you'll find that it is 20 characters long instead of 5, and in the inspector it looks something like this:

"\\xfc\\xe8\\x82\\x00\\x00"

That's because the argument is the literal text that was passed in, excluding the quotes, and escape characters are not interpreted.

Aleks beat me to the punch on this one, but his solution is correct. The Regex class has a method that takes an escaped string and interprets the escapes, which will give you the 5-character string you were looking for:

var two = System.Text.RegularExpressions.Regex.Unescape(args[0]);
var twoBytes = two.Select(c => (byte)c).ToArray();

Now you'll have the same bytes in the two arrays.

---

Incidentally, don't try to use arbitrary bytes as string values and presume that they will be correctly reproduced in any particular encoding. In .Net strings are stored as Unicode, and so far I haven't found any encoding that won't result in changes in the first 256 code points ( \ - \ÿ ) during conversion. That's why the direct conversion from char to byte is your most direct option.

Second, I hope you're only doing this for arguments. Using a string as a byte store is horribly wasteful.