信息计算2019级2班16号吴盛盛

吴盛盛

RSA数字签名算法

   RSA数字签名算法的过程为：A对明文m用解密变换作: (公钥用来加密，私钥用来解密，数字签名是用私钥完成的，所以称为解密变换，这与onu sdk中一致)sº Dk (m)=md mod n,其中d，n为A的私人密钥，只有A才知道它；B收到Ａ的签名后，用A的公钥和加密变换得到明文，因: Ek(s)= Ek(Dk (m))= (md)e mod n,又 deº1 mod j(n)即de=lj(n)+1,根据欧拉定理mj(n)=1 mod n，所以Ek(s)=mlj(n)+1=[mj(n)]em=m mod n。若明文m和签名s一起送给用户B,B可以确信信息确实是A发送的。同时A也不能否认送给这个信息，因为除了A本人外，其他任何人都无法由明文m产生s.因此RSA数字签名方案是可行的。

1. 
   
2. 
   
3. import javax.crypto.Cipher;
   
4. import java.io.ByteArrayOutputStream;
   
5. import java.security.*;
   
6. import java.security.interfaces.RSAPrivateKey;
   
7. import java.security.interfaces.RSAPublicKey;
   
8. import java.security.spec.PKCS8EncodedKeySpec;
   
9. import java.security.spec.X509EncodedKeySpec;
   
10. import java.util.ArrayList;
    
11. import java.util.Base64;
    
12. import java.util.List;
    
13. 
    
14. public class RSAUtils {
    
15. 
    
16.     // 加密算法
    
17.     private final static String ALGORITHM_RSA = "RSA";
    
18. 
    
19.     /**
    
20.      * 直接生成公钥、私钥对象
    
21.      *
    
22.      * @param modulus
    
23.      *
    
24.      * @throws NoSuchAlgorithmException
    
25.      *
    
26.      */
    
27.     public static List<Key> getRSAKeyObject(int modulus) throws NoSuchAlgorithmException{
    
28. 
    
29.         List<Key> keyList = new ArrayList<>(2);
    
30.         // 创建RSA密钥生成器
    
31.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(ALGORITHM_RSA);
    
32.         // 设置密钥的大小，此处是RSA算法的模长 = 最大加密数据的大小
    
33.         keyPairGen.initialize(modulus);
    
34.         KeyPair keyPair = keyPairGen.generateKeyPair();
    
35.         // keyPair.getPublic() 生成的是RSAPublic的是咧
    
36.         keyList.add(keyPair.getPublic());
    
37.         // keyPair.getPrivate() 生成的是RSAPrivateKey的实例
    
38.         keyList.add(keyPair.getPrivate());
    
39.         return keyList;
    
40.     }
    
41. 
    
42.     /**
    
43.      * 生成公钥、私钥的字符串
    
44.      * 方便传输
    
45.      *
    
46.      * @param modulus 模长
    
47.      * @return
    
48.      * @throws NoSuchAlgorithmException
    
49.      */
    
50.     public static List<String> getRSAKeyString(int modulus) throws NoSuchAlgorithmException{
    
51. 
    
52.         List<String> keyList = new ArrayList<>(2);
    
53.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(ALGORITHM_RSA);
    
54.         keyPairGen.initialize(modulus);
    
55.         KeyPair keyPair = keyPairGen.generateKeyPair();
    
56.         String publicKey = Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
    
57.         String privateKey = Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());
    
58.         keyList.add(publicKey);
    
59.         keyList.add(privateKey);
    
60.         return keyList;
    
61.     }
    
62. 
    
63.     // Java中RSAPublicKeySpec、X509EncodedKeySpec支持生成RSA公钥
    
64.     // 此处使用X509EncodedKeySpec生成
    
65.     public static RSAPublicKey getPublicKey(String publicKey) throws Exception {
    
66. 
    
67.         KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
    
68.         byte[] keyBytes = Base64.getDecoder().decode(publicKey);
    
69.         X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
    
70.         return (RSAPublicKey) keyFactory.generatePublic(spec);
    
71.     }
    
72. 
    
73.     // Java中只有RSAPrivateKeySpec、PKCS8EncodedKeySpec支持生成RSA私钥
    
74.     // 此处使用PKCS8EncodedKeySpec生成
    
75.     public static RSAPrivateKey getPrivateKey(String privateKey) throws Exception {
    
76. 
    
77.         KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
    
78.         byte[] keyBytes = Base64.getDecoder().decode(privateKey);
    
79.         PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
    
80.         return (RSAPrivateKey) keyFactory.generatePrivate(spec);
    
81.     }
    
82. 
    
83.     /**
    
84.      * 公钥加密
    
85.      *
    
86.      * @param data
    
87.      * @param publicKey
    
88.      * @return
    
89.      * @throws Exception
    
90.      */
    
91.     public static String encryptByPublicKey(String data, RSAPublicKey publicKey)
    
92.             throws Exception {
    
93.         Cipher cipher = Cipher.getInstance(ALGORITHM_RSA);
    
94.         cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    
95.         // 模长n转换成字节数
    
96.         int modulusSize = publicKey.getModulus().bitLength() / 8;
    
97.         // PKCS Padding长度为11字节，所以实际要加密的数据不能要 - 11byte
    
98.         int maxSingleSize = modulusSize - 11;
    
99.         // 切分字节数组，每段不大于maxSingleSize
    
100.         byte[][] dataArray = splitArray(data.getBytes(), maxSingleSize);
     
101.         ByteArrayOutputStream out = new ByteArrayOutputStream();
     
102.         // 分组加密，并将加密后的内容写入输出字节流
     
103.         for (byte[] s : dataArray) {
     
104.             out.write(cipher.doFinal(s));
     
105.         }
     
106.         // 使用Base64将字节数组转换String类型
     
107.         return Base64.getEncoder().encodeToString(out.toByteArray());
     
108.     }
     
109. 
     
110.     /**
     
111.      * 私钥解密
     
112.      *
     
113.      * @param data
     
114.      * @param privateKey
     
115.      * @return
     
116.      * @throws Exception
     
117.      */
     
118.     public static String decryptByPrivateKey(String data, RSAPrivateKey privateKey)
     
119.             throws Exception {
     
120.         Cipher cipher = Cipher.getInstance(ALGORITHM_RSA);
     
121.         cipher.init(Cipher.DECRYPT_MODE, privateKey);
     
122.         // RSA加密算法的模长 n
     
123.         int modulusSize = privateKey.getModulus().bitLength() / 8;
     
124.         byte[] dataBytes = data.getBytes();
     
125.         // 之前加密的时候做了转码，此处需要使用Base64进行解码
     
126.         byte[] decodeData = Base64.getDecoder().decode(dataBytes);
     
127.         // 切分字节数组，每段不大于modulusSize
     
128.         byte[][] splitArrays = splitArray(decodeData, modulusSize);
     
129.         ByteArrayOutputStream out = new ByteArrayOutputStream();
     
130.         for(byte[] arr : splitArrays){
     
131.             out.write(cipher.doFinal(arr));
     
132.         }
     
133.         return new String(out.toByteArray());
     
134.     }
     
135. 
     
136.     /**
     
137.      * 按指定长度切分数组
     
138.      *
     
139.      * @param data
     
140.      * @param len 单个字节数组长度
     
141.      * @return
     
142.      */
     
143.     private static byte[][] splitArray(byte[] data,int len){
     
144. 
     
145.         int dataLen = data.length;
     
146.         if (dataLen <= len) {
     
147.             return new byte[][]{data};
     
148.         }
     
149.         byte[][] result = new byte[(dataLen-1)/len + 1][];
     
150.         int resultLen = result.length;
     
151.         for (int i = 0; i < resultLen; i++) {
     
152.             if (i == resultLen - 1) {
     
153.                 int slen = dataLen - len * i;
     
154.                 byte[] single = new byte[slen];
     
155.                 System.arraycopy(data, len * i, single, 0, slen);
     
156.                 result[i] = single;
     
157.                 break;
     
158.             }
     
159.             byte[] single = new byte[len];
     
160.             System.arraycopy(data, len * i, single, 0, len);
     
161.             result[i] = single;
     
162.         }
     
163.         return result;
     
164.     }
     
165. 
     
166. 
     
167. }
     

复制代码

吴盛盛

ECC加密算法
加密过程
1.选取一条椭圆曲线Ep(a,b)，并取椭圆曲线上一点作为基点P
2.选定一个大数K作为私钥，并生成公钥Q = K*P
加密：选择一个随机数r(r < n)，将消息M生成密文C
1.密文是一个点对，C = （rP，M * rQ）
2.解密：M = r * Q - K * (r * P) = M + r * (K * p) - K * (r * P) = M

1. 
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. /**
   
7. * @ClassName: Ellipse
   
8. * @Description:针对于加密的椭圆曲线，Eq(a,b)由a,b,q三个参数决定
   
9. * privateKey为私钥,basePoint为基点,publicKey为公钥;
   
10. * rankOfBasePoint为基点的阶，rankOfEllipse为Ellipse的阶;
    
11. * multiPoint(k,P)更新私钥和基点，返回公钥;
    
12. * getAllPointsOnEllipse()返回所有平常点;
    
13. * getRankOfBasePoint()返回基点的阶;
    
14. * setPrivateKey(k)设置私钥;
    
15. * setBasePoint(P)设置基点;
    
16. * getPublicKey()返回公钥;
    
17. * @author: dong.yanchao
    
18. * @date: 2018年8月14日 10点42分
    
19. * @Copyright: v2
    
20. */
    
21. public class Ellipse {
    
22.         //Eq(a,b)，椭圆曲线的三个参数
    
23.         private int a;
    
24.         private int b;
    
25.         private int q;
    
26. 
    
27.         //私钥
    
28.         private long privateKey;
    
29.         //基点
    
30.         private String basePoint;
    
31.         //公钥
    
32.         private String publicKey;
    
33.        
    
34.         //基点的阶
    
35.         private long rankOfBasePoint;
    
36.         //Ellipse的阶
    
37.         private long rankOfEllipse;
    
38.         //Ellipse上的所有平常点
    
39.         private List<String> allPoints;
    
40.        
    
41.         public Ellipse(int a, int b, int q) {
    
42.                 this.a = a;
    
43.                 this.b = b;
    
44.                 this.q = q;
    
45.                 this.allPoints = this.getAllPointsOnEllipse();
    
46.                 this.rankOfEllipse = this.allPoints.size() + 1;
    
47.         }
    
48.         public int getA() {
    
49.                 return a;
    
50.         }
    
51.         public void setA(int a) {
    
52.                 this.a = a;
    
53.         }
    
54.         public int getB() {
    
55.                 return b;
    
56.         }
    
57.         public void setB(int b) {
    
58.                 this.b = b;
    
59.         }
    
60.         public int getQ() {
    
61.                 return q;
    
62.         }
    
63.         public void setQ(int q) {
    
64.                 this.q = q;
    
65.         }
    
66.         //返回私钥
    
67.         public long getPrivateKey() {
    
68.                 return privateKey;
    
69.         }
    
70.         //重置私钥
    
71.         public void setPrivateKey(long k) {
    
72.                 this.privateKey = k;
    
73.         }
    
74.         //返回基点
    
75.         public String getBasePoint() {
    
76.                 return basePoint;
    
77.         }
    
78.         //重置基点
    
79.         public void setBasePoint(String p) {
    
80.                 basePoint = p;
    
81.                 this.rankOfBasePoint = getRankOfBasePoint();
    
82.         }
    
83.         //返回公钥
    
84.         public String getPublicKey() {
    
85.                 return publicKey;
    
86.         }
    
87.         //返回Ellipse的阶
    
88.         public long getRankOfEllipse() {
    
89.                 return rankOfEllipse;
    
90.         }
    
91.         //返回所有Ellipse的平常点，不包括无穷远点
    
92.         public List<String> getAllPoints() {
    
93.                 return allPoints;
    
94.         }
    
95.         public static void main(String[] args) {
    
96. //                Ellipse algorithm = new Ellipse(1,1,23);//E23(1,1)
    
97. //                String s = "3v10";//基点G(3,10)
    
98. //                for (int j = 0; j < 100; j++) {
    
99. //                        String multiPoint = algorithm.multiPoint(j+1, s);
    
100. //                        System.out.println(j+1+":"+multiPoint);
     
101. //                        if(multiPoint.equals("0v0"))break;
     
102. //                }
     
103.                
     
104. //                Ellipse algorithm = new Ellipse(1,1,19);//E19(1,1)
     
105. //                String s = "10v2";//基点G(10,2)
     
106. //                String multiPoint = algorithm.multiPoint(2,s);
     
107. //                System.out.println(multiPoint);
     
108. 
     
109. //                List<String> allPointsOnEllipse = algorithm.getAllPointsOnEllipse();
     
110. //                for (String string : allPointsOnEllipse) {
     
111. //                        System.out.println(string);
     
112. //                }
     
113.                 Ellipse algorithm = new Ellipse(1,1,23);//Eq(a,b)
     
114.                 System.out.println(algorithm.getAllPoints());//所有平常点
     
115.                 System.out.println(algorithm.getRankOfEllipse());//Ellipse的阶
     
116.                 algorithm.setPrivateKey(8);//设置私钥
     
117.                 algorithm.setBasePoint("3v10");//设置基点
     
118.                 System.out.println(algorithm.getRankOfBasePoint());//基点的阶
     
119.                 algorithm.multiPoint(algorithm.getPrivateKey(), algorithm.getBasePoint());
     
120.                 System.out.println(algorithm.getPublicKey());//返回公钥
     
121.                
     
122.         }
     
123.        
     
124.         /**
     
125.          * @Title: multiPoint
     
126.          * @Description:
     
127.          * 倍点运算，给定一个点P，按照k的二进制展开进行计算
     
128.          * @return: String，"XvY"形式,表示点(x,y)
     
129.          */
     
130.         public String multiPoint(long k,String P) {
     
131.                 List<Byte> bins = new ArrayList<Byte>();//k的二进制展开
     
132.                 if (k == 0)return "0v0";
     
133.                 while (k != 0) {
     
134.                         byte tmp = (byte) (k % 2);
     
135.                         bins.add(tmp);
     
136.                         k /= 2;
     
137.                 }
     
138.                 String Q = "0v0";
     
139.                 for (int i = bins.size() - 1; i >= 0; i--) {
     
140.                         Q = doublePoint(Q);//Q=2Q
     
141.                         if (bins.get(i) == 1)Q = pAddP(Q, P);//Q=Q+P
     
142.                 }
     
143.                
     
144.                 this.publicKey = Q;
     
145.                 return Q;
     
146.         }
     
147.        
     
148.         /**
     
149.          * @Title: doublePoint
     
150.          * @Description: 计算一个点p的2倍
     
151.          * @param: p 被计算的点
     
152.          * @return: String，"XvY"形式,表示点(x,y)
     
153.          */
     
154.         public String doublePoint(String p) {
     
155.                 String[] vp = p.split("v");
     
156.                 int x1 = Integer.parseInt(vp[0]);
     
157.                 int y1 = Integer.parseInt(vp[1]);
     
158.                 if (y1 == 0)return "0v0";//分母为0
     
159.                
     
160.                 long numer = 3 * x1 * x1 + a;//分子
     
161.                 long denom = 2 * y1;//分母
     
162.                 denom = inv(denom, q);//计算分母的逆元
     
163.                 denom = AmodB(denom,q);
     
164.                 long slope = (long)AmodB(numer*denom,q);
     
165.                 long x11 = AmodB(slope*slope-2*x1,q);
     
166.                 int Xr = (int) x11;// 横坐标
     
167.                 long y11 = AmodB(slope*(x1-Xr)-y1,q);
     
168.                 int Yr = (int) y11;// 纵坐标
     
169.                 return Xr + "v" + Yr;// 返回2倍点的新坐标
     
170.         }
     
171. 
     
172.         /**
     
173.          * @Title: pAddP
     
174.          * @Description: 计算两个不同点相加
     
175.          * @param: P1
     
176.          * @param: P2
     
177.          * @return: String，"XvY"形式,表示点(x,y)
     
178.          */
     
179.         public String pAddP(String P1, String P2) {
     
180.                 if (P2.equals(P1)) return doublePoint(P1);// 如果两个点一致，直接调用doublePoint运算
     
181.                
     
182.                 String[] vp = P1.split("v");
     
183.                 String[] vq = P2.split("v");
     
184.                 if (vp[0].equals(vq[0]))return "0v0";//x1==x2，不可能
     
185. 
     
186.                 if (P2.equals("0v0"))return P1;
     
187.                 if (P1.equals("0v0"))return P2;
     
188.                 //P1和P2全不为0v0，则展开如下计算
     
189.                 int x1 = Integer.parseInt(vp[0]);
     
190.                 int y1 = Integer.parseInt(vp[1]);
     
191. 
     
192.                 int x2 = Integer.parseInt(vq[0]);
     
193.                 int y2 = Integer.parseInt(vq[1]);
     
194. 
     
195.                 long DValueY = AmodB(y2-y1,q);
     
196.                 long DValueX = AmodB(x2-x1,q);
     
197.                 DValueX = inv(DValueX, q);//取倒数
     
198.                 DValueX = AmodB(DValueX,q);
     
199.                 long slope = AmodB(DValueY*DValueX,q);//斜率
     
200.                 long xrr = AmodB(slope*slope-x1-x2,q);
     
201.                
     
202.                 int xr = (int) xrr;
     
203.                 long y11 = AmodB(slope*(x1-xr)-y1,q);
     
204.                 int yr = (int) y11;
     
205.                 return xr + "v" + yr;
     
206.         }
     
207.         /**
     
208.          * @Title: inv 取倒数
     
209.          * @Description: 计算逆元，理解为在mod r2的基础上，“取倒数”的意思
     
210.          * 假设得到的结果为res，则有res*r1 == 1 （mod r2）恒成立
     
211.          */
     
212.         public long inv(long r1,long r2){
     
213.                 return extraEuclid(r1,r2,1,0);
     
214. //                return AexpB(r1,r2-2);
     
215.         }
     
216.         /**
     
217.          * @Title: extraEuclid 扩展的欧几里得算法
     
218.          */
     
219.         public long extraEuclid(long r1, long r2, long x1, long x2) {
     
220.                 long qr = r1 / r2;
     
221.                 long r = r1 % r2;
     
222.                 long x = x1 - qr * x2;
     
223.                 if (r == 1) return x;
     
224.                 return extraEuclid(r2, r, x2, x);
     
225.         }
     
226.         /**
     
227.          * @Title: AexpB Fq上的指数运算
     
228.          * @Description: 计算a^b的值
     
229.          * @return: long ，返回值范围[0,b-1]
     
230.          */
     
231.         public long AexpB(long g,long e){
     
232.                 if(AmodB(e,q)==0)return 1l;
     
233.                 List<Byte> bins = new ArrayList<Byte>();//e的二进制展开
     
234.                 while (e != 0) {
     
235.                         byte tmp = (byte) (e % 2);
     
236.                         bins.add(tmp);
     
237.                         e /= 2;
     
238.                 }
     
239.                 long x = g;
     
240.                 for (int i = bins.size() - 2; i >= 0; i--) {
     
241.                         x = AmodB(x*x,q);//x=x^2
     
242.                         if (bins.get(i) == 1)x = AmodB(g*x,q);//x=g*x
     
243.                 }
     
244.                 return x;
     
245.         }
     
246.         /**
     
247.          * @Title: AmodB 整数求模运算
     
248.          * @Description: 计算a mod b的值
     
249.          * @return: long ，返回值范围[0,b-1]
     
250.          */
     
251.         public long AmodB(long a, long b) {
     
252.                 long res = a % b;
     
253.                 if(res<0)return res+b;
     
254.                 return res;
     
255.         }
     
256.        
     
257.         /**
     
258.          * @Title: getAllPointsOnEllipse 求椭圆曲线上所有的平常点，不包括无穷远点
     
259.          * @Description: 平常点(X,Y)，X和Y都属于Fp有限域，(X,Y)满足Eq(a,b)方程
     
260.          * @return: List<String>，点的集合，每个String采用"XvY"的格式，即平常点(X,Y)
     
261.          */
     
262.         public List<String> getAllPointsOnEllipse(){
     
263.                 List<String> retPoints = new ArrayList<String>();
     
264.                 for(long X = 0;X<q;X++){
     
265.                         long A = AmodB(X*X*X+a*X+b,q);
     
266.                         if(A==0){
     
267.                                 retPoints.add(new String(X+"v0"));
     
268.                                 continue;
     
269.                         }
     
270.                         long Y = square(A);
     
271.                         if(q==Y)continue;
     
272.                         retPoints.add(new String(X+"v"+Y));
     
273.                         retPoints.add(new String(X+"v"+(q-Y)));
     
274.                 }
     
275.                 return retPoints;
     
276.         }
     
277.         /**
     
278.          * @Title: square 整数求平方根的运算
     
279.          * @param g 满足[0,q)的整数
     
280.          * @Description: ret为g的平方根，有ret*ret=g（mod q）恒成立，若ret成立，则q-ret也成立
     
281.          * @return: long ，返回任意一个值，返回值范围[0,q-1]，另一个为q-ret;返回q，则代表g不存在平方根
     
282.          */
     
283.         public long square(long g){
     
284.                 if(g<0||g>=q){
     
285.                         System.err.print("square的参数g应满足[0,q)");
     
286.                         System.exit(0);
     
287.                 }
     
288.                 if(g==0)return 0;
     
289.                 long u = q/4;
     
290.                 long ret = AexpB(g,u+1);
     
291.                 if(AmodB(ret*ret,q)==g)return ret;
     
292.                 return q;
     
293.         }
     
294.         /**
     
295.          * @Title: getRankOfBasePoint 求基点的阶
     
296.          * @Description: 设P为基点，nP=O，则n为P的阶。有限域上P的阶一定存在，可证明
     
297.          */
     
298.         public long getRankOfBasePoint(){
     
299.                 long ret = -1L;
     
300.                 String G = this.basePoint;
     
301.                 for(long i = 2;;i++){
     
302.                         G=pAddP(G,this.basePoint);
     
303.                         if(G.equals("0v0")){
     
304.                                 ret = i;
     
305.                                 break;
     
306.                         }
     
307.                 }
     
308.                 return ret;
     
309.         }
     
310.        
     
311. }
     
312. 
     

复制代码