MD5 හැෂ් එකක් ජනනය කරන්නේ කෙසේද?

ජාවා හි එම්ඩී 5 හැෂ් නූලක් ජනනය කිරීමට ක්‍රමයක් තිබේද?

ඔබට අවශ්‍යයි java.security.MessageDigest.

ඔබට භාවිතා කළ හැකි MessageDigest.getInstance("MD5")MD5 උදාහරණයක් ලබා ගැනීමට අමතන්න MessageDigest.

එකක් කිරීමෙන් හැෂ් ගණනය කරන්න:

• සම්පූර්ණ ආදානය a ලෙස පෝෂණය byte[]කර එක් මෙහෙයුමක දී හැෂ් ගණනය කරන්න md.digest(bytes).
• ඇමතුමකින් MessageDigestවරකට එක byte[]කැබැල්ලක් පෝෂණය කරන්න md.update(bytes). ආදාන බයිට් එකතු කිරීම ඔබ අවසන් කළ විට, සමඟ හැෂ් ගණනය කරන්න md.digest().

මෙම byte[]විසින් ලබා md.digest()තුළ MD5 හැෂ් වේ.

මෙම MessageDigestපන්ති තුළ MD5 ජීර්ණය ක උදාහරණයක් ඔබට ලබා ගත හැක.

නූල් සහ ක්‍රිප්ටෝ පංති සමඟ වැඩ කරන විට ඔබට බයිට් නිරූපණය අවශ්‍ය කේතන ක්‍රමය සැමවිටම සඳහන් කිරීමට වග බලා ගන්න . ඔබ එය භාවිතා කරන්නේ නම් string.getBytes()එය වේදිකා පෙරනිමිය භාවිතා කරයි. (සියලුම වේදිකා එකම පෙරනිමි භාවිතා නොකරයි)

import java.security.*;

..

byte[] bytesOfMessage = yourString.getBytes("UTF-8");

MessageDigest md = MessageDigest.getInstance("MD5");
byte[] thedigest = md.digest(bytesOfMessage);

ඔබ සතුව දත්ත විශාල ප්‍රමාණයක් තිබේ .update(byte[])නම් නැවත නැවත කැඳවිය හැකි ක්‍රමය දෙස බලන්න . ඉන්පසු .digest()ලැබෙන හැෂ් ලබා ගැනීමට අමතන්න .

ඔබට ඇත්ත වශයෙන්ම පිළිතුර බයිට් අරාවකට වඩා නූලක් ලෙස අවශ්‍ය නම්, ඔබට සැමවිටම මෙවැනි දෙයක් කළ හැකිය:

String plaintext = "your text here";
MessageDigest m = MessageDigest.getInstance("MD5");
m.reset();
m.update(plaintext.getBytes());
byte[] digest = m.digest();
BigInteger bigInt = new BigInteger(1,digest);
String hashtext = bigInt.toString(16);
// Now we need to zero pad it if you actually want the full 32 chars.
while(hashtext.length() < 32 ){
  hashtext = "0"+hashtext;
}

MD5 හෝ SHA ජීර්ණයන් නිර්මාණය කිරීම සඳහා ඉතා පහසු ක්‍රම සපයන අපාචේ කොමන්ස් කෝඩෙක් ව්‍යාපෘතියේ ඩයිජෙස්ටිල්ස් පන්තිය දෙස බැලීමටද ඔබට අවශ්‍ය විය හැකිය .

මෙය හමු විය:

public String MD5(String md5) {
   try {
        java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
        byte[] array = md.digest(md5.getBytes());
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < array.length; ++i) {
          sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1,3));
       }
        return sb.toString();
    } catch (java.security.NoSuchAlgorithmException e) {
    }
    return null;
}

පහත වෙබ් අඩවියේ, මම ඒ සඳහා කිසිදු ගෞරවයක් නොගනිමි, නමුත් එය ක්‍රියාත්මක වන විසඳුමකි! මට වෙනත් කේත බොහොමයක් නිසියාකාරව ක්‍රියාත්මක නොවූ නිසා, මම හැෂ් හි 0s අතුරුදහන් විය. මෙය PHP සතුව ඇති ආකාරයටම පෙනේ. මූලාශ්‍රය: http://m2tec.be/blog/2010/02/03/java-md5-hex-0093

මෙන්න මම එය භාවිතා කරන ආකාරය:

final MessageDigest messageDigest = MessageDigest.getInstance("MD5");
messageDigest.reset();
messageDigest.update(string.getBytes(Charset.forName("UTF8")));
final byte[] resultByte = messageDigest.digest();
final String result = new String(Hex.encodeHex(resultByte));

hex යනු: org.apache.commons.codec.binary.Hexවෙතින් Apache Commons ව්යාපෘතිය .

මම දැන් commons-codec.jar බාගත කර md5 වැනි පරිපූර්ණ php ලබා ගත්තා. මෙන්න අත්පොත .

එය ඔබේ ව්‍යාපෘතියට ආනයනය කර භාවිතා කරන්න

String Url = "your_url";

System.out.println( DigestUtils.md5Hex( Url ) );

එහි ඔබට එය තිබේ.

මෙය කිරීමට වඩාත්ම පැහැදිලි හා සංක්ෂිප්ත ක්‍රමය ලෙස මම සොයාගෙන ඇත:

MessageDigest md5 = MessageDigest.getInstance("MD5");
md5.update(StandardCharsets.UTF_8.encode(string));
return String.format("%032x", new BigInteger(1, md5.digest()));

එම්ඩී 5 හැෂ් එකකින් සංගීත නිරූපණයක් ලබා ගැනීමේදී වඩා පිරිසිදු වන මෙම විසඳුම සොයා ගන්නා ලදී.

import java.security.*;
import java.math.*;

public class MD5 {
    public static void main(String args[]) throws Exception{
        String s="This is a test";
        MessageDigest m=MessageDigest.getInstance("MD5");
        m.update(s.getBytes(),0,s.length());
        System.out.println("MD5: "+new BigInteger(1,m.digest()).toString(16));
    }
}

කේතය මෙතැනින් උපුටා ගන්නා ලදි .

තවත් ක්‍රියාත්මක කිරීම:

import javax.xml.bind.DatatypeConverter;

String hash = DatatypeConverter.printHexBinary( 
           MessageDigest.getInstance("MD5").digest("SOMESTRING".getBytes("UTF-8")));

තවත් විකල්පයක් වන්නේ ගුවා හැෂිං ක්‍රම භාවිතා කිරීමයි :

Hasher hasher = Hashing.md5().newHasher();
hasher.putString("my string");
byte[] md5 = hasher.hash().asBytes();

හැන්ඩි ඔබ දැනටමත් ගුවා භාවිතා කරන්නේ නම් (ඔබ එසේ නොවේ නම්, ඔබ එසේ විය යුතුය).

සරල පෙළ හැෂ් ආකාරයෙන් හැඩතල ගැන්වීමට මට පංතියක් (හැෂ්) ඇත: md5 හෝ sha1, php ක්‍රියා කරන සමාන ( md5 , sha1 ):

public class Hash {
    /**
     * 
     * @param txt, text in plain format
     * @param hashType MD5 OR SHA1
     * @return hash in hashType 
     */
    public static String getHash(String txt, String hashType) {
        try {
                    java.security.MessageDigest md = java.security.MessageDigest.getInstance(hashType);
                    byte[] array = md.digest(txt.getBytes());
                    StringBuffer sb = new StringBuffer();
                    for (int i = 0; i < array.length; ++i) {
                        sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1,3));
                 }
                    return sb.toString();
            } catch (java.security.NoSuchAlgorithmException e) {
                //error action
            }
            return null;
    }

    public static String md5(String txt) {
        return Hash.getHash(txt, "MD5");
    }

    public static String sha1(String txt) {
        return Hash.getHash(txt, "SHA1");
    }
}

JUnit සහ PHP සමඟ පරීක්ෂා කිරීම

PHP පිටපත:

<?php

echo 'MD5 :' . md5('Hello World') . "\n";
echo 'SHA1:' . sha1('Hello World') . "\n";

ප්‍රතිදාන PHP පිටපත:

MD5 :b10a8db164e0754105b7a99be72e3fe5
SHA1:0a4d55a8d778e5022fab701977c5d840bbc486d0

උදාහරණය භාවිතා කිරීම සහ ජුනිට් සමඟ පරීක්ෂා කිරීම:

    public class HashTest {

    @Test
    public void test() {
        String txt = "Hello World";
        assertEquals("b10a8db164e0754105b7a99be72e3fe5", Hash.md5(txt));
        assertEquals("0a4d55a8d778e5022fab701977c5d840bbc486d0", Hash.sha1(txt));
    }

}

GitHub හි කේතය

https://github.com/fitorec/java-hashes

එය ඕනෑවට වඩා සංකීර්ණ කිරීමට අවශ්‍ය නැත.
ඩයිජෙස්ටිල්ස් හොඳින් ක්‍රියා කරන අතර md5හැෂ් සමඟ වැඩ කරන විට ඔබට සුවපහසු වේ.

DigestUtils.md5Hex(_hash);

හෝ

DigestUtils.md5(_hash);

එක්කෝ ඔබ වැනි වෙනත් ඕනෑම දත්ත ආරක්ෂණ ක්රමයකි භාවිතා කළ හැකි shaහෝ md.

මගේ එතරම් හෙළි නොකරන පිළිතුර:

private String md5(String s) {
    try {
        MessageDigest m = MessageDigest.getInstance("MD5");
        m.update(s.getBytes(), 0, s.length());
        BigInteger i = new BigInteger(1,m.digest());
        return String.format("%1$032x", i);         
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    return null;
}

එහි වේ DigestUtilsපන්තියේ වසන්තය ද:

http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/util/DigestUtils.html

මෙම පන්තියේ කාර්යය කරන ක්‍රමය අඩංගු වේ md5DigestAsHex().

ඔබට අනුගමනය කිරීමට උත්සාහ කළ හැකිය. විස්තර සහ කේත මෙතැනින් බාගන්න: http://jkssweetlife.com/java-hashgenerator-md5-sha-1/

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5Example {

public static void main(String[] args) throws Exception {

    final String inputString = "Hello MD5";

    System.out.println("MD5 hex for '" + inputString + "' :");
    System.out.println(getMD5Hex(inputString));
}

public static String getMD5Hex(final String inputString) throws NoSuchAlgorithmException {

    MessageDigest md = MessageDigest.getInstance("MD5");
    md.update(inputString.getBytes());

    byte[] digest = md.digest();

    return convertByteToHex(digest);
}

private static String convertByteToHex(byte[] byteData) {

    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < byteData.length; i++) {
        sb.append(Integer.toString((byteData[i] & 0xff) + 0x100, 16).substring(1));
    }

    return sb.toString();
}
}

බොම්බේගේ පිළිතුර නිවැරදි ය, කෙසේ වෙතත් ඔබ නියත වශයෙන්ම MD5 භාවිතා කළ යුතු නොවේ නම් (උදා: අන්තර් ක්‍රියාකාරිත්වය සඳහා ඔබ මත බල කරනු ලැබේ), වඩා හොඳ තේරීමක් SHA1 වන බැවින් MD5 දිගුකාලීන භාවිතය සඳහා දුර්වලතා ඇත.

SHA1 හි න්‍යායාත්මක දුර්වලතා ඇති නමුත් එය එතරම් දරුණු නොවන බව මම එකතු කළ යුතුය. හැෂින් කිරීමේ වර්තමාන කලාව නම් අපේක්ෂක ප්‍රතිස්ථාපන හැෂ් ශ්‍රිත ගණනාවක් ඇති නමුත් SHA1 ප්‍රතිස්ථාපනය කිරීමේ සම්මත හොඳම ක්‍රමය ලෙස තවමත් කිසිවක් මතු වී නැත. එබැවින්, ඔබගේ අවශ්‍යතා අනුව ඔබේ හැෂ් ඇල්ගොරිතම වින්‍යාසගත කළ හැකි වන පරිදි ඔබට උපදෙස් දෙනු ඇත, එවිට එය අනාගතයේදී ප්‍රතිස්ථාපනය කළ හැකිය.

තවත් ක්‍රියාත්මක කිරීම: ජාවා හි වේගවත් MD5 ක්‍රියාත්මක කිරීම

String hash = MD5.asHex(MD5.getHash(new File(filename)));

මෙය කියවන ඕනෑම කෙනෙකුට මෙය අදාළ දැයි මම නොදනිමි, නමුත් මට අවශ්‍ය ගැටලුව මට තිබුණි

• දී ඇති URL එකකින් ගොනුවක් බාගන්න සහ
• එහි MD5 දන්නා අගයකට සංසන්දනය කරන්න.

මට එය කිරීමට අවශ්‍ය වූයේ JRE පන්ති සමඟ පමණි (Apache Commons හෝ ඊට සමාන නැත). ඉක්මන් වෙබ් සෙවුමක් මඟින් නියැදි කේත ස්නිපෙට් දෙකම එකවර කරන බවක් මට නොපෙන්වයි , එක් එක් කාර්යය වෙන වෙනම. මේ සඳහා එකම ගොනුව දෙවරක් කියවීමට අවශ්‍ය බැවින්, කාර්යයන් දෙකම ඒකාබද්ධ කරන කේතයක් ලිවීම වටී යැයි මම සිතුවෙමි, ගොනුව බාගත කරන අතරතුර මැස්ස මත චෙක්සම් ගණනය කරන්න. මෙය මගේ ප්‍රති result ලයයි (සමාවෙන්න එය පරිපූර්ණ ජාවා නොවේ නම්, නමුත් ඔබට කෙසේ හෝ අදහස ලැබෙනු ඇතැයි මම සිතමි):

import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.security.DigestOutputStream;        // new
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

void downloadFile(String fromURL, String toFile, BigInteger md5)
    throws IOException, NoSuchAlgorithmException
{
    ReadableByteChannel in = Channels.newChannel(new URL(fromURL).openStream());
    MessageDigest md5Digest = MessageDigest.getInstance("MD5");
    WritableByteChannel out = Channels.newChannel(
        //new FileOutputStream(toFile));  // old
        new DigestOutputStream(new FileOutputStream(toFile), md5Digest));  // new
    ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);  // 1 MB

    while (in.read(buffer) != -1) {
        buffer.flip();
        //md5Digest.update(buffer.asReadOnlyBuffer());  // old
        out.write(buffer);
        buffer.clear();
    }

    BigInteger md5Actual = new BigInteger(1, md5Digest.digest()); 
    if (! md5Actual.equals(md5))
        throw new RuntimeException(
            "MD5 mismatch for file " + toFile +
            ": expected " + md5.toString(16) +
            ", got " + md5Actual.toString(16)
        );
}

PHP මෙන් නොව md5 ශ්‍රිතය ඇමතීමෙන් ඔබේ පෙළෙහි MD5 හැෂිං එකක් කළ හැකිය md5($text), එනම් ජාවා හි එය ටිකක් සංකීර්ණ විය. මම සාමාන්‍යයෙන් එය ක්‍රියාත්මක කළේ md5 හෑෂ් පෙළ නැවත ලබා දෙන ශ්‍රිතයක් ඇමතීමෙනි. මෙන්න මම එය ක්‍රියාත්මක කළ ආකාරය, පළමුව md5hashingපහත දැක්වෙන පරිදි ඔබේ ප්‍රධාන පන්තිය තුළ නම් කරන ලද ශ්‍රිතයක් සාදන්න .

public static String md5hashing(String text)
    {   String hashtext = null;
        try 
        {
            String plaintext = text;
            MessageDigest m = MessageDigest.getInstance("MD5");
            m.reset();
            m.update(plaintext.getBytes());
            byte[] digest = m.digest();
            BigInteger bigInt = new BigInteger(1,digest);
            hashtext = bigInt.toString(16);
            // Now we need to zero pad it if you actually want the full 32 chars.
            while(hashtext.length() < 32 ){
              hashtext = "0"+hashtext;   
            }
        } catch (Exception e1) 
        {
            // TODO: handle exception
            JOptionPane.showMessageDialog(null,e1.getClass().getName() + ": " + e1.getMessage());   
        }
        return hashtext;     
    }

පහත දැක්වෙන පරිදි ඔබට අවශ්‍ය විටෙක ශ්‍රිතය අමතන්න.

String text = textFieldName.getText();
String pass = md5hashing(text);

PHP හි md5 හැෂිං සමඟ ගැලපෙන පරිදි හැෂ් ටෙක්ස්ට් බිංදුවක් සමඟ එකතු කර ඇති බව මෙහිදී ඔබට දැක ගත හැකිය.

පහත සබැඳිය දෙස බලන්න, උදාහරණය මඟින් සපයන ලද රූපයක MD5 හැෂ් එකක් ලැබේ : රූපයක MD5 හැෂ්

එය වටින දෙය සඳහා, COM සංරචක ස්ථාපනය කරන වැඩසටහනක් සඳහා ස්වාභාවික යතුරකින් GUID සංස්ලේෂණය කිරීමට අවශ්‍ය නිසා මම මෙය පැකිලීමි; GUID ජීවන චක්‍රය කළමනාකරණය නොකිරීමට මට සංයුක්ත කිරීමට අවශ්‍යයි. මම MD5 භාවිතා කර UUID පන්තිය භාවිතා කර එයින් නූලක් ලබා ගනිමි. (http://stackoverflow.com/questions/2190890/how-can-i-generate-guid-for-a-string-values/12867439 මෙම ගැටළුව මතු කරයි).

ඕනෑම අවස්ථාවක, java.util.UUID ඔබට MD5 බයිට් වලින් ලස්සන සංගීතයක් ලබා ගත හැකිය.

return UUID.nameUUIDFromBytes(md5Bytes).toString();

import java.security.*;
import javax.xml.bind.*;

byte[] bytesOfMessage = yourString.getBytes("UTF-8");
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] bytesOfDigest = md.digest(bytesOfMessage);
String digest = DatatypeConverter.printHexBinary(bytesOfDigest).toLowerCase();

ඔබට හොඳම ආරක්ෂාව අවශ්‍ය නොවන්නේ නම් MD5 ඉතා හොඳයි, ඔබ ගොනු අඛණ්ඩතාව පරීක්ෂා කිරීම වැනි දෙයක් කරන්නේ නම් ආරක්ෂාව සලකා බැලිය යුතු නොවේ. එවැනි අවස්ථාවකදී ඔබට ජාවා පුස්තකාලවල සහය දක්වන ඇඩ්ලර් 32 වැනි සරල හා වේගවත් යමක් සලකා බැලීමට අවශ්‍ය විය හැකිය.

මෙය mysql හි md5 ශ්‍රිතයෙන් හෝ php හි md5 ශ්‍රිත වලින් ලබා ගන්නා ආකාරයටම md5 ලබා දෙයි. මෙය මම භාවිතා කරන ක්‍රමයයි (ඔබේ අවශ්‍යතා අනුව ඔබට වෙනස් විය හැකිය)

public static String md5( String input ) {
    try {
        java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
        byte[] array = md.digest(input.getBytes( "UTF-8" ));
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < array.length; i++) {
            sb.append( String.format( "%02x", array[i]));
        }
        return sb.toString();
    } catch ( NoSuchAlgorithmException | UnsupportedEncodingException e) {
        return null;            
    }

}

මේක උත්සාහ කරන්න:

public static String getHashMD5(String string) {
    try {
        MessageDigest md = MessageDigest.getInstance("MD5");
        BigInteger bi = new BigInteger(1, md.digest(string.getBytes()));
        return bi.toString(16);
    } catch (NoSuchAlgorithmException ex) {
        Logger.getLogger(MD5Utils.class
                .getName()).log(Level.SEVERE, null, ex);

        return "";
    }
}

import java.security.MessageDigest

val digest = MessageDigest.getInstance("MD5")

//Quick MD5 of text
val text = "MD5 this text!"
val md5hash1 = digest.digest(text.getBytes).map("%02x".format(_)).mkString

//MD5 of text with updates
digest.update("MD5 ".getBytes())
digest.update("this ".getBytes())
digest.update("text!".getBytes())
val md5hash2 = digest.digest().map(0xFF & _).map("%02x".format(_)).mkString

//Output
println(md5hash1 + " should be the same as " + md5hash2)

පැකේජයේ ඇති පන්තියේ ක්‍රම භාවිතා කිරීමෙන් ඔබට දී ඇති පෙළක් සඳහා MD5 හෑෂ් උත්පාදනය කළ හැකිය . පහත දැක්වෙන්නේ සම්පූර්ණ කේත ස්නිපටය,MessageDigestjava.security

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.xml.bind.DatatypeConverter;

public class MD5HashGenerator 
{

   public static void main(String args[]) throws NoSuchAlgorithmException
   {
       String stringToHash = "MyJavaCode"; 
       MessageDigest messageDigest = MessageDigest.getInstance("MD5");
       messageDigest.update(stringToHash.getBytes());
       byte[] digiest = messageDigest.digest();
       String hashedOutput = DatatypeConverter.printHexBinary(digiest);
       System.out.println(hashedOutput);
   }
}

MD5 ශ්‍රිතයේ ප්‍රතිදානය ෂඩාස්රාකාර සංඛ්‍යා 32 කින් නියෝජනය වන බිට් 128 හැෂ් වේ.

ඔබ MySQL වැනි දත්ත සමුදායක් භාවිතා කරන්නේ නම්, ඔබට මෙය වඩාත් සරල ආකාරයකින් කළ හැකිය. විමසුම Select MD5(“text here”)වරහනෙහි ඇති පෙළෙහි MD5 හැෂ් නැවත ලබා දෙනු ඇත.

මෙය මා මෙහි පැමිණියේ- MD5 හෑෂ් නූල් නැවත ලබා දෙන පහසු පරිමාණ ශ්‍රිතයක් සඳහා ය:

def md5(text: String) : String = java.security.MessageDigest.getInstance("MD5").digest(text.getBytes()).map(0xFF & _).map { "%02x".format(_) }.foldLeft(""){_ + _}

 import java.math.BigInteger;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;

/**
* MD5 encryption
*
* @author Hongten
*
*/
public class MD5 {

 public static void main(String[] args) {
     System.out.println(MD5.getMD5("123456"));
 }

 /**
  * Use md5 encoded code value
  *
  * @param sInput
  * clearly
  * @ return md5 encrypted password
  */
 public static String getMD5(String sInput) {

     String algorithm = "";
     if (sInput == null) {
         return "null";
     }
     try {
         algorithm = System.getProperty("MD5.algorithm", "MD5");
     } catch (SecurityException se) {
     }
     MessageDigest md = null;
     try {
         md = MessageDigest.getInstance(algorithm);
     } catch (NoSuchAlgorithmException e) {
         e.printStackTrace();
     }
     byte buffer[] = sInput.getBytes();

     for (int count = 0; count < sInput.length(); count++) {
         md.update(buffer, 0, count);
     }
     byte bDigest[] = md.digest();
     BigInteger bi = new BigInteger(bDigest);
     return (bi.toString(16));
 }
}

ඒ ගැන කෝඩින්කිට් පිළිබඳ ලිපියක් තිබේ. පරීක්ෂා කරන්න: http://codingkit.com/a/JAVA/2013/1020/2216.html