我试图解密C＃中的自动密钥密码，但我一直得到一个未处理的异常

Question

I know how to fix the error, but I don't know where to place the line of code to make it successfully run. The place that I am having issues with is where I try and create the passletter character.

static string AutokeyDecrypt(string encryptmess, string pass)
    {
        //sets both secret message and password to arrays so they can be shifted
        char[] passkey = pass.ToCharArray();
        char[] decryptmess = encryptmess.ToCharArray();
        char newletter = ' ';

        for (int i = 0; i < decryptmess.Length; i++)
        {
            char passletter = (char)(passkey[i] + newletter); //This is the line on which I am having issues. I need to concatenate the key (passletter) with each newletter that I decode.
            char messletter = decryptmess[i];

            //shifts the letters in the message back to original using the first letter of the concatenated key
            int shift = passletter - ' '; // passletter - (space character)
            newletter = (char)(messletter - shift); // Add shift to message letter

            //loops through the ASCII table
            if (newletter > '~')
            {
                newletter = (char)(newletter - 94);
            }
            else if (newletter < ' ')
            {
                newletter = (char)(newletter + 94);
            }
            decryptmess[i] = newletter;
        }
        return new string(decryptmess);
    }

Answer 1

The problem is almost certainly that you are trying to access an index in the passkey array that is beyond the end of the array, which results in an IndexOutOfRange exception.

Specifically:

char passletter = (char)(passkey[i] + newletter);

Let's say that you have a password that is 10 characters in length. The valid indices for the passkey array are 0 to 9. At the 11th character of the message ( i == 10 ) your code attempts to read from index 10, which is invalid.

The standard way to handle this is to use the modulus operator % to wrap the indexing through the valid values:

char passletter = (char)(passkey[i % passkey.Length] + newletter);

At i = 10 (for a 10 character array) this will return the first character (index 0) from the array.

---

Beyond the indexing error, there are some other issues that you should address.

At the top of your code you do this:

char[] passkey = new char[pass.Length];
passkey = pass.ToCharArray();

This creates an empty array, then immediately replaces it with a new array that is created from the pass string. The initial array is wasted space that will be disposed of by the garbage collector and isn't necessary here.

Long story short, replace the above code (and the same pattern immediately after it for decryptmess ) with:

char[] passkey = pass.ToCharArray();

This is a very common pattern for people coming to C# from C or C++ where you often have to allocate arrays and then fill them and most code assumes that you will be giving it an array to fill rather than expecting it to allocate and return. There are reasons why you might want to do either, mostly around resource management that we don't tend to use in C#.

In C# it is more normal for arrays to be created by methods like ToArray() , ToCharArray() , etc. There can be some performance implications here, but that's how it goes. When you call a method that returns an array or other object it is not necessary for you to pre-allocate the array or object.

Answer 2

The other answer didn't factor in the AutoKey cypher, so here's a better one.

Using the cypher description and examples here I think it's clear that your code isn't going to implement the decryption correctly.

The encryption algorithm uses a key stream that is composed of the message text appended to the password, and the decryption process rebuilds the key stream as it goes.

I've chosen to implement based on a flexible alphabet that looks like this:

char[] alphabet = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~".ToCharArray();

This includes all ASCII printable characters from 32 ( ) to 127 ( ~ ) in numeric order, but could be any order and/or useful subset of the range. The alphabet is the first defining characteristic of your specific variant of the cypher. From your code it appears that the alphabet above matches what you're expecting.

Each encrypted character is calculated from the characters in the key stream and message at the location by looking up their indices in the array, adding those indices and locating the encrypted character in the alphabet:

string Encrypt(string plain, string pass) 
{
    char[] message = plain.ToCharArray();
    char[] keystream = (pass + plain).ToCharArray();

    for (int i = 0; i < message.Length; i++)
    {
        int keyidx = Array.IndexOf(alphabet, keystream[i]);
        int msgidx = Array.IndexOf(alphabet, message[i]);

        message[i] = alphabet[(alphabet.Length + keyidx + msgidx) % alphabet.Length];
    }
    return new string(message);
}

NB: the line that sets message[i] uses a modulo operation to constrain the result to the array bounds. Since keyidx + msgidx could both be a negative and the % operator doesn't wrap this ( -1 % 10 == -1 , etc) I've added alphabet.Length to ensure only positive indices.

Decryption is basically the same except that the output of the decryption loop is used to build the content of the key stream as it goes. The key stream is initialized in the same way - concatenate password and message - but is updated as the decryption progresses.

string Decrypt(string encrypted, string pass)
{
    char[] message = encrypted.ToCharArray();
    char[] keystream = (pass + encrypted).ToCharArray();

    for (int i = 0; i < message.Length; i++)
    {
        int keyidx = Array.IndexOf(alphabet, keystream[i]);
        int msgidx = Array.IndexOf(alphabet, message[i]);

        message[i] = alphabet[(alphabet.Length + msgidx - keyidx) % alphabet.Length];
        keystream[i + pass.Length] = message[i];
    }
    return new string(message);
}

Constructing the keystream buffer in this way ensures that we always have sufficient space to update, even when we reach the end of the process and no longer need the last few characters.

Of course the code above assumes that your inputs are going to be well behaved and not include anything outside of the alphabet values. Any value in the password or the message that doesn't match one of the values in the alphabet will be treated as identical to the last character in the alphabet since Array.IndexOf returns -1 for any failed search. So if your input string includes any Unicode or high ASCII characters they will be rendered as ~ in the output.