ASP -> PHP : SHA Password Encryption

[arya]

I'm trying to convert a ASP script used by Web Wiz forum so that i can migrate to some other php based forum. I have written script for SQL migration but its been difficult as the functions used by ASP forum and PHP forum are different.

I tried using ASP2PHP which translated the code to much extenet and reduced many pains for me. I'm posting both ASP and PHP code. Both have some print/response.write statements which i used to trace the output.

It seems that functions go well halfway then i start getting strange hexes. I and my forum members will be very glad, if someone can spare some time over this.

See attachment in next post for code.

[arya]

ASP Continued.....

Function HexAdd(strHex1, strHex2)

Dim intCalc
Dim strNew

intCalc = 0
intCalc = CDbl(CDbl(HexToInt(strHex1)) + CDbl(HexToInt(strHex2)))
Do While CDbl(intCalc) > 2^32
	intCalc = CDbl(intCalc) - 2^32
Loop

strNew = IntToBinary(CDbl(intCalc))
Do While Len(strNew) < 32
    strNew = "0" & strNew
Loop
strNew = BlockToHex(strNew)

if InStr(strNew, "00") = 1 and len(strNew) = 10 then
	strNew = right(strNew, 8)
end if

HexAdd = strNew

End Function

Function getHexDec(strHex)

Select Case strHex
Case "0"
    getHexDec = 0
Case "1"
    getHexDec = 1
Case "2"
    getHexDec = 2
Case "3"
    getHexDec = 3
Case "4"
    getHexDec = 4
Case "5"
    getHexDec = 5
Case "6"
    getHexDec = 6
Case "7"
    getHexDec = 7
Case "8"
    getHexDec = 8
Case "9"
    getHexDec = 9
Case "A"
    getHexDec = 10
Case "B"
    getHexDec = 11
Case "C"
    getHexDec = 12
Case "D"
    getHexDec = 13
Case "E"
    getHexDec = 14
Case "F"
    getHexDec = 15
Case Else
    getHexDec = -1
End Select
End Function

Function getDecHex(strHex)
' Function Converts a single decimal value(0 - 15) into it's hex equivalent
'
' Written By: Mark Jager
' Written Date: 8/10/2000
'
' Free to distribute as long as code is not modified, and header is kept intact
'
    Select Case CInt(strHex)
    Case 0
       getDecHex = "0"
    Case 1
       getDecHex = "1"
    Case 2
       getDecHex = "2"
    Case 3
       getDecHex = "3"
    Case 4
       getDecHex = "4"
    Case 5
       getDecHex = "5"
    Case 6
       getDecHex = "6"
    Case 7
       getDecHex = "7"
    Case 8
       getDecHex = "8"
    Case 9
       getDecHex = "9"
    Case 10
       getDecHex = "A"
    Case 11
       getDecHex = "B"
    Case 12
       getDecHex = "C"
    Case 13
       getDecHex = "D"
    Case 14
       getDecHex = "E"
    Case 15
       getDecHex = "F"
    Case Else
       getDecHex = "Z"
    End Select
End Function

Function BinaryShift(strBinary, intPos)
' Function circular left shifts a binary value n places
'
' Written By: Mark Jager
' Written Date: 8/10/2000
'
' Free to distribute as long as code is not modified, and header is kept intact
'
    BinaryShift = Right(strBinary, Len(strBinary) - cint(intPos)) & _
		Left(strBinary, cint(intPos))

End Function

Function BinaryXOR(strBin1, strBin2)
' Function performs an exclusive or function on each position of two binary values
'
' Written By: Mark Jager
' Written Date: 8/10/2000
'
' Free to distribute as long as code is not modified, and header is kept intact
'
    Dim strBinaryFinal
    Dim intPos

For intPos = 1 To Len(strBin1)
    Select Case Mid(strBin1, cint(intPos), 1)

    Case Mid(strBin2, cint(intPos), 1)
        strBinaryFinal = strBinaryFinal & "0"
    Case Else
        strBinaryFinal = strBinaryFinal & "1"
    End Select
Next

BinaryXOR = strBinaryFinal

End Function

Function BinaryOR(strBin1, strBin2)
' Function performs an inclusive or function on each position of two binary values
'
' Written By: Mark Jager
' Written Date: 8/10/2000
'
' Free to distribute as long as code is not modified, and header is kept intact
'
    Dim strBinaryFinal
    Dim intPos

For intPos = 1 To Len(strBin1)
    If Mid(strBin1, cint(intPos), 1) = "1" Or Mid(strBin2, cint(intPos), 1) = "1" Then
        strBinaryFinal = strBinaryFinal & "1"
    Else
        strBinaryFinal = strBinaryFinal & "0"
    End If
Next

BinaryOR = strBinaryFinal
End Function

Function BinaryAND(strBin1, strBin2)
' Function performs an AND function on each position of two binary values
'
' Written By: Mark Jager
' Written Date: 8/10/2000
'
' Free to distribute as long as code is not modified, and header is kept intact
'
    Dim strBinaryFinal
    Dim intPos

For intPos = 1 To Len(strBin1)
    If Mid(strBin1, cint(intPos), 1) = "1" And Mid(strBin2, cint(intPos), 1) = "1" Then
        strBinaryFinal = strBinaryFinal & "1"
    Else
        strBinaryFinal = strBinaryFinal & "0"
    End If
Next

BinaryAND = strBinaryFinal
End Function

Function BinaryNOT(strBinary)
' Function makes each position of a binary value from 1 to 0 and 0 to 1
'
' Written By: Mark Jager
' Written Date: 8/10/2000
'
' Free to distribute as long as code is not modified, and header is kept intact
'
    Dim strBinaryFinal
    Dim intPos

For intPos = 1 To Len(strBinary)
    If Mid(strBinary, cint(intPos), 1) = "1" Then
        strBinaryFinal = strBinaryFinal & "0"
    Else
        strBinaryFinal = strBinaryFinal & "1"
    End If
Next

BinaryNOT = strBinaryFinal

End Function

Function HexBlockToBinary(strHex)
' Function Converts a 8 digit/32 bit hex value to its 32 bit binary equivalent
'
' Written By: Mark Jager
' Written Date: 8/10/2000
'
' Free to distribute as long as code is not modified, and header is kept intact
'
    Dim intPos
    Dim strTemp
   ' Response.Write("<br>->" & strHex & "<br>")
    For intPos = 1 To Len(strHex)
        strTemp = strTemp & HexToBinary(Mid(strHex, cint(intPos), 1))

Next

HexBlockToBinary = strTemp

End Function

Response.Write(HashEncode("ABCD"))

Function HexToBinary(btHex)

Select Case btHex
Case "0"
    HexToBinary = "0000"
Case "1"
    HexToBinary = "0001"
Case "2"
    HexToBinary = "0010"
Case "3"
    HexToBinary = "0011"
Case "4"
    HexToBinary = "0100"
Case "5"
    HexToBinary = "0101"
Case "6"
    HexToBinary = "0110"
Case "7"
    HexToBinary = "0111"
Case "8"
    HexToBinary = "1000"
Case "9"
    HexToBinary = "1001"
Case "A"
    HexToBinary = "1010"
Case "B"
    HexToBinary = "1011"
Case "C"
    HexToBinary = "1100"
Case "D"
    HexToBinary = "1101"
Case "E"
    HexToBinary = "1110"
Case "F"
    HexToBinary = "1111"
Case Else
    HexToBinary = "2222"
End Select
End Function

Function BinaryToHex(strBinary)

Select Case strBinary
Case "0000"
    BinaryToHex = "0"
Case "0001"
    BinaryToHex = "1"
Case "0010"
    BinaryToHex = "2"
Case "0011"
    BinaryToHex = "3"
Case "0100"
    BinaryToHex = "4"
Case "0101"
    BinaryToHex = "5"
Case "0110"
    BinaryToHex = "6"
Case "0111"
    BinaryToHex = "7"
Case "1000"
    BinaryToHex = "8"
Case "1001"
    BinaryToHex = "9"
Case "1010"
    BinaryToHex = "A"
Case "1011"
    BinaryToHex = "B"
Case "1100"
    BinaryToHex = "C"
Case "1101"
    BinaryToHex = "D"
Case "1110"
    BinaryToHex = "E"
Case "1111"
    BinaryToHex = "F"
Case Else
    BinaryToHex = "Z"
End Select
End Function
%>

[arya]

PHP CODE

<? 
function HashEncode($strSecret)
{
  extract($GLOBALS);


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=WordToBinary($strEncode); //convert to binary
	$strEncode=PadBinary($strEncode); //make it 512 bites
	$strEncode=BlockToHex($strEncode); //convert to hex value

print $strEncode."<-<br>";
//Encode the hex value using the previous runs digest
//If it is the first run then use the initial values above
    $strEncode=DigestHex($strEncode,$strH[0],$strH[1],$strH[2],$strH[3],$strH[4]);

//Combine the old digest with the new digest
    $strH[0]=HexAdd(substr($strEncode,0,8),$strH[0]);
    $strH[1]=HexAdd(substr($strEncode,8,8),$strH[1]);
    $strH[2]=HexAdd(substr($strEncode,16,8),$strH[2]);
    $strH[3]=HexAdd(substr($strEncode,24,8),$strH[3]);
    $strH[4]=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;
} 



function HexToBinary($btHex)
{
  extract($GLOBALS);

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

function BinaryToHex($strBinary)
{
  extract($GLOBALS);
  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;
} 

function WordToBinary($strWord)
{
  extract($GLOBALS);

$strBinary = '';
  for ($intPos=1; $intPos<=strlen($strWord); $intPos=$intPos+1)
  {
    $strTemp=substr($strWord,intval($intPos)-1,1);
    $strBinary=$strBinary.IntToBinary(ord($strTemp));

  }


  $function_ret=$strBinary;

  return $function_ret;
} 

function HexToInt($strHex)
{
  extract($GLOBALS);

 $intNew=0;
  $intLen=doubleval(strlen($strHex))-1;

  for ($intPos=doubleval($intLen); $intPos>=0; $intPos=$intPos-1)
  {    switch (substr($strHex,doubleval($intPos)+1-1,1))
    {
      case "0":
        $intNew=doubleval($intNew)+(0*16^doubleval($intLen-$intPos));
        break;
      case "1":
        $intNew=doubleval($intNew)+(1*16^doubleval($intLen-$intPos));
        break;
      case "2":
        $intNew=doubleval($intNew)+(2*16^doubleval($intLen-$intPos));
        break;
      case "3":
        $intNew=doubleval($intNew)+(3*16^doubleval($intLen-$intPos));
        break;
      case "4":
        $intNew=doubleval($intNew)+(4*16^doubleval($intLen-$intPos));
        break;
      case "5":
        $intNew=doubleval($intNew)+(5*16^doubleval($intLen-$intPos));
        break;
      case "6":
        $intNew=doubleval($intNew)+(6*16^doubleval($intLen-$intPos));
        break;
      case "7":
        $intNew=doubleval($intNew)+(7*16^doubleval($intLen-$intPos));
        break;
      case "8":
        $intNew=doubleval($intNew)+(8*16^doubleval($intLen-$intPos));
        break;
      case "9":
        $intNew=doubleval($intNew)+(9*16^doubleval($intLen-$intPos));
        break;
      case "A":
        $intNew=doubleval($intNew)+(10*16^doubleval($intLen-$intPos));
        break;
      case "B":
        $intNew=doubleval($intNew)+(11*16^doubleval($intLen-$intPos));
        break;
      case "C":
        $intNew=doubleval($intNew)+(12*16^doubleval($intLen-$intPos));
        break;
      case "D":
        $intNew=doubleval($intNew)+(13*16^doubleval($intLen-$intPos));
        break;
      case "E":
        $intNew=doubleval($intNew)+(14*16^doubleval($intLen-$intPos));
        break;
      case "F":
        $intNew=doubleval($intNew)+(15*16^doubleval($intLen-$intPos));
        break;
    } 


  }


  $function_ret=doubleval($intNew);

  return $function_ret;
} 

function IntToBinary($intNum)
{
  extract($GLOBALS);

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

  }


  $function_ret=$strBinary;

  return $function_ret;
} 

function PadBinary($strBinary)
{
  extract($GLOBALS);

  $intLen=strlen($strBinary);

  $strBinary=$strBinary."1";

  for ($intPos=strlen($strBinary); $intPos<=447; $intPos=$intPos+1)
  {
    $strBinary=$strBinary."0";

  }


  $strTemp=IntToBinary($intLen);

  for ($intPos=strlen($strTemp); $intPos<=63; $intPos=$intPos+1)
  {
    $strTemp="0".$strTemp;

  }


  $strBinary=$strBinary.$strTemp;

  $function_ret=$strBinary;

  return $function_ret;
} 

function BlockToHex($strBinary)
{
  extract($GLOBALS);

$strHex = '';
  for ($intPos=1; $intPos<=strlen($strBinary); $intPos=$intPos+4)
  {    $strHex=$strHex.BinaryToHex(substr($strBinary,$intPos-1,4));

  }


  $function_ret=$strHex;

  return $function_ret;
} 

[arya]

PHP COntinued...

function DigestHex($strHex,$strH0,$strH1,$strH2,$strH3,$strH4)
{
  extract($GLOBALS);

//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=HexBlockToBinary($strTemp);
    $strTemp=$strWords[intval($intPos)-8];
    $strTemp2=HexBlockToBinary($strTemp);
    $strTemp=$strWords[intval($intPos)-14];
    $strTemp3=HexBlockToBinary($strTemp);
    $strTemp=$strWords[intval($intPos)-16];
    $strTemp4=HexBlockToBinary($strTemp);
    $strTemp=BinaryXOR($strTemp1,$strTemp2);
    $strTemp=BinaryXOR($strTemp,$strTemp3);
    $strTemp=BinaryXOR($strTemp,$strTemp4);
    $strWords[intval($intPos)]=BlockToHex(BinaryShift($strTemp,1));
	print "<br>->".$strWords[intval($intPos)]."<br>";
  }


//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];
//print "<br>->".$strWords[0]."<br>";
//Main encryption loop on all 80 hex word positions
  for ($intPos=0; $intPos<=79; $intPos=$intPos+1)
  {
    $strTemp=BinaryShift(HexBlockToBinary($strA[0]),5);
    $strTemp1=HexBlockToBinary($strA[3]);
    $strTemp2=HexBlockToBinary($strWords[intval($intPos)]);
	print "<br>".$intPos." -> ".$strA[4]."<br>";
    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=HexBlockToBinary($strK[0]);
        $strTemp4=BinaryOR(BinaryAND(HexBlockToBinary($strA[1]),
        HexBlockToBinary($strA[2])),BinaryAND(BinaryNOT(HexBlockToBinary($strA[1])),
        HexBlockToBinary($strA[3])));
		echo "<br> - > Case1";
        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=HexBlockToBinary($strK[1]);
        $strTemp4=BinaryXOR(BinaryXOR(HexBlockToBinary($strA[1]),
        HexBlockToBinary($strA[2])),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=HexBlockToBinary($strK[2]);
        $strTemp4=BinaryOR(BinaryOR(BinaryAND(HexBlockToBinary($strA[1]),
        HexBlockToBinary($strA[2])),BinaryAND(HexBlockToBinary($strA[1]),
        HexBlockToBinary($strA[3]))),BinaryAND(HexBlockToBinary($strA[2]),
        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=HexBlockToBinary($strK[3]);
        $strTemp4=BinaryXOR(BinaryXOR(HexBlockToBinary($strA[1]),
        HexBlockToBinary($strA[2])),HexBlockToBinary($strA[3]));
        break;
    } 

$strTemp=BlockToHex($strTemp);
$strTemp1=BlockToHex($strTemp1);
$strTemp2=BlockToHex($strTemp2);
$strTemp3=BlockToHex($strTemp3);
$strTemp4=BlockToHex($strTemp4);

$strTemp=HexAdd($strTemp,$strTemp1);
$strTemp=HexAdd($strTemp,$strTemp2);
$strTemp=HexAdd($strTemp,$strTemp3);
$strTemp=HexAdd($strTemp,$strTemp4);

$strA[4]=$strA[3];
$strA[3]=$strA[2];
$strA[2]=BlockToHex(BinaryShift(HexBlockToBinary($strA[1]),30));
$strA[1]=$strA[0];
$strA[0]=$strTemp;


  }


//Concatenate the final Hex Digest
  $function_ret=$strA[0].$strA[1].$strA[2].$strA[3].$strA[4];

  return $function_ret;
} 

function HexAdd($strHex1,$strHex2)
{
  extract($GLOBALS);


  $intCalc=0;
  $intCalc=doubleval(doubleval(HexToInt($strHex1))+doubleval(HexToInt($strHex2)));
  while(doubleval($intCalc)> pow(2,32))
  {

$intCalc=doubleval($intCalc)- pow(2,32);
  } 

  $strNew=IntToBinary(doubleval($intCalc));
  while(strlen($strNew)<32)
  {

$strNew="0".$strNew;
  } 
  $strNew=BlockToHex($strNew);

  if ((strpos($strNew,"00") ? strpos($strNew,"00")+1 : 0)==1 && strlen($strNew)==10)
  {

$strNew=substr($strNew,strlen($strNew)-(8));
  } 


  $function_ret=$strNew;

  return $function_ret;
} 

function getHexDec($strHex)
{
  extract($GLOBALS);

  switch ($strHex)
  {
    case "0":
      $function_ret=0;
      break;
    case "1":
      $function_ret=1;
      break;
    case "2":
      $function_ret=2;
      break;
    case "3":
      $function_ret=3;
      break;
    case "4":
      $function_ret=4;
      break;
    case "5":
      $function_ret=5;
      break;
    case "6":
      $function_ret=6;
      break;
    case "7":
      $function_ret=7;
      break;
    case "8":
      $function_ret=8;
      break;
    case "9":
      $function_ret=9;
      break;
    case "A":
      $function_ret=10;
      break;
    case "B":
      $function_ret=11;
      break;
    case "C":
      $function_ret=12;
      break;
    case "D":
      $function_ret=13;
      break;
    case "E":
      $function_ret=14;
      break;
    case "F":
      $function_ret=15;
      break;
    default:

  $function_ret=-1;
  break;
  } 
  return $function_ret;
} 

function getDecHex($strHex)
{
  extract($GLOBALS);

  switch (intval($strHex))
  {
    case 0:
      $function_ret="0";
      break;
    case 1:
      $function_ret="1";
      break;
    case 2:
      $function_ret="2";
      break;
    case 3:
      $function_ret="3";
      break;
    case 4:
      $function_ret="4";
      break;
    case 5:
      $function_ret="5";
      break;
    case 6:
      $function_ret="6";
      break;
    case 7:
      $function_ret="7";
      break;
    case 8:
      $function_ret="8";
      break;
    case 9:
      $function_ret="9";
      break;
    case 10:
      $function_ret="A";
      break;
    case 11:
      $function_ret="B";
      break;
    case 12:
      $function_ret="C";
      break;
    case 13:
      $function_ret="D";
      break;
    case 14:
      $function_ret="E";
      break;
    case 15:
      $function_ret="F";
      break;
    default:

  $function_ret="Z";
  break;
  } 
  return $function_ret;
} 

[arya]

UPDATE : Added a zip file with both php and ASP files. It will be easier to download the attached file than copy pasting.

[Weedpacket]

Or you could just use [man]sha1[/man]...?

[arya]

well i cant use SHA1 as passwords already encrypted use different words and salt while encrypting. I can afford to loose my members as passwords will be changed if i use sha1.

I tried using sha1 and it gives different output....if someone can give it a shot i can provide some asp/php space where they can experiment....if scared to use this on your pc 🙂

[laserlight]

well i cant use SHA1 as passwords already encrypted use different words and salt while encrypting. I can afford to loose my members as passwords will be changed if i use sha1.

The HashEncode function in your original script implements the SHA-1 algorithm, according to the comments. You can use sha1() since it also implements SHA-1.

The getSalt function in your original script is meant for generating a salt for new users. This has no bearing on current users, and you can always use some other salt generating scheme for new users.

All the other functions in your original script are just there to support these two functions. What you need to do is find out just how is the salt used. Is it prepended to the password, or appended, or used in some other way? Once you know that, you can do the same and use PHP's sha1() with it.

[arya]

Thanks laserlight

The reason why i need same encrypted string from php function , i have 1000 members on my asp forum which i dont want to loose...if i adapt to new function it will never be able to compare to old saved passwords, so i end up loosing them. many of them havnt given correct mail id, so i cant even batch reset password and mail them.

I tried generating hash from sha1() but it was quite different from the one generated by the ASP function HashEncode. I dont mind using any other function....but i need to have a function which generates same hash as the ASP function.

As of getSalt(), it adds a random hex value to password and then the whole string is encrypted. the salt value is stored in db along with password, so whenever password is checked, salt is appended to cleartext password and then the whole string is encrypted.

salt=getSalt()
HashEncode ( password + salt) = hashed password.

Any thoughts....

p.s. In php file you can see i've tried to use SHA1 function as well
sha1('ABCD');

[laserlight]

I tried generating hash from sha1() but it was quite different from the one generated by the ASP function HashEncode. I dont mind using any other function....but i need to have a function which generates same hash as the ASP function.

That's the crux of the matter. The hashes generated should be the same. What do you get from HashEncode("ABCD")?

[arya]

Thanks a lot laserlight for following on this issue.

HashEncode("ABCD") = A11D4F0A70B882D58494B188DA0430CF4F17CFA8
sha1('ABCD') = fb2f85c88567f3c8ce9b799c7c54642d0c7b41f6

$strEncode contains the hashed string. which is passed through various functions. If you notice in both php and asp versions the $strEncode remains same till

$strEncode=BlockToHex($strEncode);

but after DigestHex function is called it doesnt give correct output in php version.
this is what i get in place of expected hash

00000538000004B800000618000005E800000598

The reason why i cant use sha1 directly because it uses these values

//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";

then these are passed in the DigestHex Function alongwith $strEncode

$strEncode=DigestHex($strEncode,$strH[0],$strH[1],$strH[2],$strH[3],$strH[4]);

If you run the php script you'll notice that its terribly slow, which may be probably because i missed something. My knowledge of php is very basic. so its very much possible there may be a problem with the code which i could not trace.

[eiaccb]

Arya,

The main problem is that function HexAdd is not correct. The translation done by aps2php does not produce an equivalent version.

Try to replace completely that function by this, simpler and faster, version:

function HexAdd($strHex1,$strHex2)
{
$n1 = hexdec($strHex1);
$n2 = hexdec($strHex2);
$sum = $n1 + $n2;
return sprintf("%08X", $sum);
}

I am not sure if it works in all cases, but it does for all the passwords I knew.

In general, the translated code seems very clumsy and it seems that a better version may be written by using PHP primitives. I will do so over the next few days, since I also want to migrate some forums, to SMF in may case.

Hope this helps.

[swhiteside]

I have a similar issue with a PHP system accessing ASP-generated passwords.
Did you work out a solution to encrypting the passwords in the same way in PHP as in ASP?