Файл: IPBMafia.ru_IPB_3.4.6_Final_Rus _Nulled/board/upload/admin/sources/loginauth/convert/newauth.php
Строк: 1278
<?php
/**
* IPS Converters
* Application Files
* Login functions
* Last Updated: $Date: 2013-09-04 23:08:17 -0400 (Wed, 04 Sep 2013) $
*
* @author $Author: rashbrook $
* @copyright (c) 2006 - 2009 Invision Power Services, Inc.
* @package IPS Converters
* @link http://www.invisionpower.com
* @version $Revision: 12342 $
*/
class converters
{
/**
* Constructor
*
* @param ipsRegistry
* @return @e void
**/
public function __construct(ipsRegistry $registry, $parent)
{
$this->registry = $registry;
$this->DB = $this->registry->DB();
$this->settings =& $this->registry->fetchSettings();
$this->request =& $this->registry->fetchRequest();
$this->parent = $parent;
$this->lang = $this->registry->getClass('class_localization');
$this->registry->getClass( 'class_localization' )->loadLanguageFile( array( 'public_clobal' ), 'core' );
}
/**
* Work out which function to use
**/
public function go($username, $email, $password)
{
$success = false;
$this->parent->loadMember($username);
$this->DB->build(array('select' => 'app_key', 'from' => 'conv_apps', 'where' => 'login=1'));
$this->DB->execute();
$cycle = array();
while ($r = $this->DB->fetch())
{
$cycle[$r['app_key']] = $r['app_key'];
}
foreach ($cycle as $sw)
{
if ($this->$sw($username, $email, $password))
{
$success = true;
break; //already true, skip other possible checks
}
}
if( $success )
{
// Give them an IPB style password
$this->parent->cleanConvertData( md5($password) );
// Force the log in
require_once( IPS_ROOT_PATH . 'sources/handlers/han_login.php' );/*noLibHook*/
$this->han_login = new han_login( $this->registry );
$this->han_login->loginWithoutCheckingCredentials($this->parent->_memberData['member_id']);
// And form our own redirect
$this->registry->getClass('output')->redirectScreen( $this->lang->words['partial_login'] , $this->settings['base_url'] );
}
else
{
unset($this->parent->_memberData);
return "WRONG_AUTH";
}
}
private function aef ( $username, $email, $password )
{
if ( $this->parent->_memberData['conv_password'] == md5 ( $this->parent->_memberData['misc'] . $password ) )
{
return true;
}
else
{
return false;
}
}
/**
* BBPress
**/
private function bbpress_standalone($username, $email, $password)
{
return $this->bbpress($username, $email, $password);
}
private function bbpress($username, $email, $password)
{
$hash = $this->parent->_memberData['conv_password'];
if ( strlen( $hash ) == 32 )
{
return (bool) ( md5( $password ) == $this->parent->_memberData['conv_password'] );
}
$itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
$crypt = $this->parent->hashCryptPrivate($password, $hash, $itoa64, 'P');
if ($crypt[0] == '*')
{
$crypt = crypt( $password, $hash );
}
return $crypt == $hash ? TRUE : FALSE;
}
private function bbpress23($username, $email, $password)
{
$password = html_entity_decode( $password );
$success = $this->bbpress( $username, $email, $password );
// Did it work?
if ( ! $success )
{
// No - check against WordPress.
// Note to self - perhaps push this to main bbpress method.
$success = $this->wordpress( $username, $email, $password );
}
return $success;
}
/**
* Community Server authentication
*
* @access private
* @param string Username
* @param string Password
* @return boolean Successful
*/
private function cs( $username, $password )
{
$hash = $this->parent->_memberData['conv_password'];
$encodedHashPass = base64_encode(pack("H*", sha1(base64_decode($this->parent->_memberData['misc']) . $password)));
$single_md5_pass = md5( $password );
if ($encodedHashPass == $hash)
{
$this->return_code = "SUCCESS";
return true;
}
else
{
$this->return_code = "WRONG_AUTH";
return false;
}
}
function CSAuth($username, $password)
{
$wsdl = 'https://internal.auth.com/Service.asmx?wsdl';
$dest = 'https://interal.auth.com/Service.asmx';
$single_md5_pass = md5( $password );
try
{
$client = new SoapClient($wsdl, array('trace' => 1));
$client->__setLocation($dest);
$loginparams = array('username' => $username, 'password' => $password);
$result = $client->AuthCS($loginparams);
switch ( $result->AuthCSResult )
{
case 'SUCCESS':
$this->cleanConvertData( $single_md5_pass );
$this->return_code = $result->AuthCSResult;
return TRUE;
case 'WRONG_AUTH':
$this->return_code = $result->AuthCSResult;
return FALSE;
default:
$this->return_code = 'FAIL';
return FALSE;
}
}
catch(Exception $ex)
{
//handle error
$this->return_code = 'FAIL';
return FALSE;
}
}
/**
* FudForum
**/
private function fudforum($username, $email, $password)
{
$success = false;
$single_md5_pass = md5( $password );
$hash = $this->parent->_memberData['conv_password'];
if (strlen($hash) == 40)
{
$success = (sha1($this->parent->_memberData['misc'] . sha1($password)) === $hash) ? true : false;
}
else
{
$success = ($single_md5_pass === $hash) ? true : false;
}
return $success;
}
/**
* Ikonboard
**/
private function ikonboard($username, $email, $password)
{
if ( $this->parent->_memberData['conv_password'] == crypt( $password, $this->parent->_memberData['misc'] ) )
{
return true;
}
else if ( $this->parent->_memberData['conv_password'] == md5( $password . $username ) )
{
return true;
}
else
{
return false;
}
}
/**
* Joomla!
*/
private function joomla ( $username, $email, $password )
{
if ( $this->parent->_memberData['conv_password'] == md5 ( $password . $this->parent->_memberData['misc'] ) )
{
return true;
}
else
{
return false;
}
}
/**
* Kunena
*/
private function kunena ( $username, $email, $password )
{
// Kunena authenticates using internal Joomla functions.
// This is required, however, if the member only converts from
// Kunena and not Joomla + Kunena.
return $this->joomla ( $username, $email, $password );
}
/**
* PHPBB
**/
private function phpbb($username, $email, $password)
{
//$password = $_POST['password'] ? $_POST['password'] : $password;
$password = html_entity_decode( $password );
$success = false;
$single_md5_pass = md5( $password );
$hash = $this->parent->_memberData['conv_password'];
$itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
if (strlen($hash) == 34)
{
$success = ($this->parent->hashCryptPrivate($password, $hash, $itoa64) === $hash) ? true : false;
}
else
{
$success = ($single_md5_pass === $hash) ? true : false;
}
// Are we successful? If not - make sure the board hasn't been upgraded from phpBB2 and the user
// just hasn't logged in yet to get their pass converted to phpBB3 format.
if ( ! $success )
{
$success = ( $this->parent->hashCryptPrivate( $single_md5_hash, $hash, $itoa64 ) === $hash ? true : false );
}
return $success;
}
/**
* PHPBB Legacy (2.x)
**/
private function phpbb_legacy($username, $email, $password)
{
return $this->phpbb($username, $email, $password);
}
/**
* Vanilla
**/
private function vanilla($username, $email, $password)
{
if ($this->parent->_memberData['conv_password'] == md5(md5(str_replace(''', "'", html_entity_decode($password))) . $this->parent->_memberData['misc']))
{
return true;
}
else
{
return false;
}
}
/**
* vBulletin 5
**/
private function vb5connect($username, $email, $password)
{
return $this->vbulletin($username, $email, $password);
}
/**
* vBulletin 4
**/
private function vbulletin($username, $email, $password)
{
$password = html_entity_decode( $password );
if ($this->parent->_memberData['conv_password'] == md5(md5(str_replace(''', "'", $password)) . $this->parent->_memberData['misc']))
{
return true;
}
else
{
return false;
}
}
/**
* vBulletin Legacy (3.8)
**/
private function vbulletin_legacy($username, $email, $password)
{
return $this->vbulletin($username, $email, $password);
}
/**
* vBulletin Legacy (3.6)
**/
private function vbulletin_legacy36($username, $email, $password)
{
return $this->vbulletin($username, $email, $password);
}
/**
* MyBB
**/
private function mybb($username, $email, $password)
{
if ($this->parent->_memberData['conv_password'] == md5(md5($this->parent->_memberData['misc']) . md5($password)))
{
return true;
}
else
{
return false;
}
}
/**
* SMF
**/
private function smf($username, $email, $password)
{
if($this->parent->_memberData['conv_password'] == sha1(strtolower($username) . html_entity_decode($password)))
{
return true;
}
else if($this->parent->_memberData['conv_password'] == sha1(strtolower($username) . $password))
{
return true;
}
else
{
return false;
}
}
/**
* SMF LEGACY
**/
private function smf_legacy($username, $email, $password)
{
if(sha1(strtolower($username) . $password) == $this->parent->_memberData['conv_password'])
{
return true;
}
else
{
return false;
}
}
/**
* WOLTLAB
**/
private function woltlab($username, $email, $password)
{
if ( $this->parent->_memberData['conv_password'] == sha1( $this->parent->_memberData['misc'] . sha1( $this->parent->_memberData['misc'] . sha1($password) ) ) )
{
return true;
}
else
{
return false;
}
}
/**
* WebWiz 8.X authentication
*
* @access private
* @param string Username
* @param string Password
* @return boolean Successful
*/
private function webwiz( $username, $email, $password )
{
$success = false;
if ( webWizAuth::HashEncode($password . $this->parent->_memberData['misc']) == $this->parent->_memberData['conv_password'] )
{
$success = true;
}
return $success;
}
/**
* XenForo authentication
*
* @access private
* @param string Username
* @param string Email
* @param string Password
* @return boolean Successful
*/
private function xenforo( $username, $email, $password )
{
$password = html_entity_decode ( $password );
if ( extension_loaded( 'hash' ) )
{
$hashedPassword = hash( 'sha256', hash( 'sha256', $password ) . $this->parent->_memberData['misc'] );
}
else
{
$hashedPassword = sha1( sha1( $password ) . $this->parent->_memberData['misc'] );
}
if ( $this->parent->_memberData['conv_password'] == $hashedPassword )
{
return true;
}
else
{
// No match. We may have converted from vBulletin > XF > IPB, so let's try there as a last ditch attempt.
// Doesn't make sense to me but whatever.
if ( $this->vbulletin( $username, $email, $password ) )
{
return true;
}
else
{
return false;
}
}
}
/*
* CUSTOM - 607195
*/
private function custom_607195($username, $email, $password)
{
$pass_info = unserialize( $this->parent->_memberData['misc'] );
$clef = $pass_info[0];
$chaine = $pass_info[1];
$pwd_base = $this->parent->_memberData['conv_password'];
$pwd_base = $this->decrypterChaine($pwd_base,$clef,$chaine);
if ( $pwd_base == $password )
{
return TRUE;
}
else
{
return FALSE;
}
}
private function decrypterChaine($p_strChaine, $p_strClee, $p_strSubst)
{
$strChaine = $p_strChaine;
$intLng = strlen($strChaine);
$intLngCle = strlen($p_strClee);
$intCpt2 = 0;
// On remplace les lettres par des chiffres
for ($intCpt = 0; $intCpt < 10 ; $intCpt++)
{
$strChaine = str_replace(substr($p_strSubst, $intCpt, 1), $intCpt, $strChaine);
}
for ($intCpt = 0 ; $intCpt < $intLng ; $intCpt += 3)
{
$intCarStr = substr($strChaine, $intCpt, 3);
$intCle = ord(substr($p_strClee, $intCpt2, 1));
$intCar = $intCarStr ^ $intCle;
$strCar = chr($intCar);
if (isset($strRes)) {
$strRes = $strRes . $strCar;
} else {
$strRes = $strCar;
}
if ($intCpt2 >= $intLngCle) {
$intCpt2 = 0;
} else {
$intCpt2++;
}
}
return $strRes;
}
/**
* PHP-Fusion
*/
private function phpfusion($username, $email, $password)
{
return (bool) md5( md5( $password ) ) == $this->parent->_memberData['conv_password'];
}
/**
* punBB
*/
private function fluxbb($username, $email, $password)
{
$success = false;
$hash = $this->parent->_memberData['conv_password'];
if ( strlen($hash) == 40 )
{
if ( $hash == sha1($this->parent->_memberData['misc'].sha1($password)) )
{
$success = true;
}
elseif ( $hash == sha1($password) )
{
$success = true;
}
}
else
{
$success = ( md5($password) == $hash ) ? true : false;
}
return $success;
}
/**
* punBB
*/
private function punbb($username, $email, $password)
{
$success = false;
$hash = $this->parent->_memberData['conv_password'];
if ( strlen($hash) == 40 )
{
if ( $hash == sha1($this->parent->_memberData['misc'].sha1($password)) )
{
$success = true;
}
elseif ( $hash == sha1($password) )
{
$success = true;
}
}
else
{
$success = ( md5($password) == $hash ) ? true : false;
}
return $success;
}
/**
* SimplePress Forum (link for wordpress)
*/
private function simplepress($username, $email, $password)
{
return $this->wordpress($username, $email, $password);
}
private function ubbthreads($username, $email, $password)
{
$hash = $this->parent->_memberData['members_pass_hash'];
$salt = $this->parent->_memberData['members_pass_salt'];
if ( md5( $password ) == $hash )
{
return true;
}
// Not using md5, UBB salts the password with the password
// IPB already md5'd it though, *sigh*
if ( md5( md5( $salt ) . crypt( $password, $password ) ) == $hash )
{
return true;
}
// Now standard IPB check.
if ( md5( md5( $salt ) . md5( $password ) ) == $hash )
{
return true;
}
return false;
}
/**
* Wordpress (Blog)
*/
private function wordpress($username, $email, $password)
{
$success = FALSE;
$password = ( trim($_POST['password']) != '' ) ? trim($_POST['password']) : $password;
// If the hash is still md5...
if ( strlen($this->parent->_memberData['conv_password']) <= 32 )
{
$success = ( $this->parent->_memberData['conv_password'] == md5($password) ) ? TRUE : FALSE;
}
// New pass hash check
else
{
// Init the pass class
$ph = new PasswordHash(8, TRUE);
// Check it
$success = $ph->CheckPassword($password, $this->parent->_memberData['conv_password']) ? TRUE : FALSE;
}
return $success;
}
}
/**
* Portable PHP password hashing framework.
* @package phpass
* @since 2.5
* @version 0.1
* @link http://www.openwall.com/phpass/
*/
#
# Written by Solar Designer <solar at openwall.com> in 2004-2006 and placed in
# the public domain.
#
# There's absolutely no warranty.
#
# Please be sure to update the Version line if you edit this file in any way.
# It is suggested that you leave the main version number intact, but indicate
# your project name (after the slash) and add your own revision information.
#
# Please do not change the "private" password hashing method implemented in
# here, thereby making your hashes incompatible. However, if you must, please
# change the hash type identifier (the "$P$") to something different.
#
# Obviously, since this code is in the public domain, the above are not
# requirements (there can be none), but merely suggestions.
#
// This is needed for the SimplePress Forum login and for any other login based on this class (wordpress, bbpress, etc)
class PasswordHash {
var $itoa64;
var $iteration_count_log2;
var $portable_hashes;
var $random_state;
function PasswordHash($iteration_count_log2, $portable_hashes)
{
$this->itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
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() . (function_exists('getmypid') ? getmypid() : '') . uniqid(rand(), TRUE);
}
function get_random_bytes($count)
{
$output = '';
if (($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';
if (substr($setting, 0, 3) != '$P$')
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 = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
$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)
{
$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)
{
$hash = $this->crypt_private($password, $stored_hash);
if ($hash[0] == '*')
$hash = crypt($password, $stored_hash);
return $hash == $stored_hash;
}
}
class webWizAuth {
static public function HashEncode($strSecret)
{
if (strlen($strSecret) == 0 || strlen($strSecret) >= pow(2,61)) {
return "0000000000000000000000000000000000000000";
break;
}
//Initial Hex words are used for encoding Digest.
//These can be any valid 8-digit hex value (0 to F)
$strH[0]="FB0C14C2";
$strH[1]="9F00AB2E";
$strH[2]="991FFA67";
$strH[3]="76FA2C3F";
$strH[4]="ADE426FA";
for ($intPos=1; $intPos<=strlen($strSecret); $intPos=$intPos+56)
{
$strEncode=substr($strSecret,$intPos-1,56); //get 56 character chunks
$strEncode= self::WordToBinary($strEncode); //convert to binary
$strEncode= self::PadBinary($strEncode); //make it 512 bites
$strEncode= self::BlockToHex($strEncode); //convert to hex value
//Encode the hex value using the previous runs digest
//If it is the first run then use the initial values above
$strEncode= self::DigestHex($strEncode,$strH[0],$strH[1],$strH[2],$strH[3],$strH[4]);
//Combine the old digest with the new digest
$strH[0]= self::HexAdd(substr($strEncode,0,8),$strH[0]);
$strH[1]= self::HexAdd(substr($strEncode,8,8),$strH[1]);
$strH[2]= self::HexAdd(substr($strEncode,16,8),$strH[2]);
$strH[3]= self::HexAdd(substr($strEncode,24,8),$strH[3]);
$strH[4]= self::HexAdd(substr($strEncode,strlen($strEncode)-(8)),$strH[4]);
}
//This is the final Hex Digest
$function_ret=$strH[0].$strH[1].$strH[2].$strH[3].$strH[4];
return $function_ret;
}
private function HexToBinary($btHex)
{
switch ($btHex)
{
case "0":
$function_ret="0000";
break;
case "1":
$function_ret="0001";
break;
case "2":
$function_ret="0010";
break;
case "3":
$function_ret="0011";
break;
case "4":
$function_ret="0100";
break;
case "5":
$function_ret="0101";
break;
case "6":
$function_ret="0110";
break;
case "7":
$function_ret="0111";
break;
case "8":
$function_ret="1000";
break;
case "9":
$function_ret="1001";
break;
case "A":
$function_ret="1010";
break;
case "B":
$function_ret="1011";
break;
case "C":
$function_ret="1100";
break;
case "D":
$function_ret="1101";
break;
case "E":
$function_ret="1110";
break;
case "F":
$function_ret="1111";
break;
default:
$function_ret="2222";
break;
}
return $function_ret;
}
private function BinaryToHex($strBinary)
{
switch ($strBinary)
{
case "0000":
$function_ret="0";
break;
case "0001":
$function_ret="1";
break;
case "0010":
$function_ret="2";
break;
case "0011":
$function_ret="3";
break;
case "0100":
$function_ret="4";
break;
case "0101":
$function_ret="5";
break;
case "0110":
$function_ret="6";
break;
case "0111":
$function_ret="7";
break;
case "1000":
$function_ret="8";
break;
case "1001":
$function_ret="9";
break;
case "1010":
$function_ret="A";
break;
case "1011":
$function_ret="B";
break;
case "1100":
$function_ret="C";
break;
case "1101":
$function_ret="D";
break;
case "1110":
$function_ret="E";
break;
case "1111":
$function_ret="F";
break;
default:
$function_ret="Z";
break;
}
return $function_ret;
}
private function WordToBinary($strWord)
{
$strBinary = '';
for ($intPos=1; $intPos<=strlen($strWord); $intPos=$intPos+1)
{
$strTemp=substr($strWord,intval($intPos)-1,1);
$strBinary=$strBinary . self::IntToBinary(ord($strTemp));
}
return $strBinary;
}
private function IntToBinary($intNum)
{
$intNew=$intNum;
$strBinary='';
while($intNew>1)
{
$dblNew=doubleval($intNew)/2;
$intNew=round(doubleval($dblNew) - 0.1, 0);
if (doubleval($dblNew)==doubleval($intNew))
{
$strBinary="0".$strBinary;
} else {
$strBinary="1".$strBinary;
}
}
$strBinary=$intNew.$strBinary;
$intTemp=strlen($strBinary)%8;
for ($intNew=$intTemp; $intNew<=7; $intNew=$intNew+1)
{
$strBinary="0".$strBinary;
}
return $strBinary;
}
private function PadBinary($strBinary)
{
$intLen=strlen($strBinary);
$strBinary=$strBinary."1";
for ($intPos=strlen($strBinary); $intPos<=447; $intPos=$intPos+1)
{
$strBinary=$strBinary."0";
}
$strTemp= self::IntToBinary($intLen);
for ($intPos=strlen($strTemp); $intPos<=63; $intPos=$intPos+1)
{
$strTemp="0".$strTemp;
}
return $strBinary.$strTemp;
}
private function BlockToHex($strBinary)
{
$strHex = '';
for ($intPos=1; $intPos<=strlen($strBinary); $intPos=$intPos+4)
{
$strHex=$strHex . self::BinaryToHex(substr($strBinary,$intPos-1,4));
}
return $strHex;
}
private function DigestHex($strHex,$strH0,$strH1,$strH2,$strH3,$strH4)
{
//Constant hex words are used for encryption, these can be any valid 8 digit hex value
$strK[0]="5A827999";
$strK[1]="6ED9EBA1";
$strK[2]="8F1BBCDC";
$strK[3]="CA62C1D6";
//Hex words are used in the encryption process, these can be any valid 8 digit hex value
$strH[0]=$strH0;
$strH[1]=$strH1;
$strH[2]=$strH2;
$strH[3]=$strH3;
$strH[4]=$strH4;
//divide the Hex block into 16 hex words
for ($intPos=0; $intPos<=(strlen($strHex)/8)-1; $intPos=$intPos+1)
{
$strWords[intval($intPos)]=substr($strHex,(intval($intPos)*8)+1-1,8);
}
//encode the Hex words using the constants above
//innitialize 80 hex word positions
for ($intPos=16; $intPos<=79; $intPos=$intPos+1)
{
$strTemp=$strWords[intval($intPos)-3];
$strTemp1= self::HexBlockToBinary($strTemp);
$strTemp=$strWords[intval($intPos)-8];
$strTemp2= self::HexBlockToBinary($strTemp);
$strTemp=$strWords[intval($intPos)-14];
$strTemp3= self::HexBlockToBinary($strTemp);
$strTemp=$strWords[intval($intPos)-16];
$strTemp4= self::HexBlockToBinary($strTemp);
$strTemp= self::BinaryXOR($strTemp1,$strTemp2);
$strTemp= self::BinaryXOR($strTemp,$strTemp3);
$strTemp= self::BinaryXOR($strTemp,$strTemp4);
$strWords[intval($intPos)]= self::BlockToHex( self::BinaryShift($strTemp,1));
}
//initialize the changing word variables with the initial word variables
$strA[0]=$strH[0];
$strA[1]=$strH[1];
$strA[2]=$strH[2];
$strA[3]=$strH[3];
$strA[4]=$strH[4];
//Main encryption loop on all 80 hex word positions
for ($intPos=0; $intPos<=79; $intPos=$intPos+1)
{
$strTemp= self::BinaryShift( self::HexBlockToBinary($strA[0]),5);
$strTemp1= self::HexBlockToBinary($strA[3]);
$strTemp2= self::HexBlockToBinary($strWords[intval($intPos)]);
switch ($intPos)
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
$strTemp3= self::HexBlockToBinary($strK[0]);
$strTemp4= self::BinaryOR( self::BinaryAND( self::HexBlockToBinary($strA[1]),
self::HexBlockToBinary($strA[2])), self::BinaryAND( self::BinaryNOT( self::HexBlockToBinary($strA[1])),
self::HexBlockToBinary($strA[3])));
break;
case 20:
case 21:
case 22:
case 23:
case 24:
case 25:
case 26:
case 27:
case 28:
case 29:
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
case 38:
case 39:
$strTemp3= self::HexBlockToBinary($strK[1]);
$strTemp4= self::BinaryXOR( self::BinaryXOR( self::HexBlockToBinary($strA[1]),
self::HexBlockToBinary($strA[2])), self::HexBlockToBinary($strA[3]));
break;
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
case 48:
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
case 58:
case 59:
$strTemp3= self::HexBlockToBinary($strK[2]);
$strTemp4= self::BinaryOR( self::BinaryOR( self::BinaryAND( self::HexBlockToBinary($strA[1]),
self::HexBlockToBinary($strA[2])), self::BinaryAND( self::HexBlockToBinary($strA[1]),
self::HexBlockToBinary($strA[3]))), self::BinaryAND( self::HexBlockToBinary($strA[2]),
self::HexBlockToBinary($strA[3])));
break;
case 60:
case 61:
case 62:
case 63:
case 64:
case 65:
case 66:
case 67:
case 68:
case 69:
case 70:
case 71:
case 72:
case 73:
case 74:
case 75:
case 76:
case 77:
case 78:
case 79:
$strTemp3= self::HexBlockToBinary($strK[3]);
$strTemp4= self::BinaryXOR( self::BinaryXOR( self::HexBlockToBinary($strA[1]),
self::HexBlockToBinary($strA[2])), self::HexBlockToBinary($strA[3]));
break;
}
$strTemp= self::BlockToHex($strTemp);
$strTemp1=self::BlockToHex($strTemp1);
$strTemp2= self::BlockToHex($strTemp2);
$strTemp3= self::BlockToHex($strTemp3);
$strTemp4= self::BlockToHex($strTemp4);
$strTemp= self::HexAdd($strTemp,$strTemp1);
$strTemp= self::HexAdd($strTemp,$strTemp2);
$strTemp= self::HexAdd($strTemp,$strTemp3);
$strTemp= self::HexAdd($strTemp,$strTemp4);
$strA[4]=$strA[3];
$strA[3]=$strA[2];
$strA[2]= self::BlockToHex( self::BinaryShift( self::HexBlockToBinary($strA[1]),30) );
$strA[1]=$strA[0];
$strA[0]=$strTemp;
}
//Concatenate the final Hex Digest
return $strA[0].$strA[1].$strA[2].$strA[3].$strA[4];
}
private function HexAdd($strHex1,$strHex2)
{
$n1 = hexdec($strHex1);
$n2 = hexdec($strHex2);
$sum = $n1 + $n2;
return sprintf("%08X", $sum);
}
private function BinaryShift($strBinary,$intPos)
{
return substr($strBinary,strlen($strBinary)-(strlen($strBinary)-intval($intPos))).
substr($strBinary,0,intval($intPos));
}
// Function performs an exclusive or function on each position of two binary values
private function BinaryXOR($strBin1,$strBin2)
{
$strBinaryFinal = '';
for ($intPos=1; $intPos<=strlen($strBin1); $intPos=$intPos+1)
{
switch (substr($strBin1,intval($intPos)-1,1))
{
case substr($strBin2, intval($intPos)-1, 1):
$strBinaryFinal=$strBinaryFinal."0";
break;
default:
$strBinaryFinal=$strBinaryFinal."1";
break;
}
}
return $strBinaryFinal;
}
// Function performs an inclusive or function on each position of two binary values
private function BinaryOR($strBin1,$strBin2)
{
$strBinaryFinal = '';
for ($intPos=1; $intPos<=strlen($strBin1); $intPos=$intPos+1)
{
if (substr($strBin1,intval($intPos)-1,1)=="1" || substr($strBin2,intval($intPos)-1,1)=="1")
{
$strBinaryFinal=$strBinaryFinal."1";
} else {
$strBinaryFinal=$strBinaryFinal."0";
}
}
return $strBinaryFinal;
}
// Function performs an AND function on each position of two binary values
private function BinaryAND($strBin1,$strBin2)
{
$strBinaryFinal = '';
for ($intPos=1; $intPos<=strlen($strBin1); $intPos=$intPos+1)
{
if (substr($strBin1,intval($intPos)-1,1)=="1" && substr($strBin2,intval($intPos)-1,1)=="1")
{
$strBinaryFinal=$strBinaryFinal."1";
} else {
$strBinaryFinal=$strBinaryFinal."0";
}
}
return $strBinaryFinal;
}
// Function makes each position of a binary value from 1 to 0 and 0 to 1
private function BinaryNOT($strBinary)
{
$strBinaryFinal = '';
for ($intPos=1; $intPos<=strlen($strBinary); $intPos=$intPos+1)
{
if (substr($strBinary,intval($intPos)-1,1)=="1")
{
$strBinaryFinal=$strBinaryFinal."0";
} else {
$strBinaryFinal=$strBinaryFinal."1";
}
}
return $strBinaryFinal;
}
// Function Converts a 8 digit/32 bit hex value to its 32 bit binary equivalent
private function HexBlockToBinary($strHex)
{
$strTemp = '';
for ($intPos=1; $intPos<=strlen($strHex); $intPos=$intPos+1)
{
$strTemp=$strTemp . self::HexToBinary(substr($strHex,intval($intPos)-1,1));
}
return $strTemp;
}
}