信息计算2019级1班17号刘帆杰

刘帆杰

rsa算法原理

RSA算法产生密钥的过程： 1.系统产生两个大素数p, q（保密） 2.计算n=pq（公开），欧拉函数Φ(n)=(p-1)(q-1)(保密) 3.随机选择满足gcd(e,Φ(n))=1的e作为公钥(公开)，加密密钥就是(e,n) 4.计算满足ed=1(mod Φ(n))的d作为私钥(保密)，解密密钥即为(d,n) RSA的加解密过程： 首先将明文分组并数字化，每个数字化分组明文的长度不大于log n，然后对每个明文分组m依次进行加解密运算： 1.加密运算：使用公钥e和要加密的明文m进行c=me(mod n)运算即得密文 2.解密运算：使用私钥d和要加密的明文m进行c=md(mod n)运算即得明文。

代码

1. package com.密码算法;
   
2. 
   
3. import java.io.UnsupportedEncodingException;
   
4. import java.math.BigInteger;
   
5. import java.util.Random;
   
6. import java.util.Scanner;
   
7. 
   
8. public class RSA4 {
   
9.     private static BigInteger n;// = p * q，两个大质数的乘积
   
10.     private static BigInteger n2;// = p * q，两个大质数的乘积
    
11.     private static BigInteger e;// 加密公钥指数
    
12.     private static BigInteger e2;// 签名公钥指数
    
13.     private static BigInteger d;// 加密私钥指数
    
14.     private static BigInteger b;// 签名私钥指数,签名公钥和加密公钥相同
    
15.     private final int PQMINLENGTH = 1024;// p、q最小的长度（比特数）
    
16.     private static final BigInteger ZERO = BigInteger.ZERO;
    
17.     private static final BigInteger ONE = BigInteger.ONE;
    
18.     private static final BigInteger TWO = new BigInteger("2");
    
19.     private static final int ERR_VAL = 100;
    
20. 
    
21.     public static void main(String[] args) throws RSA4.pqException, UnsupportedEncodingException {
    
22.         Scanner input = new Scanner(System.in);
    
23.         int pqLength = 1024;// p、q长度（比特数）
    
24.         System.out.println("请输入要加密的内容：");
    
25.         String originalText = input.nextLine();
    
26.         RSA4 rsa = new RSA4(pqLength);
    
27.         System.out.println("加密前：" + originalText);
    
28.         BigInteger[] c2 = rsa.encryption(originalText, b, n2);// 签名
    
29.         System.out.print("加签后：");
    
30.         for (int i = 0; i < c2.length; i++) {
    
31.             System.out.println(c2[i]);
    
32.         }
    
33.         String tmp = rsa.decryption(c2, e2, n2);
    
34.         System.out.println("解签后：" + tmp);// 解密
    
35.         if (originalText.equals(tmp)) {
    
36.             System.out.println("签名验证成功");
    
37.             BigInteger[] c = rsa.encryption(originalText, e, n);// 加密
    
38.             System.out.print("加密后：");
    
39.             for (int i = 0; i < c.length; i++) {
    
40.                 System.out.println(c[i]);
    
41.             }
    
42.             System.out.println("解密后：" + rsa.decryption(c, d, n));// 解密
    
43.         } else System.out.println("签名验证失败");
    
44.     }
    
45. 
    
46.     private class pqException extends Exception {
    
47.         private static final long serialVersionUID = -7777566816579144864L;
    
48. 
    
49.         public pqException(String message) {
    
50.             super(message);
    
51.         }
    
52.     }
    
53. 
    
54.     public RSA4(int pqLength) throws RSA4.pqException {
    
55.         generateKey(pqLength);// 产生密钥
    
56.     }
    
57. 
    
58.     //密钥产生。
    
59.     private void generateKey(int pqLength) throws RSA4.pqException {
    
60.         BigInteger p = BigInteger.ZERO;// 两个大素数用于加密
    
61.         BigInteger q = BigInteger.ZERO;
    
62.         BigInteger p2 = BigInteger.ZERO;// 两个大素数用于签名
    
63.         BigInteger q2 = BigInteger.ZERO;
    
64.         BigInteger φn;// = (p-1)(q-1)
    
65.         BigInteger φn2;// = (p2-1)(q2-1)
    
66. 
    
67.         if (pqLength < PQMINLENGTH) {
    
68.             throw new pqException("p、q长度小于" + PQMINLENGTH + "，请重新选择更大的比特数！");
    
69.         }
    
70.         p = RSA4.generateNBitRandomPrime(pqLength);
    
71.         q = RSA4.generateNBitRandomPrime(pqLength);
    
72. 
    
73.         p2 = RSA4.generateNBitRandomPrime(pqLength);
    
74.         q2 = RSA4.generateNBitRandomPrime(pqLength);
    
75. 
    
76.         n = p.multiply(q);
    
77.         n2 = p2.multiply(q2);
    
78. 
    
79.         System.out.println("随机产生四个素数p、q、p2、q2");
    
80.         System.out.println("p:" + p);
    
81.         System.out.println("q:" + q);
    
82.         System.out.println("p2:" + p2);
    
83.         System.out.println("q2:" + q2);
    
84.         System.out.println("p、q乘积为n:" + n);
    
85.         System.out.println("p2、q2乘积为n2:" + n2);
    
86.         φn = (p.subtract(BigInteger.ONE)).multiply(q.subtract(BigInteger.ONE));
    
87.         φn2 = (p2.subtract(BigInteger.ONE)).multiply(q2.subtract(BigInteger.ONE));
    
88. 
    
89.         //随机产生公钥
    
90.         int numDigits;
    
91.         try {
    
92.             numDigits = Integer.parseInt("15");
    
93.         } catch (Exception e1) {
    
94.             numDigits = 128;
    
95.         }
    
96. 
    
97.         BigInteger start = bigRandom(numDigits);
    
98.         BigInteger start2 = bigRandom(numDigits);
    
99.         BigInteger big = nextPrime(start);
    
100.         BigInteger big2 = nextPrime(start2);
     
101.         e = big;
     
102.         e2 = big2;
     
103.         while (e.compareTo(φn) == 1 || fun(e, φn)) {
     
104.             System.out.println("e不合要求，请重新产生" + (e.compareTo(φn) == 1)
     
105.                     + fun(e, φn));
     
106.             try {
     
107.                 numDigits = Integer.parseInt("15");
     
108.             } catch (Exception e1) {
     
109.                 numDigits = 128;
     
110.             }
     
111.             start = bigRandom(numDigits);
     
112.             big = nextPrime(start);
     
113.             e = big;
     
114.         }
     
115.         while (e2.compareTo(φn2) == 1 || fun(e2, φn2)) {
     
116.             System.out.println("e2不合要求，请重新产生" + (e2.compareTo(φn2) == 1)
     
117.                     + fun(e2, φn2));
     
118.             try {
     
119.                 numDigits = Integer.parseInt("15");
     
120.             } catch (Exception e1) {
     
121.                 numDigits = 128;
     
122.             }
     
123.             start = bigRandom(numDigits);
     
124.             big = nextPrime(start);
     
125.             e2 = big;
     
126.         }
     
127. 
     
128.         d = RSA4.extdGcd(e, φn)[1];// 利用扩展欧几里得算法求私钥d
     
129.         b = RSA4.extdGcd(e2, φn2)[1];// 利用扩展欧几里得算法求私钥b
     
130.         if (d.compareTo(BigInteger.ZERO) != 1) {// 私钥不可以小于0
     
131.             d = d.add(φn);
     
132.         }
     
133.         if (b.compareTo(BigInteger.ZERO) != 1) {// 私钥不可以小于0
     
134.             b = b.add(φn2);
     
135.         }
     
136.         System.out.println("加密公钥为:" + e);
     
137.         System.out.println("签名公钥为:" + e2);
     
138.         System.out.println("加密私钥为:" + d);
     
139.         System.out.println("签名私钥为:" + b);
     
140.     }
     
141. 
     
142.     //RSA加密。
     
143.     private BigInteger[] encryption(String plainText, BigInteger e, BigInteger n) throws UnsupportedEncodingException {
     
144.         String textNum = "";// 明文数字字符串表示形式
     
145.         BigInteger m = BigInteger.ZERO;// 明文数字表示形式
     
146.         byte[] textByte = plainText.getBytes("UTF-8");
     
147.         for (int i = 0; i < textByte.length; i++) {// 每个字节用3位数的整数表示，不够则在前面补0
     
148.             int bn = textByte[i] & 0xff;
     
149.             if (bn < 10) {
     
150.                 textNum += "00" + bn;
     
151.             } else if (bn < 100) {
     
152.                 textNum += "0" + bn;
     
153.             } else {
     
154.                 textNum += bn;
     
155.             }
     
156.         }
     
157.         m = new BigInteger(textNum);
     
158. 
     
159.         BigInteger[] mArray = null;// 明文分组结果
     
160.         if (m.compareTo(n) == -1) {// m < n，可直接加密
     
161.             mArray = new BigInteger[1];
     
162.             mArray[0] = m;
     
163.         } else {
     
164.             int groupLength = n.toString().length() - 1;// 每组明文长度
     
165.             int mStringLength = m.toString().length();// 明文转化为字符串的长度
     
166.             while (groupLength % 3 != 0) {// 由于前面每个字节用3位整数表示，因此每组的长度必须为3的整数，避免恢复时错误
     
167.                 groupLength--;
     
168.             }
     
169.             if (mStringLength % groupLength != 0) {// 如果最后一组的长度不足
     
170.                 mArray = new BigInteger[mStringLength / groupLength + 1];
     
171.             } else {
     
172.                 mArray = new BigInteger[mStringLength / groupLength];
     
173.             }
     
174. 
     
175.             String tmp;
     
176.             for (int i = 0; i < mArray.length; i++) {
     
177.                 tmp = "";
     
178.                 if (i != mArray.length - 1) {// 根据每组长度进行分割分组保存
     
179.                     tmp = textNum.substring(groupLength * i, groupLength * i + groupLength);
     
180.                 } else {
     
181.                     tmp = textNum.substring(groupLength * i);
     
182.                 }
     
183.                 mArray[i] = new BigInteger(tmp);
     
184.             }
     
185.         }
     
186. 
     
187.         for (int i = 0; i < mArray.length; i++) {// 逐组加密并返回
     
188.             mArray[i] = expMod(mArray[i], e, n);
     
189.         }
     
190.         return mArray;
     
191.     }
     
192. 
     
193. 
     

复制代码

刘帆杰

1. //RSA解密。
   
2.     private String decryption(BigInteger[] c, BigInteger d, BigInteger n) {
   
3.         String cPadding = "";
   
4.         String mToString = "";
   
5.         int mToStringLengthMod = 0;
   
6.         BigInteger m = BigInteger.ZERO;
   
7.         for (int i = 0; i < c.length; i++) {// 逐组解密
   
8.             m = RSA4.expMod(c[i], d, n);
   
9.             mToString = m.toString();
   
10.             mToStringLengthMod = m.toString().length() % 3;
    
11.             if (mToStringLengthMod != 0) {// 由于加密时String转BigInter时前者前面的0并不会计入，所以需要确认并补全
    
12.                 for (int j = 0; j < 3 - mToStringLengthMod; j++) {
    
13.                     mToString = "0" + mToString;
    
14.                 }
    
15.             }
    
16.             cPadding += mToString;
    
17.         }
    
18. 
    
19.         int byteNum = cPadding.length() / 3;// 明文总字节数
    
20.         byte[] result = new byte[byteNum];
    
21.         for (int i = 0; i < byteNum; i++) {// 每三位数转化为byte型并返回该byte数组所表达的字符串
    
22.             result[i] = (byte) (Integer.parseInt(cPadding.substring(i * 3, i * 3 + 3)));
    
23.         }
    
24.         return new String(result);
    
25.     }
    
26. 
    
27. 
    
28.     //利用扩展欧几里得算法求出私钥d，使得de = kφ(n)+1，k为整数。
    
29.     private static BigInteger[] extdGcd(BigInteger e, BigInteger φn) {
    
30.         BigInteger[] gdk = new BigInteger[3];
    
31. 
    
32.         if (φn.compareTo(BigInteger.ZERO) == 0) {
    
33.             gdk[0] = e;
    
34.             gdk[1] = BigInteger.ONE;
    
35.             gdk[2] = BigInteger.ZERO;
    
36.             return gdk;
    
37.         } else {
    
38.             gdk = extdGcd(φn, e.remainder(φn));
    
39.             BigInteger tmp_k = gdk[2];
    
40.             gdk[2] = gdk[1].subtract(e.divide(φn).multiply(gdk[2]));
    
41.             gdk[1] = tmp_k;
    
42.             return gdk;
    
43.         }
    
44.     }
    
45. 
    
46.     // 利用米勒·罗宾算法判断一个数是否是质数。
    
47.     private static boolean isPrime(BigInteger p) {
    
48.         if (p.compareTo(BigInteger.TWO) == -1) {// 小于2直接返回false
    
49.             return false;
    
50.         }
    
51.         if ((p.compareTo(BigInteger.TWO) != 0) && (p.remainder(BigInteger.TWO).compareTo(BigInteger.ZERO) == 0)) {// 不等于2且是偶数直接返回false
    
52.             return false;
    
53.         }
    
54. 
    
55.         BigInteger p_1 = p.subtract(BigInteger.ONE);
    
56.         BigInteger m = p_1;// 找到q和m使得p = 1 + 2^q * m
    
57.         int q = m.getLowestSetBit();// 二进制下从右往左返回第一次出现1的索引
    
58.         m = m.shiftRight(q);
    
59. 
    
60.         for (int i = 0; i < 5; i++) {// 判断的轮数，精度、轮数和时间三者之间成正比关系
    
61.             BigInteger b;
    
62.             do {// 在区间1~p上生成均匀随机数
    
63.                 b = new BigInteger(String.valueOf(p.bitLength()));
    
64.             } while (b.compareTo(BigInteger.ONE) <= 0 || b.compareTo(p) >= 0);
    
65. 
    
66.             int j = 0;
    
67.             BigInteger z = RSA4.expMod(b, m, p);
    
68.             while (!((j == 0 && z.equals(BigInteger.ONE)) || z.equals(p_1))) {
    
69.                 if ((j > 0 && z.equals(BigInteger.ONE)) || ++j == q) {
    
70.                     return false;
    
71.                 }
    
72.                 z = RSA4.expMod(z, BigInteger.TWO, p);
    
73.             }
    
74.         }
    
75. 
    
76.         return true;
    
77.     }
    
78. 
    
79.     private static BigInteger generateNBitRandomPrime(int n) {
    
80.         BigInteger tmp = new BigInteger("2").pow(n - 1);// 最高位肯定是1
    
81.         BigInteger result = new BigInteger("2").pow(n - 1);
    
82.         Random random = new Random();
    
83.         int r1 = random.nextInt(101);// 产生0-100的整数，用于确定0和1的比例
    
84.         int r2;
    
85. 
    
86.         while (true) {// 循环产生数，直到该数为素数
    
87.             for (int i = n - 2; i >= 0; i--) {// 逐位产生表示数的0和1，并根据所在位计算结果相加起来
    
88.                 r2 = random.nextInt(101);
    
89.                 if (0 < r2 && r2 < r1) {// 产生的数为1
    
90.                     result = result.add(BigInteger.TWO.pow(i));
    
91.                 }
    
92.                 continue;
    
93.             }
    
94. 
    
95.             if (RSA4.isPrime(result)) {// 素数判断
    
96.                 return result;
    
97.             }
    
98. 
    
99.             result = tmp;// 重新计算
    
100.         }
     
101.     }
     
102. 
     
103.     //蒙哥马利快速幂模运算，返回base^exponent mod module的结果。
     
104.     private static BigInteger expMod(BigInteger base, BigInteger exponent, BigInteger module) {
     
105.         BigInteger result = BigInteger.ONE;
     
106.         BigInteger tmp = base.mod(module);
     
107. 
     
108.         while (exponent.compareTo(BigInteger.ZERO) != 0) {
     
109.             if ((exponent.and(BigInteger.ONE).compareTo(BigInteger.ZERO)) != 0) {
     
110.                 result = result.multiply(tmp).mod(module);
     
111.             }
     
112.             tmp = tmp.multiply(tmp).mod(module);
     
113.             exponent = exponent.shiftRight(1);
     
114.         }
     
115.         return result;
     
116.     }
     
117. 
     
118.     //判断是否互素
     
119.     public static boolean fun(BigInteger x, BigInteger y) {
     
120.         BigInteger t;
     
121.         while (!(y.equals(new BigInteger("0")))) {
     
122.             t = x;
     
123.             x = y;
     
124.             y = t.mod(y);
     
125.         }
     
126.         if (x.equals(new BigInteger("1")))
     
127.             return false;
     
128.         else
     
129.             return true;
     
130.     }
     
131. 
     
132.     public BigInteger bigRandom(int numDigits) {
     
133.         // 产生一个随机大整数，各位上的数字都是随机产生的，首位不为 0
     
134.         StringBuffer s = new StringBuffer("");
     
135.         for (int i = 0; i < numDigits; i++)
     
136.             if (i == 0)
     
137.                 s.append(randomDigit(false));
     
138.             else
     
139.                 s.append(randomDigit(true));
     
140.         return (new BigInteger(s.toString()));
     
141.     }
     
142. 
     
143.     private StringBuffer randomDigit(boolean isZeroOK) {
     
144.         // 产生一个随机的数字（字符串形式的），isZeroOK 决定这个数字是否可以为 0
     
145.         int index;
     
146.         if (isZeroOK)
     
147.             index = (int) Math.floor(Math.random() * 10);
     
148.         else
     
149.             index = 1 + (int) Math.floor(Math.random() * 9);
     
150.         return (digits[index]);
     
151.     }
     
152. 
     
153.     private static StringBuffer[] digits = {
     
154.             new StringBuffer("0"),
     
155.             new StringBuffer("1"), new StringBuffer("2"),
     
156.             new StringBuffer("3"), new StringBuffer("4"),
     
157.             new StringBuffer("5"), new StringBuffer("6"),
     
158.             new StringBuffer("7"), new StringBuffer("8"), new StringBuffer("9")};
     
159. 
     
160.     public BigInteger nextPrime(BigInteger start) {
     
161.         if (isEven(start))
     
162.             start = start.add(ONE);
     
163.         else
     
164.             start = start.add(TWO);
     
165.         if (start.isProbablePrime(ERR_VAL))
     
166.             return (start);
     
167.         else
     
168.             return (nextPrime(start));
     
169.     }
     
170. 
     
171.     private static boolean isEven(BigInteger n) {
     
172.         // 测试一个大整数是否为偶数
     
173.         return (n.mod(TWO).equals(ZERO));
     
174.     }
     
175. }
     

复制代码

刘帆杰

刘帆杰 发表于 2022-5-30 19:48

ECC算法
原理：ECC加密算法是一种公钥加密技术，以椭圆曲线理论为基础。利用有限域上椭圆曲线的点构成的Abel群离散对数难解性，实现加密、解密和数字签名。将椭圆曲线中的加法运算与离散对数中的模乘运算相对应，就可以建立基于椭圆曲线的对应密码体制。
代码：

1. package com.example.test;
   
2. 
   
3. import javax.crypto.Cipher;
   
4. import javax.crypto.NullCipher;
   
5. import java.io.*;
   
6. import java.security.*;
   
7. import java.security.interfaces.ECPrivateKey;
   
8. import java.security.interfaces.ECPublicKey;
   
9. import java.security.spec.PKCS8EncodedKeySpec;
   
10. import java.security.spec.X509EncodedKeySpec;
    
11. import java.util.HashMap;
    
12. import java.util.Map;
    
13. 
    
14. public class ECC {
    
15.     public static void main(String[] args) throws Exception {
    
16.         Map<String,String> map = GenerateKey.getGenerateKey();
    
17.         String privKey = map.get(ECCEnum.PRIVATE_KEY.value());
    
18.         String pubKey = map.get(ECCEnum.PUBLIC_KEY.value());
    
19. 
    
20.         System.out.println("私钥：" + privKey);
    
21.         System.out.println("公钥：" + pubKey);
    
22.         String text = "aslkdjlwkjdlaskjdlaskjdlakjwdlkawjdJkasldjals卢卡斯的积分";
    
23.         byte [] b = ECCUtil.encrypt(text.getBytes("UTF-8"),pubKey);
    
24.         String str = BASE64Encoder.encodeBuffer(b);
    
25.         System.out.println("密文：" + str);
    
26.         String outputStr = new String(ECCUtil.decrypt(b,privKey));
    
27.         System.out.println("原始文本：" + text);
    
28.         System.out.println("解密文本：" + outputStr);
    
29.     }
    
30. }
    
31. 
    
32. enum ECCEnum {
    
33. 
    
34.     ALGORITHM("EC"),
    
35.     PROVIDER("BC"),
    
36.     PUBLIC_KEY("PUBLIC_KEY"),
    
37.     PRIVATE_KEY("PRIVATE_KEY");
    
38. 
    
39. 
    
40. 
    
41.     private String value;
    
42. 
    
43.     ECCEnum(String value) {
    
44.         this.value = value;
    
45.     }
    
46. 
    
47.     public String value() {
    
48.         return this.value;
    
49.     }
    
50. }
    
51. 
    
52. 
    
53. 
    
54. class ECCUtil implements Serializable {
    
55.     public static byte[] encrypt(byte[] data, String publicKey)
    
56.             throws Exception {
    
57.         byte[] keyBytes = BASE64Decoder.decodeBuffer(publicKey);
    
58. 
    
59.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
    
60.         KeyFactory keyFactory = KeyFactory.getInstance(ECCEnum.ALGORITHM.value());
    
61. 
    
62.         ECPublicKey pubKey = (ECPublicKey) keyFactory
    
63.                 .generatePublic(x509KeySpec);
    
64. 
    
65.         Cipher cipher = new NullCipher();
    
66.         cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    
67.         return cipher.doFinal(data);
    
68.     }
    
69. 
    
70.     public static byte[] decrypt(byte[] data, String privateKey) throws Exception {
    
71.         byte[] keyBytes = BASE64Decoder.decodeBuffer(privateKey);
    
72. 
    
73.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    
74.         KeyFactory keyFactory = KeyFactory.getInstance(ECCEnum.ALGORITHM.value());
    
75. 
    
76.         ECPrivateKey priKey = (ECPrivateKey) keyFactory
    
77.                 .generatePrivate(pkcs8KeySpec);
    
78. 
    
79.         Cipher cipher = new NullCipher();
    
80.         cipher.init(Cipher.DECRYPT_MODE, priKey);
    
81. 
    
82.         return cipher.doFinal(data);
    
83.     }
    
84. }
    
85. 
    
86. 
    
87. class GenerateKey implements Serializable {
    
88. 
    
89.     static {
    
90.         Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
    
91.     }
    
92. 
    
93.     public static Map<String,String> getGenerateKey() throws NoSuchProviderException, NoSuchAlgorithmException {
    
94.         KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ECCEnum.ALGORITHM.value(),
    
95.                 ECCEnum.PROVIDER.value());
    
96.         keyPairGenerator.initialize(256, new SecureRandom());
    
97.         KeyPair kp = keyPairGenerator.generateKeyPair();
    
98.         ECPublicKey publicKey = (ECPublicKey) kp.getPublic();
    
99.         ECPrivateKey privateKey = (ECPrivateKey) kp.getPrivate();
    
100.         Map<String,String> map = new HashMap<>();
     
101. 
     
102.         map.put(ECCEnum.PRIVATE_KEY.value(), BASE64Encoder.encodeBuffer(privateKey.getEncoded()));
     
103.         map.put(ECCEnum.PUBLIC_KEY.value(), BASE64Encoder.encodeBuffer(publicKey.getEncoded()));
     
104.         return map;
     
105.     }
     
106. }
     
107. 
     

复制代码

刘帆杰

刘帆杰 发表于 2022-5-30 20:02
ECC算法
原理：ECC加密算法是一种公钥加密技术，以椭圆曲线理论为基础。利用有限域上椭圆曲线的点构成的A ...

1. class BASE64Decoder extends FilterInputStream {
   
2. private static final char[] chars = {
   
3. 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
   
4. 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
   
5. 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
   
6. 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
   
7. 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
   
8. 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
   
9. '8', '9', '+', '/'
   
10. };
    
11. 
    
12. private static final int[] ints = new int[128];
    
13. static {
    
14. for (int i = 0; i < 64; i++) {
    
15. ints[chars[i]] = i;
    
16. }
    
17. }
    
18. 
    
19. private int charCount;
    
20. private int carryOver;
    
21. 
    
22. 
    
23. public BASE64Decoder(InputStream in) {
    
24. super(in);
    
25. }
    
26. 
    
27. 
    
28. public int read() throws IOException {
    
29. int x;
    
30. do {
    
31. x = in.read();
    
32. if (x == -1) {
    
33. return -1;
    
34. }
    
35. } while (Character.isWhitespace((char)x));
    
36. charCount++;
    
37. 
    
38. if (x == '=') {
    
39. return -1;
    
40. }
    
41. 
    
42. x = ints[x];
    
43. 
    
44. int mode = (charCount - 1) % 4;
    
45. 
    
46. if (mode == 0) {
    
47. carryOver = x & 63;
    
48. return read();
    
49. }
    
50. 
    
51. else if (mode == 1) {
    
52. int decoded = ((carryOver << 2) + (x >> 4)) & 255;
    
53. carryOver = x & 15;
    
54. return decoded;
    
55. }
    
56. else if (mode == 2) {
    
57. int decoded = ((carryOver << 4) + (x >> 2)) & 255;
    
58. carryOver = x & 3;
    
59. return decoded;
    
60. }
    
61. else if (mode == 3) {
    
62. int decoded = ((carryOver << 6) + x) & 255;
    
63. return decoded;
    
64. }
    
65. return -1;
    
66. }
    
67. 
    
68. 
    
69. public int read(byte[] buf, int off, int len) throws IOException {
    
70. if (buf.length < (len + off - 1)) {
    
71. throw new IOException("The input buffer is too small: " + len +
    
72. " bytes requested starting at offset " + off + " while the buffer " +
    
73. " is only " + buf.length + " bytes long.");
    
74. }
    
75. 
    
76. int i;
    
77. for (i = 0; i < len; i++) {
    
78. int x = read();
    
79. if (x == -1 && i == 0) { // an immediate -1 returns -1
    
80. return -1;
    
81. }
    
82. else if (x == -1) { // a later -1 returns the chars read so far
    
83. break;
    
84. }
    
85. buf[off + i] = (byte) x;
    
86. }
    
87. return i;
    
88. }
    
89. 
    
90. public static String decode(String encoded) {
    
91. return new String(decodeToBytes(encoded));
    
92. }
    
93. 
    
94. 
    
95. public static byte[] decodeToBytes(String encoded) {
    
96. byte[] bytes = null;
    
97. try {
    
98. bytes = encoded.getBytes("8859_1");
    
99. }
    
100. catch (UnsupportedEncodingException ignored) { }
     
101. 
     
102. BASE64Decoder in = new BASE64Decoder(
     
103. new ByteArrayInputStream(bytes));
     
104. 
     
105. ByteArrayOutputStream out =
     
106. new ByteArrayOutputStream((int) (bytes.length * 0.67));
     
107. 
     
108. try {
     
109. byte[] buf = new byte[4 * 1024]; // 4K buffer
     
110. int bytesRead;
     
111. while ((bytesRead = in.read(buf)) != -1) {
     
112. out.write(buf, 0, bytesRead);
     
113. }
     
114. out.close();
     
115. 
     
116. return out.toByteArray();
     
117. }
     
118. catch (IOException ignored) { return null; }
     
119. }
     
120. 
     
121. public static void main(String[] args) throws Exception {
     
122. if (args.length != 1) {
     
123. System.err.println("Usage: java Base64Decoder fileToDecode");
     
124. return;
     
125. }
     
126. 
     
127. BASE64Decoder decoder = null;
     
128. try {
     
129. decoder = new BASE64Decoder(
     
130. new BufferedInputStream(
     
131. new FileInputStream(args[0])));
     
132. byte[] buf = new byte[4 * 1024]; // 4K buffer
     
133. int bytesRead;
     
134. while ((bytesRead = decoder.read(buf)) != -1) {
     
135. System.out.write(buf, 0, bytesRead);
     
136. }
     
137. }
     
138. finally {
     
139. if (decoder != null) decoder.close();
     
140. }
     
141. }
     
142. 
     
143. public static byte[] decodeBuffer(String key) {
     
144. 
     
145. return decodeToBytes(key);
     
146. }
     
147. }
     
148. 
     
149. class BASE64Encoder {
     
150. private static final char last2byte = (char) Integer.parseInt("00000011", 2);
     
151. private static final char last4byte = (char) Integer.parseInt("00001111", 2);
     
152. private static final char last6byte = (char) Integer.parseInt("00111111", 2);
     
153. private static final char lead6byte = (char) Integer.parseInt("11111100", 2);
     
154. private static final char lead4byte = (char) Integer.parseInt("11110000", 2);
     
155. private static final char lead2byte = (char) Integer.parseInt("11000000", 2);
     
156. private static final char[] encodeTable = new char[]{'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', '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', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
     
157. 
     
158. private BASE64Encoder() {
     
159. }
     
160. 
     
161. public static String encode(byte[] from) {
     
162. StringBuffer to = new StringBuffer((int) (from.length * 1.34) + 3);
     
163. int num = 0;
     
164. char currentByte = 0;
     
165. for (int i = 0; i < from.length; i++) {
     
166. num = num % 8;
     
167. while (num < 8) {
     
168. switch (num) {
     
169. case 0:
     
170. currentByte = (char) (from[i] & lead6byte);
     
171. currentByte = (char) (currentByte >>> 2);
     
172. break;
     
173. case 2:
     
174. currentByte = (char) (from[i] & last6byte);
     
175. break;
     
176. case 4:
     
177. currentByte = (char) (from[i] & last4byte);
     
178. currentByte = (char) (currentByte << 2);
     
179. if ((i + 1) < from.length) {
     
180. currentByte |= (from[i + 1] & lead2byte) >>> 6;
     
181. }
     
182. break;
     
183. case 6:
     
184. currentByte = (char) (from[i] & last2byte);
     
185. currentByte = (char) (currentByte << 4);
     
186. if ((i + 1) < from.length) {
     
187. currentByte |= (from[i + 1] & lead4byte) >>> 4;
     
188. }
     
189. break;
     
190. }
     
191. to.append(encodeTable[currentByte]);
     
192. num += 6;
     
193. }
     
194. }
     
195. if (to.length() % 4 != 0) {
     
196. for (int i = 4 - to.length() % 4; i > 0; i--) {
     
197. to.append("=");
     
198. }
     
199. }
     
200. return to.toString();
     
201. }
     
202. 
     
203. public static String encodeBuffer(byte[] key) {
     
204. return encode(key);
     
205. }
     
206. }
     

复制代码