it-swarm.com.de

Berechnen Sie einen MD5-Hash aus einer Zeichenfolge

Ich verwende den folgenden C # -Code, um einen MD5-Hash aus einer Zeichenfolge zu berechnen .. __ Er funktioniert gut und generiert eine 32-stellige hexadezimale Zeichenfolge wie folgt: 900150983cd24fb0d6963f7d28e17f72

string sSourceData;
byte[] tmpSource;
byte[] tmpHash;
sSourceData = "MySourceData";

//Create a byte array from source data.
tmpSource = ASCIIEncoding.ASCII.GetBytes(sSourceData);
tmpHash = new MD5CryptoServiceProvider().ComputeHash(tmpSource);

// and then convert tmpHash to string...

Gibt es eine Möglichkeit, mit diesem Code eine 16-stellige Hex-Zeichenfolge (oder eine 12-stellige Zeichenfolge) zu generieren? Eine 32-stellige Hex-Zeichenfolge ist gut, aber ich denke, es wird langweilig für den Kunden, den Code einzugeben!

91
user1422847

Wie pro MSDN

MD5 erstellen:

   public static string CreateMD5(string input)
    {
        // Use input string to calculate MD5 hash
        using (System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create())
        {
            byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(input);
            byte[] hashBytes = md5.ComputeHash(inputBytes);

            // Convert the byte array to hexadecimal string
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < hashBytes.Length; i++)
            {
                sb.Append(hashBytes[i].ToString("X2"));
            }
            return sb.ToString();
        }
    }
134
Anant Dabhi
// given, a password in a string
string password = @"1234abcd";

// byte array representation of that string
byte[] encodedPassword = new UTF8Encoding().GetBytes(password);

// need MD5 to calculate the hash
byte[] hash = ((HashAlgorithm) CryptoConfig.CreateFromName("MD5")).ComputeHash(encodedPassword);

// string representation (similar to UNIX format)
string encoded = BitConverter.ToString(hash)
   // without dashes
   .Replace("-", string.Empty)
   // make lowercase
   .ToLower();

// encoded contains the hash you are wanting
81
Michael

Sie können Convert.ToBase64String verwenden, um die 16-Byte-Ausgabe von MD5 in eine Zeichenfolge von ~ 24 Zeichen zu konvertieren. Ein bisschen besser ohne die Sicherheit zu beeinträchtigen. (j9JIbSY8HuT89/pwdC8jlw== für Ihr Beispiel)

7
L.B

Kommt ganz darauf an, was Sie erreichen wollen. Technisch könnten Sie einfach die ersten 12 Zeichen aus dem Ergebnis des MD5-Hashwerts entnehmen, aber die Spezifikation von MD5 besteht darin, ein 32-Zeichen-Zeichen zu generieren.

Durch die Reduzierung der Hashgröße wird die Sicherheit verringert und die Wahrscheinlichkeit von Kollisionen und die Zerstörung des Systems erhöht.

Wenn Sie uns mehr darüber informieren, was Sie erreichen möchten, können wir möglicherweise mehr helfen.

7
KingCronus

Versuchte, mit LINQ eine Zeichenfolgendarstellung für MD5-Hash zu erstellen, war jedoch keine der Antworten eine LINQ-Lösung, weshalb dies zum Smorgasbord der verfügbaren Lösungen hinzugefügt wurde. 

string result;
using (MD5 hash = MD5.Create())
{
    result = String.Join
    (
        "",
        from ba in hash.ComputeHash
        (
            Encoding.UTF8.GetBytes(observedText)
        ) 
        select ba.ToString("x2")
    );
}
6
craigdfrench

Unterstützt String und Dateistream.

beispiele

string hashString = EasyMD5.Hash("My String");

string hashFile = EasyMD5.Hash(System.IO.File.OpenRead("myFile.txt"));

-

   class EasyMD5
        {
            private static string GetMd5Hash(byte[] data)
            {
                StringBuilder sBuilder = new StringBuilder();
                for (int i = 0; i < data.Length; i++)
                    sBuilder.Append(data[i].ToString("x2"));
                return sBuilder.ToString();
            }

            private static bool VerifyMd5Hash(byte[] data, string hash)
            {
                return 0 == StringComparer.OrdinalIgnoreCase.Compare(GetMd5Hash(data), hash);
            }

            public static string Hash(string data)
            {
                using (var md5 = MD5.Create())
                    return GetMd5Hash(md5.ComputeHash(Encoding.UTF8.GetBytes(data)));
            }
            public static string Hash(FileStream data)
            {
                using (var md5 = MD5.Create())
                    return GetMd5Hash(md5.ComputeHash(data));
            }

            public static bool Verify(string data, string hash)
            {
                using (var md5 = MD5.Create())
                    return VerifyMd5Hash(md5.ComputeHash(Encoding.UTF8.GetBytes(data)), hash);
            }

            public static bool Verify(FileStream data, string hash)
            {
                using (var md5 = MD5.Create())
                    return VerifyMd5Hash(md5.ComputeHash(data), hash);
            }
        }
5
Think Big

Ich nehme an, es ist besser, UTF-8-Kodierung im String MD5 zu verwenden.

public static string MD5(this string s)
{
    using (var provider = System.Security.Cryptography.MD5.Create())
    {
        StringBuilder builder = new StringBuilder();                           

        foreach (byte b in provider.ComputeHash(Encoding.UTF8.GetBytes(s)))
            builder.Append(b.ToString("x2").ToLower());

        return builder.ToString();
    }
}
3
Tomas Kubes

Ein MD5-Hash ist 128 Bit, daher kann er nicht mit weniger als 32 Zeichen in Hex dargestellt werden.

3
Thomas Levesque
System.Text.StringBuilder hash = new System.Text.StringBuilder();
        System.Security.Cryptography.MD5CryptoServiceProvider md5provider = new System.Security.Cryptography.MD5CryptoServiceProvider();
        byte[] bytes = md5provider.ComputeHash(new System.Text.UTF8Encoding().GetBytes(YourEntryString));

        for (int i = 0; i < bytes.Length; i++)
        {
            hash.Append(bytes[i].ToString("x2")); //lowerCase; X2 if uppercase desired
        }
        return hash.ToString();
3
Kristian Jay

https://docs.Microsoft.com/en-us/dotnet/api/system.security.cryptography.md5?view=netframework-4.7.2

using System;
using System.Security.Cryptography;
using System.Text;

    static string GetMd5Hash(string input)
            {
                using (MD5 md5Hash = MD5.Create())
                {

                    // Convert the input string to a byte array and compute the hash.
                    byte[] data = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(input));

                    // Create a new Stringbuilder to collect the bytes
                    // and create a string.
                    StringBuilder sBuilder = new StringBuilder();

                    // Loop through each byte of the hashed data 
                    // and format each one as a hexadecimal string.
                    for (int i = 0; i < data.Length; i++)
                    {
                        sBuilder.Append(data[i].ToString("x2"));
                    }

                    // Return the hexadecimal string.
                    return sBuilder.ToString();
                }
            }

            // Verify a hash against a string.
            static bool VerifyMd5Hash(string input, string hash)
            {
                // Hash the input.
                string hashOfInput = GetMd5Hash(input);

                // Create a StringComparer an compare the hashes.
                StringComparer comparer = StringComparer.OrdinalIgnoreCase;

                return 0 == comparer.Compare(hashOfInput, hash);

            }
0
KhaledDev
StringBuilder sb= new StringBuilder();
for (int i = 0; i < tmpHash.Length; i++)
{
   sb.Append(tmpHash[i].ToString("x2"));
}
0
Suhrob Samiev

Eine schnellere Alternative zu bestehenden Antworten für .NET Core 2.1 und höher:

public static string CreateMD5(string s)
{
    using (System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create())
    {
        var encoding = Encoding.ASCII;
        var data = encoding.GetBytes(s);

        Span<byte> hashBytes = stackalloc byte[16];
        md5.TryComputeHash(data, hashBytes, out int written);
        if(written != hashBytes.Length)
            throw new OverflowException();


        Span<char> stringBuffer = stackalloc char[32];
        for (int i = 0; i < hashBytes.Length; i++)
        {
            hashBytes[i].TryFormat(stringBuffer.Slice(2 * i), out _, "x2");
        }
        return new string(stringBuffer);
    }
}

Sie können es noch weiter optimieren, wenn Sie sicher sind, dass Ihre Zeichenfolgen klein genug sind, und die Codierung durch unsichere int-GetBytes-Alternative (ReadOnlySpan-Zeichen, Span-Bytes) ersetzen.

0
Tomas Kubes

Diese Lösung erfordert c # 7.2 und nutzt Span<T>. Unabhängig von der Eingangsgröße weist dies eine feste Speichermenge zu und ist schneller als die akzeptierte Antwort. Beachten Sie, dass Sie dennoch .Replace("-", string.Empty).ToLowerInvariant() aufrufen müssen, um das Ergebnis bei Bedarf zu formatieren.

public static string CreateMD5(ReadOnlySpan<char> input)
{
    var encoding = System.Text.Encoding.UTF8;
    var inputByteCount = encoding.GetByteCount(input);

    using (var md5 = System.Security.Cryptography.MD5.Create())
    {
        Span<byte> bytes = stackalloc byte[inputByteCount];
        Span<byte> destination = stackalloc byte[md5.HashSize / 8];

        encoding.GetBytes(input, bytes);

        // checking the result is not required because this only returns false if "(destination.Length < HashSizeValue/8)", which is never true in this case
        md5.TryComputeHash(bytes, destination, out int _bytesWritten);

        return BitConverter.ToString(destination.ToArray());
    }
}
0
Brad M