提交代码

2025-03-13 09:20:11 +08:00
parent 6d0c6e28de
commit 980946f316
3443 changed files with 188150 additions and 3 deletions
@@ -0,0 +1,144 @@
+// 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
+// dave@ohdave.com 
+
+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 (rob@robsaunders.net). 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<msgLength; x++)
+		{
+		    b[x] = a[i+msgLength-1-x];
+		}
+		b[msgLength] = 0; // marker
+		var paddedSize = Math.max(8, key.digitSize - 3 - msgLength);
+	
+		for (x=0; x<paddedSize; x++) {
+		    b[msgLength+1+x] = Math.floor(Math.random()*254) + 1; // [1,255]
+		}
+		// It can be asserted that msgLength+paddedSize == key.digitSize-3
+		b[key.digitSize-2] = 2; // marker
+		b[key.digitSize-1] = 0; // marker
+		
+		for (k = 0; k < key.digitSize; ++j) 
+		{
+		    block.digits[j] = b[k++];
+		    block.digits[j] += b[k++] << 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;
+}