OpenSSL 密码软件库学习

说明：本次的密码算法采用C++编写，使用clion开发平台，Cmake编译配置工具；通过集成OpenSSL密码软件库，实现加解密功能。
1 对称加解密（AES）

1.1 AES简介：

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };AES（Advanced Encryption Standard）是分组密码，每组的长度相同，为128位，即16个字节。密钥长度可以使用128位，192位或256位。密钥长度不同，加密轮数也不同。
AES的处理单位是字节，128位的明文分组P和密钥K都分为16个字节，其中P=(p0,```,p15),K=(k0,```,k15)。明文分组使用以节为单位的4*4矩阵描述，即状态矩阵；状态矩阵中字节排列顺序是从上到下，从左到右；每轮加密，状态矩阵发生变化，最终输出为密文。
1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };同样，128位密钥也使用方阵表示，矩阵的每一列称为1个32位比特字。通过密钥扩展，该密钥矩阵被排列成44个字组成的序列W=(W0,```,W43),其中W[0-3]为原始密钥，后面的密钥分成10组，每组的4个字作为轮密钥，用于10轮的加密。
1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };
1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 图1.1 明文矩阵 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };图1.2密钥矩阵
1.2 AES加解密规则：

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };AES加密操作分为10轮，第1轮到第9轮加密的轮函数一样，包括4个操作：字节代换，行移位，列混淆和轮密钥加。第一轮开始时，先将原文和原密钥进行一次异或；最后一轮加密，不包括列混淆。AES解密过程与加密类似，每一轮的操作是加密操作的逆。
1.2.1字节代换

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; AES中定义了一个S盒和逆S盒，即映射表，分别对应加密和解密。字节代换操作就是查表的过程，将状态矩阵中的元素按照一定规则映射成新的一个字节。即，将原有元素（16进制数）的高4位作为行，低4位作为列，选中行列相交的元素，然后替代原来的元素。例如，原来输出的元素Si是0x7f，将其拆分为0x7,0xf；选择0x7行，0xf列，挑选出相应的元素0x68。在新的状态表中，用0x68代替0x7f。
1.2.2 行移位

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 行移位是对状态矩阵的每行进行相关的移位操作。加密过程，状态矩阵的第1行循环左移0位，第2行循环左移1位，第3行循环左移2位，第4行循环左移3位。解密过程，将状态矩阵的每行循环右移，位数与左移相同。
1.2.3 列混合

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 列混合操作是通过矩阵的乘法来实现的，即S’=PS。其中P为固定的矩阵，S为变换前的矩阵，S’为变换后的矩阵。矩阵元素的乘法和加法都是定义在基于GF(2^8)上的二元运算。 列混合的逆操作，相当于将矩阵P变为P的逆。
1.2.4 密钥轮加

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 将轮密钥W=（W[4i],W[4i+1],W[4i+2],W[4i+3]）同状态矩阵S(S[0-3],S[4-7],s[8-11],s[12-15])进行异或操作。其中状态矩阵的每列可组成一个32位的字，与W大小相同。
1.3 AES加解密的源代码（OpenSSL实现）

1. 1 #include <cstdio>
2. 2 #include <openssl/aes.h>
3. 3 #include <cstdlib>
4. 4 #include <cstring>
5. 5
6. 6 #define AES_KEY_SIZE 128
7. 7 #define AES_BLOCK_SIZE 16
8. 8 #define N 3600
9. 9
10. 10 using namespace std;
11. 11
12. 12 void aes_encrypt(unsigned char *plaintext, unsigned char *ciphertext, const unsigned char *key) {
13. 13     AES_KEY aesKey;
14. 14     AES_set_encrypt_key(key, AES_KEY_SIZE, &aesKey);
15. 15     AES_encrypt(plaintext, ciphertext, &aesKey);
16. 16 }
17. 17
18. 18 void aes_decrypt(unsigned char *ciphertext, unsigned char *plaintext, const unsigned char *key) {
19. 19     AES_KEY aesKey;
20. 20     AES_set_decrypt_key(key, AES_KEY_SIZE, &aesKey);
21. 21     AES_decrypt(ciphertext, plaintext, &aesKey);
22. 22 }
23. 23
24. 24 void inputPlain(char *&plainText, size_t &length) {
25. 25     char str[N],ch;
26. 26     length = 0;
27. 27     while (true) {
28. 28         ch = getchar();
29. 29         if (ch == '\n') break;
30. 30         str[length++] = ch;
31. 31     }
32. 32     str[length]='\0';
33. 33     plainText=str;
34. 34 }
35. 35
36. 36 int main() {
37. 37     char *plainText;
38. 38     unsigned char *cipherText, *decryptedText;
39. 39     size_t plainTextLen, cipherTextLen;
40. 40     const unsigned char aesKey[] = {
41. 41             0x7b, 0xf3, 0x5c, 0xd6, 0x9c, 0x47, 0x5d, 0x5e,
42. 42             0x6f, 0x1d, 0x7a, 0x23, 0x18, 0x7b, 0xf9, 0x34
43. 43     };
44. 44
45. 45     //输入
46. 46     printf("请输入明文（换行结束）：\n");
47. 47     fflush(stdout);
48. 48     inputPlain(plainText, plainTextLen);
49. 49
50. 50     //分配密文空间
51. 51     cipherTextLen = (plainTextLen + AES_BLOCK_SIZE - 1) / AES_BLOCK_SIZE;
52. 52     cipherTextLen *= AES_BLOCK_SIZE;
53. 53     cipherText = new unsigned char[cipherTextLen];
54. 54
55. 55     //对明文进行AES加密
56. 56     aes_encrypt((unsigned char*)plainText, cipherText, aesKey);
57. 57     *(cipherText+cipherTextLen)='\0';
58. 58
59. 59     printf("加密后的密码：");
60. 60     for (size_t i = 0; i < cipherTextLen; i++) {
61. 61         printf("%02x", cipherText[i]);
62. 62     }
63. 63     printf("\n");
64. 64
65. 65     decryptedText=new unsigned char[plainTextLen];
66. 66
67. 67     aes_decrypt(cipherText,decryptedText,aesKey);
68. 68
69. 69     printf("解密后的密码:%s\n",decryptedText);
70. 70
71. 71     free(cipherText);
72. 72     free(decryptedText);
73. 73
74. 74     return 0;
75. 75 }

复制代码

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 备注：代码参考 https://blog.csdn.net/buhuidage/article/details/129192727

2 非对称加密（RSA）

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };  1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; RSA建立在大数分解的困难性之上。RSA 加密包括：密钥生成，加解密和签名验证。
2.1密钥生成

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; 1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     }; （1）选择两个素数p和q，保密的。
1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };（2）计算整数n，n=p*q，公开的。

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };（3）选择整数e，e与θ(n)互素（θ(n)=(p-1)(q-1)），1p = 0;  41.        this->q = 0;  42.        this->n = 0;  43.        this->d = 0;  44.        this->e = 0;  45.        this->r = 0;  46.        this->len = 0;  47.        cText = new long long[N];  48.        pText = new long long[N];  49.        dText = new long long[N];  50.    }  51.      52.    RSA::RSA() {  53.        init();  54.    }  55.      56.    bool RSA::isPrime(long t) {  57.        if (t == 1) return false;  58.        for (int i = 2; i > p >> q;  75.      76.            if (p q = q;  91.            this->n = p * q;  92.            this->r = (p - 1) * (q - 1);  93.            break;  94.        }  95.    }  96.      97.    void RSA::genKeyPair() {  98.        long value = 1;  99.        inputPQ();  100.      101.        for (int i = 2; i < r; i++) {  102.            if (gcd(r, i) == 1) {  103.                this->e = i;  104.                break;  105.            }  106.        }  107.      108.        for (long j = 1;; j++) {  109.            value = j * this->r + 1;  110.            if (value % this->e == 0 && value / this->e < this->r) {  111.                this->d = value / this->e;  112.                break;  113.            }  114.        }  115.      116.        printf("设定的公钥为(%ld,%ld)\n", this->e, this->n);  117.        printf("生成的私钥为(%ld,%d,%d)\n", this->d, this->p, this->q);  118.    }  119.      120.    long RSA::quickPower(long long a, long b, long n) {  121.        long res = 1;  122.        while (b > 0) {  123.            if ((b & 1) != 0)  124.                res = (res * a) % n;  125.            b = b >> 1;  126.            a = (a * a) % n;  127.        }  128.        return res;  129.    }  130.      131.    char* RSA::encrypt(char* str) {  132.        unsigned char ch;  133.        char* es, cipher[N];  134.      135.        for (int i = 0; str != 0; i++) {  136.            if (i > N) {  137.                realloc(cText, N * ((i / 1024) + 1) * sizeof(int64_t));  138.                realloc(pText, N * ((i / 1024) + 1) * sizeof(int64_t));  139.                realloc(dText, N * ((i / 1024) + 1) * sizeof(int64_t));  140.            }  141.      142.            ch = (unsigned char)str;  143.            pText = ch;  144.            cText = quickPower(pText, this->e, this->n);  145.            memset(cipher, 0, sizeof(cipher));  146.            mLtoa(cText, cipher, 16);  147.            res.append(cipher);  148.            this->len++;  149.        }  150.        es = (char*)res.c_str();  151.      152.        return es;  153.    }  154.      155.    char* RSA::decrypt() {  156.        for (int i = 0; i < len; i++) {  157.            dText = quickPower(cText, this->d, this->n);  158.            ds = (char)dText;  159.        }  160.        return ds;  161.    }
[/code]

1.   1 #include <stdio.h>
2.   2 #include <string>
3.   3 #include <openssl/rsa.h>
4.   4 #include <openssl/pem.h>
5.   5 #include <openssl/evp.h>
6.   6
7.   7 using namespace std;
8.   8
9.   9
10. 10 /**
11. 11  * 生成密钥对，并保存为文件
12. 12  * @param pubFile
13. 13  * @param priFile
14. 14  * @param bits
15. 15  */
16. 16 void genKeyFile(const string &pubFile,const string &priFile,int bits){
17. 17     //生成公钥和私钥
18. 18     RSA *rsa= RSA_generate_key(bits,RSA_F4, nullptr, nullptr);
19. 19     BIO *bp= BIO_new(BIO_s_file());
20. 20     BIO_write_filename(bp,(void *) pubFile.c_str());
21. 21     PEM_write_bio_RSAPublicKey(bp,rsa);
22. 22     BIO_free_all(bp);
23. 23
24. 24     bp=BIO_new(BIO_s_file());
25. 25     BIO_write_filename(bp,(void *) priFile.c_str());
26. 26     PEM_write_bio_RSAPrivateKey(bp,rsa,nullptr,nullptr,0,nullptr,nullptr);
27. 27     CRYPTO_cleanup_all_ex_data();
28. 28     BIO_free_all(bp);
29. 29     RSA_free(rsa);
30. 30 }
31. 31
32. 32 //获取公钥和私钥
33. 33 void genKeyPair(string &pubKey,string &priKey,int bits){
34. 34     RSA *rsa= RSA_generate_key(bits,RSA_F4,nullptr,nullptr);
35. 35     BIO *kPub=BIO_new(BIO_s_mem());
36. 36     BIO *kPri=BIO_new(BIO_s_mem());
37. 37     int priKeyLen,pubKeyLen;
38. 38
39. 39     PEM_write_bio_RSAPrivateKey(kPri,rsa,nullptr,nullptr,0,nullptr, nullptr);
40. 40     PEM_write_bio_RSA_PUBKEY(kPub,rsa);
41. 41
42. 42     priKeyLen= BIO_pending(kPri);
43. 43     pubKeyLen= BIO_pending(kPub);
44. 44
45. 45     priKey.resize(priKeyLen);
46. 46     pubKey.resize(pubKeyLen);
47. 47
48. 48     BIO_read(kPri,priKey.c_str(),priKeyLen);
49. 49     BIO_read(kPub, pubKey.c_str(), pubKeyLen);
50. 50
51. 51     RSA_free(rsa);
52. 52     BIO_free_all(kPri);
53. 53     BIO_free_all(kPub);
54. 54 }
55. 55
56. 56 //读取公钥
57. 57 RSA* readPublicKey(const string &pubKey){
58. 58     BIO *bio= BIO_new_mem_buf(pubKey.data(),pubKey.length());
59. 59     RSA *rsa= PEM_read_bio_RSA_PUBKEY(bio,nullptr,nullptr,nullptr);
60. 60     BIO_free_all(bio);
61. 61     return rsa;
62. 62 }
63. 63
64. 64 //读取私钥
65. 65 RSA* readPrivateKey(const string &priKey){
66. 66     BIO *bio= BIO_new_mem_buf(priKey.data(),priKey.length());
67. 67     RSA *rsa= PEM_read_bio_RSAPrivateKey(bio,nullptr, nullptr, nullptr);
68. 68     BIO_free_all(bio);
69. 69     return rsa;
70. 70 }
71. 71
72. 72
73. 73 /**
74. 74  * 公钥加密
75. 75  * @param in
76. 76  * @param out
77. 77  * @param pubKey
78. 78  */
79. 79 bool encrypt(const string &in,string &out,const string &pubKey){
80. 80     int keySize,inLen,readLen=0,len;
81. 81     const unsigned char *from;
82. 82     string to;
83. 83     RSA *rsa= readPublicKey(pubKey);
84. 84     if(rsa==nullptr)  return false;
85. 85
86. 86     //分段加密
87. 87     keySize= RSA_size(rsa);
88. 88     inLen=in.length();
89. 89     from=(const unsigned char*)in.data();
90. 90     to.resize(keySize);
91. 91
92. 92     do{
93. 93         len=(keySize-11)<inLen? (keySize-11):inLen;
94. 94         RSA_public_encrypt(len,(from+readLen),(unsigned char*)to.c_str(),rsa,RSA_PKCS1_PADDING);
95. 95         inLen-=len;
96. 96         readLen+=len;
97. 97         out.append(to);
98. 98     }while(inLen>0);
99. 99     RSA_free(rsa);
100. 100
101. 101     return true;
102. 102 }
103. 103
104. 104
105. 105 /**
106. 106  * 私钥解密
107. 107  * @param in
108. 108  * @param out
109. 109  * @param priKey
110. 110  */
111. 111 bool decrypt(const string &in,string &out,const string &priKey){
112. 112     unsigned char *from;
113. 113     string to;
114. 114     int keySize,inLen,readLen=0,len;
115. 115     RSA *rsa= readPrivateKey(priKey);
116. 116     if(rsa==nullptr)  return false;
117. 117
118. 118     keySize= RSA_size(rsa);
119. 119     from=(unsigned char*)in.data();
120. 120     inLen=in.length();
121. 121     to.resize(keySize);
122. 122
123. 123     do{
124. 124         len=RSA_private_decrypt(keySize,(from+readLen),(unsigned char*)to.c_str(),rsa,RSA_PKCS1_PADDING);
125. 125         inLen-=keySize;
126. 126         readLen+=keySize;
127. 127         out.append(to.data(),len);
128. 128     }while(inLen>0);
129. 129     RSA_free(rsa);
130. 130     return true;
131. 131 }
132. 132
133. 133
134. 134 /**
135. 135  * 签名
136. 136  * @param digest
137. 137  * @param sign
138. 138  * @param priKey
139. 139  */
140. 140 bool signa(const string &digest,string &sign,string &priKey){
141. 141     string out;
142. 142     unsigned int signLen=0;
143. 143     RSA* rsa= readPrivateKey(priKey);
144. 144     if(rsa==nullptr)  return false;
145. 145     out.resize(RSA_size(rsa));
146. 146
147. 147     RSA_sign(NID_sha1, (const unsigned char*)digest.c_str(), digest.length(),
148. 148              (unsigned char*)out.c_str(), &signLen, rsa);
149. 149
150. 150     sign.clear();
151. 151     sign.append(out);
152. 152     RSA_free(rsa);
153. 153     return true;
154. 154 }
155. 155
156. 156
157. 157 /**
158. 158  * 验签
159. 159  * @param digest
160. 160  * @param sign
161. 161  * @param pubKey
162. 162  */
163. 163 bool verify(const string &digest,string &sign,string &pubKey){
164. 164     RSA *rsa= readPublicKey(pubKey);
165. 165     if(rsa== nullptr)
166. 166         return false;
167. 167
168. 168     int res=RSA_verify(NID_sha1,(const unsigned char*)digest.c_str(),digest.length(),
169. 169                (const unsigned char*)sign.c_str(),sign.length(),rsa);
170. 170     RSA_free(rsa);
171. 171
172. 172     if(res==1)
173. 173         return true;
174. 174     return false;
175. 175 }
176. 176
177. 177 //准备数据
178. 178 void prepareData(string &str,int size){
179. 179     for(int i=0;i<size;i++){
180. 180         str+=to_string((i%128));
181. 181     }
182. 182 }
183. 183
184. 184 //哈希摘要
185. 185 string hashDigests(string name,string data){
186. 186     unsigned char mdValue[EVP_MAX_MD_SIZE]={0};
187. 187     unsigned int mdLen=0;
188. 188     const EVP_MD *md= nullptr;
189. 189     string out;
190. 190
191. 191     OpenSSL_add_all_digests();
192. 192     md= EVP_get_digestbyname(name.c_str());
193. 193     if(!md){
194. 194         return NULL;
195. 195     }
196. 196
197. 197     EVP_MD_CTX *mdCtx=EVP_MD_CTX_new();
198. 198     EVP_MD_CTX_init(mdCtx);
199. 199     EVP_DigestInit_ex(mdCtx,md,nullptr);
200. 200     EVP_DigestUpdate(mdCtx,data.data(),data.length());
201. 201     EVP_DigestFinal_ex(mdCtx,mdValue,&mdLen);
202. 202     EVP_MD_CTX_free(mdCtx);
203. 203
204. 204     for(int i=0;mdValue[i]!=0;i++){
205. 205         out+=mdValue[i];
206. 206     }
207. 207     return out;
208. 208 }
209. 209
210. 210 void testRSA(string data){
211. 211     string priKey,pubKey;
212. 212     string plainText=data,encryptedText,decryptedText;
213. 213     string digest,sign;
214. 214     int flag=1;
215. 215
216. 216     genKeyFile("./pub.pem","./pri.pem",1024);
217. 217     genKeyPair(pubKey, priKey, 1024);
218. 218     if(!encrypt(plainText,encryptedText,pubKey)){
219. 219         flag=0;
220. 220         printf("RSA加密失败");
221. 221     }
222. 222     if(!decrypt(encryptedText,decryptedText,priKey)){
223. 223         flag=0;
224. 224         printf("RSA解密失败");
225. 225     }
226. 226     if(!flag)  return;
227. 227
228. 228     if(decryptedText==plainText){
229. 229         printf("加解密验证成功\n");
230. 230     }
231. 231
232. 232     digest=hashDigests("SHA256","i lost love");
233. 233     signa(digest,sign,priKey);
234. 234     bool res=verify(digest,sign,pubKey);
235. 235     if(res){
236. 236         printf("RSA 签名验证成功");
237. 237     }
238. 238     else{
239. 239         printf("RSA签名验证失败");
240. 240     }
241. 241 }
242. 242
243. 243 int main(){
244. 244     string str;
245. 245     prepareData(str,1024*512+9);
246. 246     testRSA(str);
247. 247
248. 248     return 0;
249. 249 }

复制代码

1. 1 #include <cstdio>
2. 2 #include <string>
3. 3 #include <openssl/evp.h>
4. 4
5. 5 using namespace std;
6. 6 //准备数据
7. 7 void prepareData(string &str,int size){
8. 8     for(int i=0;i<size;i++){
9. 9         str+=to_string((i%128));
10. 10     }
11. 11 }
12. 12 //摘要算法
13. 13 string hashDigests(string name,string data){
14. 14     unsigned char mdValue[EVP_MAX_MD_SIZE]={0};
15. 15     unsigned int mdLen=0;
16. 16     const EVP_MD *md= nullptr;
17. 17     string out;
18. 18
19. 19     OpenSSL_add_all_digests();
20. 20     md= EVP_get_digestbyname(name.c_str());
21. 21     if(!md){
22. 22         return NULL;
23. 23     }
24. 24
25. 25     EVP_MD_CTX *mdCtx=EVP_MD_CTX_new();
26. 26     EVP_MD_CTX_init(mdCtx);
27. 27     EVP_DigestInit_ex(mdCtx,md,nullptr);
28. 28     EVP_DigestUpdate(mdCtx,data.data(),data.length());
29. 29     EVP_DigestFinal_ex(mdCtx,mdValue,&mdLen);
30. 30     EVP_MD_CTX_free(mdCtx);
31. 31
32. 32     for(int i=0;mdValue[i]!=0;i++){
33. 33         out+=mdValue[i];
34. 34     }
35. 35     return out;
36. 36 }
37. 37
38. 38 int main(){
39. 39     string str;
40. 40     prepareData(str,1*1024*1024+7);
41. 41
42. 42     string sha256=hashDigests("SHA256",str);
43. 43     string sha1=hashDigests("SHA1",str);
44. 44     string md5=hashDigests("MD5",str);
45. 45
46. 46     char *chSha256=(char*)sha1.c_str();
47. 47     char *chSha1=(char*)sha256.c_str();
48. 48     char *chMd5=(char*)md5.c_str();
49. 49
50. 50     for(int i=0;chSha1[i]!='\0';i++){
51. 51         printf("%x",chSha1[i]);
52. 52     }
53. 53     printf("\n");
54. 54
55. 55     for(int i=0;chSha256[i]!='\0';i++){
56. 56         printf("%x",chSha256[i]);
57. 57     }
58. 58     printf("\n");
59. 59
60. 60     for(int i=0;chMd5[i]!='\0';i++){
61. 61         printf("%x",chMd5[i]);
62. 62     }
63. 63     printf("\n");
64. 64
65. 65     return 0;
66. 66 }

复制代码

1 #pragma once  
2     #include <cstdio>  
3     #include <iostream>  
4     #include <stdlib.h>  
5     #include <cstring>  
6     #define N 1024  
7      
8     class RSA {  
9         int p, q, len;  
10         long n, r, e, d;  
11         long long* pText, * cText, * dText;  
12     public:  
13         void init();  
14         RSA();  
15         bool isPrime(long);  
16         long gcd(long, long);  
17         void inputPQ();  
18         void genKeyPair();  
19             long quickPower(long long, long, long);  
20         char* encrypt(char*);  
21         char* decrypt();  
22     };

1. 1 #pragma once  
2. 2     #include <cstdio>  
3. 3     #include <iostream>  
4. 4     #include <stdlib.h>  
5. 5     #include <cstring>  
6. 6     #define N 1024  
7. 7      
8. 8     class RSA {  
9. 9         int p, q, len;  
10. 10         long n, r, e, d;  
11. 11         long long* pText, * cText, * dText;  
12. 12     public:  
13. 13         void init();  
14. 14         RSA();  
15. 15         bool isPrime(long);  
16. 16         long gcd(long, long);  
17. 17         void inputPQ();  
18. 18         void genKeyPair();  
19. 19             long quickPower(long long, long, long);  
20. 20         char* encrypt(char*);  
21. 21         char* decrypt();  
22. 22     };

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！