注册时候使用 RSA 实现前台对密码加密和后台解密

注册时候使用 RSA 实现前台对密码加密和后台解密

原理这里就不分析了，直接干货奉上。orchard中写的一个moudle，也就是C# mvc代码。

---

前台加密部分

首先项目中引用三个 js 文件

• rsa.js
• Barrett.js
• BigInt.js
  

  // RSA, a suite of routines for performing RSA public-key computations in
  // JavaScript.
  //
  // Requires BigInt.js and Barrett.js.
  //
  // Copyright 1998-2005 David Shapiro.
  //
  // You may use, re-use, abuse, copy, and modify this code to your liking, but
  // please keep this header.
  //
  // Thanks!
  // 
  // Dave Shapiro
  // [email protected] 
  
  function RSAKeyPair(encryptionExponent, decryptionExponent, modulus)
  {
  	this.e = biFromHex(encryptionExponent);
  	this.d = biFromHex(decryptionExponent);
  	this.m = biFromHex(modulus);
  	
  	// We can do two bytes per digit, so
  	// chunkSize = 2 * (number of digits in modulus - 1).
  	// Since biHighIndex returns the high index, not the number of digits, 1 has
  	// already been subtracted.
  	//this.chunkSize = 2 * biHighIndex(this.m);
  	
  	////////////////////////////////// TYF
      	this.digitSize = 2 * biHighIndex(this.m) + 2;
  	this.chunkSize = this.digitSize - 11; // maximum, anything lower is fine
  	////////////////////////////////// TYF
  
  	this.radix = 16;
  	this.barrett = new BarrettMu(this.m);
  }
  
  function twoDigit(n)
  {
  	return (n < 10 ? "0" : "") + String(n);
  }
  
  function encryptedString(key, s)
  // Altered by Rob Saunders ([email protected]). New routine pads the
  // string after it has been converted to an array. This fixes an
  // incompatibility with Flash MX's ActionScript.
  // Altered by Tang Yu Feng for interoperability with Microsoft's
  // RSACryptoServiceProvider implementation.
  {
  	////////////////////////////////// TYF
  	if (key.chunkSize > key.digitSize - 11)
  	{
  	    return "Error";
  	}
  	////////////////////////////////// TYF
  
  
  	var a = new Array();
  	var sl = s.length;
  	
  	var i = 0;
  	while (i < sl) {
  		a[i] = s.charCodeAt(i);
  		i++;
  	}
  
  	//while (a.length % key.chunkSize != 0) {
  	//	a[i++] = 0;
  	//}
  
  	var al = a.length;
  	var result = "";
  	var j, k, block;
  	for (i = 0; i < al; i += key.chunkSize) {
  		block = new BigInt();
  		j = 0;
  		
  		//for (k = i; k < i + key.chunkSize; ++j) {
  		//	block.digits[j] = a[k++];
  		//	block.digits[j] += a[k++] << 8;
  		//}
  		
  		////////////////////////////////// TYF
  		// Add PKCS#1 v1.5 padding
  		// 0x00 || 0x02 || PseudoRandomNonZeroBytes || 0x00 || Message
  		// Variable a before padding must be of at most digitSize-11
  		// That is for 3 marker bytes plus at least 8 random non-zero bytes
  		var x;
  		var msgLength = (i+key.chunkSize)>al ? al%key.chunkSize : key.chunkSize;
  		
  		// Variable b with 0x00 || 0x02 at the highest index.
  		var b = new Array();
  		for (x=0; x
        
         << 8;
  		}
  		////////////////////////////////// TYF
  
  		var crypt = key.barrett.powMod(block, key.e);
  		var text = key.radix == 16 ? biToHex(crypt) : biToString(crypt, key.radix);
  		result += text + " ";
  	}
  	return result.substring(0, result.length - 1); // Remove last space.
  }
  
  function decryptedString(key, s)
  {
  	var blocks = s.split(" ");
  	var result = "";
  	var i, j, block;
  	for (i = 0; i < blocks.length; ++i) {
  		var bi;
  		if (key.radix == 16) {
  			bi = biFromHex(blocks[i]);
  		}
  		else {
  			bi = biFromString(blocks[i], key.radix);
  		}
  		block = key.barrett.powMod(bi, key.d);
  		for (j = 0; j <= biHighIndex(block); ++j) {
  			result += String.fromCharCode(block.digits[j] & 255,
  			                              block.digits[j] >> 8);
  		}
  	}
  	// Remove trailing null, if any.
  	if (result.charCodeAt(result.length - 1) == 0) {
  		result = result.substring(0, result.length - 1);
  	}
  	return result;
  }
  // BigInt, a suite of routines for performing multiple-precision arithmetic in
  // JavaScript.
  //
  // Copyright 1998-2005 David Shapiro.
  //
  // You may use, re-use, abuse,
  // copy, and modify this code to your liking, but please keep this header.
  // Thanks!
  //
  // Dave Shapiro
  // [email protected]
  
  // IMPORTANT THING: Be sure to set maxDigits according to your precision
  // needs. Use the setMaxDigits() function to do this. See comments below.
  //
  // Tweaked by Ian Bunning
  // Alterations:
  // Fix bug in function biFromHex(s) to allow
  // parsing of strings of length != 0 (mod 4)
  
  // Changes made by Dave Shapiro as of 12/30/2004:
  //
  // The BigInt() constructor doesn't take a string anymore. If you want to
  // create a BigInt from a string, use biFromDecimal() for base-10
  // representations, biFromHex() for base-16 representations, or
  // biFromString() for base-2-to-36 representations.
  //
  // biFromArray() has been removed. Use biCopy() instead, passing a BigInt
  // instead of an array.
  //
  // The BigInt() constructor now only constructs a zeroed-out array.
  // Alternatively, if you pass 
         
          , it won't construct any array. See the
  // biCopy() method for an example of this.
  //
  // Be sure to set maxDigits depending on your precision needs. The default
  // zeroed-out array ZERO_ARRAY is constructed inside the setMaxDigits()
  // function. So use this function to set the variable. DON'T JUST SET THE
  // VALUE. USE THE FUNCTION.
  //
  // ZERO_ARRAY exists to hopefully speed up construction of BigInts(). By
  // precalculating the zero array, we can just use slice(0) to make copies of
  // it. Presumably this calls faster native code, as opposed to setting the
  // elements one at a time. I have not done any timing tests to verify this
  // claim.
  
  // Max number = 10^16 - 2 = 9999999999999998;
  //               2^53     = 9007199254740992;
  
  var biRadixBase = 2;
  var biRadixBits = 16;
  var bitsPerDigit = biRadixBits;
  var biRadix = 1 << 16; // = 2^16 = 65536
  var biHalfRadix = biRadix >>> 1;
  var biRadixSquared = biRadix * biRadix;
  var maxDigitVal = biRadix - 1;
  var maxInteger = 9999999999999998; 
  
  // maxDigits:
  // Change this to accommodate your largest number size. Use setMaxDigits()
  // to change it!
  //
  // In general, if you're working with numbers of size N bits, you'll need 2*N
  // bits of storage. Each digit holds 16 bits. So, a 1024-bit key will need
  //
  // 1024 * 2 / 16 = 128 digits of storage.
  //
  
  var maxDigits;
  var ZERO_ARRAY;
  var bigZero, bigOne;
  
  function setMaxDigits(value)
  {
  	maxDigits = value;
  	ZERO_ARRAY = new Array(maxDigits);
  	for (var iza = 0; iza < ZERO_ARRAY.length; iza++) ZERO_ARRAY[iza] = 0;
  	bigZero = new BigInt();
  	bigOne = new BigInt();
  	bigOne.digits[0] = 1;
  }
  
  setMaxDigits(20);
  
  // The maximum number of digits in base 10 you can convert to an
  // integer without JavaScript throwing up on you.
  var dpl10 = 15;
  // lr10 = 10 ^ dpl10
  var lr10 = biFromNumber(1000000000000000);
  
  function BigInt(flag)
  {
  	if (typeof flag == "boolean" && flag == true) {
  		this.digits = null;
  	}
  	else {
  		this.digits = ZERO_ARRAY.slice(0);
  	}
  	this.isNeg = false;
  }
  
  function biFromDecimal(s)
  {
  	var isNeg = s.charAt(0) == '-';
  	var i = isNeg ? 1 : 0;
  	var result;
  	// Skip leading zeros.
  	while (i < s.length && s.charAt(i) == '0') ++i;
  	if (i == s.length) {
  		result = new BigInt();
  	}
  	else {
  		var digitCount = s.length - i;
  		var fgl = digitCount % dpl10;
  		if (fgl == 0) fgl = dpl10;
  		result = biFromNumber(Number(s.substr(i, fgl)));
  		i += fgl;
  		while (i < s.length) {
  			result = biAdd(biMultiply(result, lr10),
  			               biFromNumber(Number(s.substr(i, dpl10))));
  			i += dpl10;
  		}
  		result.isNeg = isNeg;
  	}
  	return result;
  }
  
  function biCopy(bi)
  {
  	var result = new BigInt(true);
  	result.digits = bi.digits.slice(0);
  	result.isNeg = bi.isNeg;
  	return result;
  }
  
  function biFromNumber(i)
  {
  	var result = new BigInt();
  	result.isNeg = i < 0;
  	i = Math.abs(i);
  	var j = 0;
  	while (i > 0) {
  		result.digits[j++] = i & maxDigitVal;
  		i = Math.floor(i / biRadix);
  	}
  	return result;
  }
  
  function reverseStr(s)
  {
  	var result = "";
  	for (var i = s.length - 1; i > -1; --i) {
  		result += s.charAt(i);
  	}
  	return result;
  }
  
  var hexatrigesimalToChar = new Array(
   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
   'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
   'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
   'u', 'v', 'w', 'x', 'y', 'z'
  );
  
  function biToString(x, radix)
  	// 2 <= radix <= 36
  {
  	var b = new BigInt();
  	b.digits[0] = radix;
  	var qr = biDivideModulo(x, b);
  	var result = hexatrigesimalToChar[qr[1].digits[0]];
  	while (biCompare(qr[0], bigZero) == 1) {
  		qr = biDivideModulo(qr[0], b);
  		digit = qr[1].digits[0];
  		result += hexatrigesimalToChar[qr[1].digits[0]];
  	}
  	return (x.isNeg ? "-" : "") + reverseStr(result);
  }
  
  function biToDecimal(x)
  {
  	var b = new BigInt();
  	b.digits[0] = 10;
  	var qr = biDivideModulo(x, b);
  	var result = String(qr[1].digits[0]);
  	while (biCompare(qr[0], bigZero) == 1) {
  		qr = biDivideModulo(qr[0], b);
  		result += String(qr[1].digits[0]);
  	}
  	return (x.isNeg ? "-" : "") + reverseStr(result);
  }
  
  var hexToChar = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                            'a', 'b', 'c', 'd', 'e', 'f');
  
  function digitToHex(n)
  {
  	var mask = 0xf;
  	var result = "";
  	for (i = 0; i < 4; ++i) {
  		result += hexToChar[n & mask];
  		n >>>= 4;
  	}
  	return reverseStr(result);
  }
  
  function biToHex(x)
  {
  	var result = "";
  	var n = biHighIndex(x);
  	for (var i = biHighIndex(x); i > -1; --i) {
  		result += digitToHex(x.digits[i]);
  	}
  	return result;
  }
  
  function charToHex(c)
  {
  	var ZERO = 48;
  	var NINE = ZERO + 9;
  	var littleA = 97;
  	var littleZ = littleA + 25;
  	var bigA = 65;
  	var bigZ = 65 + 25;
  	var result;
  
  	if (c >= ZERO && c <= NINE) {
  		result = c - ZERO;
  	} else if (c >= bigA && c <= bigZ) {
  		result = 10 + c - bigA;
  	} else if (c >= littleA && c <= littleZ) {
  		result = 10 + c - littleA;
  	} else {
  		result = 0;
  	}
  	return result;
  }
  
  function hexToDigit(s)
  {
  	var result = 0;
  	var sl = Math.min(s.length, 4);
  	for (var i = 0; i < sl; ++i) {
  		result <<= 4;
  		result |= charToHex(s.charCodeAt(i))
  	}
  	return result;
  }
  
  function biFromHex(s)
  {
  	var result = new BigInt();
  	var sl = s.length;
  	for (var i = sl, j = 0; i > 0; i -= 4, ++j) {
  		result.digits[j] = hexToDigit(s.substr(Math.max(i - 4, 0), Math.min(i, 4)));
  	}
  	return result;
  }
  
  function biFromString(s, radix)
  {
  	var isNeg = s.charAt(0) == '-';
  	var istop = isNeg ? 1 : 0;
  	var result = new BigInt();
  	var place = new BigInt();
  	place.digits[0] = 1; // radix^0
  	for (var i = s.length - 1; i >= istop; i--) {
  		var c = s.charCodeAt(i);
  		var digit = charToHex(c);
  		var biDigit = biMultiplyDigit(place, digit);
  		result = biAdd(result, biDigit);
  		place = biMultiplyDigit(place, radix);
  	}
  	result.isNeg = isNeg;
  	return result;
  }
  
  function biDump(b)
  {
  	return (b.isNeg ? "-" : "") + b.digits.join(" ");
  }
  
  function biAdd(x, y)
  {
  	var result;
  
  	if (x.isNeg != y.isNeg) {
  		y.isNeg = !y.isNeg;
  		result = biSubtract(x, y);
  		y.isNeg = !y.isNeg;
  	}
  	else {
  		result = new BigInt();
  		var c = 0;
  		var n;
  		for (var i = 0; i < x.digits.length; ++i) {
  			n = x.digits[i] + y.digits[i] + c;
  			result.digits[i] = n % biRadix;
  			c = Number(n >= biRadix);
  		}
  		result.isNeg = x.isNeg;
  	}
  	return result;
  }
  
  function biSubtract(x, y)
  {
  	var result;
  	if (x.isNeg != y.isNeg) {
  		y.isNeg = !y.isNeg;
  		result = biAdd(x, y);
  		y.isNeg = !y.isNeg;
  	} else {
  		result = new BigInt();
  		var n, c;
  		c = 0;
  		for (var i = 0; i < x.digits.length; ++i) {
  			n = x.digits[i] - y.digits[i] + c;
  			result.digits[i] = n % biRadix;
  			// Stupid non-conforming modulus operation.
  			if (result.digits[i] < 0) result.digits[i] += biRadix;
  			c = 0 - Number(n < 0);
  		}
  		// Fix up the negative sign, if any.
  		if (c == -1) {
  			c = 0;
  			for (var i = 0; i < x.digits.length; ++i) {
  				n = 0 - result.digits[i] + c;
  				result.digits[i] = n % biRadix;
  				// Stupid non-conforming modulus operation.
  				if (result.digits[i] < 0) result.digits[i] += biRadix;
  				c = 0 - Number(n < 0);
  			}
  			// Result is opposite sign of arguments.
  			result.isNeg = !x.isNeg;
  		} else {
  			// Result is same sign.
  			result.isNeg = x.isNeg;
  		}
  	}
  	return result;
  }
  
  function biHighIndex(x)
  {
  	var result = x.digits.length - 1;
  	while (result > 0 && x.digits[result] == 0) --result;
  	return result;
  }
  
  function biNumBits(x)
  {
  	var n = biHighIndex(x);
  	var d = x.digits[n];
  	var m = (n + 1) * bitsPerDigit;
  	var result;
  	for (result = m; result > m - bitsPerDigit; --result) {
  		if ((d & 0x8000) != 0) break;
  		d <<= 1;
  	}
  	return result;
  }
  
  function biMultiply(x, y)
  {
  	var result = new BigInt();
  	var c;
  	var n = biHighIndex(x);
  	var t = biHighIndex(y);
  	var u, uv, k;
  
  	for (var i = 0; i <= t; ++i) {
  		c = 0;
  		k = i;
  		for (j = 0; j <= n; ++j, ++k) {
  			uv = result.digits[k] + x.digits[j] * y.digits[i] + c;
  			result.digits[k] = uv & maxDigitVal;
  			c = uv >>> biRadixBits;
  			//c = Math.floor(uv / biRadix);
  		}
  		result.digits[i + n + 1] = c;
  	}
  	// Someone give me a logical xor, please.
  	result.isNeg = x.isNeg != y.isNeg;
  	return result;
  }
  
  function biMultiplyDigit(x, y)
  {
  	var n, c, uv;
  
  	result = new BigInt();
  	n = biHighIndex(x);
  	c = 0;
  	for (var j = 0; j <= n; ++j) {
  		uv = result.digits[j] + x.digits[j] * y + c;
  		result.digits[j] = uv & maxDigitVal;
  		c = uv >>> biRadixBits;
  		//c = Math.floor(uv / biRadix);
  	}
  	result.digits[1 + n] = c;
  	return result;
  }
  
  function arrayCopy(src, srcStart, dest, destStart, n)
  {
  	var m = Math.min(srcStart + n, src.length);
  	for (var i = srcStart, j = destStart; i < m; ++i, ++j) {
  		dest[j] = src[i];
  	}
  }
  
  var highBitMasks = new Array(0x0000, 0x8000, 0xC000, 0xE000, 0xF000, 0xF800,
                               0xFC00, 0xFE00, 0xFF00, 0xFF80, 0xFFC0, 0xFFE0,
                               0xFFF0, 0xFFF8, 0xFFFC, 0xFFFE, 0xFFFF);
  
  function biShiftLeft(x, n)
  {
  	var digitCount = Math.floor(n / bitsPerDigit);
  	var result = new BigInt();
  	arrayCopy(x.digits, 0, result.digits, digitCount,
  	          result.digits.length - digitCount);
  	var bits = n % bitsPerDigit;
  	var rightBits = bitsPerDigit - bits;
  	for (var i = result.digits.length - 1, i1 = i - 1; i > 0; --i, --i1) {
  		result.digits[i] = ((result.digits[i] << bits) & maxDigitVal) |
  		                   ((result.digits[i1] & highBitMasks[bits]) >>>
  		                    (rightBits));
  	}
  	result.digits[0] = ((result.digits[i] << bits) & maxDigitVal);
  	result.isNeg = x.isNeg;
  	return result;
  }
  
  var lowBitMasks = new Array(0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F,
                              0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF,
                              0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF);
  
  function biShiftRight(x, n)
  {
  	var digitCount = Math.floor(n / bitsPerDigit);
  	var result = new BigInt();
  	arrayCopy(x.digits, digitCount, result.digits, 0,
  	          x.digits.length - digitCount);
  	var bits = n % bitsPerDigit;
  	var leftBits = bitsPerDigit - bits;
  	for (var i = 0, i1 = i + 1; i < result.digits.length - 1; ++i, ++i1) {
  		result.digits[i] = (result.digits[i] >>> bits) |
  		                   ((result.digits[i1] & lowBitMasks[bits]) << leftBits);
  	}
  	result.digits[result.digits.length - 1] >>>= bits;
  	result.isNeg = x.isNeg;
  	return result;
  }
  
  function biMultiplyByRadixPower(x, n)
  {
  	var result = new BigInt();
  	arrayCopy(x.digits, 0, result.digits, n, result.digits.length - n);
  	return result;
  }
  
  function biDivideByRadixPower(x, n)
  {
  	var result = new BigInt();
  	arrayCopy(x.digits, n, result.digits, 0, result.digits.length - n);
  	return result;
  }
  
  function biModuloByRadixPower(x, n)
  {
  	var result = new BigInt();
  	arrayCopy(x.digits, 0, result.digits, 0, n);
  	return result;
  }
  
  function biCompare(x, y)
  {
  	if (x.isNeg != y.isNeg) {
  		return 1 - 2 * Number(x.isNeg);
  	}
  	for (var i = x.digits.length - 1; i >= 0; --i) {
  		if (x.digits[i] != y.digits[i]) {
  			if (x.isNeg) {
  				return 1 - 2 * Number(x.digits[i] > y.digits[i]);
  			} else {
  				return 1 - 2 * Number(x.digits[i] < y.digits[i]);
  			}
  		}
  	}
  	return 0;
  }
  
  function biDivideModulo(x, y)
  {
  	var nb = biNumBits(x);
  	var tb = biNumBits(y);
  	var origYIsNeg = y.isNeg;
  	var q, r;
  	if (nb < tb) {
  		// |x| < |y|
  		if (x.isNeg) {
  			q = biCopy(bigOne);
  			q.isNeg = !y.isNeg;
  			x.isNeg = false;
  			y.isNeg = false;
  			r = biSubtract(y, x);
  			// Restore signs, 'cause they're references.
  			x.isNeg = true;
  			y.isNeg = origYIsNeg;
  		} else {
  			q = new BigInt();
  			r = biCopy(x);
  		}
  		return new Array(q, r);
  	}
  
  	q = new BigInt();
  	r = x;
  
  	// Normalize Y.
  	var t = Math.ceil(tb / bitsPerDigit) - 1;
  	var lambda = 0;
  	while (y.digits[t] < biHalfRadix) {
  		y = biShiftLeft(y, 1);
  		++lambda;
  		++tb;
  		t = Math.ceil(tb / bitsPerDigit) - 1;
  	}
  	// Shift r over to keep the quotient constant. We'll shift the
  	// remainder back at the end.
  	r = biShiftLeft(r, lambda);
  	nb += lambda; // Update the bit count for x.
  	var n = Math.ceil(nb / bitsPerDigit) - 1;
  
  	var b = biMultiplyByRadixPower(y, n - t);
  	while (biCompare(r, b) != -1) {
  		++q.digits[n - t];
  		r = biSubtract(r, b);
  	}
  	for (var i = n; i > t; --i) {
      var ri = (i >= r.digits.length) ? 0 : r.digits[i];
      var ri1 = (i - 1 >= r.digits.length) ? 0 : r.digits[i - 1];
      var ri2 = (i - 2 >= r.digits.length) ? 0 : r.digits[i - 2];
      var yt = (t >= y.digits.length) ? 0 : y.digits[t];
      var yt1 = (t - 1 >= y.digits.length) ? 0 : y.digits[t - 1];
  		if (ri == yt) {
  			q.digits[i - t - 1] = maxDigitVal;
  		} else {
  			q.digits[i - t - 1] = Math.floor((ri * biRadix + ri1) / yt);
  		}
  
  		var c1 = q.digits[i - t - 1] * ((yt * biRadix) + yt1);
  		var c2 = (ri * biRadixSquared) + ((ri1 * biRadix) + ri2);
  		while (c1 > c2) {
  			--q.digits[i - t - 1];
  			c1 = q.digits[i - t - 1] * ((yt * biRadix) | yt1);
  			c2 = (ri * biRadix * biRadix) + ((ri1 * biRadix) + ri2);
  		}
  
  		b = biMultiplyByRadixPower(y, i - t - 1);
  		r = biSubtract(r, biMultiplyDigit(b, q.digits[i - t - 1]));
  		if (r.isNeg) {
  			r = biAdd(r, b);
  			--q.digits[i - t - 1];
  		}
  	}
  	r = biShiftRight(r, lambda);
  	// Fiddle with the signs and stuff to make sure that 0 <= r < y.
  	q.isNeg = x.isNeg != origYIsNeg;
  	if (x.isNeg) {
  		if (origYIsNeg) {
  			q = biAdd(q, bigOne);
  		} else {
  			q = biSubtract(q, bigOne);
  		}
  		y = biShiftRight(y, lambda);
  		r = biSubtract(y, r);
  	}
  	// Check for the unbelievably stupid degenerate case of r == -0.
  	if (r.digits[0] == 0 && biHighIndex(r) == 0) r.isNeg = false;
  
  	return new Array(q, r);
  }
  
  function biDivide(x, y)
  {
  	return biDivideModulo(x, y)[0];
  }
  
  function biModulo(x, y)
  {
  	return biDivideModulo(x, y)[1];
  }
  
  function biMultiplyMod(x, y, m)
  {
  	return biModulo(biMultiply(x, y), m);
  }
  
  function biPow(x, y)
  {
  	var result = bigOne;
  	var a = x;
  	while (true) {
  		if ((y & 1) != 0) result = biMultiply(result, a);
  		y >>= 1;
  		if (y == 0) break;
  		a = biMultiply(a, a);
  	}
  	return result;
  }
  
  function biPowMod(x, y, m)
  {
  	var result = bigOne;
  	var a = x;
  	var k = y;
  	while (true) {
  		if ((k.digits[0] & 1) != 0) result = biMultiplyMod(result, a, m);
  		k = biShiftRight(k, 1);
  		if (k.digits[0] == 0 && biHighIndex(k) == 0) break;
  		a = biMultiplyMod(a, a, m);
  	}
  	return result;
  }
  
  // BarrettMu, a class for performing Barrett modular reduction computations in
  // JavaScript.
  //
  // Requires BigInt.js.
  //
  // Copyright 2004-2005 David Shapiro.
  //
  // You may use, re-use, abuse, copy, and modify this code to your liking, but
  // please keep this header.
  //
  // Thanks!
  // 
  // Dave Shapiro
  // [email protected] 
  
  function BarrettMu(m)
  {
  	this.modulus = biCopy(m);
  	this.k = biHighIndex(this.modulus) + 1;
  	var b2k = new BigInt();
  	b2k.digits[2 * this.k] = 1; // b2k = b^(2k)
  	this.mu = biDivide(b2k, this.modulus);
  	this.bkplus1 = new BigInt();
  	this.bkplus1.digits[this.k + 1] = 1; // bkplus1 = b^(k+1)
  	this.modulo = BarrettMu_modulo;
  	this.multiplyMod = BarrettMu_multiplyMod;
  	this.powMod = BarrettMu_powMod;
  }
  
  function BarrettMu_modulo(x)
  {
  	var q1 = biDivideByRadixPower(x, this.k - 1);
  	var q2 = biMultiply(q1, this.mu);
  	var q3 = biDivideByRadixPower(q2, this.k + 1);
  	var r1 = biModuloByRadixPower(x, this.k + 1);
  	var r2term = biMultiply(q3, this.modulus);
  	var r2 = biModuloByRadixPower(r2term, this.k + 1);
  	var r = biSubtract(r1, r2);
  	if (r.isNeg) {
  		r = biAdd(r, this.bkplus1);
  	}
  	var rgtem = biCompare(r, this.modulus) >= 0;
  	while (rgtem) {
  		r = biSubtract(r, this.modulus);
  		rgtem = biCompare(r, this.modulus) >= 0;
  	}
  	return r;
  }
  
  function BarrettMu_multiplyMod(x, y)
  {
  	/*
  	x = this.modulo(x);
  	y = this.modulo(y);
  	*/
  	var xy = biMultiply(x, y);
  	return this.modulo(xy);
  }
  
  function BarrettMu_powMod(x, y)
  {
  	var result = new BigInt();
  	result.digits[0] = 1;
  	var a = x;
  	var k = y;
  	while (true) {
  		if ((k.digits[0] & 1) != 0) result = this.multiplyMod(result, a);
  		k = biShiftRight(k, 1);
  		if (k.digits[0] == 0 && biHighIndex(k) == 0) break;
  		a = this.multiplyMod(a, a);
  	}
  	return result;
  }
  
  
         
        

  
  

前台header上加入js代码

 function RSAPassAndSubmit(passTxtBox, confirmPassTxtBox, exponent, modulus) {
        setMaxDigits(130);
        var key = new RSAKeyPair(exponent, "", modulus);
        passTxtBox.value = encryptedString(key, passTxtBox.value);
        confirmPassTxtBox.value = encryptedString(key, confirmPassTxtBox.value);
        }

注册的button上加入事件

<button class="primaryAction btn btn-default" type="submit" id="btnRegister" onsubmit="javascript:return validatePlus();" onclick="@string.Format("javascript:RSAPassAndSubmit(Password,ConfirmPassword,'{0}','{1}');", ViewData["Exponent"],
                 ViewData["Modulus"])" > @T("註冊")button>

关于ViewData[“Exponent”]，ViewData[“Modulus”])，这两个参数是后台传过来的

后台代码

对前台加密传过来的密码进行解密了

当然首先前台还需要的东西 加密键值对 要给他传过去。

private const string RsaKeyname = "RSAKeyPair";
//第一次执行的时候调用，当然在执行post的时候，比如注册不成功，我们还需要在调用InitialRsaViewData()方法 初始化返回view().
public ActionResult Register()
        {  
            InitialRsaViewData()；
            return View();
        }

/// 

/// Create Exponent and Modulus For RSA Encrypt Password 
/// 
private void InitialRsaViewData()
        {
            var rsa = new RSACryptoServiceProvider(1024);
            RSAParameters para = rsa.ExportParameters(true);
            ViewData["Exponent"] = _userAcountService.BytesToHex(para.Exponent);
            ViewData["Modulus"] = _userAcountService.BytesToHex(para.Modulus);

            Session[RsaKeyname] = para;
        }

上面的还有两个方法BytesToHex(),BytesToHex()是写在serivice中的，可以拿出来：

 public string BytesToHex(byte[] input)
        {
            StringBuilder hexString = new StringBuilder(64);

            for (int i = 0; i < input.Length; i++)
            {
                hexString.Append(String.Format("{0:X2}", input[i]));
            }
            return hexString.ToString();
        }

   public byte[] HexToBytes(string hex)
        {

            if (hex.Length == 0)
            {
                return new byte[] { 0 };
            }

            if (hex.Length % 2 == 1)
            {
                hex = "0" + hex;
            }

            byte[] result = new byte[hex.Length / 2];

            for (int i = 0; i < hex.Length / 2; i++)
            {
                result[i] = byte.Parse(hex.Substring(2 * i, 2), System.Globalization.NumberStyles.AllowHexSpecifier);
            }

            return result;
        }

然后就是解密方法了,需要对密码操作的地方调用一下

 /// 

 /// The password to decrypt
 /// 
 /// 
 /// 
 private string RsaDecrypt(string s)
        {
            var rsa = new RSACryptoServiceProvider();
            rsa.ImportParameters((RSAParameters)Session[RsaKeyname]);
            string strPassword = System.Text.Encoding.ASCII.GetString(rsa.Decrypt(_userAcountService.HexToBytes(s), false));
            return strPassword;
        }

[toc]
再说说遇到的一些问题吧，在chrome中运行程序的时候，我一开始把解密方法没封装成函数，直接写，也就是同时解密password和confirmPassword，出现不正确的数据什么的bug。不管他，但是单一的解密又是可以的，后来把chrome的缓存关了，就好了。乱七八糟的bug，orchad破玩意~~