Vergleichen Passwort-Hashes zwischen C# und Coldfusion (CFMX_COMPAT)

Question

ich ein Passwort-Hash, die in einer Tabelle gespeichert und dort Script- durch die folgende Coldfusion setzen

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

Ich versuche, einige außerhalb Funktionalität hinzugefügt, die in aC# -Anwendung. Ich möchte die bereits vorhandenen Daten nutzen können, um Benutzer authentifizieren zu können. Weiß jemand, wie ich den oben genannten Coldfusion-Code in C# replizieren kann?

Danke für irgendwelche Gedanken.

Answer 1

Ich lasse die ursprüngliche Antwort Inhalt unten für historische Referenz, aber es sollte beachtet werden, dass dies ist keine funktionierende Antwort auf die ursprüngliche Frage.

Stattdessen sehen Sie die am häufigsten gewählte Antwort in diesem Thread von @Terrapin im Januar 2011. Ich hoffe, das OP sieht dies und kann die akzeptierte Antwort ändern. Verdammt, ich werde sogar die Mods markieren, um zu sehen, ob etwas dagegen unternommen werden kann.

---

auf der Antwort von Edward Smith, und den nachfolgenden Kommentaren von czuroski zu bauen, hier meine Lösung ist.

Zuerst benötigen Sie eine XOR-Funktion in C#, die ich von here genommen und geringfügig geändert habe.

Dann nehmen Sie das Ergebnis der XOR-und Base-64 kodieren Sie es.Nachdem Sie diese Zeichenfolge haben, MD5 Hash es. Das Ergebnis sollte mit dem Ergebnis des ursprünglichen Code-Snippets übereinstimmen:

Answer 2

MD5 ist der Standard-Hashing-Algorithmus für die hash(). Ich bin kein C# -Programmierer, aber es sollte nicht zu schwer sein, einen MD5-Hash zu erstellen, um ihn mit Ihrem ColdFusion-Ergebnis zu vergleichen.

Wie für encrypt(), gibt es einen Grund, dass Sie den Benutzernamen vor dem Hashing verschlüsseln? Ich kann mir keinen Nutzen daraus machen, aber das bedeutet nicht, dass es keinen gibt. Ich würde einfach tun:

Hash(UCase(GetPass.username)) 

Welche sollte in C# einfacher zu replizieren sein.

Answer 3

Eine der Lösungen wäre die DB zu tun haben, das Hashing und encription könnte einfacher sein ...

Answer 4

Der Standard "Verschlüsselung" in CF ist einfach ein XOR:

Chiffretext = base64_encode (Klartext^Schlüssel)

so, zu entschlüsseln:

Klartext = base64_decode (Chiffretext)^Schlüssel

Der Standard-Hash, wie menti oned, ist md5.

Edit:

Nun, weitere Forschung zeigt dies nicht wahr ist - nur eine von diesen allgegenwärtigen Mythen.

Ich kann keine Dokumentation des tatsächlichen Algorithmus für die Verschlüsselungsmethode CFMX_COMPAT finden.

Sorry wegen der wilden Gans Chase.

Answer 5

Ich sah durch den Railo-Code als jemand anderes hier in Kommentaren erwähnt.

Im Folgenden wird CFMX_Compat aus der Railo-Java-Quelle nach C# portiert. Siehe unten für ein Anwendungsbeispiel.

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); 
     } 
    } 
} 

Hier ist ein Anwendungsbeispiel, dass die verschlüsselten Text Hex-codiert und entschlüsselt dann die gleiche Sache.

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);