信息计算2019级1班18号冯雨

冯雨

1. import java.math.BigInteger;
   
2. import java.util.ArrayList;
   
3. import java.util.Scanner;
   
4. 
   
5. public class Rsamim01 {
   
6.         static BigInteger z, y;
   
7. 
   
8.         public static boolean fun(BigInteger x, BigInteger y) {
   
9.                 BigInteger t;
   
10.                 while (!(y.equals(new BigInteger("0")))) {
    
11.                         t = x;
    
12.                         x = y;
    
13.                         y = t.mod(y);
    
14.                 }
    
15.                 if (x.equals(new BigInteger("1")))
    
16.                         return false;
    
17.                 else
    
18.                         return true;
    
19.         }
    
20. 
    
21.         public static BigInteger siyue(BigInteger a, BigInteger b) {
    
22.                 BigInteger temp;
    
23.                 if (b.equals(new BigInteger("0"))) {
    
24.                         z = new BigInteger("1");
    
25.                         y = new BigInteger("0");
    
26.                         return z;
    
27.                 }
    
28.                 siyue(b, a.mod(b));
    
29.                 temp = z;
    
30.                 z = y;
    
31.                 y = temp.subtract((a.divide(b).multiply(y)));
    
32.                 return z;
    
33.         }
    
34. 
    
35.         public static double entropy(String mess) {
    
36.                 ArrayList<Node> jieguo = new ArrayList<Node>();
    
37.                 jieguo.clear();
    
38.                 double num = mess.length();
    
39.                 for (int i = 0; i < num; i++) {
    
40.                         boolean flag_exit = true;
    
41.                         for (int j = 0; j < jieguo.size(); j++) {
    
42.                                 if (jieguo.get(j).getalpha() == mess.charAt(i)) {
    
43.                                         flag_exit = false;
    
44.                                         jieguo.get(j).setp(jieguo.get(j).getp() + 1 / num);
    
45.                                 }
    
46.                         }
    
47.                         if (flag_exit)
    
48.                                 jieguo.add(new Node(1 / num, mess.charAt(i)));
    
49.                 }
    
50.                 /** 计算熵 */
    
51.                 double entropy = 0;
    
52.                 for (int i = 0; i < jieguo.size(); i++) {
    
53.                         double p1 = jieguo.get(i).getp();
    
54.                         entropy += (-p1 * (Math.log(p1) / Math.log(2)));
    
55.                 }
    
56.                 return entropy;
    
57.         }
    
58.         
    
59.         
    
60.         public static void main(String[] args) {
    
61.                 BigInteger p = null;
    
62.                 BigInteger e, d, n, t, c;
    
63.                 BigInteger q = null;
    
64.                 for (int i = 0; i < 2; i++) {
    
65.                         int numDigits;
    
66.                         Prime pri = new Prime();
    
67.                         try {
    
68.                                 numDigits = Integer.parseInt("15");
    
69.                         } catch (Exception e1) {
    
70.                                 numDigits = 128;
    
71.                         }
    
72.                         BigInteger start = pri.bigRandom(numDigits);
    
73.                         BigInteger big = pri.nextPrime(start);
    
74.                         if (i == 0)
    
75.                                 p = big;
    
76.                         else
    
77.                                 q = big;
    
78.                 }
    
79.                 Scanner input = new Scanner(System.in);
    
80.                 n = p.multiply(q);
    
81.                 t = p.subtract(new BigInteger("1")).multiply(
    
82.                                 q.subtract(new BigInteger("1")));
    
83.                 int numDigits;
    
84.                 Prime pri = new Prime();
    
85.                 try {
    
86.                         numDigits = Integer.parseInt("15");
    
87.                 } catch (Exception e1) {
    
88.                         numDigits = 128;
    
89.                 }
    
90.                 BigInteger start = pri.bigRandom(numDigits);
    
91.                 BigInteger big = pri.nextPrime(start);
    
92.                 e = big;
    
93.                 while (e.compareTo(t) == 1 || fun(e, t)) {
    
94.                         System.out.println("e不合要求，请重新产生" + (e.compareTo(t) == 1)
    
95.                                         + fun(e, t));
    
96.                         pri = new Prime();
    
97.                         try {
    
98.                                 numDigits = Integer.parseInt("15");
    
99.                         } catch (Exception e1) {
    
100.                                 numDigits = 128;
     
101.                         }
     
102.                         start = pri.bigRandom(numDigits);
     
103.                         big = pri.nextPrime(start);
     
104.                         e = big;
     
105.                 }
     
106.                 d = siyue(e, t);
     
107.                 System.out.println("由计算机随机产生2个素数p,q:");
     
108.                 System.out.println("素数p:"+p);
     
109.                 System.out.println("素数q:"+q);
     
110.                 System.out.println("计算得到的n:");
     
111.                 System.out.println(n);
     
112.                 System.out.println("计算得到的t:");
     
113.                 System.out.println(t);
     
114.                 System.out.println("随机产生的公钥：");
     
115.                 System.out.println(e);
     
116.                 while (true) {
     
117.                         System.out.println("请输入明文：");
     
118.                         String mess = input.nextLine();
     
119.                         BigInteger m = new BigInteger(mess.getBytes());// 把字串转成一个BigInteger对象
     
120.                         System.out.println("明文的大整数表示形式：" + m);
     
121.                         /** 调用函数计算信息，统计信息 */
     
122.                         mess = m.toString();
     
123.                         c = m.modPow(e, n);// JAVA中的方法
     
124.                         System.out.println("密文的大整数表示形式：" + c);
     
125.                         System.out.println("密文的字符串表示形式：" + new String(c.toByteArray()));
     
126.                         m = c.modPow(d, n);
     
127.                         System.out.println("解密得到明文的大整数表示形式：" + c);
     
128.                         String str = new String(m.toByteArray());// 把返回的结果还原成一个字串
     
129.                         System.out.println("解密得到：" + str);
     
130.                 }
     
131.         }
     
132. }
     
133. class Prime {
     
134.         public boolean sushu(double n) {
     
135.                 // 判断素数
     
136.                 boolean isPrime = true;
     
137.                 // 如果n大于2 继续判断 否则 isPrime的值不变 2素数
     
138.                 if (n > 2) {
     
139.                         // 如果n是大于2的偶数 认定不是素数 修改变量值为false
     
140.                         if (n % 2 == 0) {
     
141.                                 isPrime = false;
     
142.                         } else {
     
143.                                 // 循环判断如果找到一个可以整除的数 则判定不是素数跳出循环 因为是判断奇数 因此 2 4 6
     
144.                                 // 不用考虑 循环递增
     
145.                                 for (int i = 3; i <= (int) Math.sqrt(n); i += 2) {
     
146.                                         if (n % i == 0) {
     
147.                                                 isPrime = false;
     
148.                                                 break;
     
149.                                         }
     
150.                                 }
     
151.                         }
     
152. 
     
153.                 }
     
154.                 return isPrime;
     
155.         }
     
156. 
     
157.         private static final BigInteger ZERO = BigInteger.ZERO;
     
158.         private static final BigInteger ONE = BigInteger.ONE;
     
159.         private static final BigInteger TWO = new BigInteger("2");
     
160.         private static final int ERR_VAL = 100;
     
161. 
     
162.         public BigInteger nextPrime(BigInteger start) {
     
163.                 if (isEven(start))
     
164.                         start = start.add(ONE);
     
165.                 else
     
166.                         start = start.add(TWO);
     
167.                 if (start.isProbablePrime(ERR_VAL))
     
168.                         return (start);
     
169.                 else
     
170.                         // 采用递归方式（递归的层数会是个天文数字吗？）
     
171.                         return (nextPrime(start));
     
172.         }
     
173. 
     
174.         private static boolean isEven(BigInteger n) {
     
175.                 // 测试一个大整数是否为偶数
     
176.                 return (n.mod(TWO).equals(ZERO));
     
177.         }
     
178. 
     
179.         public BigInteger bigRandom(int numDigits) {
     
180.                 // 产生一个随机大整数，各位上的数字都是随机产生的，首位不为 0
     
181.                 StringBuffer s = new StringBuffer("");
     
182.                 for (int t= 0; t< numDigits; t++)

复制代码

冯雨