C语言实现数据加密算法
加密算法 c语言
加密算法 c语言C语言是一种广泛应用于计算机科学领域的编程语言，它具有高效、灵活、可靠的特点。
在密码学中，加密算法是一种用于保护信息安全的重要工具。
本文将介绍一些常见的加密算法和在C语言中的实现。
一、对称加密算法对称加密算法是一种使用相同的密钥进行加密和解密的算法。
其中，最常见的对称加密算法是DES（Data Encryption Standard）和AES（Advanced Encryption Standard）。
1. DES算法DES算法是一种将64位明文加密为64位密文的块加密算法。
它使用56位的密钥和一系列的置换、替换和移位操作来进行加密。
C语言中可以使用openssl库中的函数来实现DES算法的加密和解密。
2. AES算法AES算法是一种使用128位、192位或256位密钥进行加密和解密的块加密算法。
它使用一系列的置换、替换和线性变换操作来进行加密。
C语言中可以使用openssl库中的函数来实现AES算法的加密和解密。
二、非对称加密算法非对称加密算法是一种使用不同的密钥进行加密和解密的算法。
其中，最常见的非对称加密算法是RSA（Rivest-Shamir-Adleman）算法。
1. RSA算法RSA算法是一种基于数论的非对称加密算法。
它使用一对公钥和私钥来进行加密和解密。
C语言中可以使用openssl库中的函数来实现RSA算法的加密和解密。
三、散列函数散列函数是一种将任意长度的输入映射为固定长度输出的算法。
其中，最常见的散列函数是MD5（Message Digest Algorithm 5）和SHA（Secure Hash Algorithm）系列算法。
1. MD5算法MD5算法是一种广泛使用的散列函数，它将任意长度的输入映射为128位的输出。
C语言中可以使用openssl库中的函数来实现MD5算法。
2. SHA算法SHA算法是一系列散列函数，其中最常见的是SHA-1、SHA-256和SHA-512。
RSA加密算法(C语言实现)
RSA加密算法（C语言实现）RSA（Rivest-Shamir-Adleman）算法是一种非对称加密算法，它是目前应用最广泛的加密算法之一、RSA算法基于两个大素数之间的乘积很难分解的特性，并使用公钥和私钥进行加密和解密。
在C语言中实现RSA算法需要进行以下步骤：1.生成大素数p和q：选择两个大素数p和q，它们需要满足p≠q。
这样选取p和q是为了使得计算n=p*q变得困难，保护私钥。
2.计算n：计算n=p*q，n即为公钥和私钥的参数之一3.计算欧拉函数φ(n)：计算欧拉函数φ(n)=(p-1)*(q-1)。
4.选择e：选择一个与φ(n)互质且小于φ(n)的整数e作为加密指数，e即为公钥的参数。
5. 计算d：计算d = e^(-1) mod φ(n)，d即为私钥的参数。
可以使用扩展欧几里得算法来计算d。
6. 加密：将明文M转换为整数m，加密后的密文C = m^e mod n。
7. 解密：解密密文C得到明文M = C^d mod n。
以下是C语言实现RSA加密算法的代码示例：```c#include <stdio.h>int gcd(int a, int b)if(b == 0)}return gcd(b, a % b);int extendedGcd(int a, int b, int *x, int *y) if(a == 0)*x=0;*y=1;return b;}int x1, y1;int gcd = extendedGcd(b % a, a, &x1, &y1);*x=y1-(b/a)*x1;*y=x1;return gcd;int modInverse(int a, int m)int x, y;int gcd = extendedGcd(a, m, &x, &y);if(gcd != 1)printf("Inverse doesn't exist\n");}return (x % m + m) % m;int powerMod(int x, unsigned int y, int m) if (y == 0)return 1;}int p = powerMod(x, y/2, m) % m;p=(p*p)%m;return (y%2 == 0) ? p : (x*p) % m;int maiint p, q, n, phiN, e, d;//选择两个大素数p和qp=31;q=17;//计算n和φ(n)n=p*q;phiN = (p - 1) * (q - 1);//选择加密指数ee=7;//计算解密指数dd = modInverse(e, phiN);int plaintext = 88;int ciphertext = powerMod(plaintext, e, n);int decryptedtext = powerMod(ciphertext, d, n);printf("Plaintext: %d\n", plaintext);printf("Ciphertext: %d\n", ciphertext);printf("Decryptedtext: %d\n", decryptedtext);return 0;```在上面的代码中，我们使用了几个辅助函数来实现扩展欧几里得算法、计算模反元素和快速幂算法。
C语言实现RSA算法
C语言实现RSA算法RSA算法是一种非对称加密算法，用于在网络通信中进行数据加密和解密。
下面我将给出C语言中RSA算法的实现。
首先，我们需要生成RSA密钥对，包括公钥和私钥。
以下是生成RSA 密钥对的C代码实现：```c#include <stdio.h>#include <stdlib.h>#include <math.h>//定义最大素数范围//定义RSA密钥结构体typedef structunsigned long long e; // 公钥指数unsigned long long d; // 私钥指数unsigned long long n; // 模数} RSAKey;//判断一个数是否为素数int isPrime(unsigned long long num)//小于等于1的数不是素数if (num <= 1) return 0;//判断是否存在因子for (unsigned long long i = 2; i <= sqrt(num); i++)if (num % i == 0)return 0;}}return 1;//生成一个指定范围内的随机素数unsigned long long generateRandomPrime(unsigned long long min, unsigned long long max)unsigned long long num;donum = rand( % (max - min + 1) + min;} while (!isPrime(num));return num;//求最大公约数unsigned long long gcd(unsigned long long a, unsigned long long b)unsigned long long temp;while (b != 0)temp = a % b;a=b;b = temp;}return a;//求模反元素unsigned long long modReverse(unsigned long long a, unsigned long long b)unsigned long long m0 = b, t, q;unsigned long long x0 = 0, x1 = 1;if (b == 1) return 0;while (a > 1)q=a/b;t=b;b=a%b;a=t;t=x0;x0=x1-q*x0;x1=t;}if (x1 < 0) x1 += m0;return x1;//生成RSA密钥对RSAKey generateRSAKeys(unsigned long long p, unsigned long long q)RSAKey keys;//计算模数keys.n = p * q;//计算欧拉函数值unsigned long long phi = (p - 1) * (q - 1);//选择公钥指数ekeys.e = generateRandomPrime(2, phi - 1);//计算私钥指数dkeys.d = modReverse(keys.e, phi);return keys;int mai//设置随机种子//生成两个不同的随机素数unsigned long long p = generateRandomPrime(2,MAX_PRIME_NUMBER);unsigned long long q = generateRandomPrime(2,MAX_PRIME_NUMBER);RSAKey keys = generateRSAKeys(p, q);printf("公钥指数e: %llu\n", keys.e);printf("私钥指数d: %llu\n", keys.d);printf("模数n: %llu\n", keys.n);return 0;```运行上述代码，即可生成RSA密钥对。
AESECB加密算法C语言代码实现
AESECB加密算法C语言代码实现要实现AESECB加密算法的C语言代码，需要先了解AES算法的基本原理和步骤。
以下是一个使用C语言实现AESECB加密算法的示例代码：```c#include <stdio.h>#include <stdlib.h>#include <string.h>#include <openssl/aes.h>//定义密钥长度#define KEY_LENGTH 16//ECBAES加密函数void AESEncrypt_ECB(const unsigned char* plainText, int plainTextLength, unsigned char* cipherText,const unsigned char* key)//创建AES密钥结构体AES_KEY aesKey;//设置加密密码AES_set_encrypt_key(key, KEY_LENGTH * 8, &aesKey);//加密数据AES_ecb_encrypt(plainText, cipherText, &aesKey, AES_ENCRYPT);//ECBAES解密函数void AESDecrypt_ECB(const unsigned char* cipherText, int cipherTextLength, unsigned char* plainText,const unsigned char* key)//创建AES密钥结构体AES_KEY aesKey;//设置解密密码AES_set_decrypt_key(key, KEY_LENGTH * 8, &aesKey);//解密数据AES_ecb_encrypt(cipherText, plainText, &aesKey, AES_DECRYPT);int mai//指定原始明文和密钥unsigned char plainText[] = "Hello, World!";unsigned char key[] = "secretkey";//计算明文长度int plainTextLength = strlen(plainText);//计算加密后的数据长度int cipherTextLength = ((plainTextLength / KEY_LENGTH) + 1) * KEY_LENGTH;//分配加密后数据的内存unsigned char* cipherText = (unsignedchar*)malloc(cipherTextLength);//加密数据AESEncrypt_ECB(plainText, plainTextLength, cipherText, key);//打印加密后的结果printf("Cipher text: ");for (int i = 0; i < cipherTextLength; i++)printf("%02x ", cipherText[i]);}printf("\n");//分配解密后数据的内存unsigned char* decryptedText = (unsignedchar*)malloc(cipherTextLength);//解密数据AESDecrypt_ECB(cipherText, cipherTextLength, decryptedText, key);//打印解密后的结果printf("Decrypted text: %s\n", decryptedText);//释放已分配的内存free(cipherText);free(decryptedText);return 0;```上述代码使用了OpenSSL库提供的AES函数来实现ECB模式的AES加密和解密操作。
C语言加密与解密算法
C语言加密与解密算法在计算机科学与信息安全领域，加密与解密算法起着至关重要的作用。
加密算法用于将原始数据转换为不可读的密文，而解密算法则用于将密文还原为可读的原始数据。
C语言是一种常用的编程语言，具备高效性和灵活性，适用于加密与解密算法的开发。
本文将介绍几种常用的C语言加密与解密算法。
一、凯撒密码算法凯撒密码算法是一种最简单的替换加密算法，通过将字母按照固定的偏移量进行替换来实现加密与解密。
以下是一个简单的C语言凯撒密码实现例子：```c#include <stdio.h>void caesarEncrypt(char* message, int key) {int i = 0;while (message[i] != '\0') {if (message[i] >= 'a' && message[i] <= 'z') {message[i] = (message[i] - 'a' + key) % 26 + 'a';} else if (message[i] >= 'A' && message[i] <= 'Z') {message[i] = (message[i] - 'A' + key) % 26 + 'A';}i++;}}void caesarDecrypt(char* message, int key) {int i = 0;while (message[i] != '\0') {if (message[i] >= 'a' && message[i] <= 'z') {message[i] = (message[i] - 'a' - key + 26) % 26 + 'a'; } else if (message[i] >= 'A' && message[i] <= 'Z') {message[i] = (message[i] - 'A' - key + 26) % 26 + 'A'; }i++;}}int main() {char message[] = "Hello, World!";int key = 3;printf("Original message: %s\n", message);caesarEncrypt(message, key);printf("Encrypted message: %s\n", message);caesarDecrypt(message, key);printf("Decrypted message: %s\n", message);return 0;}```以上程序演示了凯撒密码的加密与解密过程，通过指定偏移量实现对消息的加密与解密。
c语言简单的加密算法
c语言简单的加密算法C语言中有很多加密算法，但是大多数都比较复杂，对于初学者来说难度比较大。
本文将介绍一种简单的加密算法，以便初学者可以更容易地理解和实现。
该加密算法的基本原理是将明文中的每个字符按照一定规则进行加密，然后输出密文。
在解密时，只需将密文中的每个字符按照相同的规则进行解密即可还原为明文。
具体来说，加密的规则如下：1. 将明文中的每个字符按照ASCII码值加上一个固定的密钥，得到相应的密文字符。
2. 密钥可以是任意整数，但为了保证解密时能正确还原，需要将密钥存储在程序中，以便在解密时使用。
3. 加密和解密时使用的密钥需要相同，否则无法正确解密。
下面是一段使用该加密算法进行加密和解密的C代码：```#include<stdio.h>#include<string.h>int main(){char input[100], output[100], temp;int key = 3, i;printf('请输入要加密的明文：');gets(input);// 加密for(i = 0; i < strlen(input); i++) {temp = input[i] + key; // 加密规则 output[i] = temp;}output[i] = '0';printf('加密后的密文为：%s', output);// 解密for(i = 0; i < strlen(output); i++) {temp = output[i] - key; // 解密规则 input[i] = temp;}input[i] = '0';printf('解密后的明文为：%s', input);return 0;}```在上面的代码中，我们首先定义了一个名为input的字符数组，用于存储输入的明文。
MD5加密C语言实现
MD5加密C语言实现MD5 （Message Digest Algorithm 5) 是一种常用的密码散列函数，用于将数据加密为128位长度的摘要。
在C语言中，可以通过一系列步骤来实现MD5加密算法。
1.准备工作：首先需要包含一些C标准头文件和预定义常量。
在C语言中，可以使用以下代码来实现：```c#include <stdio.h>#include <stdlib.h>#include <string.h>#include <stdint.h>#define HASH_LENGTH 16```2.定义数据结构：MD5算法涉及到一个64字节的消息块和一个4字节的消息摘要块。
在C语言中，可以使用以下代码来定义这些结构：```ctypedef structuint8_t data[64];uint32_t datalen;uint32_t bitlen[2];uint32_t state[4];}MD5_CTX;typedef uint8_t (*hash_function)(uint8_t *);```3.定义常量和函数：MD5算法使用到一些常量和函数。
在C语言中，可以使用以下代码来定义这些常量和函数：```cconst uint32_t k[64] =// more constants ...};const uint32_t r[64] =7,12,17,22,7,12,17,22,// more constants ...};void md5_transform(MD5_CTX *ctx, uint8_t data[]);void md5_init(MD5_CTX *ctx)ctx->datalen = 0;ctx->bitlen[0] = 0;ctx->bitlen[1] = 0;ctx->state[1] = 0xEFCDAB89;ctx->state[2] = 0x98BADCFE;void md5_update(MD5_CTX *ctx, uint8_t data[], uint32_t len) for (uint32_t i = 0; i < len; i++)ctx->data[ctx->datalen] = data[i];ctx->datalen++;if (ctx->datalen == 64)md5_transform(ctx, ctx->data);ctx->bitlen[0] += 512;ctx->bitlen[1] += (ctx->bitlen[0] < 512);ctx->datalen = 0;}}void md5_final(MD5_CTX *ctx, uint8_t hash[])uint32_t i = ctx->datalen;if (ctx->datalen < 56)ctx->data[i++] = 0x80;while (i < 56)ctx->data[i++] = 0x00;}} elsectx->data[i++] = 0x80;while (i < 64)ctx->data[i++] = 0x00;}md5_transform(ctx, ctx->data);memset(ctx->data, 0, 56);}ctx->bitlen[0] += ctx->datalen * 8;ctx->bitlen[1] += (ctx->bitlen[0] < ctx->datalen * 8); ctx->data[63] = ctx->bitlen[0] & 0xff;ctx->data[62] = (ctx->bitlen[0] >> 8) & 0xff;ctx->data[61] = (ctx->bitlen[0] >> 16) & 0xff;ctx->data[60] = (ctx->bitlen[0] >> 24) & 0xff;ctx->data[59] = ctx->bitlen[1] & 0xff;ctx->data[58] = (ctx->bitlen[1] >> 8) & 0xff;ctx->data[57] = (ctx->bitlen[1] >> 16) & 0xff;ctx->data[56] = (ctx->bitlen[1] >> 24) & 0xff;md5_transform(ctx, ctx->data);for (i = 0; i < 4; i++)hash[i] = (ctx->state[0] >> (i * 8)) & 0xff;hash[i + 4] = (ctx->state[1] >> (i * 8)) & 0xff;hash[i + 8] = (ctx->state[2] >> (i * 8)) & 0xff;hash[i + 12] = (ctx->state[3] >> (i * 8)) & 0xff;}void md5_transform(MD5_CTX *ctx, uint8_t data[])uint32_t a, b, c, d, f, g, temp;uint32_t m[16], i, j;for (i = 0, j = 0; i < 16; i++, j += 4)m[i] = (data[j]) + (data[j + 1] << 8) + (data[j + 2] << 16) + (data[j + 3] << 24);}a = ctx->state[0];b = ctx->state[1];c = ctx->state[2];d = ctx->state[3];for (i = 0; i < 64; i++)if (i < 16)f=(b&c)，((~b)&d);g=i;} else if (i < 32)f=(d&b)，((~d)&c);g=(5*i+1)%16;} else if (i < 48)f=b^c^d;g=(3*i+5)%16;} elsef=c^(b，(~d));g=(7*i)%16;}temp = d;d=c;c=b;b = b + leftrotate((a + f + k[i] + m[g]), r[i]);a = temp;}ctx->state[0] += a;ctx->state[1] += b;ctx->state[2] += c;ctx->state[3] += d;```4.实现加密函数：最后，可以编写一个简单的调用MD5算法的加密函数。
fpe 算法 c语言
fpe 算法 c语言FPE算法（Format-Preserving Encryption）是一种在密码学中常用的算法，它能够将加密后的数据保持原有的格式不变。
本文将介绍FPE算法的原理和在C语言中的实现。
一、FPE算法的原理FPE算法是一种可逆的加密算法，它可以将一个输入的明文数据加密成相同格式的密文数据，并且可以将密文数据解密回原始的明文数据。
FPE算法的核心思想是将明文数据按照一定的规则进行重排，然后再进行加密处理。
FPE算法的具体实现步骤如下：1. 明文数据的长度和格式确定后，将明文数据进行切分，得到不同的数据块。
2. 对每个数据块进行加密处理，得到对应的密文数据块。
3. 将所有的密文数据块按照一定的规则进行重排，得到最终的密文数据。
FPE算法的关键在于如何确定数据块的加密方式和重排规则。
常用的方法是使用Feistel网络结构，该结构由多个轮次组成，每个轮次都包括一个加密函数和一个解密函数。
二、在C语言中实现FPE算法在C语言中实现FPE算法需要进行以下步骤：1. 定义明文数据和密文数据的数据类型，并确定数据的长度和格式。
2. 实现加密函数和解密函数。
加密函数将明文数据块作为输入，经过一系列的操作得到密文数据块；解密函数将密文数据块作为输入，经过相反的操作得到原始的明文数据块。
3. 实现数据重排的函数。
该函数将所有的密文数据块按照一定的规则进行重排，得到最终的密文数据。
4. 编写主函数，调用上述的函数完成整个加密和解密的过程。
下面是一个简单的示例代码：```c#include <stdio.h>// 定义明文数据和密文数据的数据类型typedef unsigned int data_t;// 加密函数data_t encrypt(data_t plaintext) {// TODO: 实现加密函数的具体操作return plaintext;}// 解密函数data_t decrypt(data_t ciphertext) {// TODO: 实现解密函数的具体操作return ciphertext;}// 数据重排函数data_t permute(data_t ciphertext) {// TODO: 实现数据重排的具体操作return ciphertext;}int main() {// 输入明文数据data_t plaintext = 1234;// 加密过程data_t ciphertext = encrypt(plaintext); printf("密文数据：%u\n", ciphertext);// 解密过程data_t decrypted = decrypt(ciphertext); printf("解密后的数据：%u\n", decrypted);// 数据重排data_t permuted = permute(ciphertext);printf("重排后的密文数据：%u\n", permuted);return 0;}```以上代码只是一个简单的示例，实际上FPE算法的实现需要考虑更多的细节和安全性问题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
// 请输入密钥以解密 // 得到密钥 // 设置密钥 // 解密输出到 MyMessage // 解密结束
} /*------------------------------把 DatIn 开始的长度位 Len 位的二进制 复制到 DatOut 后 --------------------------------*/ void BitsCopy(bool *DatOut,bool *DatIn,int Len) { int i=0; for(i=0;i<Len;i++) { DatOut[i]=DatIn[i]; } } /*------------------------------字节转换成位函数 每 8 次换一个字节 每次向右移一位 和 1 与取最后一位 共 64 位 --------------------------------*/ void ByteToBit(bool *DatOut,char *DatIn,int Num) { int i=0; for(i=0;i<Num;i++) { DatOut[i]=(DatIn[i/8]>>(i%8))&0x01; } } /*------------------------------位转换成字节函数 字节数组每 8 次移一位 位每次向左移 与上一次或 ---------------------------------*/ void BitToByte(char *DatOut,bool *DatIn,int Num) { int i=0; for(i=0;i<(Num/8);i++) { DatOut[i]=0; } for(i=0;i<Num;i++) { DatOut[i/8]|=DatIn[i]<<(i%8);
// 数组复制 OK
// OK
// OK
} }
/*---------------------------------二进制密文转换为十六进制 需要 16 个字符表示 -----------------------------------*/ void BitToHex(char *DatOut,bool *DatIn,int Num) { int i=0; for(i=0;i<Num/4;i++) { DatOut[i]=0; } for(i=0;i<Num/4;i++) { DatOut[i] = DatIn[i*4]+(DatIn[i*4+1]<<1) +(DatIn[i*4+2]<<2)+(DatIn[i*4+3]<<3); if((DatOut[i]%16)>9) { DatOut[i]=DatOut[i]%16+'7'; // 余数大于 9 时处理 10-15 to A-F } // 输出字符 else { DatOut[i]=DatOut[i]%16+'0'; // 输出字符 } } } /*--------------------------------------------十六进制字符转二进制 ----------------------------------------------*/ void HexToBit(bool *DatOut,char *DatIn,int Num) { int i=0; // 字符型输入 for(i=0;i<Num;i++) { if((DatIn[i/4])>'9') // 大于 9 { DatOut[i]=((DatIn[i/4]-'7')>>(i%4))&0x01; } else
X=(DatIn[1]<<3)+(DatIn[2]<<2)+(DatIn[3]<<1)+DatIn[4]; // bcde 代表第几列 ByteToBit(DatOut,&S_Box[i][Y][X],4); // 把找到的点数据换为二进制 } } // F 函数 void F_Change(bool DatIn[32],bool DatKi[48]) // F 函数 { static bool MiR[48]={0}; // 输入 32 位通过 E 选位变为 48 位 TablePermute(MiR,DatIn,E_Table,48); Xor(MiR,DatKi,48); // 和子密钥异或 S_Change(DatIn,MiR); // S 盒变换 TablePermute(DatIn,DatIn,P_Table,32); // P 置换 Message is Encrypted!:\n"); for(i=0;i<16;i++) { printf("%c ",MesHex[i]); } printf("\n"); printf("\n");
printf("Please input your Secret Key to Deciphering:\n"); gets(YourKey); SetKey(YourKey); KickDes(MyMessage,MesHex); printf("Deciphering Over !!:\n"); for(i=0;i<8;i++) { printf("%c ",MyMessage[i]); } printf("\n"); system("pause"); /*------------------------------------------------*/
// 异或函数
// 异或
// 输入 48 位 输出 32 位 与 Ri 异或 void S_Change(bool DatOut[32],bool DatIn[48]) // S 盒变换 { int i,X,Y; // i 为 8 个 S 盒 for(i=0,Y=0,X=0;i<8;i++,DatIn+=6,DatOut+=4) // 每执行一次,输入数据偏移 6 位 { // 每执行一次,输出数据偏移 4 位 Y=(DatIn[0]<<1)+DatIn[5]; // af 代表第几行
void ByteToBit(bool *DatOut,char *DatIn,int Num); // 字节到位 void BitToByte(char *DatOut,bool *DatIn,int Num); // 位到字节 void BitToHex(char *DatOut,bool *DatIn,int Num); void HexToBit(bool *DatOut,char *DatIn,int Num); // 二进制到十六进制 64 位 to 4*16 字符 // 十六进制到二进制
/*-----------------------------------------------*/ printf("Welcome! Please input your Message(64 bit):\n"); gets(MyMessage); // 明文 printf("Please input your Secret Key:\n"); gets(MyKey); // 密钥
void TablePermute(bool *DatOut,bool *DatIn,const char *Table,int Num); // 位表置换函数 void LoopMove(bool *DatIn,int Len,int Num); // 循环左移 Len 长度 Num 移动位数 void Xor(bool *DatA,bool *DatB,int Num); // 异或函数 void S_Change(bool DatOut[32],bool DatIn[48]); void F_Change(bool DatIn[32],bool DatKi[48]); void SetKey(char KeyIn[8]); void PlayDes(char MesOut[8],char MesIn[8]); void KickDes(char MesOut[8],char MesIn[8]); // S 盒变换 // F 函数 // 设置密钥 // 执行 DES 加密 // 执行 DES 解密
while(MyKey[i]!='\0') { i++; }
// 计算密钥长度
while(i!=8) // 不是 8 提示错误 { printf("Please input a correct Secret Key!\n"); gets(MyKey); i=0; while(MyKey[i]!='\0') // 再次检测 { i++; } } SetKey(MyKey); PlayDes(MesHex,MyMessage); // 设置密钥 得到子密钥 Ki // 执行 DES 加密 // 信息已加密