var shaSuccess = 0;
var shaNull = 1;         /* Null pointer parameter */
var shaInputTooLong = 2;    /* input data too long */
var shaStateError = 3;      /* called Input after Result */

function SHA1Context()
{
	this.Intermediate_Hash = new Array(5); /* Message Digest  */

    this.Length_Low = 0;            /* Message length in bits      */
    this.Length_High = 0;           /* Message length in bits      */

                               /* Index into message block array   */
    this.Message_Block_Index = 0;
    this.Message_Block = new Array(64);      /* 512-bit message blocks      */

    this.Computed = 0;               /* Is the digest computed?         */
    this.Corrupted = 0;             /* Is the message digest corrupted? */
}

var context = new SHA1Context();

function SHA1Reset()
{
    if (context == null)
    {
        return shaNull;
    }

    context.Length_Low             = 0;
    context.Length_High            = 0;
    context.Message_Block_Index    = 0;

    context.Intermediate_Hash[0]   = 1732584193;
    context.Intermediate_Hash[1]   = -271733879;
    context.Intermediate_Hash[2]   = -1732584194;
    context.Intermediate_Hash[3]   = 271733878;
    context.Intermediate_Hash[4]   = -1009589776;
  
    context.Computed   = 0;
    context.Corrupted  = 0;

    return shaSuccess;
}

function SHA1Input(message_array, length)
{
    if (length == 0)
    {
        return shaSuccess;
    }

    if (context == null || message_array == null)
    {
        return shaNull;
    }

    if (context.Computed)
    {
        context.Corrupted = shaStateError;

        return shaStateError;
    }

    if (context.Corrupted)
    {
         return context.Corrupted;
    }
    
    var i = 0;
    
    while(length -- && context.Corrupted == 0)
    {
		context.Message_Block[context.Message_Block_Index ++] = (message_array[i] & 0xFF);

		context.Length_Low = UintAdd(context.Length_Low, 8);
		if (context.Length_Low == 0)
		{
			context.Length_High = UintAdd(context.Length_High, 1);
			if (context.Length_High == 0)
			{
				/* Message is too long */
				context.Corrupted = 1;
			}
		}

		if (context.Message_Block_Index == 64)
		{
			SHA1ProcessMessageBlock(context);
		}
		i++;
    }

    return shaSuccess;
}

function SHA1CircularShift(bits, word)
{
	return ((word << bits) | (word >>> (32 - bits)));
}

function UintAdd(x, y)
{
  var lsw =(x & 0xFFFF) + (y & 0xFFFF);
  var msw =(x >> 16) + (y >> 16) + (lsw >> 16);
  return (msw << 16) | (lsw & 0xFFFF);
}

function SHA1ProcessMessageBlock()
{  
	/* Constants defined in SHA-1   */
    var K = new Array(1518500249, 1859775393, -1894007588, -899497514);
    var           t;                 /* Loop counter                */
    var      temp;              /* Temporary word value        */
    var      W = new Array(80);             /* Word sequence               */
    var      A, B, C, D, E;     /* Word buffers                */

    /*
     *  Initialize the first 16 words in the array W
     */
    for(t = 0; t < 16; t++)
    {
        W[t] = context.Message_Block[t * 4] << 24;
        W[t] |= context.Message_Block[t * 4 + 1] << 16;
        W[t] |= context.Message_Block[t * 4 + 2] << 8;
        W[t] |= context.Message_Block[t * 4 + 3];
    }

    for(t = 16; t < 80; t++)
    {
       W[t] = SHA1CircularShift(1, W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
    }

    A = context.Intermediate_Hash[0];
    B = context.Intermediate_Hash[1];
    C = context.Intermediate_Hash[2];
    D = context.Intermediate_Hash[3];
    E = context.Intermediate_Hash[4];

    for(t = 0; t < 20; t++)
    {
        temp = UintAdd(UintAdd(SHA1CircularShift(5,A), ((B & C) | ((~B) & D))), UintAdd(UintAdd(E, W[t]), K[0]));
        E = D;
        D = C;
        C = SHA1CircularShift(30,B);

        B = A;
        A = temp;
    }

    for(t = 20; t < 40; t++)
    {
        temp = UintAdd(UintAdd(SHA1CircularShift(5,A), (B ^ C ^ D)), UintAdd(UintAdd(E, W[t]), K[1]));
        E = D;
        D = C;
        C = SHA1CircularShift(30,B);
        B = A;
        A = temp;
    }

    for(t = 40; t < 60; t++)
    {
        temp = UintAdd(UintAdd(SHA1CircularShift(5,A), ((B & C) | (B & D) | (C & D))), UintAdd(UintAdd(E, W[t]), K[2]));
        E = D;
        D = C;
        C = SHA1CircularShift(30,B);
        B = A;
        A = temp;
    }

    for(t = 60; t < 80; t++)
    {
        temp = UintAdd(UintAdd(SHA1CircularShift(5,A), (B ^ C ^ D)), UintAdd(UintAdd(E, W[t]), K[3]));
        E = D;
        D = C;
        C = SHA1CircularShift(30,B);
        B = A;
        A = temp;
    }

    context.Intermediate_Hash[0] = UintAdd(context.Intermediate_Hash[0], A);
    context.Intermediate_Hash[1] = UintAdd(context.Intermediate_Hash[1], B);
    context.Intermediate_Hash[2] = UintAdd(context.Intermediate_Hash[2], C);
    context.Intermediate_Hash[3] = UintAdd(context.Intermediate_Hash[3], D);
    context.Intermediate_Hash[4] = UintAdd(context.Intermediate_Hash[4], E);

    context.Message_Block_Index = 0;
}

//var Message_Digest = new Array(20);
var SHA1HashSize = 20;
function SHA1Result(Message_Digest)
{
    var i;

    if (context == null || Message_Digest == null)
    {
        return shaNull;
    }

    if (context.Corrupted)
    {
        return context.Corrupted;
    }

    if (context.Computed == 0)
    {
        SHA1PadMessage(context);
        for(i = 0; i < 64; ++ i)
        {
            /* message may be sensitive, clear it out */
            context.Message_Block[i] = 0;
        }
        context.Length_Low = 0;    /* and clear length */
        context.Length_High = 0;
        context.Computed = 1;

    }

    for(i = 0; i < SHA1HashSize; ++i)
    {
        Message_Digest[i] = context.Intermediate_Hash[i >> 2] >>> 8 * (3 - (i & 0x03)) & 0xFF;
    }

    return shaSuccess;
}


function SHA1PadMessage()
{
    /*
     *  Check to see if the current message block is too small to hold
     *  the initial padding bits and length.  If so, we will pad the
     *  block, process it, and then continue padding into a second
     *  block.
     */
    if (context.Message_Block_Index > 55)
    {
        context.Message_Block[context.Message_Block_Index ++] = 0x80;
        while(context.Message_Block_Index < 64)
        {
            context.Message_Block[context.Message_Block_Index ++] = 0;
        }

        SHA1ProcessMessageBlock();

        while(context.Message_Block_Index < 56)
        {
            context.Message_Block[context.Message_Block_Index ++] = 0;
        }
    }
    else
    {
        context.Message_Block[context.Message_Block_Index ++] = 0x80;
        while(context.Message_Block_Index < 56)
        {

            context.Message_Block[context.Message_Block_Index ++] = 0;
        }
    }

    /*
     *  Store the message length as the last 8 octets
     */
    context.Message_Block[56] = context.Length_High >> 24;
    context.Message_Block[57] = context.Length_High >> 16;
    context.Message_Block[58] = context.Length_High >> 8;
    context.Message_Block[59] = context.Length_High;
    context.Message_Block[60] = context.Length_Low >> 24;
    context.Message_Block[61] = context.Length_Low >> 16;
    context.Message_Block[62] = context.Length_Low >> 8;
    context.Message_Block[63] = context.Length_Low;

    SHA1ProcessMessageBlock();
}

var sHEXChars="0123456789abcdef";

function SHA1Print(Message_Digest, length)
{
	var str="";
	for(var i= 0; i < length; i++)
		str += (sHEXChars.charAt(Message_Digest[i] >> 4 & 0x0F) + sHEXChars.charAt(Message_Digest[i] & 0x0F));
	
	return str;
}

function SHA1(strMessage)
{
	var nStrLen = strMessage.length;
	var buffer = new Array(nStrLen * 2);
	var len = 0;
	for (var i = 0; i < nStrLen; i ++)
	{
		buffer[2*i] = (strMessage.charCodeAt(i) & 0xFF);
		buffer[2*i + 1] = (strMessage.charCodeAt(i) >> 8 & 0xFF);
	}
		
	len = i*2;
		
	SHA1Reset();
	SHA1Input(buffer, len);	
	var digest = new Array(20);
	SHA1Result(digest);
		
	return (SHA1Print (digest, 20));
}



/*
 * Validate Javascript version.
 */
function isValidJs() {
   if (navigator.userAgent.indexOf("Mozilla/") == 0) {
      return (parseInt(navigator.appVersion) >= 4);
   }
   return false;
}

function preSubmit(objForm) {
	if (self != top)
	{
		top.LoginStatus = 1;
	}
	if (isValidJs()) {
		var strPwd = objForm.pwd.value;
		var strHash;
		var strHash1 = SHA1(objForm.pwd.value);
		var strHash2 = "";
		var strChallenge = "";
		
		if (objForm["challenge"] != null && objForm["challenge"].value != "") {
			strChallenge = objForm["challenge"].value;
			strHash2 = strHash1 + strChallenge;
			strHash = SHA1(strHash2);
		}
		else
			strHash = strHash1;

		objForm.pwd.value = strHash;
		objForm.hash.value = (strHash2 == "") ? "0" : "1";
		objForm.sha1.value = "1";
	}

	return true;
}

function EncryptPwd(objPwd, objChange) {
	if (isValidJs()) {
	
		var strPwd = document.all(objPwd).value;
		var strHash;
		var strHash1 = SHA1(document.all(objPwd).value);
		var strHash2 = "";
		var strChallenge = "";

		if (document.all.item(objChange) != null && document.all.item(objChange).value != "") {
			strChallenge = document.all.item(objChange).value;
			strHash2 = strHash1 + strChallenge;
			strHash = SHA1(strHash2);
		}
		else
			strHash = strHash1;

		document.all(objPwd).value = strHash;
		
	}

	return true;
}