Как проверить два md5

Question

Я хочу проверить 2 md5 в java!

Это мой пароль в базе данных онлайн Basic4android и результат md5 в базе данных $P$B..Th1QjN4F2nHHg8pvtT2IY8ehMPG/

Теперь в Android Studio Я хочу, чтобы проверить это.

Log.d("MD5", String.valueOf("$P$B..Th1QjN4F2nHHg8pvtT2IY8ehMPG/".equals(MD5("Basic4android")))); 

Это моя MD5 функция.

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

Но оно возвращает false.

Answer 1

Наконец, я нашел ответ сам.

С этим php класс я могу проверить простой пароль с помощью wordpress mdp.

<?php 

$wp_hasher = new PasswordHash(8, TRUE); 
$password_hashed = '$P$B/ljsoSW9uHKz9pmjZ6WiBJCZLGIv50'; 
$plain_password = 'TAHA25tt'; 

if($wp_hasher->CheckPassword($plain_password, $password_hashed)) { 
    echo "YES, Matched"; 
} else { 
    echo "No, Wrong Password"; 
} 

class PasswordHash { 
var $itoa64; 
var $iteration_count_log2; 
var $portable_hashes; 
var $random_state; 

/** 
* PHP5 constructor. 
*/ 
function __construct($iteration_count_log2, $portable_hashes) 
{ 
    $this->itoa64 = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'; 

    if ($iteration_count_log2 < 4 || $iteration_count_log2 > 31) 
     $iteration_count_log2 = 8; 
    $this->iteration_count_log2 = $iteration_count_log2; 

    $this->portable_hashes = $portable_hashes; 

    $this->random_state = microtime() . uniqid(rand(), TRUE); // removed getmypid() for compatibility reasons 
} 

/** 
* PHP4 constructor. 
*/ 
public function PasswordHash($iteration_count_log2, $portable_hashes) { 
    self::__construct($iteration_count_log2, $portable_hashes); 
} 

function get_random_bytes($count) 
{ 
    $output = ''; 
    if (@is_readable('/dev/urandom') && 
     ($fh = @fopen('/dev/urandom', 'rb'))) { 
     $output = fread($fh, $count); 
     fclose($fh); 
    } 

    if (strlen($output) < $count) { 
     $output = ''; 
     for ($i = 0; $i < $count; $i += 16) { 
      $this->random_state = 
       md5(microtime() . $this->random_state); 
      $output .= 
       pack('H*', md5($this->random_state)); 
     } 
     $output = substr($output, 0, $count); 
    } 

    return $output; 
} 

function encode64($input, $count) 
{ 
    $output = ''; 
    $i = 0; 
    do { 
     $value = ord($input[$i++]); 
     $output .= $this->itoa64[$value & 0x3f]; 
     if ($i < $count) 
      $value |= ord($input[$i]) << 8; 
     $output .= $this->itoa64[($value >> 6) & 0x3f]; 
     if ($i++ >= $count) 
      break; 
     if ($i < $count) 
      $value |= ord($input[$i]) << 16; 
     $output .= $this->itoa64[($value >> 12) & 0x3f]; 
     if ($i++ >= $count) 
      break; 
     $output .= $this->itoa64[($value >> 18) & 0x3f]; 
    } while ($i < $count); 

    return $output; 
} 

function gensalt_private($input) 
{ 
    $output = '$P$'; 
    $output .= $this->itoa64[min($this->iteration_count_log2 + 
     ((PHP_VERSION >= '5') ? 5 : 3), 30)]; 
    $output .= $this->encode64($input, 6); 

    return $output; 
} 

function crypt_private($password, $setting) 
{ 
    $output = '*0'; 
    if (substr($setting, 0, 2) == $output) 
     $output = '*1'; 

    $id = substr($setting, 0, 3); 
    # We use "$P$", phpBB3 uses "$H$" for the same thing 
    if ($id != '$P$' && $id != '$H$') 
     return $output; 

    $count_log2 = strpos($this->itoa64, $setting[3]); 
    if ($count_log2 < 7 || $count_log2 > 30) 
     return $output; 

    $count = 1 << $count_log2; 

    $salt = substr($setting, 4, 8); 
    if (strlen($salt) != 8) 
     return $output; 

    # We're kind of forced to use MD5 here since it's the only 
    # cryptographic primitive available in all versions of PHP 
    # currently in use. To implement our own low-level crypto 
    # in PHP would result in much worse performance and 
    # consequently in lower iteration counts and hashes that are 
    # quicker to crack (by non-PHP code). 
    if (PHP_VERSION >= '5') { 
     $hash = md5($salt . $password, TRUE); 
     do { 
      $hash = md5($hash . $password, TRUE); 
     } while (--$count); 
    } else { 
     $hash = pack('H*', md5($salt . $password)); 
     do { 
      $hash = pack('H*', md5($hash . $password)); 
     } while (--$count); 
    } 

    $output = substr($setting, 0, 12); 
    $output .= $this->encode64($hash, 16); 

    return $output; 
} 

function gensalt_extended($input) 
{ 
    $count_log2 = min($this->iteration_count_log2 + 8, 24); 
    # This should be odd to not reveal weak DES keys, and the 
    # maximum valid value is (2**24 - 1) which is odd anyway. 
    $count = (1 << $count_log2) - 1; 

    $output = '_'; 
    $output .= $this->itoa64[$count & 0x3f]; 
    $output .= $this->itoa64[($count >> 6) & 0x3f]; 
    $output .= $this->itoa64[($count >> 12) & 0x3f]; 
    $output .= $this->itoa64[($count >> 18) & 0x3f]; 

    $output .= $this->encode64($input, 3); 

    return $output; 
} 

function gensalt_blowfish($input) 
{ 
    # This one needs to use a different order of characters and a 
    # different encoding scheme from the one in encode64() above. 
    # We care because the last character in our encoded string will 
    # only represent 2 bits. While two known implementations of 
    # bcrypt will happily accept and correct a salt string which 
    # has the 4 unused bits set to non-zero, we do not want to take 
    # chances and we also do not want to waste an additional byte 
    # of entropy. 
    $itoa64 = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'; 

    $output = '$2a$'; 
    $output .= chr(ord('0') + $this->iteration_count_log2/10); 
    $output .= chr(ord('0') + $this->iteration_count_log2 % 10); 
    $output .= '$'; 

    $i = 0; 
    do { 
     $c1 = ord($input[$i++]); 
     $output .= $itoa64[$c1 >> 2]; 
     $c1 = ($c1 & 0x03) << 4; 
     if ($i >= 16) { 
      $output .= $itoa64[$c1]; 
      break; 
     } 

     $c2 = ord($input[$i++]); 
     $c1 |= $c2 >> 4; 
     $output .= $itoa64[$c1]; 
     $c1 = ($c2 & 0x0f) << 2; 

     $c2 = ord($input[$i++]); 
     $c1 |= $c2 >> 6; 
     $output .= $itoa64[$c1]; 
     $output .= $itoa64[$c2 & 0x3f]; 
    } while (1); 

    return $output; 
} 

function HashPassword($password) 
{ 
    if (strlen($password) > 4096) { 
     return '*'; 
    } 

    $random = ''; 

    if (CRYPT_BLOWFISH == 1 && !$this->portable_hashes) { 
     $random = $this->get_random_bytes(16); 
     $hash = 
      crypt($password, $this->gensalt_blowfish($random)); 
     if (strlen($hash) == 60) 
      return $hash; 
    } 

    if (CRYPT_EXT_DES == 1 && !$this->portable_hashes) { 
     if (strlen($random) < 3) 
      $random = $this->get_random_bytes(3); 
     $hash = 
      crypt($password, $this->gensalt_extended($random)); 
     if (strlen($hash) == 20) 
      return $hash; 
    } 

    if (strlen($random) < 6) 
     $random = $this->get_random_bytes(6); 
    $hash = 
     $this->crypt_private($password, 
     $this->gensalt_private($random)); 
    if (strlen($hash) == 34) 
     return $hash; 

    # Returning '*' on error is safe here, but would _not_ be safe 
    # in a crypt(3)-like function used _both_ for generating new 
    # hashes and for validating passwords against existing hashes. 
    return '*'; 
} 

function CheckPassword($password, $stored_hash) 
{ 
    if (strlen($password) > 4096) { 
     return false; 
    } 

    $hash = $this->crypt_private($password, $stored_hash); 
    if ($hash[0] == '*') 
     $hash = crypt($password, $stored_hash); 

    return $hash === $stored_hash; 
} 
} 

?> 

Answer 2

ваша админка то, что это принесет это неправильно, MD5 не может быть, как это «$ P $ B..Th1QjN4F2nHHg8pvtT2IY8ehMPG /», как вы вывесили убедитесь, что его не base64 или другая Algos,

в Java вы можете использовать эта функция используется для получения MD5 строки

public static final String getmd5ofstring(final String s) { 
     final String MD5 = "MD5"; 
     try { 
      // Create MD5 Hash 
      MessageDigest digest = java.security.MessageDigest 
        .getInstance(MD5); 
      digest.update(s.getBytes()); 
      byte messageDigest[] = digest.digest(); 

      // Create Hex String 
      StringBuilder hexString = new StringBuilder(); 
      for (byte aMessageDigest : messageDigest) { 
       String h = Integer.toHexString(0xFF & aMessageDigest); 
       while (h.length() < 2) 
        h = "0" + h; 
       hexString.append(h); 
      } 
      return hexString.toString().toUpparCase(Locale.US); // return md5 

     } catch (NoSuchAlgorithmException e) { 
      e.printStackTrace(); 
     } 
     return ""; 
    } 

, когда вы прошли, например

String firstmd5 = getmd5ofstring("Basic4android"); // get first md5 
String loadyousecondmd5here = ("ur md5 here the second one u want to compare").toUpparCase(Locale.US); 

if (firstmd5.equals(loadyousecondmd5here)){ 
// its equal 
} 

сделано