Сравните хэши паролей между C # и ColdFusion (CFMX_COMPAT)

Question

У меня есть хэш пароля, который хранится в таблице и помещается туда с помощью следующего сценария coldfusion-

#Hash(Encrypt(Form.UserPassword,GetSiteVars.EnCode))#

Я пытаюсь добавить некоторые внешние функции в приложении c #. Я хотел бы иметь возможность воспользоваться данными, которые уже существуют, чтобы я мог аутентифицировать пользователей. Кто-нибудь знает, как я могу повторить вышеупомянутый код Coldfusion в C #?

Спасибо за любые мысли.

Answer 1

Я просмотрел код Railo, как кто-то здесь, упомянутый в комментариях.

Ниже приведен CFMX_Compat, портированный на C # из исходного кода Railo Java. Ниже приведен пример использования.

using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;

namespace RailoUtil
{
    // SOURCE: Railo Source Code License LGPL v2
    // http://wiki.getrailo.org/wiki/RailoLicense
    public class RailoCFMXCompat
    {
        private String m_Key;
        private int m_LFSR_A = 0x13579bdf;
        private int m_LFSR_B = 0x2468ace0;
        private int m_LFSR_C = unchecked((int)0xfdb97531);
        private int m_Mask_A = unchecked((int)0x80000062);
        private int m_Mask_B = 0x40000020;
        private int m_Mask_C = 0x10000002;
        private int m_Rot0_A = 0x7fffffff;
        private int m_Rot0_B = 0x3fffffff;
        private int m_Rot0_C = 0xfffffff;
        private int m_Rot1_A = unchecked((int)0x80000000);
        private int m_Rot1_B = unchecked((int)0xc0000000);
        private int m_Rot1_C = unchecked((int)0xf0000000);

        public byte[] transformString(String key, byte[] inBytes)
        {
            setKey(key);
            int length = inBytes.Length;
            byte[] outBytes = new byte[length];
            for (int i = 0; i < length; i++)
            {
                outBytes[i] = transformByte(inBytes[i]);
            }
            return outBytes;
        }

        private byte transformByte(byte target)
        {
            byte crypto = 0;
            int b = m_LFSR_B & 1;
            int c = m_LFSR_C & 1;
            for (int i = 0; i < 8; i++)
            {
                if (0 != (m_LFSR_A & 1))
                {
                    m_LFSR_A = m_LFSR_A ^ m_Mask_A >> 1 | m_Rot1_A;
                    if (0 != (m_LFSR_B & 1))
                    {
                        m_LFSR_B = m_LFSR_B ^ m_Mask_B >> 1 | m_Rot1_B;
                        b = 1;
                    }
                    else
                    {
                        m_LFSR_B = m_LFSR_B >> 1 & m_Rot0_B;
                        b = 0;
                    }
                }
                else
                {
                    m_LFSR_A = (m_LFSR_A >> 1) & m_Rot0_A;
                    if (0 != (m_LFSR_C & 1))
                    {
                        m_LFSR_C = m_LFSR_C ^ m_Mask_C >> 1 | m_Rot1_C;
                        c = 1;
                    }
                    else
                    {
                        m_LFSR_C = m_LFSR_C >> 1 & m_Rot0_C;
                        c = 0;
                    }
                }

                crypto = (byte)(crypto << 1 | b ^ c);
            }

            target ^= crypto;
            return target;
        }

        private void setKey(String key)
        {
            int i = 0;
            m_Key = key;
            if (String.IsNullOrEmpty(key)) key = "Default Seed";
            char[] Seed = new char[key.Length >= 12 ? key.Length : 12];
            Array.Copy(m_Key.ToCharArray(), Seed, m_Key.Length);
            int originalLength = m_Key.Length;
            for (i = 0; originalLength + i < 12; i++)
                Seed[originalLength + i] = Seed[i];

            for (i = 0; i < 4; i++)
            {
                m_LFSR_A = (m_LFSR_A <<= 8) | Seed[i + 4];
                m_LFSR_B = (m_LFSR_B <<= 8) | Seed[i + 4];
                m_LFSR_C = (m_LFSR_C <<= 8) | Seed[i + 4];
            }
            if (0 == m_LFSR_A) m_LFSR_A = 0x13579bdf;
            if (0 == m_LFSR_B) m_LFSR_B = 0x2468ace0;
            if (0 == m_LFSR_C) m_LFSR_C = unchecked((int)0xfdb97531);
        }
    }
}

Вот пример использования, который кодирует зашифрованный текст в шестнадцатеричном формате, а затем дешифрует то же самое.

RailoCFMXCompat cfmx = new RailoCFMXCompat();
UTF8Encoding encoding = new UTF8Encoding();

//encrypt my string
byte[] encrypted = cfmx.transformString("mySecretKey", encoding.GetBytes("clear text"));
string encryptedHex = BitConverter.ToString(encrypted); //72-07-AA-1B-89-CB-01-96-4F-51

//decrypt my string
byte[] encryptedBytes = HexToBytes("72-07-AA-1B-89-CB-01-96-4F-51");
byte[] decrypted = cfmx.transformString("mySecretKey", encryptedBytes);
string cleartext = encoding.GetString(decrypted);

Answer 2

MD5 - алгоритм хеширования по умолчанию для hash(). Я не программист на C #, но не должно быть слишком сложно создать хеш MD5 для сравнения с вашим результатом ColdFusion.

Что касается encrypt(), есть ли причина, по которой вы шифруете имя пользователя перед его хэшированием? Я не могу думать о какой-либо пользе для этого, но это не значит, что ее нет. Я бы просто сделал:

Hash( UCase( GetPass.username ) )

Что должно быть проще копировать в C #.

Answer 3

Я оставлю оригинальное содержание ответа ниже для исторической справки, но следует отметить, что это НЕ рабочий ответ на оригинальный вопрос .

Вместо этого посмотрите ответ с наибольшим количеством голосов в этой теме, @Terrapin в январе 2011 года. Я надеюсь, что ОП видит это и может изменить принятый ответ. Черт возьми, я даже отмечу моды, чтобы посмотреть, можно ли что-нибудь с этим сделать.

---

Чтобы продолжить ответ Эдварда Смита и последующие комментарии Чуроски, вот мое решение.

Во-первых, вам нужна функция XOR в C #, которую я взял из здесь и немного изменил.

using System;
using System.Collections.Generic;
using System.Text;

namespace SimpleXOREncryption
{    
    public static class EncryptorDecryptor
    {
        public static string EncryptDecrypt(string textToEncrypt, int key)
        {            
            StringBuilder inSb = new StringBuilder(textToEncrypt);
            StringBuilder outSb = new StringBuilder(textToEncrypt.Length);
            char c;
            for (int i = 0; i < textToEncrypt.Length; i++)
            {
                c = inSb[i];
                c = (char)(c ^ key);
                outSb.Append(c);
            }
            return outSb.ToString();
        }   
    }
}

Затем возьмите результат XOR и закодируйте его в base-64. После того, как вы получили эту строку, MD5 хеширует ее. Результат должен соответствовать результату из исходного фрагмента кода:

#Hash(Encrypt(Form.UserPassword,GetSiteVars.EnCode))#

Answer 4

По умолчанию «шифрование» в CF - просто XOR:

ciphertext = base64_encode (простой текст ^ ключ)

Итак, расшифровать:

обычный текст = base64_decode (зашифрованный текст) ^ ключ

Как уже упоминалось, хэш по умолчанию - md5.

Edit:

Что ж, дальнейшие исследования показывают, что это неправда - только один из тех распространенных мифов.

Я не могу найти документацию по фактическому алгоритму для метода шифрования CFMX_COMPAT.

Извините за погоню за диким гусем.

Answer 5

Одним из решений было бы сделать так, чтобы БД выполняла хеширование и запись, было бы проще ...