信息计算2019级1班9号陈佳怡

19-1-09陈佳怡

RSA加密与签名算法

一 RSA算法简介

  RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。

二 RSA加密、签名区别

  加密和签名都是为了安全性考虑，但略有不同。简单的说，加密是为了防止信息被泄露，而签名是为了防止信息被篡改。

三 实现代码

1. import java.io.ByteArrayInputStream;
   
2. import java.io.ByteArrayOutputStream;
   
3. import java.io.InputStream;
   
4. import java.security.Key;
   
5. import java.security.KeyFactory;
   
6. import java.security.KeyPair;
   
7. import java.security.KeyPairGenerator;
   
8. import java.security.PrivateKey;
   
9. import java.security.PublicKey;
   
10. import java.security.interfaces.RSAPrivateKey;
    
11. import java.security.interfaces.RSAPublicKey;
    
12. import java.security.spec.PKCS8EncodedKeySpec;
    
13. import java.security.spec.X509EncodedKeySpec;
    
14. import java.util.Base64;
    
15. import javax.crypto.Cipher;
    
16. 
    
17. public class RSAUtil{
    
18.        
    
19.         public static final String  SIGN_ALGORITHMS = "SHA1WithRSA";
    
20.        
    
21.     /**加密算法RSA*/
    
22.     public static final String KEY_ALGORITHM = "RSA";
    
23.    
    
24.         /**RSA最大加密明文大小*/
    
25.     private static final int MAX_ENCRYPT_BLOCK = 117;
    
26.    
    
27.     /**RSA最大解密密文大小*/
    
28.     private static final int MAX_DECRYPT_BLOCK = 128;
    
29.        
    
30.         /**
    
31.         * RSA签名
    
32.         * @param content 待签名数据
    
33.         * @param privateKey 商户私钥
    
34.         * @param input_charset 编码格式
    
35.         */
    
36.         public static String sign(String content, String privateKey, String input_charset){
    
37.         try {
    
38.                 PKCS8EncodedKeySpec priPKCS8         = new PKCS8EncodedKeySpec(Base64_.decode(privateKey) );
    
39.                 KeyFactory keyf                                 = KeyFactory.getInstance(KEY_ALGORITHM);
    
40.                 PrivateKey priKey                                 = keyf.generatePrivate(priPKCS8);
    
41.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
    
42.             signature.initSign(priKey);
    
43.             signature.update(content.getBytes(input_charset));
    
44.             byte[] signed = signature.sign();
    
45.             return Base64_.encode(signed);
    
46.         }catch (Exception e) {
    
47.                 e.printStackTrace();
    
48.         }
    
49.         return null;
    
50.     }
    
51.        
    
52.         /**
    
53.         * RSA验签名检查
    
54.         * @param content 待签名数据
    
55.         * @param sign 签名值
    
56.         * @param ali_public_key 支付宝公钥
    
57.         * @param input_charset 编码格式
    
58.         */
    
59.         public static boolean verify(String content, String sign, String ali_public_key, String input_charset){
    
60.                 try {
    
61.                         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
62.                 byte[] encodedKey = Base64_.decode(ali_public_key);
    
63.                 PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
    
64.                         java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
    
65.                         signature.initVerify(pubKey);
    
66.                         signature.update(content.getBytes(input_charset) );
    
67.                         boolean bverify = signature.verify( Base64_.decode(sign) );
    
68.                         return bverify;
    
69.                 } catch (Exception e) {
    
70.                         e.printStackTrace();
    
71.                 }
    
72.                 return false;
    
73.         }
    
74.        
    
75.         /**
    
76.         * 私钥解密
    
77.         * @param content 密文
    
78.         * @param private_key 商户私钥
    
79.         * @param input_charset 编码格式
    
80.         */
    
81.         public static String decrypt(String content, String private_key, String input_charset) throws Exception {
    
82.         PrivateKey prikey = getPrivateKey(private_key);
    
83.         Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
    
84.         cipher.init(Cipher.DECRYPT_MODE, prikey);
    
85.         InputStream ins = new ByteArrayInputStream(Base64_.decode(content));
    
86.         ByteArrayOutputStream writer = new ByteArrayOutputStream();
    
87.         byte[] buf = new byte[128];
    
88.         int bufl;
    
89.         while ((bufl = ins.read(buf)) != -1) {
    
90.             byte[] block = null;
    
91.             if (buf.length == bufl) {
    
92.                 block = buf;
    
93.             } else {
    
94.                 block = new byte[bufl];
    
95.                 for (int i = 0; i < bufl; i++) {
    
96.                     block[i] = buf[i];
    
97.                 }
    
98.             }
    
99.             writer.write(cipher.doFinal(block));
    
100.         }
     
101.         return new String(writer.toByteArray(), input_charset);
     
102.     }
     
103.        
     
104.         /**
     
105.      * 公钥加密
     
106.      * @param data 源数据
     
107.      * @param publicKey 公钥(BASE64编码)
     
108.      */
     
109.     public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
     
110.         byte[] keyBytes = Base64_.decode(publicKey);
     
111.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
     
112.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
     
113.         Key publicK = keyFactory.generatePublic(x509KeySpec);
     
114.         // 对数据加密
     
115.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
     
116.         cipher.init(Cipher.ENCRYPT_MODE, publicK);
     
117.         int inputLen = data.length;
     
118.         ByteArrayOutputStream out = new ByteArrayOutputStream();
     
119.         int offSet = 0;
     
120.         byte[] cache;
     
121.         int i = 0;
     
122.         // 对数据分段加密
     
123.         while (inputLen - offSet > 0) {
     
124.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
     
125.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
     
126.             } else {
     
127.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
     
128.             }
     
129.             out.write(cache, 0, cache.length);
     
130.             i++;
     
131.             offSet = i * MAX_ENCRYPT_BLOCK;
     
132.         }
     
133.         byte[] encryptedData = out.toByteArray();
     
134.         out.close();
     
135.         return encryptedData;
     
136.     }
     
137.    
     
138.     public static String encryptByPublicKeyToStr(byte[] data, String publicKey) throws Exception {
     
139.             byte[] bytes = encryptByPublicKey(data, publicKey);
     
140.             String result = Base64_.encode(bytes);
     
141.             return result;
     
142.     }
     
143.        
     
144.         /**
     
145.         * 得到私钥
     
146.         * @param key 密钥字符串（经过base64编码）
     
147.         * @throws Exception
     
148.         */
     
149.         public static PrivateKey getPrivateKey(String key) throws Exception {
     
150.                 byte[] keyBytes;
     
151.                 keyBytes = Base64_.decode(key);
     
152.                 PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
     
153.                 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
     
154.                 PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
     
155.                 return privateKey;
     
156.         }
     
157.        
     
158.         public static class Base64_ {
     
159.                 private static final Base64.Decoder decoder = Base64.getDecoder();
     
160.                 private static final Base64.Encoder encoder = Base64.getEncoder();
     
161.                 public static byte[] decode(String key) {
     
162.                         if (key == null) { return null;}
     
163.                         byte[] decode = decoder.decode(key);
     
164.                         return decode;
     
165.                 }
     
166.                 public static String encode(byte[] content) {
     
167.                         if (content == null) {return null;}
     
168.                         String encode = encoder.encodeToString(content);
     
169.                         return encode;
     
170.                 }
     
171.         }
     
172.        
     
173.         /**
     
174.          * 测试
     
175.          */
     
176.         public static void main(String args[]) throws Exception{
     
177.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
     
178.         keyPairGen.initialize(1024);
     
179.         KeyPair keyPair = keyPairGen.generateKeyPair();
     
180.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
     
181.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
     
182.         String pubKey = Base64_.encode(publicKey.getEncoded()); //公钥
     
183.         String priKey = Base64_.encode(privateKey.getEncoded()); //私钥
     
184.         String sourceStr = "hello world!";
     
185.         //公钥加密
     
186.         byte[] ens = RSAUtil.encryptByPublicKey(sourceStr.getBytes(),pubKey);
     
187.         String encodes = Base64_.encode(ens);
     
188.         System.out.println("加密："+encodes);
     
189.         //私钥解密
     
190.         String res2 = RSAUtil.decrypt(encodes, priKey, "UTF-8");
     
191.         System.out.println("解密："+res2);
     
192.         
     
193. //.......................................签名验证，私钥签名，公钥验证是否正确!
     
194.         
     
195.         String source = "id=shoig&name=shoer&age=23dnjlegj;reg";
     
196.         
     
197.         String sign = RSAUtil.sign(source, priKey, "UTF-8");
     
198.         
     
199.         System.out.println("签名是："+sign);
     
200.         
     
201.         // 公钥验证签名是否正确.
     
202.         // 具体流程是，请求参数+sign发送给公钥方，然后公钥方过滤掉sign，用公钥验证其他参数是否通过。
     
203.         
     
204.         boolean result = RSAUtil.verify(source, sign, pubKey, "UTF-8");
     
205.         
     
206.         System.out.println("签名是否正确："+result);
     
207.         
     
208.         }
     
209. }
     

复制代码

四 运行截图

19-1-09陈佳怡

ECC加密算法

一 算法简介

  椭圆曲线加密算法，简称ECC，是基于椭圆曲线数学理论实现的一种非对称加密算法。相比RSA，ECC优势是可以使用更短的密钥，来实现与RSA相当或更高的安全。

二 代码实现

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<string.h>
   
4. #include<math.h>
   
5. #include<time.h>
   
6. #define MAX 100
   
7. 
   
8. typedef struct point {
   
9.         int point_x;
   
10.         int point_y;
    
11. }Point;
    
12. typedef struct ecc {
    
13.         struct point p[MAX];
    
14.         int len;
    
15. }ECCPoint;
    
16. typedef struct generator {
    
17.         Point p;
    
18.         int p_class;
    
19. }GENE_SET;
    
20. 
    
21. void get_all_points();
    
22. int int_sqrt(int s);
    
23. Point timesPiont(int k, Point p);
    
24. Point add_two_points(Point p1, Point p2);
    
25. int inverse(int n, int b);
    
26. void get_generetor_class();
    
27. void encrypt_ecc();
    
28. void decrypt_ecc();
    
29. int mod_p(int s);
    
30. void print();
    
31. int isPrime(int n);
    
32. 
    
33. char alphabet[27] = "abcdefghijklmnopqrstuvwxyz";
    
34. int a = -1, b = 0, p = 89;//椭圆曲线为E89(-1,0)： y2=x3-x (mod 89)
    
35. ECCPoint eccPoint;
    
36. GENE_SET geneSet[MAX];
    
37. int geneLen;
    
38. char plain[] = "yes";
    
39. int m[MAX];
    
40. int cipher[MAX];
    
41. int nB;//私钥
    
42. Point P1, P2, Pt, G, PB;
    
43. Point Pm;
    
44. int C[MAX];
    
45. 
    
46. int main()
    
47. {
    
48.         get_generetor_class();
    
49.         encrypt_ecc();
    
50.         decrypt_ecc();
    
51.         return 0;
    
52. }
    
53. //加密
    
54. void encrypt_ecc()
    
55. {
    
56.         int num, i, j;
    
57.         int gene_class;
    
58.         int num_t;
    
59.         int k;
    
60.         srand(time(NULL));
    
61.         //明文转换过程
    
62.         for (i = 0; i < strlen(plain); i++)
    
63.         {
    
64.                 for (j = 0; j < 26; j++) //for(j=0;j<26;j++)
    
65.                 {
    
66.                         if (plain[i] == alphabet[j])
    
67.                         {
    
68.                                 m[i] = j;//将字符串明文换成数字，并存到整型数组m里面
    
69.                         }
    
70.                 }
    
71.         }
    
72.         //选择生成元
    
73.         num = rand() % geneLen;
    
74.         gene_class = geneSet[num].p_class;
    
75.         while (isPrime(gene_class) == -1)//不是素数
    
76.         {
    
77.                 num = rand() % (geneLen - 3) + 3;
    
78.                 gene_class = geneSet[num].p_class;
    
79.         }
    
80.         //printf("gene_class=%d\n",gene_class);
    
81.         G = geneSet[num].p;
    
82.         //printf("G:(%d,%d)\n",geneSet[num].p.point_x,geneSet[num].p.point_y);
    
83.         nB = rand() % (gene_class - 1) + 1;//选择私钥
    
84.         PB = timesPiont(nB, G);
    
85.         printf("\n公钥：\n");
    
86.         printf("{y^2=x^3%d*x+%d,%d,(%d,%d),(%d,%d)}\n", a, b, gene_class, G.point_x, G.point_y, PB.point_x, PB.point_y);
    
87.         printf("私钥：\n");
    
88.         printf("nB=%d\n", nB);
    
89.         //加密
    
90.         //
    
91.         k = rand() % (gene_class - 2) + 1;
    
92.         P1 = timesPiont(k, G);
    
93.         //
    
94.         num_t = rand() % eccPoint.len; //选择映射点
    
95.         Pt = eccPoint.p[num_t];
    
96.         //printf("Pt:(%d,%d)\n",Pt.point_x,Pt.point_y);
    
97.         P2 = timesPiont(k, PB);
    
98.         Pm = add_two_points(Pt, P2);
    
99.         printf("加密数据：\n");
    
100.         printf("kG=(%d,%d),Pt+kPB=(%d,%d),C={", P1.point_x, P1.point_y, Pm.point_x, Pm.point_y);
     
101.         for (i = 0; i < strlen(plain); i++)
     
102.         {
     
103.                 //                num_t=rand()%eccPoint.len; //选择映射点
     
104.                 //                Pt=eccPoint.p[num_t];
     
105.                 C[i] = m[i] * Pt.point_x + Pt.point_y;
     
106.                 printf("{%d}", C[i]);
     
107.         }
     
108.         printf("}\n");
     
109. }
     
110. //解密
     
111. void decrypt_ecc()
     
112. {
     
113.         Point temp, temp1;
     
114.         int m, i;
     
115.         temp = timesPiont(nB, P1);
     
116.         temp.point_y = 0 - temp.point_y;
     
117.         temp1 = add_two_points(Pm, temp);//求解Pt
     
118. //        printf("(%d,%d)\n",temp.point_x,temp.point_y);
     
119. //        printf("(%d,%d)\n",temp1.point_x,temp1.point_y);
     
120.         printf("\n解密结果：\n");
     
121.         for (i = 0; i < strlen(plain); i++)
     
122.         {
     
123.                 m = (C[i] - temp1.point_y) / temp1.point_x;
     
124.                 printf("%c", alphabet[m]);//输出密文
     
125.         }
     
126.         printf("\n");
     
127. }
     
128. //判断是否为素数
     
129. int isPrime(int n)
     
130. {
     
131.         int i, k;
     
132.         k = sqrt(n);
     
133.         for (i = 2; i <= k; i++)
     
134.         {
     
135.                 if (n % i == 0)
     
136.                         break;
     
137.         }
     
138.         if (i <= k) {
     
139.                 return -1;
     
140.         }
     
141.         else {
     
142.                 return 0;
     
143.         }
     
144. }
     
145. //求生成元以及阶
     
146. void get_generetor_class()
     
147. {
     
148.         int i, j = 0;
     
149.         int count = 1;
     
150.         Point p1, p2;
     
151.         get_all_points();
     
152.         printf("\n**********************************输出生成元以及阶：*************************************\n");
     
153.         for (i = 0; i < eccPoint.len; i++)
     
154.         {
     
155.                 count = 1;
     
156.                 p1.point_x = p2.point_x = eccPoint.p[i].point_x;
     
157.                 p1.point_y = p2.point_y = eccPoint.p[i].point_y;
     
158.                 while (1)
     
159.                 {
     
160.                         p2 = add_two_points(p1, p2);
     
161.                         if (p2.point_x == -1 && p2.point_y == -1)
     
162.                         {
     
163.                                 break;
     
164.                         }
     
165.                         count++;
     
166.                         if (p2.point_x == p1.point_x)
     
167.                         {
     
168.                                 break;
     
169.                         }
     
170.                 }
     
171.                 count++;
     
172.                 if (count <= eccPoint.len + 1)
     
173.                 {
     
174.                         geneSet[j].p.point_x = p1.point_x;
     
175.                         geneSet[j].p.point_y = p1.point_y;
     
176.                         geneSet[j].p_class = count;
     
177.                         printf("(%d,%d)--->>%d\t", geneSet[j].p.point_x, geneSet[j].p.point_y, geneSet[j].p_class);
     
178.                         j++;
     
179.                         if (j % 6 == 0) {
     
180.                                 printf("\n");
     
181.                         }
     
182.                 }
     
183.                 geneLen = j;
     
184.         }
     
185. }
     
186. 
     
187. //倍点运算的递归算法
     
188. Point timesPiont(int k, Point p0)
     
189. {
     
190.         if (k == 1) {
     
191.                 return p0;
     
192.         }
     
193.         else if (k == 2) {
     
194.                 return add_two_points(p0, p0);
     
195.         }
     
196.         else {
     
197.                 return add_two_points(p0, timesPiont(k - 1, p0));
     
198.         }
     
199. }
     
200. 
     
201. //两点的加法运算
     
202. Point add_two_points(Point p1, Point p2)
     
203. {
     
204.         long t;
     
205.         int x1 = p1.point_x;
     
206.         int y1 = p1.point_y;
     
207.         int x2 = p2.point_x;
     
208.         int y2 = p2.point_y;
     
209.         int tx, ty;
     
210.         int x3, y3;
     
211.         int flag = 0;
     
212.         //求
     
213.         if ((x2 == x1) && (y2 == y1))
     
214.         {
     
215.                 //相同点相加
     
216.                 if (y1 == 0)
     
217.                 {
     
218.                         flag = 1;
     
219.                 }
     
220.                 else {
     
221.                         t = (3 * x1 * x1 + a) * inverse(p, 2 * y1) % p;
     
222.                 }
     
223.                 //printf("inverse(p,2*y1)=%d\n",inverse(p,2*y1));
     
224.         }
     
225.         else {
     
226.                 //不同点相加
     
227.                 ty = y2 - y1;
     
228.                 tx = x2 - x1;
     
229.                 while (ty < 0)
     
230.                 {
     
231.                         ty += p;
     
232.                 }
     
233.                 while (tx < 0)
     
234.                 {
     
235.                         tx += p;
     
236.                 }
     
237.                 if (tx == 0 && ty != 0)
     
238.                 {
     
239.                         flag = 1;
     
240.                 }
     
241.                 else {
     
242.                         t = ty * inverse(p, tx) % p;
     
243.                 }
     
244.         }
     
245.         if (flag == 1)
     
246.         {
     
247.                 p2.point_x = -1;
     
248.                 p2.point_y = -1;
     
249.         }
     
250.         else {
     
251.                 x3 = (t * t - x1 - x2) % p;
     
252.                 y3 = (t * (x1 - x3) - y1) % p;
     
253.                 //使结果在有限域GF(P)上
     
254.                 while (x3 < 0)
     
255.                 {
     
256.                         x3 += p;
     
257.                 }
     
258.                 while (y3 < 0)
     
259.                 {
     
260.                         y3 += p;
     
261.                 }
     
262.                 p2.point_x = x3;
     
263.                 p2.point_y = y3;
     
264.         }
     
265.         return p2;
     
266. }
     
267. //求b关于n的逆元
     
268. int inverse(int n, int b)
     
269. {
     
270.         int q, r, r1 = n, r2 = b, t, t1 = 0, t2 = 1, i = 1;
     
271.         while (r2 > 0)
     
272.         {
     
273.                 q = r1 / r2;
     
274.                 r = r1 % r2;
     
275.                 r1 = r2;
     
276.                 r2 = r;
     
277.                 t = t1 - q * t2;
     
278.                 t1 = t2;
     
279.                 t2 = t;
     
280.         }
     
281.         if (t1 >= 0)
     
282.                 return t1 % n;
     
283.         else {
     
284.                 while ((t1 + i * n) < 0)
     
285.                         i++;
     
286.                 return t1 + i * n;
     
287.         }
     
288. }
     
289. //求出椭圆曲线上所有点
     
290. void get_all_points()
     
291. {
     
292.         int i = 0;
     
293.         int j = 0;
     
294.         int s, y = 0;
     
295.         int n = 0, q = 0;
     
296.         int modsqrt = 0;
     
297.         int flag = 0;
     
298.         if (4 * a * a * a + 27 * b * b != 0)
     
299.         {
     
300.                 for (i = 0; i <= p - 1; i++)
     
301.                 {
     
302.                         flag = 0;
     
303.                         n = 1;
     
304.                         y = 0;
     
305.                         s = i * i * i + a * i + b;
     
306.                         while (s < 0)
     
307.                         {
     
308.                                 s += p;
     
309.                         }
     
310.                         s = mod_p(s);
     
311.                         modsqrt = int_sqrt(s);
     
312.                         if (modsqrt != -1)
     
313.                         {
     
314.                                 flag = 1;
     
315.                                 y = modsqrt;
     
316.                         }
     
317.                         else {
     
318.                                 while (n <= p - 1)
     
319.                                 {
     
320.                                         q = s + n * p;
     
321.                                         modsqrt = int_sqrt(q);
     
322.                                         if (modsqrt != -1)
     
323.                                         {
     
324.                                                 y = modsqrt;
     
325.                                                 flag = 1;
     
326.                                                 break;
     
327.                                         }
     
328.                                         flag = 0;
     
329.                                         n++;
     
330.                                 }
     
331.                         }
     
332.                         if (flag == 1)
     
333.                         {
     
334.                                 eccPoint.p[j].point_x = i;
     
335.                                 eccPoint.p[j].point_y = y;
     
336.                                 j++;
     
337.                                 if (y != 0)
     
338.                                 {
     
339.                                         eccPoint.p[j].point_x = i;
     
340.                                         eccPoint.p[j].point_y = (p - y) % p;
     
341.                                         j++;
     
342.                                 }
     
343.                         }
     
344.                 }
     
345.                 eccPoint.len = j;//点集个数
     
346.                 print(); //打印点集
     
347.         }
     
348. }
     
349. 
     
350. //取模函数
     
351. int mod_p(int s)
     
352. {
     
353.         int i;        //保存s/p的倍数
     
354.         int result;        //模运算的结果
     
355.         i = s / p;
     
356.         result = s - i * p;
     
357.         if (result >= 0)
     
358.         {
     
359.                 return result;
     
360.         }
     
361.         else
     
362.         {
     
363.                 return result + p;
     
364.         }
     
365. }
     
366. 
     
367. //判断平方根是否为整数
     
368. int int_sqrt(int s)
     
369. {
     
370.         int temp;
     
371.         temp = (int)sqrt(s);//转为整型
     
372.         if (temp * temp == s)
     
373.         {
     
374.                 return temp;
     
375.         }
     
376.         else {
     
377.                 return -1;
     
378.         }
     
379. }
     
380. //打印点集
     
381. void print()
     
382. {
     
383.         int i;
     
384.         int len = eccPoint.len;
     
385.         printf("\n该椭圆曲线上共有%d个点(包含无穷远点)\n", len + 1);
     
386.         for (i = 0; i < len; i++)
     
387.         {
     
388.                 if (i % 8 == 0)
     
389.                 {
     
390.                         printf("\n");
     
391.                 }
     
392.                 printf("(%2d,%2d)\t", eccPoint.p[i].point_x, eccPoint.p[i].point_y);
     
393.         }
     
394.         printf("\n");
     
395. }

复制代码

三 运行截图