• 前后端加密解密工具类(前端rsa加密,后端进行解密)

    前端代码中传入后端工具类返回的两个加密串信息进行加密

    1. html>
    2. <html lang="en">
    3.  
    4. <head>
    5.   <meta charset="UTF-8">
    6.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    7.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    8.   <title>什么是对象以及对象属性title>
    9.  
    10. head>
    11.  
    12. <body>
    13.   <script type="text/javascript" charset="utf-8" src="../03-code/14-学成在线/RSA.js">script>
    14.   <script>
    15.     // 对象也是一种数据类型，保存数据同时可以更直观的描述事物
    16.     // 1. 定义对象属性
    17.     RSAUtils.setMaxDigits(200); 
    18.     var key = new RSAUtils.getKeyPair('010001', "", '00951e7a698c4dc31fe292a67c12c94a56f1ba409945b6175470d696b167a073e4fe099f52fbaa041e5be0a473dfe5818ea6a2f9c1b4db5e66fa26d6a31575deb488fda96128e143b9e3a4131972ebb2d8e6e092a464725dfaa441268b787820b5fe915ee1676ef139ae001aa8235d3325689445963f32789087927f6194c5a6f9');  
    19.     console.log(key)
    20.     var wad=  RSAUtils.encryptedString(key,"123456".split("").reverse().join(""))
    21.     console.log(wad)
    22.     
    23.     let pig = {
    24.       sex: '女',
    25.       age: 4,
    26.       uname: '佩奇',
    27.       weight: 12.6
    28.     }
    29.  
    30.     // 2. 访问对象属性  对象.属性
    31.     console.log(pig.age)  // 4
    32.     console.log(pig.weight)  // 12.6
    33.   script>
    34. body>
    35.  
    36. html>

    附录工具类

    1. package com.atguigu.yygh.cmn.Rsa;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.FileOutputStream;
    6. import java.io.ObjectInputStream;
    7. import java.io.ObjectOutputStream;
    8. import java.math.BigInteger;
    9. import java.security.InvalidParameterException;
    10. import java.security.KeyFactory;
    11. import java.security.KeyPair;
    12. import java.security.KeyPairGenerator;
    13. import java.security.NoSuchAlgorithmException;
    14. import java.security.PrivateKey;
    15. import java.security.Provider;
    16. import java.security.PublicKey;
    17. import java.security.SecureRandom;
    18. import java.security.interfaces.RSAPrivateKey;
    19. import java.security.interfaces.RSAPublicKey;
    20. import java.security.spec.InvalidKeySpecException;
    21. import java.security.spec.RSAPrivateKeySpec;
    22. import java.security.spec.RSAPublicKeySpec;
    23. import java.util.Date;
    24. import java.util.HashMap;
    25.  
    26. import javax.crypto.Cipher;
    27.  
    28. import org.apache.commons.codec.DecoderException;
    29. import org.apache.commons.codec.binary.Hex;
    30. import org.apache.commons.io.FileUtils;
    31. import org.apache.commons.io.IOUtils;
    32. import org.apache.commons.lang.StringUtils;
    33. import org.apache.commons.lang.time.DateFormatUtils;
    34. import org.bouncycastle.jce.provider.BouncyCastleProvider;
    35. import org.slf4j.Logger;
    36. import org.slf4j.LoggerFactory;
    37.  
    38.   
    39. /**
    40.  * 
    41.  * RSA?
    42.  * @author Administrator
    43.  *
    44.  */
    45.  
    46.  
    47. public class RSAUtils {
    48.  
    49.     public static void main(String[] args) {
    50.         HashMap map = new HashMap<>();
    51.         map.put("path","9065336912");
    52.         //todo 这块是重载方法  可以传一个map,也可以不穿,最后返回的是两个字符串,前端用该字符串加密密码,后端解密就行
    53.         PublicKeyMap publicKeyMap = RSAUtils.getPublicKeyMap();
    54.         System.out.println(publicKeyMap);
    55.         System.out.println(RSAUtils.decryptStringByJs("2e5ea42abd7a3c06d07e6cc1d08a824455994bc30cb9d34541b7878e1bcd01c4a168ce3c98216a29b13eadab84889134ee4f52bdaabd68ec1171a29a021058854e659bf00c808a24c04fab85b4e08e6ff5da32c9abc47501b212ee98f7f09f2164d9d19ca7abce8763d6ae7ec608752af7d3a92517ff535f53afb54a78ce7143"));
    56.     }
    57.   
    58. 	private static final Logger LOGGER = LoggerFactory.getLogger(RSAUtils.class);
    59.  
    60.     /** ?????? */
    61.     private static final String ALGORITHOM = "RSA";
    62.     /**??????????????????????? */
    63.     private static final String RSA_PAIR_FILENAME = "/__RSA_PAIR.txt";
    64.     /** ?????С */
    65.     private static final int KEY_SIZE = 1024;
    66.     /** ?????????????? */
    67.     private static final Provider DEFAULT_PROVIDER = new BouncyCastleProvider();
    68.  
    69.     private static KeyPairGenerator keyPairGen = null;
    70.     private static KeyFactory keyFactory = null;
    71.     /** ??????????? */
    72.     private static KeyPair oneKeyPair = null;
    73.  
    74.     private static File rsaPairFile = null;
    75.  
    76.     static {
    77.         try {
    78.             keyPairGen = KeyPairGenerator.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
    79.             keyFactory = KeyFactory.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
    80.         } catch (NoSuchAlgorithmException ex) {
    81.             LOGGER.error(ex.getMessage());
    82.         }
    83.         rsaPairFile = new File(getRSAPairFilePath());
    84.     }
    85.  
    86.     private RSAUtils() {
    87.     }
    88.  
    89.     /**
    90.      * ?????????RSA??????
    91.      */
    92.     private static synchronized KeyPair generateKeyPair() {
    93.         try {
    94.             keyPairGen.initialize(KEY_SIZE, new SecureRandom(DateFormatUtils.format(new Date(),"yyyyMMdd").getBytes()));
    95.             oneKeyPair = keyPairGen.generateKeyPair();
    96.             saveKeyPair(oneKeyPair);
    97.             return oneKeyPair;
    98.         } catch (InvalidParameterException ex) {
    99.             LOGGER.error("KeyPairGenerator does not support a key length of " + KEY_SIZE + ".", ex);
    100.         } catch (NullPointerException ex) {
    101.             LOGGER.error("RSAUtils#KEY_PAIR_GEN is null, can not generate KeyPairGenerator instance.",ex);
    102.         }
    103.         return null;
    104.     }
    105.  
    106.     /**
    107.      * ????????/???????????????·????
    108.      */
    109.     private static String getRSAPairFilePath() {
    110.         String urlPath = RSAUtils.class.getResource("/").getPath();
    111.         return (new File(urlPath).getParent() + RSA_PAIR_FILENAME);
    112.     }
    113.  
    114.     /**
    115.      * ????????????????????????? {@code true}?????? {@code false}??
    116.      */
    117.     private static boolean isCreateKeyPairFile() {
    118.         // ???????????????
    119.         boolean createNewKeyPair = false;
    120.         if (!rsaPairFile.exists() || rsaPairFile.isDirectory()) {
    121.             createNewKeyPair = true;
    122.         }
    123.         return createNewKeyPair;
    124.     }
    125.  
    126.     /**
    127.      * ???????RSA????????????????档
    128.      * 
    129.      * @param keyPair ????????????
    130.      */
    131.     private static void saveKeyPair(KeyPair keyPair) {
    132.         FileOutputStream fos = null;
    133.         ObjectOutputStream oos = null;
    134.         try {
    135.             fos = FileUtils.openOutputStream(rsaPairFile);
    136.             oos = new ObjectOutputStream(fos);
    137.             oos.writeObject(keyPair);
    138.         } catch (Exception ex) {
    139.             ex.printStackTrace();
    140.         } finally {
    141.         	IOUtils.closeQuietly(oos);
    142.             IOUtils.closeQuietly(fos);
    143.         }
    144.     }
    145.  
    146.     /**
    147.      * ????RSA??????
    148.      */
    149.     public static KeyPair getKeyPair() {
    150.         // ?????ж??????????????????????????
    151.         if (isCreateKeyPairFile()) {
    152.             // ???????????????????????????档
    153.             return generateKeyPair();
    154.         }
    155.         if (oneKeyPair != null) {
    156.             return oneKeyPair;
    157.         }
    158.         return readKeyPair();
    159.     }
    160.     
    161.     // ?????????????????
    162.     private static KeyPair readKeyPair() {
    163.         FileInputStream fis = null;
    164.         ObjectInputStream ois = null;
    165.         try {
    166.             fis = FileUtils.openInputStream(rsaPairFile);
    167.             ois = new ObjectInputStream(fis);
    168.             oneKeyPair = (KeyPair) ois.readObject();
    169.             return oneKeyPair;
    170.         } catch (Exception ex) {
    171.             ex.printStackTrace();
    172.         } finally {
    173.             IOUtils.closeQuietly(ois);
    174.             IOUtils.closeQuietly(fis);
    175.         }
    176.         return null;
    177.     }
    178.  
    179.     /**
    180.      * ???????????????????????????RSA??????????
    181.      * 
    182.      * @param modulus ?????
    183.      * @param publicExponent ????????
    184.      * @return RSA??ù??????
    185.      */
    186.     public static RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) {
    187.         RSAPublicKeySpec publicKeySpec = new RSAPublicKeySpec(new BigInteger(modulus),
    188.                 new BigInteger(publicExponent));
    189.         try {
    190.             return (RSAPublicKey) keyFactory.generatePublic(publicKeySpec);
    191.         } catch (InvalidKeySpecException ex) {
    192.             LOGGER.error("RSAPublicKeySpec is unavailable.", ex);
    193.         } catch (NullPointerException ex) {
    194.             LOGGER.error("RSAUtils#KEY_FACTORY is null, can not generate KeyFactory instance.", ex);
    195.         }
    196.         return null;
    197.     }
    198.  
    199.     /**
    200.      * ???????????????????????????RSA??????????
    201.      * 
    202.      * @param modulus ?????
    203.      * @param privateExponent ????????
    204.      * @return RSA?????????
    205.      */
    206.     public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) {
    207.         RSAPrivateKeySpec privateKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus),
    208.                 new BigInteger(privateExponent));
    209.         try {
    210.             return (RSAPrivateKey) keyFactory.generatePrivate(privateKeySpec);
    211.         } catch (InvalidKeySpecException ex) {
    212.             LOGGER.error("RSAPrivateKeySpec is unavailable.", ex);
    213.         } catch (NullPointerException ex) {
    214.             LOGGER.error("RSAUtils#KEY_FACTORY is null, can not generate KeyFactory instance.", ex);
    215.         }
    216.         return null;
    217.     }
    218.     
    219.     /**
    220.      * ?????????16???????????????????????????RSA??????????
    221.      * 
    222.      * @param modulus ?????
    223.      * @param privateExponent ????????
    224.      * @return RSA?????????
    225.      */
    226.     public static RSAPrivateKey getRSAPrivateKey(String hexModulus, String hexPrivateExponent) {
    227.         if(StringUtils.isBlank(hexModulus) || StringUtils.isBlank(hexPrivateExponent)) {
    228.             if(LOGGER.isDebugEnabled()) {
    229.                 LOGGER.debug("hexModulus and hexPrivateExponent cannot be empty. RSAPrivateKey value is null to return.");
    230.             }
    231.             return null;
    232.         }
    233.         byte[] modulus = null;
    234.         byte[] privateExponent = null;
    235.         try {
    236.             modulus = Hex.decodeHex(hexModulus.toCharArray());
    237.             privateExponent = Hex.decodeHex(hexPrivateExponent.toCharArray());
    238.         } catch(DecoderException ex) {
    239.             LOGGER.error("hexModulus or hexPrivateExponent value is invalid. return null(RSAPrivateKey).");
    240.         }
    241.         if(modulus != null && privateExponent != null) {
    242.             return generateRSAPrivateKey(modulus, privateExponent);
    243.         }
    244.         return null;
    245.     }
    246.     
    247.     /**
    248.      * ?????????16???????????????????????????RSA??????????
    249.      * 
    250.      * @param modulus ?????
    251.      * @param publicExponent ????????
    252.      * @return RSA??ù??????
    253.      */
    254.     public static RSAPublicKey getRSAPublidKey(String hexModulus, String hexPublicExponent) {
    255.         if(StringUtils.isBlank(hexModulus) || StringUtils.isBlank(hexPublicExponent)) {
    256.             if(LOGGER.isDebugEnabled()) {
    257.                 LOGGER.debug("hexModulus and hexPublicExponent cannot be empty. return null(RSAPublicKey).");
    258.             }
    259.             return null;
    260.         }
    261.         byte[] modulus = null;
    262.         byte[] publicExponent = null;
    263.         try {
    264.             modulus = Hex.decodeHex(hexModulus.toCharArray());
    265.             publicExponent = Hex.decodeHex(hexPublicExponent.toCharArray());
    266.         } catch(DecoderException ex) {
    267.             LOGGER.error("hexModulus or hexPublicExponent value is invalid. return null(RSAPublicKey).");
    268.         }
    269.         if(modulus != null && publicExponent != null) {
    270.             return generateRSAPublicKey(modulus, publicExponent);
    271.         }
    272.         return null;
    273.     }
    274.  
    275.     /**
    276.      * ???????????????????
    277.      * 
    278.      * @param publicKey ??????????
    279.      * @param data ???????????
    280.      * @return ???????????
    281.      */
    282.     public static byte[] encrypt(PublicKey publicKey, byte[] data) throws Exception {
    283.         Cipher ci = Cipher.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
    284.         ci.init(Cipher.ENCRYPT_MODE, publicKey);
    285.         return ci.doFinal(data);
    286.     }
    287.  
    288.     /**
    289.      * ???????????????????
    290.      * 
    291.      * @param privateKey ??????????
    292.      * @param data ???????????
    293.      * @return ??????
    294.      */
    295.     public static byte[] decrypt(PrivateKey privateKey, byte[] data) throws Exception {
    296.         Cipher ci = Cipher.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
    297.         ci.init(Cipher.DECRYPT_MODE, privateKey);
    298.         return ci.doFinal(data);
    299.     }
    300.  
    301.     /**
    302.      * ??????????????????????????
    303.      * 
    304.      * ?? {@code publicKey} ? {@code null}?????? {@code plaintext} ? {@code null} ??? {@code
    305.      * null}??
    306.      * 
    307.      * @param publicKey ??????????
    308.      * @param plaintext ???????
    309.      * @return ????????????????
    310.      */
    311.     public static String encryptString(PublicKey publicKey, String plaintext) {
    312.         if (publicKey == null || plaintext == null) {
    313.             return null;
    314.         }
    315.         byte[] data = plaintext.getBytes();
    316.         try {
    317.             byte[] en_data = encrypt(publicKey, data);
    318.             return new String(Hex.encodeHex(en_data));
    319.         } catch (Exception ex) {
    320.             LOGGER.error(ex.getCause().getMessage());
    321.         }
    322.         return null;
    323.     }
    324.     
    325.     /**
    326.      * ?????????????????????????
    327.      * 
    328.      * ??{@code plaintext} ? {@code null} ??? {@code null}??
    329.      * 
    330.      * @param plaintext ???????
    331.      * @return ????????????????
    332.      */
    333.     public static String encryptString(String plaintext) {
    334.         if(plaintext == null) {
    335.             return null;
    336.         }
    337.         byte[] data = plaintext.getBytes();
    338.         KeyPair keyPair = getKeyPair();
    339.         try {
    340.             byte[] en_data = encrypt((RSAPublicKey)keyPair.getPublic(), data);
    341.             return new String(Hex.encodeHex(en_data));
    342.         } catch(NullPointerException ex) {
    343.             LOGGER.error("keyPair cannot be null.");
    344.         } catch(Exception ex) {
    345.             LOGGER.error(ex.getCause().getMessage());
    346.         }
    347.         return null;
    348.     }
    349.  
    350.     /**
    351.      * ??????????????????????????
    352.      * 
    353.      * ????? {@code null}?????? {@code encrypttext} ? {@code null}??????????? {@code null}??
    354.      * ?????????????? {@code null}??
    355.      * 
    356.      * @param privateKey ??????????
    357.      * @param encrypttext ?????
    358.      * @return ??????????
    359.      */
    360.     public static String decryptString(PrivateKey privateKey, String encrypttext) {
    361.         if (privateKey == null || StringUtils.isBlank(encrypttext)) {
    362.             return null;
    363.         }
    364.         try {
    365.             byte[] en_data = Hex.decodeHex(encrypttext.toCharArray());
    366.             byte[] data = decrypt(privateKey, en_data);
    367.             return new String(data);
    368.         } catch (Exception ex) {
    369.             LOGGER.error(String.format("\"%s\" Decryption failed. Cause: %s", encrypttext, ex.getCause().getMessage()));
    370.         }
    371.         return null;
    372.     }
    373.     
    374.     /**
    375.      * ?????????????????????????
    376.      * 
    377.      * ??{@code encrypttext} ? {@code null}??????????? {@code null}??
    378.      * ?????????????? {@code null}??
    379.      * 
    380.      * @param encrypttext ?????
    381.      * @return ??????????
    382.      */
    383.     public static String decryptString(String encrypttext) {
    384.         if(StringUtils.isBlank(encrypttext)) {
    385.             return null;
    386.         }
    387.         KeyPair keyPair = getKeyPair();
    388.         try {
    389.             byte[] en_data = Hex.decodeHex(encrypttext.toCharArray());
    390.             byte[] data = decrypt((RSAPrivateKey)keyPair.getPrivate(), en_data);
    391.             return new String(data);
    392.         } catch(NullPointerException ex) {
    393.             LOGGER.error("keyPair cannot be null.");
    394.         } catch (Exception ex) {
    395.             LOGGER.error(String.format("\"%s\" Decryption failed. Cause: %s", encrypttext, ex.getMessage()));
    396.         }
    397.         return null;
    398.     }
    399.     
    400.     /**
    401.      * ???????????????JS???????????????????????????????
    402.      * 
    403.      * @param encrypttext ?????
    404.      * @return {@code encrypttext} ????????????
    405.      */
    406.     public static String decryptStringByJs(String encrypttext) {
    407.         String text = decryptString(encrypttext);
    408.         if(text == null) {
    409.             return null;
    410.         }
    411.         return text;
    412.     }
    413.     
    414.     /** ????????????????????*/
    415.     public static RSAPublicKey getDefaultPublicKey() {
    416.         KeyPair keyPair = getKeyPair();
    417.         if(keyPair != null) {
    418.             return (RSAPublicKey)keyPair.getPublic();
    419.         }
    420.         return null;
    421.     }
    422.     
    423.     /** ????????????????????*/
    424.     public static RSAPrivateKey getDefaultPrivateKey() {
    425.         KeyPair keyPair = getKeyPair();
    426.         if(keyPair != null) {
    427.             return (RSAPrivateKey)keyPair.getPrivate();
    428.         }
    429.         return null;
    430.     }
    431.     
    432.     /** ????public key ??*/
    433.     public static PublicKeyMap getPublicKeyMap() {
    434.     	PublicKeyMap publicKeyMap = new PublicKeyMap();
    435.     	RSAPublicKey rsaPublicKey = getDefaultPublicKey();
    436.     	publicKeyMap.setModulus(new String(Hex.encodeHex(rsaPublicKey.getModulus().toByteArray())));
    437. 		publicKeyMap.setExponent(new String(Hex.encodeHex(rsaPublicKey.getPublicExponent().toByteArray())));
    438. 		return publicKeyMap;
    439.     }
    440.     /**
    441.      * ??publickey ?????map??
    442.      * @param map
    443.      */
    444.     @SuppressWarnings({ "rawtypes", "unused", "unchecked" })
    445. 	public static void getPublicKeyMap(HashMap map) {
    446.     	PublicKeyMap publicKeyMap = new PublicKeyMap();
    447.     	RSAPublicKey rsaPublicKey = getDefaultPublicKey();
    448.     	map.put("publicKeyExponent", new String(Hex.encodeHex(rsaPublicKey.getPublicExponent().toByteArray())));  
    449. 		map.put("publicKeyModulus", new String(Hex.encodeHex(rsaPublicKey.getModulus().toByteArray())));
    450.     }
    451. }
    1. package com.atguigu.yygh.cmn.Rsa;
    2.  
    3. public class PublicKeyMap {
    4. 	 private String modulus;
    5. 	 private String exponent;
    6. 	 public String getModulus() {
    7. 	  return modulus;
    8. 	 }
    9. 	 public void setModulus(String modulus) {
    10. 	  this.modulus = modulus;
    11. 	 }
    12. 	 public String getExponent() {
    13. 	  return exponent;
    14. 	 }
    15. 	 public void setExponent(String exponent) {
    16. 	  this.exponent = exponent;
    17. 	 }
    18. 	 @Override
    19. 	 public String toString() {
    20. 	  return "PublicKeyMap [modulus=" + modulus + ", exponent=" + exponent
    21. 	    + "]";
    22. 	 }
    23. }

    ras.js

    1. /*
    2.  * RSA, a suite of routines for performing RSA public-key computations in JavaScript.
    3.  * Copyright 1998-2005 David Shapiro.
    4.  * Dave Shapiro
    5.  * dave@ohdave.com 
    6.  * changed by Fuchun, 2010-05-06
    7.  * fcrpg2005@gmail.com
    8.  */
    9.  
    10. (function($w) {
    11.  
    12. if(typeof $w.RSAUtils === 'undefined')
    13. 	var RSAUtils = $w.RSAUtils = {};
    14.  
    15. var biRadixBase = 2;
    16. var biRadixBits = 16;
    17. var bitsPerDigit = biRadixBits;
    18. var biRadix = 1 << 16; // = 2^16 = 65536
    19. var biHalfRadix = biRadix >>> 1;
    20. var biRadixSquared = biRadix * biRadix;
    21. var maxDigitVal = biRadix - 1;
    22. var maxInteger = 9999999999999998;
    23.  
    24. //maxDigits:
    25. //Change this to accommodate your largest number size. Use setMaxDigits()
    26. //to change it!
    27. //
    28. //In general, if you're working with numbers of size N bits, you'll need 2*N
    29. //bits of storage. Each digit holds 16 bits. So, a 1024-bit key will need
    30. //
    31. //1024 * 2 / 16 = 128 digits of storage.
    32. //
    33. var maxDigits;
    34. var ZERO_ARRAY;
    35. var bigZero, bigOne;
    36.  
    37. var BigInt = $w.BigInt = function(flag) {
    38. 	if (typeof flag == "boolean" && flag == true) {
    39. 		this.digits = null;
    40. 	} else {
    41. 		this.digits = ZERO_ARRAY.slice(0);
    42. 	}
    43. 	this.isNeg = false;
    44. };
    45.  
    46. RSAUtils.setMaxDigits = function(value) {
    47. 	maxDigits = value;
    48. 	ZERO_ARRAY = new Array(maxDigits);
    49. 	for (var iza = 0; iza < ZERO_ARRAY.length; iza++) ZERO_ARRAY[iza] = 0;
    50. 	bigZero = new BigInt();
    51. 	bigOne = new BigInt();
    52. 	bigOne.digits[0] = 1;
    53. };
    54. RSAUtils.setMaxDigits(20);
    55.  
    56. //The maximum number of digits in base 10 you can convert to an
    57. //integer without JavaScript throwing up on you.
    58. var dpl10 = 15;
    59.  
    60. RSAUtils.biFromNumber = function(i) {
    61. 	var result = new BigInt();
    62. 	result.isNeg = i < 0;
    63. 	i = Math.abs(i);
    64. 	var j = 0;
    65. 	while (i > 0) {
    66. 		result.digits[j++] = i & maxDigitVal;
    67. 		i = Math.floor(i / biRadix);
    68. 	}
    69. 	return result;
    70. };
    71.  
    72. //lr10 = 10 ^ dpl10
    73. var lr10 = RSAUtils.biFromNumber(1000000000000000);
    74.  
    75. RSAUtils.biFromDecimal = function(s) {
    76. 	var isNeg = s.charAt(0) == '-';
    77. 	var i = isNeg ? 1 : 0;
    78. 	var result;
    79. 	// Skip leading zeros.
    80. 	while (i < s.length && s.charAt(i) == '0') ++i;
    81. 	if (i == s.length) {
    82. 		result = new BigInt();
    83. 	}
    84. 	else {
    85. 		var digitCount = s.length - i;
    86. 		var fgl = digitCount % dpl10;
    87. 		if (fgl == 0) fgl = dpl10;
    88. 		result = RSAUtils.biFromNumber(Number(s.substr(i, fgl)));
    89. 		i += fgl;
    90. 		while (i < s.length) {
    91. 			result = RSAUtils.biAdd(RSAUtils.biMultiply(result, lr10),
    92. 					RSAUtils.biFromNumber(Number(s.substr(i, dpl10))));
    93. 			i += dpl10;
    94. 		}
    95. 		result.isNeg = isNeg;
    96. 	}
    97. 	return result;
    98. };
    99.  
    100. RSAUtils.biCopy = function(bi) {
    101. 	var result = new BigInt(true);
    102. 	result.digits = bi.digits.slice(0);
    103. 	result.isNeg = bi.isNeg;
    104. 	return result;
    105. };
    106.  
    107. RSAUtils.reverseStr = function(s) {
    108. 	var result = "";
    109. 	for (var i = s.length - 1; i > -1; --i) {
    110. 		result += s.charAt(i);
    111. 	}
    112. 	return result;
    113. };
    114.  
    115. var hexatrigesimalToChar = [
    116. 	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    117. 	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
    118. 	'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
    119. 	'u', 'v', 'w', 'x', 'y', 'z'
    120. ];
    121.  
    122. RSAUtils.biToString = function(x, radix) { // 2 <= radix <= 36
    123. 	var b = new BigInt();
    124. 	b.digits[0] = radix;
    125. 	var qr = RSAUtils.biDivideModulo(x, b);
    126. 	var result = hexatrigesimalToChar[qr[1].digits[0]];
    127. 	while (RSAUtils.biCompare(qr[0], bigZero) == 1) {
    128. 		qr = RSAUtils.biDivideModulo(qr[0], b);
    129. 		digit = qr[1].digits[0];
    130. 		result += hexatrigesimalToChar[qr[1].digits[0]];
    131. 	}
    132. 	return (x.isNeg ? "-" : "") + RSAUtils.reverseStr(result);
    133. };
    134.  
    135. RSAUtils.biToDecimal = function(x) {
    136. 	var b = new BigInt();
    137. 	b.digits[0] = 10;
    138. 	var qr = RSAUtils.biDivideModulo(x, b);
    139. 	var result = String(qr[1].digits[0]);
    140. 	while (RSAUtils.biCompare(qr[0], bigZero) == 1) {
    141. 		qr = RSAUtils.biDivideModulo(qr[0], b);
    142. 		result += String(qr[1].digits[0]);
    143. 	}
    144. 	return (x.isNeg ? "-" : "") + RSAUtils.reverseStr(result);
    145. };
    146.  
    147. var hexToChar = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    148.         'a', 'b', 'c', 'd', 'e', 'f'];
    149.  
    150. RSAUtils.digitToHex = function(n) {
    151. 	var mask = 0xf;
    152. 	var result = "";
    153. 	for (i = 0; i < 4; ++i) {
    154. 		result += hexToChar[n & mask];
    155. 		n >>>= 4;
    156. 	}
    157. 	return RSAUtils.reverseStr(result);
    158. };
    159.  
    160. RSAUtils.biToHex = function(x) {
    161. 	var result = "";
    162. 	var n = RSAUtils.biHighIndex(x);
    163. 	for (var i = RSAUtils.biHighIndex(x); i > -1; --i) {
    164. 		result += RSAUtils.digitToHex(x.digits[i]);
    165. 	}
    166. 	return result;
    167. };
    168.  
    169. RSAUtils.charToHex = function(c) {
    170. 	var ZERO = 48;
    171. 	var NINE = ZERO + 9;
    172. 	var littleA = 97;
    173. 	var littleZ = littleA + 25;
    174. 	var bigA = 65;
    175. 	var bigZ = 65 + 25;
    176. 	var result;
    177.  
    178. 	if (c >= ZERO && c <= NINE) {
    179. 		result = c - ZERO;
    180. 	} else if (c >= bigA && c <= bigZ) {
    181. 		result = 10 + c - bigA;
    182. 	} else if (c >= littleA && c <= littleZ) {
    183. 		result = 10 + c - littleA;
    184. 	} else {
    185. 		result = 0;
    186. 	}
    187. 	return result;
    188. };
    189.  
    190. RSAUtils.hexToDigit = function(s) {
    191. 	var result = 0;
    192. 	var sl = Math.min(s.length, 4);
    193. 	for (var i = 0; i < sl; ++i) {
    194. 		result <<= 4;
    195. 		result |= RSAUtils.charToHex(s.charCodeAt(i));
    196. 	}
    197. 	return result;
    198. };
    199.  
    200. RSAUtils.biFromHex = function(s) {
    201. 	var result = new BigInt();
    202. 	var sl = s.length;
    203. 	for (var i = sl, j = 0; i > 0; i -= 4, ++j) {
    204. 		result.digits[j] = RSAUtils.hexToDigit(s.substr(Math.max(i - 4, 0), Math.min(i, 4)));
    205. 	}
    206. 	return result;
    207. };
    208.  
    209. RSAUtils.biFromString = function(s, radix) {
    210. 	var isNeg = s.charAt(0) == '-';
    211. 	var istop = isNeg ? 1 : 0;
    212. 	var result = new BigInt();
    213. 	var place = new BigInt();
    214. 	place.digits[0] = 1; // radix^0
    215. 	for (var i = s.length - 1; i >= istop; i--) {
    216. 		var c = s.charCodeAt(i);
    217. 		var digit = RSAUtils.charToHex(c);
    218. 		var biDigit = RSAUtils.biMultiplyDigit(place, digit);
    219. 		result = RSAUtils.biAdd(result, biDigit);
    220. 		place = RSAUtils.biMultiplyDigit(place, radix);
    221. 	}
    222. 	result.isNeg = isNeg;
    223. 	return result;
    224. };
    225.  
    226. RSAUtils.biDump = function(b) {
    227. 	return (b.isNeg ? "-" : "") + b.digits.join(" ");
    228. };
    229.  
    230. RSAUtils.biAdd = function(x, y) {
    231. 	var result;
    232.  
    233. 	if (x.isNeg != y.isNeg) {
    234. 		y.isNeg = !y.isNeg;
    235. 		result = RSAUtils.biSubtract(x, y);
    236. 		y.isNeg = !y.isNeg;
    237. 	}
    238. 	else {
    239. 		result = new BigInt();
    240. 		var c = 0;
    241. 		var n;
    242. 		for (var i = 0; i < x.digits.length; ++i) {
    243. 			n = x.digits[i] + y.digits[i] + c;
    244. 			result.digits[i] = n % biRadix;
    245. 			c = Number(n >= biRadix);
    246. 		}
    247. 		result.isNeg = x.isNeg;
    248. 	}
    249. 	return result;
    250. };
    251.  
    252. RSAUtils.biSubtract = function(x, y) {
    253. 	var result;
    254. 	if (x.isNeg != y.isNeg) {
    255. 		y.isNeg = !y.isNeg;
    256. 		result = RSAUtils.biAdd(x, y);
    257. 		y.isNeg = !y.isNeg;
    258. 	} else {
    259. 		result = new BigInt();
    260. 		var n, c;
    261. 		c = 0;
    262. 		for (var i = 0; i < x.digits.length; ++i) {
    263. 			n = x.digits[i] - y.digits[i] + c;
    264. 			result.digits[i] = n % biRadix;
    265. 			// Stupid non-conforming modulus operation.
    266. 			if (result.digits[i] < 0) result.digits[i] += biRadix;
    267. 			c = 0 - Number(n < 0);
    268. 		}
    269. 		// Fix up the negative sign, if any.
    270. 		if (c == -1) {
    271. 			c = 0;
    272. 			for (var i = 0; i < x.digits.length; ++i) {
    273. 				n = 0 - result.digits[i] + c;
    274. 				result.digits[i] = n % biRadix;
    275. 				// Stupid non-conforming modulus operation.
    276. 				if (result.digits[i] < 0) result.digits[i] += biRadix;
    277. 				c = 0 - Number(n < 0);
    278. 			}
    279. 			// Result is opposite sign of arguments.
    280. 			result.isNeg = !x.isNeg;
    281. 		} else {
    282. 			// Result is same sign.
    283. 			result.isNeg = x.isNeg;
    284. 		}
    285. 	}
    286. 	return result;
    287. };
    288.  
    289. RSAUtils.biHighIndex = function(x) {
    290. 	var result = x.digits.length - 1;
    291. 	while (result > 0 && x.digits[result] == 0) --result;
    292. 	return result;
    293. };
    294.  
    295. RSAUtils.biNumBits = function(x) {
    296. 	var n = RSAUtils.biHighIndex(x);
    297. 	var d = x.digits[n];
    298. 	var m = (n + 1) * bitsPerDigit;
    299. 	var result;
    300. 	for (result = m; result > m - bitsPerDigit; --result) {
    301. 		if ((d & 0x8000) != 0) break;
    302. 		d <<= 1;
    303. 	}
    304. 	return result;
    305. };
    306.  
    307. RSAUtils.biMultiply = function(x, y) {
    308. 	var result = new BigInt();
    309. 	var c;
    310. 	var n = RSAUtils.biHighIndex(x);
    311. 	var t = RSAUtils.biHighIndex(y);
    312. 	var u, uv, k;
    313.  
    314. 	for (var i = 0; i <= t; ++i) {
    315. 		c = 0;
    316. 		k = i;
    317. 		for (j = 0; j <= n; ++j, ++k) {
    318. 			uv = result.digits[k] + x.digits[j] * y.digits[i] + c;
    319. 			result.digits[k] = uv & maxDigitVal;
    320. 			c = uv >>> biRadixBits;
    321. 			//c = Math.floor(uv / biRadix);
    322. 		}
    323. 		result.digits[i + n + 1] = c;
    324. 	}
    325. 	// Someone give me a logical xor, please.
    326. 	result.isNeg = x.isNeg != y.isNeg;
    327. 	return result;
    328. };
    329.  
    330. RSAUtils.biMultiplyDigit = function(x, y) {
    331. 	var n, c, uv;
    332.  
    333. 	result = new BigInt();
    334. 	n = RSAUtils.biHighIndex(x);
    335. 	c = 0;
    336. 	for (var j = 0; j <= n; ++j) {
    337. 		uv = result.digits[j] + x.digits[j] * y + c;
    338. 		result.digits[j] = uv & maxDigitVal;
    339. 		c = uv >>> biRadixBits;
    340. 		//c = Math.floor(uv / biRadix);
    341. 	}
    342. 	result.digits[1 + n] = c;
    343. 	return result;
    344. };
    345.  
    346. RSAUtils.arrayCopy = function(src, srcStart, dest, destStart, n) {
    347. 	var m = Math.min(srcStart + n, src.length);
    348. 	for (var i = srcStart, j = destStart; i < m; ++i, ++j) {
    349. 		dest[j] = src[i];
    350. 	}
    351. };
    352.  
    353. var highBitMasks = [0x0000, 0x8000, 0xC000, 0xE000, 0xF000, 0xF800,
    354.         0xFC00, 0xFE00, 0xFF00, 0xFF80, 0xFFC0, 0xFFE0,
    355.         0xFFF0, 0xFFF8, 0xFFFC, 0xFFFE, 0xFFFF];
    356.  
    357. RSAUtils.biShiftLeft = function(x, n) {
    358. 	var digitCount = Math.floor(n / bitsPerDigit);
    359. 	var result = new BigInt();
    360. 	RSAUtils.arrayCopy(x.digits, 0, result.digits, digitCount,
    361. 	          result.digits.length - digitCount);
    362. 	var bits = n % bitsPerDigit;
    363. 	var rightBits = bitsPerDigit - bits;
    364. 	for (var i = result.digits.length - 1, i1 = i - 1; i > 0; --i, --i1) {
    365. 		result.digits[i] = ((result.digits[i] << bits) & maxDigitVal) |
    366. 		                   ((result.digits[i1] & highBitMasks[bits]) >>>
    367. 		                    (rightBits));
    368. 	}
    369. 	result.digits[0] = ((result.digits[i] << bits) & maxDigitVal);
    370. 	result.isNeg = x.isNeg;
    371. 	return result;
    372. };
    373.  
    374. var lowBitMasks = [0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F,
    375.         0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF,
    376.         0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF];
    377.  
    378. RSAUtils.biShiftRight = function(x, n) {
    379. 	var digitCount = Math.floor(n / bitsPerDigit);
    380. 	var result = new BigInt();
    381. 	RSAUtils.arrayCopy(x.digits, digitCount, result.digits, 0,
    382. 	          x.digits.length - digitCount);
    383. 	var bits = n % bitsPerDigit;
    384. 	var leftBits = bitsPerDigit - bits;
    385. 	for (var i = 0, i1 = i + 1; i < result.digits.length - 1; ++i, ++i1) {
    386. 		result.digits[i] = (result.digits[i] >>> bits) |
    387. 		                   ((result.digits[i1] & lowBitMasks[bits]) << leftBits);
    388. 	}
    389. 	result.digits[result.digits.length - 1] >>>= bits;
    390. 	result.isNeg = x.isNeg;
    391. 	return result;
    392. };
    393.  
    394. RSAUtils.biMultiplyByRadixPower = function(x, n) {
    395. 	var result = new BigInt();
    396. 	RSAUtils.arrayCopy(x.digits, 0, result.digits, n, result.digits.length - n);
    397. 	return result;
    398. };
    399.  
    400. RSAUtils.biDivideByRadixPower = function(x, n) {
    401. 	var result = new BigInt();
    402. 	RSAUtils.arrayCopy(x.digits, n, result.digits, 0, result.digits.length - n);
    403. 	return result;
    404. };
    405.  
    406. RSAUtils.biModuloByRadixPower = function(x, n) {
    407. 	var result = new BigInt();
    408. 	RSAUtils.arrayCopy(x.digits, 0, result.digits, 0, n);
    409. 	return result;
    410. };
    411.  
    412. RSAUtils.biCompare = function(x, y) {
    413. 	if (x.isNeg != y.isNeg) {
    414. 		return 1 - 2 * Number(x.isNeg);
    415. 	}
    416. 	for (var i = x.digits.length - 1; i >= 0; --i) {
    417. 		if (x.digits[i] != y.digits[i]) {
    418. 			if (x.isNeg) {
    419. 				return 1 - 2 * Number(x.digits[i] > y.digits[i]);
    420. 			} else {
    421. 				return 1 - 2 * Number(x.digits[i] < y.digits[i]);
    422. 			}
    423. 		}
    424. 	}
    425. 	return 0;
    426. };
    427.  
    428. RSAUtils.biDivideModulo = function(x, y) {
    429. 	var nb = RSAUtils.biNumBits(x);
    430. 	var tb = RSAUtils.biNumBits(y);
    431. 	var origYIsNeg = y.isNeg;
    432. 	var q, r;
    433. 	if (nb < tb) {
    434. 		// |x| < |y|
    435. 		if (x.isNeg) {
    436. 			q = RSAUtils.biCopy(bigOne);
    437. 			q.isNeg = !y.isNeg;
    438. 			x.isNeg = false;
    439. 			y.isNeg = false;
    440. 			r = biSubtract(y, x);
    441. 			// Restore signs, 'cause they're references.
    442. 			x.isNeg = true;
    443. 			y.isNeg = origYIsNeg;
    444. 		} else {
    445. 			q = new BigInt();
    446. 			r = RSAUtils.biCopy(x);
    447. 		}
    448. 		return [q, r];
    449. 	}
    450.  
    451. 	q = new BigInt();
    452. 	r = x;
    453.  
    454. 	// Normalize Y.
    455. 	var t = Math.ceil(tb / bitsPerDigit) - 1;
    456. 	var lambda = 0;
    457. 	while (y.digits[t] < biHalfRadix) {
    458. 		y = RSAUtils.biShiftLeft(y, 1);
    459. 		++lambda;
    460. 		++tb;
    461. 		t = Math.ceil(tb / bitsPerDigit) - 1;
    462. 	}
    463. 	// Shift r over to keep the quotient constant. We'll shift the
    464. 	// remainder back at the end.
    465. 	r = RSAUtils.biShiftLeft(r, lambda);
    466. 	nb += lambda; // Update the bit count for x.
    467. 	var n = Math.ceil(nb / bitsPerDigit) - 1;
    468.  
    469. 	var b = RSAUtils.biMultiplyByRadixPower(y, n - t);
    470. 	while (RSAUtils.biCompare(r, b) != -1) {
    471. 		++q.digits[n - t];
    472. 		r = RSAUtils.biSubtract(r, b);
    473. 	}
    474. 	for (var i = n; i > t; --i) {
    475.     var ri = (i >= r.digits.length) ? 0 : r.digits[i];
    476.     var ri1 = (i - 1 >= r.digits.length) ? 0 : r.digits[i - 1];
    477.     var ri2 = (i - 2 >= r.digits.length) ? 0 : r.digits[i - 2];
    478.     var yt = (t >= y.digits.length) ? 0 : y.digits[t];
    479.     var yt1 = (t - 1 >= y.digits.length) ? 0 : y.digits[t - 1];
    480. 		if (ri == yt) {
    481. 			q.digits[i - t - 1] = maxDigitVal;
    482. 		} else {
    483. 			q.digits[i - t - 1] = Math.floor((ri * biRadix + ri1) / yt);
    484. 		}
    485.  
    486. 		var c1 = q.digits[i - t - 1] * ((yt * biRadix) + yt1);
    487. 		var c2 = (ri * biRadixSquared) + ((ri1 * biRadix) + ri2);
    488. 		while (c1 > c2) {
    489. 			--q.digits[i - t - 1];
    490. 			c1 = q.digits[i - t - 1] * ((yt * biRadix) | yt1);
    491. 			c2 = (ri * biRadix * biRadix) + ((ri1 * biRadix) + ri2);
    492. 		}
    493.  
    494. 		b = RSAUtils.biMultiplyByRadixPower(y, i - t - 1);
    495. 		r = RSAUtils.biSubtract(r, RSAUtils.biMultiplyDigit(b, q.digits[i - t - 1]));
    496. 		if (r.isNeg) {
    497. 			r = RSAUtils.biAdd(r, b);
    498. 			--q.digits[i - t - 1];
    499. 		}
    500. 	}
    501. 	r = RSAUtils.biShiftRight(r, lambda);
    502. 	// Fiddle with the signs and stuff to make sure that 0 <= r < y.
    503. 	q.isNeg = x.isNeg != origYIsNeg;
    504. 	if (x.isNeg) {
    505. 		if (origYIsNeg) {
    506. 			q = RSAUtils.biAdd(q, bigOne);
    507. 		} else {
    508. 			q = RSAUtils.biSubtract(q, bigOne);
    509. 		}
    510. 		y = RSAUtils.biShiftRight(y, lambda);
    511. 		r = RSAUtils.biSubtract(y, r);
    512. 	}
    513. 	// Check for the unbelievably stupid degenerate case of r == -0.
    514. 	if (r.digits[0] == 0 && RSAUtils.biHighIndex(r) == 0) r.isNeg = false;
    515.  
    516. 	return [q, r];
    517. };
    518.  
    519. RSAUtils.biDivide = function(x, y) {
    520. 	return RSAUtils.biDivideModulo(x, y)[0];
    521. };
    522.  
    523. RSAUtils.biModulo = function(x, y) {
    524. 	return RSAUtils.biDivideModulo(x, y)[1];
    525. };
    526.  
    527. RSAUtils.biMultiplyMod = function(x, y, m) {
    528. 	return RSAUtils.biModulo(RSAUtils.biMultiply(x, y), m);
    529. };
    530.  
    531. RSAUtils.biPow = function(x, y) {
    532. 	var result = bigOne;
    533. 	var a = x;
    534. 	while (true) {
    535. 		if ((y & 1) != 0) result = RSAUtils.biMultiply(result, a);
    536. 		y >>= 1;
    537. 		if (y == 0) break;
    538. 		a = RSAUtils.biMultiply(a, a);
    539. 	}
    540. 	return result;
    541. };
    542.  
    543. RSAUtils.biPowMod = function(x, y, m) {
    544. 	var result = bigOne;
    545. 	var a = x;
    546. 	var k = y;
    547. 	while (true) {
    548. 		if ((k.digits[0] & 1) != 0) result = RSAUtils.biMultiplyMod(result, a, m);
    549. 		k = RSAUtils.biShiftRight(k, 1);
    550. 		if (k.digits[0] == 0 && RSAUtils.biHighIndex(k) == 0) break;
    551. 		a = RSAUtils.biMultiplyMod(a, a, m);
    552. 	}
    553. 	return result;
    554. };
    555.  
    556.  
    557. $w.BarrettMu = function(m) {
    558. 	this.modulus = RSAUtils.biCopy(m);
    559. 	this.k = RSAUtils.biHighIndex(this.modulus) + 1;
    560. 	var b2k = new BigInt();
    561. 	b2k.digits[2 * this.k] = 1; // b2k = b^(2k)
    562. 	this.mu = RSAUtils.biDivide(b2k, this.modulus);
    563. 	this.bkplus1 = new BigInt();
    564. 	this.bkplus1.digits[this.k + 1] = 1; // bkplus1 = b^(k+1)
    565. 	this.modulo = BarrettMu_modulo;
    566. 	this.multiplyMod = BarrettMu_multiplyMod;
    567. 	this.powMod = BarrettMu_powMod;
    568. };
    569.  
    570. function BarrettMu_modulo(x) {
    571. 	var $dmath = RSAUtils;
    572. 	var q1 = $dmath.biDivideByRadixPower(x, this.k - 1);
    573. 	var q2 = $dmath.biMultiply(q1, this.mu);
    574. 	var q3 = $dmath.biDivideByRadixPower(q2, this.k + 1);
    575. 	var r1 = $dmath.biModuloByRadixPower(x, this.k + 1);
    576. 	var r2term = $dmath.biMultiply(q3, this.modulus);
    577. 	var r2 = $dmath.biModuloByRadixPower(r2term, this.k + 1);
    578. 	var r = $dmath.biSubtract(r1, r2);
    579. 	if (r.isNeg) {
    580. 		r = $dmath.biAdd(r, this.bkplus1);
    581. 	}
    582. 	var rgtem = $dmath.biCompare(r, this.modulus) >= 0;
    583. 	while (rgtem) {
    584. 		r = $dmath.biSubtract(r, this.modulus);
    585. 		rgtem = $dmath.biCompare(r, this.modulus) >= 0;
    586. 	}
    587. 	return r;
    588. }
    589.  
    590. function BarrettMu_multiplyMod(x, y) {
    591. 	/*
    592. 	x = this.modulo(x);
    593. 	y = this.modulo(y);
    594. 	*/
    595. 	var xy = RSAUtils.biMultiply(x, y);
    596. 	return this.modulo(xy);
    597. }
    598.  
    599. function BarrettMu_powMod(x, y) {
    600. 	var result = new BigInt();
    601. 	result.digits[0] = 1;
    602. 	var a = x;
    603. 	var k = y;
    604. 	while (true) {
    605. 		if ((k.digits[0] & 1) != 0) result = this.multiplyMod(result, a);
    606. 		k = RSAUtils.biShiftRight(k, 1);
    607. 		if (k.digits[0] == 0 && RSAUtils.biHighIndex(k) == 0) break;
    608. 		a = this.multiplyMod(a, a);
    609. 	}
    610. 	return result;
    611. }
    612.  
    613. var RSAKeyPair = function(encryptionExponent, decryptionExponent, modulus) {
    614. 	var $dmath = RSAUtils;
    615. 	this.e = $dmath.biFromHex(encryptionExponent);
    616. 	this.d = $dmath.biFromHex(decryptionExponent);
    617. 	this.m = $dmath.biFromHex(modulus);
    618. 	// We can do two bytes per digit, so
    619. 	// chunkSize = 2 * (number of digits in modulus - 1).
    620. 	// Since biHighIndex returns the high index, not the number of digits, 1 has
    621. 	// already been subtracted.
    622. 	this.chunkSize = 2 * $dmath.biHighIndex(this.m);
    623. 	this.radix = 16;
    624. 	this.barrett = new $w.BarrettMu(this.m);
    625. };
    626.  
    627. RSAUtils.getKeyPair = function(encryptionExponent, decryptionExponent, modulus) {
    628. 	return new RSAKeyPair(encryptionExponent, decryptionExponent, modulus);
    629. };
    630.  
    631. if(typeof $w.twoDigit === 'undefined') {
    632. 	$w.twoDigit = function(n) {
    633. 		return (n < 10 ? "0" : "") + String(n);
    634. 	};
    635. }
    636.  
    637. // Altered by Rob Saunders (rob@robsaunders.net). New routine pads the
    638. // string after it has been converted to an array. This fixes an
    639. // incompatibility with Flash MX's ActionScript.
    640. RSAUtils.encryptedString = function(key, s) {
    641. 	var a = [];
    642. 	var sl = s.length;
    643. 	var i = 0;
    644. 	while (i < sl) {
    645. 		a[i] = s.charCodeAt(i);
    646. 		i++;
    647. 	}
    648.  
    649. 	while (a.length % key.chunkSize != 0) {
    650. 		a[i++] = 0;
    651. 	}
    652.  
    653. 	var al = a.length;
    654. 	var result = "";
    655. 	var j, k, block;
    656. 	for (i = 0; i < al; i += key.chunkSize) {
    657. 		block = new BigInt();
    658. 		j = 0;
    659. 		for (k = i; k < i + key.chunkSize; ++j) {
    660. 			block.digits[j] = a[k++];
    661. 			block.digits[j] += a[k++] << 8;
    662. 		}
    663. 		var crypt = key.barrett.powMod(block, key.e);
    664. 		var text = key.radix == 16 ? RSAUtils.biToHex(crypt) : RSAUtils.biToString(crypt, key.radix);
    665. 		result += text + " ";
    666. 	}
    667. 	return result.substring(0, result.length - 1); // Remove last space.
    668. };
    669.  
    670. RSAUtils.decryptedString = function(key, s) {
    671. 	var blocks = s.split(" ");
    672. 	var result = "";
    673. 	var i, j, block;
    674. 	for (i = 0; i < blocks.length; ++i) {
    675. 		var bi;
    676. 		if (key.radix == 16) {
    677. 			bi = RSAUtils.biFromHex(blocks[i]);
    678. 		}
    679. 		else {
    680. 			bi = RSAUtils.biFromString(blocks[i], key.radix);
    681. 		}
    682. 		block = key.barrett.powMod(bi, key.d);
    683. 		for (j = 0; j <= RSAUtils.biHighIndex(block); ++j) {
    684. 			result += String.fromCharCode(block.digits[j] & 255,
    685. 			                              block.digits[j] >> 8);
    686. 		}
    687. 	}
    688. 	// Remove trailing null, if any.
    689. 	if (result.charCodeAt(result.length - 1) == 0) {
    690. 		result = result.substring(0, result.length - 1);
    691. 	}
    692. 	return result;
    693. };
    694.  
    695. RSAUtils.setMaxDigits(130);
    696.  
    697. })(window);

     

  • 相关阅读:
    软考高级系统架构设计师系列之：信息系统基础知识
    Vue生命周期
    ASEMI整流桥KBJ410参数，KBJ410压降，KBJ410热阻
    java毕业生设计-学生考勤管理系统-计算机源码+系统+mysql+调试部署+lw
    maven入门
    Vue框架--理解MVVM
    Secure Boot（安全启动）
    自动驾驶中的SLAM
    IODAY2
    动态内存管理
  • 原文地址：https://blog.csdn.net/weixin_61503139/article/details/138194058