2017-2018-1 20155312 实验五通讯协议设计

时间：2017-12-13 02:19:27 阅读：227 评论：0 收藏：0 [点我收藏+]

标签：cpe 密钥 publickey 简单应用缓冲区 local create 处理 turn

2017-2018-1 20155312 实验四外设驱动程序设计

实验内容

任务一

两人一组
基于Socket实现TCP通信，一人实现服务器，一人实现客户端
研究OpenSSL算法，测试对称算法中的AES，非对称算法中的RSA，Hash算法中的MD5
选用合适的算法，基于混合密码系统实现对TCP通信进行机密性、完整性保护。
学有余力者，对系统进行安全性分析和改进。

任务二

在Ubuntu中实现对实验二中的“wc服务器”通过混合密码系统进行防护

技术分享图片

实验步骤

任务一

准备工作

下载OpenSSL 1.1.0alpha
解压OpenSSL 1.1.0alpha源代码：tar xzvf openssl-1.1.0-pre1.tar.gz
然后进入源代码目录：cd openssl-1.1.0-pre1
编译安装:

./Configure//这里注意，第一个字母“C”要大写
make
sudo make install

5.这时出现了两个错误，（见问题2），解决后用老师教程中的test_openssl.c例子进行测试：

#include <stdio.h>
#include <openssl/evp.h>

int main(){
    
    OpenSSL_add_all_algorithms();
    
    return 0;
}

6.使用命令gcc -o test_openssl test_openssl.c -L/usr/local/ssl/lib -lcrypto -ldl -lpthread编译，结果生成可执行文件test_openssl

[注]：-L选项——指定链接库的文件夹地址；-lcrypto——导入OpenSSL所需包；-ldl选项——加载动态库；-lpthread选项——链接POSIX thread库

7.执行：./test_openssl;echo $?结果出错，显示“./test_openssl: error while loading shared libraries: libcrypto.so.1.1: cannot open shared object file: No such file or directory 127”

8.在/usr/local/ssl路径下创建lib文件夹，然后把openssl_master目录下所有*.a文件复制到/usr/local/ssl/lib路径下：sudo cp /home/zjy/20155312zjy/zjy20155312/src/2017-2018_Week15/openssl-master/*.a /usr/local/ssl/lib

9.重新运行./test_openssl;echo $?结果正确显示0，如下图所示：

技术分享图片

课后作业：

学习openssl几个加密算法

1.openssl简介

OpenSSL 是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及SSL协议，并提供丰富的应用程序供测试或其它目的使用。

OpenSSL一共提供了8种对称加密算法，其中7种是分组加密算法，仅有的一种流加密算法是RC4。这7种分组加密算法分别是AES、DES、Blowfish、CAST、IDEA、RC2、RC5，都支持电子密码本模式（ECB）、加密分组链接模式（CBC）、加密反馈模式（CFB）和输出反馈模式（OFB）四种常用的分组密码加密模式。其中，AES使用的加密反馈模式（CFB）和输出反馈模式（OFB）分组长度是128位，其它算法使用的则是64位。事实上，DES算法里面不仅仅是常用的DES算法，还支持三个密钥和两个密钥3DES算法。

2.对称密码中的AES算法

①AES工作模式介绍

ECB模式简介

技术分享图片

ECB模式详细介绍

设置加密密钥：

int AES_set_encrypt_key(const unsigned char *userKey, const int bits,AES_KEY *key);

参数说明：

userKey：密钥数值；
bits：密钥长度，以bit为单位，如果密钥数字是16个字节，则此参数值应为128；
key： AES_KEY对象指针；
返回值： 0 成功， -1 userkey，key为空， -2：密钥长度不是128，192，256；

设置解密密钥：

int AES_set_decrypt_key(const unsigned char *userKey, const int bits, AES_KEY *key);

参数说明：

userKey：密钥数值；
bits：密钥长度，以bit为单位，如果密钥数字是16个字节，则此参数值应为128；
key： AES_KEY对象指针；
返回值： 0 成功， -1 userkey，key为空， -2：密钥长度不是128，192，256；

对数据进行加解密:

void AES_ecb_encrypt(const unsigned char *in, unsigned char *out, const AES_KEY *key, const int enc);

参数说明：

in：需要加密/解密的数据；
out：计算后输出的数据；
key：密钥
enc： AES_ENCRYPT 代表加密， AES_DECRYPT代表解密；

利用如下代码测试openssl中ECB模式的aes算法：

#include <memory.h>
#include <stdio.h>
#include <stdlib.h>
#include <openssl/aes.h>
#pragma comment(lib,"libeay32.lib")
int main(int argc, char **argv)
{
    unsigned char buf[512];
    unsigned char buf2[512];
    unsigned char buf3[512];
    unsigned char aes_keybuf[32];
    memset(buf,1,sizeof(buf));    
    memset(buf,0,sizeof(buf2));    
    memset(buf,0,sizeof(buf3));
    memset(aes_keybuf,0,sizeof(aes_keybuf));
    AES_KEY aeskey;
    AES_set_encrypt_key(aes_keybuf,256,&aeskey);
    for(int i=0;i<sizeof(buf);i+=16)
    AES_encrypt(buf+i,buf2+i,&aeskey);
    AES_set_decrypt_key(aes_keybuf,256,&aeskey);
    for(int i=0;i<sizeof(buf);i+=16)
    AES_decrypt(buf2+i,buf3+i,&aeskey);
    if(memcmp(buf,buf3,sizeof(buf))==0)
        printf("test success\r\n");
    else
        printf("test fail\r\n");
}

运行结果如下图所示，显示成功：

技术分享图片

CBC模式简介

技术分享图片

IV一般为16字节全0，数据块长度为16字节的整数倍，则在此数据块后附加一个8字节长的数据块，附加的数据块为：16进制的“80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00”

3.非对称密码中的RSA算法

①openssl RSA命令：

生成rsa密钥：openssl genrsa -des3 -out prikey.pem
- 这个文件包含了公钥和密钥两部分，也就是说这个文件即可用来加密也可以用来解密。后面的1024是生成密钥的长度。
去除掉密钥文件保护密码:openssl rsa -in prikey.pem -out prikey.pem
分离出公钥:openssl rsa -in prikey.pem -pubout -out pubkey.pem(获取证书中的公钥 openssl req -in myreq.pem -out -pubkey.pem)
- -in指定输入文件，-out指定提取生成公钥的文件名。
对文件进行签名:open rsautl -sign -inkey prikey.pem -in a.txt -out sig.dat
验证签名:openssl rsautl -verify -inkey prikey.pem -in sig.dat
用公钥对文件加密:openssl rsautl -encrypt -pubin -inkey pubkey.pem -in a.text -out b.text
用私钥解密:openssl rsautl -decrypt -inkey prikey.pem -in b.text
用证书中的公钥加密:opensll rsautl -encrypt -certin -inkey cert1.pem -in a.txt
生成一个没有加密的ca私钥:openssl genrsa -out ca.key.pem 1024
生成ca对应的csr文件:openssl req -new -key ca.key.pem -out ca.csr
自签名:openssl x509 -in ca.csr -out ca.cer -req -signkey ca.key.pem -days 7300 -extensions v3_ca
生成DER格式的私钥:openssl pkcs8 -topk8 -inform PEM -outform DER -in ca.key.pem -out ca.private.der -nocrypt
读取证书的内容,显示在屏幕上:openssl x509 -in server.cer -noout -subject -nameopt RFC2253
将der格式的证书转成pem格式:openssl x509 -inform PEM -outform DER -in server.der -out server.pem

命令行下对hello文件“20155312”进行加解密，成功如下图所示：

技术分享图片

②编程实现RSA

利用上面生成的密钥文件，测试加密解密的代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<openssl/rsa.h>
#include<openssl/pem.h>
#include<openssl/err.h>
#define OPENSSLKEY "test.key"
#define PUBLICKEY "test_pub.key"
#define BUFFSIZE 1024
char* my_encrypt(char *str,char *path_key);//加密
char* my_decrypt(char *str,char *path_key);//解密
int main(void){
    char *source="i am 20155312 zjy!";
    char *ptr_en,*ptr_de;
    printf("source is    :%s\n",source);
    ptr_en=my_encrypt(source,PUBLICKEY);
    printf("after encrypt:%s\n",ptr_en);
    ptr_de=my_decrypt(ptr_en,OPENSSLKEY);
    printf("after decrypt:%s\n",ptr_de);
    if(ptr_en!=NULL){
        free(ptr_en);
    }   
    if(ptr_de!=NULL){
        free(ptr_de);
    }   
    return 0;
}
char *my_encrypt(char *str,char *path_key){
    char *p_en;
    RSA *p_rsa;
    FILE *file;
    int flen,rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;    
    }   
    if((p_rsa=PEM_read_RSA_PUBKEY(file,NULL,NULL,NULL))==NULL){
    //if((p_rsa=PEM_read_RSAPublicKey(file,NULL,NULL,NULL))==NULL){   换成这句死活通不过，无论是否将公钥分离源文件
        ERR_print_errors_fp(stdout);
        return NULL;
    }   
    flen=strlen(str);
    rsa_len=RSA_size(p_rsa);
    p_en=(unsigned char *)malloc(rsa_len+1);
    memset(p_en,0,rsa_len+1);
    if(RSA_public_encrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_en,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_en;
}
char *my_decrypt(char *str,char *path_key){
    char *p_de;
    RSA *p_rsa;
    FILE *file;
    int rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;
    }
    if((p_rsa=PEM_read_RSAPrivateKey(file,NULL,NULL,NULL))==NULL){
        ERR_print_errors_fp(stdout);
        return NULL;
    }
    rsa_len=RSA_size(p_rsa);
    p_de=(unsigned char *)malloc(rsa_len+1);
    memset(p_de,0,rsa_len+1);
    if(RSA_private_decrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_de,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_de;
}

运行结果如下：

技术分享图片

4.Hash中的MD5算法

①MD5算法简介：

MD5算法是一个被广泛使用的称为信息摘要的摘要算法，其主要过程包括了对字符串的填充(Padding)、分段摘要(Digesting)和最终摘要的输出(Outputting)三个步骤。其中填充是指首先需要对信息进行填充，使其字节长度对512求余得到结果为448.填充是在信息的后面填充一个1和无数个0，直到满足上面的长度条件时停止。在填充完成后，再往后面附加一个以64位二进制表示填充前信息的长度，使现在的信息字节长度等于N512+448+64=(N+1)512，这样长度恰好可以被512整除满足后面处理中对信息长度可以划分为N+1个完整分组的要求。

——引用自《摘要算法之MD5介绍及OpenSSL中MD5常用函数使用举例》

常用函数：

MD5():计算B

unsigned char*MD5(const unsigned char *d, unsigned long n, unsigned char *md);

MD5_Init(): 初始化aB

void MD5_Init(MD5_CTX *c);

MD5_Update():可以与待求散列值的消息块（B

void MD5_Update(MD5_CTX *c, const void *data, unsigned long len);

MD5_Final():将消息摘要放入B

void MD5_Final(unsigned char *md, MD5_CTX *c);

②OpenSSL中的MD5

测试代码如下：

#define _GNU_SOURCE

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <errno.h>

#include <ctype.h>

#include "openssl/md5.h"

MD5_CTX  md5_ctx;
static int MD5mod(const char* str, int length, int mod){

    char sign[16] = {0};

    MD5_Init(&md5_ctx);

    MD5_Update(&md5_ctx, str, length);

    MD5_Final(sign, &md5_ctx);

    printf("digest:%s\n",sign);

    int sum = 0;

    for (int i=0; i < 16; i ++) {

        sum += (sign[i]&0xff);

    }

    int offset = sum % mod;

    return offset;

}

int main(int argc, char** argv)

{

    if( argc < 4){

        fprintf(stderr, "%s num infile outfile\n", argv[0]);

        exit(-1);

    }

    int num = atoi(argv[1]) ;

    if( num <= 0){

        fprintf(stderr, "ERROR: num error: %s\n", argv[1]);

        exit(-1);

    }

    FILE* in = fopen(argv[2], "r");

    if( in == NULL){

        perror("fopen");

        fprintf(stderr, "ERROR: infile error: %s\n", argv[2]);

        exit(-1);

    }
    FILE** OUT = (FILE**)malloc(sizeof(FILE*) * num);

    for(int i=0; i<num; ++i){

        char buf[256] = {0};

        sprintf(buf, "%s_%d", argv[3], i);

        OUT[i] = fopen(buf, "w");

        if( OUT[i] == NULL){

            perror("fopen");

            fprintf(stderr, "ERROR: infile error: %s\n", argv[2]);

            exit(-1);

        }

    }
    size_t len = 0;
    ssize_t read;
    char * line = NULL;

    while ((read = getline(&line, &len, in)) != -1) {

        int  klen = 0;

        while( klen < read ){

            if( isspace( *(line+klen)) ) break;

            klen++;
        }

     //   char id[256]={0};

     //   strncpy(id, line, klen);

     //   printf("id=%s\tklen=%d\tread=%ld\tline=%s", id, klen, read, line);

        fprintf(OUT[MD5mod(line, klen, num)], "%s", line);

    }

    if(line) free(line);
    return 0;
}

运行结果如下：

技术分享图片

在socket编程中的简单应用

在客户端服务器通信的基础上，客户端利用rsa算法对文件加密传输给服务器
服务器利用公钥对密文解密得到明文

客户端代码如下：

#include<netinet/in.h>                         // for sockaddr_in  
#include<sys/types.h>                          // for socket  
#include<sys/socket.h>                         // for socket  
#include<stdio.h>                              // for printf  
#include<stdlib.h>                             // for exit  
#include<string.h>                             // for bzero  
#include<openssl/rsa.h>
#include<openssl/pem.h>
#include<openssl/err.h>
#define OPENSSLKEY "test.key"
#define PUBLICKEY "test_pub.key"
#define BUFFSIZE 1024  
#define HELLO_WORLD_SERVER_PORT       6000 
#define BUFFER_SIZE                   1024  
#define FILE_NAME_MAX_SIZE            512  
int mywc(char file_name[],int choose);
char* my_encrypt(char *str,char *path_key);//加密
char* my_decrypt(char *str,char *path_key);//解密
int main(int argc, char **argv)  
{  
    
    FILE *fp;
    if (argc != 2)  
    {  
        printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
        exit(1);  
    }  

// 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    struct sockaddr_in client_addr;  
    bzero(&client_addr, sizeof(client_addr));  
    client_addr.sin_family = AF_INET;   
    client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    client_addr.sin_port = htons(0); 

// 创建字节流socket，用client_socket代表客户端socket  
    int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    if (client_socket < 0)  
    {  
        printf("Create Socket Failed!\n");  
        exit(1);  
    }  

// 把客户端的socket和客户端的socket地址结构绑定   
    if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    {  
        printf("Client Bind Port Failed!\n");  
        exit(1);  
    }  

// 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    struct sockaddr_in  server_addr;  
    bzero(&server_addr, sizeof(server_addr));  
    server_addr.sin_family = AF_INET;  

// 服务器的IP地址来自程序的参数   
    if (inet_aton(argv[1], &server_addr.sin_addr) == 0) //一个字符串IP地址转换为一个32位的网络序列IP地址，也可以用inet_addr
    {  
        printf("Server IP Address Error!\n");  
        exit(1);  
    }                                                                                                               
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    int server_addr_length = sizeof(server_addr);   

        // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
        if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length)==-1)  
        {  
            printf("Can Not Connect To %s!\n", argv[1]);  
            exit(1);  
        }  

        char file_name[FILE_NAME_MAX_SIZE];  
        bzero(file_name, sizeof(file_name));  
        printf("Please Input File Name.\t");  
        scanf("%s", file_name);  
        if((fp = fopen(file_name,"r"))==NULL)
            {
                printf("Failure to open %s\n",file_name);
                exit(0);
        }
    
        char buffer[BUFFER_SIZE];  
        bzero(buffer, sizeof(buffer));  
        strcpy(buffer,file_name);
        if(send(client_socket,buffer,BUFFER_SIZE,0)==-1)
        {
            printf("发送文件名失败\n");
        }
        
        char *ptr_en,*ptr_de;       
        char ch;
        int i=0;

        while((ch=fgetc(fp))!=EOF)
        {
            buffer[i++]=ch;
            if(i>=BUFFER_SIZE)
            {
                printf("加密前 %s\n",buffer);              
                ptr_en=my_encrypt(buffer,PUBLICKEY);//加密buffer
                printf("加密后发送密文 %s\n",ptr_en);
                ptr_de=my_decrypt(buffer,OPENSSLKEY);//解密buffer
                printf("解密密文  %s\n",ptr_de);
                if((send(client_socket, ptr_en, strlen(ptr_en), 0))==-1)
                {
                    printf("发送文件失败\n");
                }
                bzero(ptr_en, sizeof(ptr_en));
                bzero(buffer, sizeof(buffer));
                i=0;
            }
        }
        if(i<BUFFER_SIZE)
        {
            printf("加密前 %s\n",buffer);              
            ptr_en=my_encrypt(buffer,PUBLICKEY);//加密buffer
            printf("加密后发送密文 %s\n",ptr_en);
printf("%d\n",strlen(ptr_en));
            if((send(client_socket, ptr_en, strlen(ptr_en), 0))==-1)
            {
                printf("发送文件失败\n");
            }
        }
        bzero(buffer, sizeof(buffer));
        printf("发送完毕\n");
        if(ptr_en!=NULL){
                free(ptr_en);
            }  
        mywc(file_name,1);
        mywc(file_name,2);

        bzero(buffer, sizeof(buffer));

        fclose(fp);
     
        close(client_socket); // 传输完毕，关闭socket  
        return 0;  

}  
int mywc(char file_name[],int choose)
{
    FILE *fp;
        char ch;
        int flag=0,num=0;
       // int choose;
       //  printf("统计单词个数还是实现“wc -w”?(1or2)\n");
       // scanf("%d",&choose);
    if((fp = fopen(file_name,"r"))==NULL)
    {
         printf("Failure to open %s\n",file_name);
             exit(0);
        }
             
    if(choose==1)
    {
        while((ch=fgetc(fp))!=EOF)
        {
            if(ch==‘ ‘ || ch==‘\n‘ || ch==‘\t‘ ||  ch==‘\!‘ || ch==‘\?‘ || ch==‘\"‘ || ch==‘\.‘ || ch== ‘\,‘ || ch==‘\:‘ || ch==‘\(‘ || ch==‘\)‘ || ch==‘\;‘     || ch==‘\-‘)
            {
                flag=0;
            }
            else
            {
                if(flag==0)
                {
                    flag=1;
                    num++;
                }
                          
            }

        }

    }
    else if(choose==2)
    {
        while((ch=fgetc(fp))!=EOF)
        {
            if(ch==‘ ‘ || ch==‘\n‘ || ch==‘\t‘ || ch==‘\r‘)
                flag=0;
            else
            {
                if(flag==0)
                {
                    flag=1;
                    num++;
                }
            }
        }
    }
    printf("单词个数为：%d_用方式%d计算\n",num,choose);
    fclose(fp);
    return num;
}
char *my_encrypt(char *str,char *path_key){
    char *p_en;
    RSA *p_rsa;
    FILE *file;
    int flen,rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;    
    }   
    if((p_rsa=PEM_read_RSA_PUBKEY(file,NULL,NULL,NULL))==NULL){
    //if((p_rsa=PEM_read_RSAPublicKey(file,NULL,NULL,NULL))==NULL){   换成这句死活通不过，无论是否将公钥分离源文件
        ERR_print_errors_fp(stdout);
        return NULL;
    }   
    flen=strlen(str);
    rsa_len=RSA_size(p_rsa);
    p_en=(unsigned char *)malloc(rsa_len+1);
    memset(p_en,0,rsa_len+1);
    if(RSA_public_encrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_en,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_en;
}
char *my_decrypt(char *str,char *path_key){
    char *p_de;
    RSA *p_rsa;
    FILE *file;
    int rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;
    }
    if((p_rsa=PEM_read_RSAPrivateKey(file,NULL,NULL,NULL))==NULL){
        ERR_print_errors_fp(stdout);
        return NULL;
    }
    rsa_len=RSA_size(p_rsa);
    p_de=(unsigned char *)malloc(rsa_len+1);
    memset(p_de,0,rsa_len+1);
    if(RSA_private_decrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_de,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_de;
}

服务器代码如下：

#include<netinet/in.h>   
#include<sys/types.h>   
#include<sys/socket.h>   
#include<stdio.h>   
#include<stdlib.h>   
#include<string.h>   
#include<pthread.h>  
#include<openssl/rsa.h>
#include<openssl/pem.h>
#include<openssl/err.h>
#define OPENSSLKEY "test.key"
#define PUBLICKEY "test_pub.key"
#define BUFFSIZE 1024
#define HELLO_WORLD_SERVER_PORT    6000 
#define LENGTH_OF_LISTEN_QUEUE     20  
#define BUFFER_SIZE                1024  
#define FILE_NAME_MAX_SIZE         512  
char* my_encrypt(char *str,char *path_key);//加密
char* my_decrypt(char *str,char *path_key);//解密
void *process_client(void *new_server_socket);
int mywc(char file_name[])
{
    char ch;
    int flag=0,num=0;
    int choose;
    FILE *fp;
    printf("统计单词个数还是实现“wc -w”?(1or2)\n");
    scanf("%d",&choose);
    if((fp = fopen(file_name,"r"))==NULL)
    {
        printf("Failure to open %s\n",file_name);
        exit(0);
    }

    if(choose==1)
    {
    while((ch=fgetc(fp))!=EOF)
    {
        if(ch==‘ ‘ || ch==‘\n‘ || ch==‘\t‘ ||  ch==‘\!‘ || ch==‘\?‘ || ch==‘\"‘ || ch==‘\.‘ || ch== ‘\,‘ || ch==‘\:‘ || ch==‘\(‘ || ch==‘\)‘ || ch==‘\;‘ || ch==‘\-‘)
        {
            flag=0;
        }
        else
        {
            if(flag==0)
            {
                flag=1;
                num++;
            }

        }          
    }
    }
    else if(choose==2)
    {
        while((ch=fgetc(fp))!=EOF)
        {
            if(ch==‘ ‘ || ch==‘\n‘ || ch==‘\t‘ || ch==‘\r‘)
                flag=0;
            else
            {
                if(flag==0)
                {
                    flag=1;
                    num++;
                }
            }
        }
    }
    printf("单词个数为：%d\n",num);
    fclose(fp);
    return num;
}
int main(int argc, char **argv)  
{  
 
// 设置一个socket地址结构server_addr,代表服务器的IP地址和端口  
    struct sockaddr_in   server_addr;  
    bzero(&server_addr, sizeof(server_addr));  
    server_addr.sin_family = AF_INET;  
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);  
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  

// 创建字节流socket:server_socket 
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);  
    if (server_socket ==-1)  
    {  
        printf("Create Socket Failed!\n");  
        exit(1);  
    }  

// 把socket和socket地址结构绑定   
    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr))==-1)  
    {  
        printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);  
        exit(1);  
    }  

// server_socket用于监听   
    if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE)==-1)  
    {  
        printf("Server Listen Failed!\n");  
        exit(1);  
    }  
// 服务器端一直运行用以持续为客户端提供服务   
      
    while(1)
    {
// 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept  
 
        struct sockaddr_in client_addr;  
        int length = sizeof(client_addr);    
// accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信  
        int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);         
        if (new_server_socket ==-1)  
        {  
            printf("Server Accept Failed!\n"); 
            exit(0); 
        }
        printf("连接到客户端\n");
        pthread_t pid;
        if(pthread_create(&pid, NULL, process_client,(void *) &new_server_socket) < 0){
              printf("pthread_create error\n");
        }
        
    }
//  close(server_socket);
}
void *process_client(void *new_server_socket)
{
        int sockid=*(int *)new_server_socket;
        FILE *fp;
        //接受来自客户端的文件
        char buffer[BUFFER_SIZE]; 
        char file_name[FILE_NAME_MAX_SIZE];
        bzero(buffer, sizeof(buffer));  
        int length=0;
        if(recv(sockid,buffer,BUFFER_SIZE, 0)==-1)
        {
            printf("接受文件名%s失败\n",buffer);
        }
        strcpy(file_name,buffer);
        strcat(file_name,"_server");
        printf("创建文件夹%s\n",file_name);
        if((fp = fopen(file_name,"w"))==NULL)
        {
            printf("Failure to open %s\n",file_name);
            exit(0);
        }
        /*char *source="i am 20155312 zjy!";
    char *ptr_en,*ptr_de;
    printf("source is    :%s\n",source);
    ptr_en=my_encrypt(source,PUBLICKEY);
    printf("after encrypt:%s\n",ptr_en);
    ptr_de=my_decrypt(ptr_en,OPENSSLKEY);
    printf("after decrypt:%s\n",ptr_de);
    if(ptr_en!=NULL){
        free(ptr_en);
    }   
    if(ptr_de!=NULL){
        free(ptr_de);
    } */
        char *ptr_en,*ptr_de;
        while( length = recv(sockid, buffer,10000, 0))
        {
            if(length<0)
            {
                printf("接受文件出错\n");
                exit(0);
            }
            printf("接受密文  %s\n",buffer);
            ptr_de=my_decrypt(buffer,OPENSSLKEY);//解密buffer
                    
            printf("解密密文  %s\n",ptr_de);
            fwrite(ptr_de,sizeof(char),strlen(ptr_de),fp)<length;
            
            bzero(buffer, sizeof(buffer));
            bzero(ptr_de, sizeof(ptr_de));
        }
        fclose(fp);
        if(ptr_de!=NULL){
                free(ptr_de);
            } 
        printf("接收完毕\n");
        bzero(buffer, BUFFER_SIZE);
        int number=0;
        number=mywc(file_name);
        //bzero(buffer, BUFFER_SIZE);  
        //buffer[0]=number+48;

            bzero(buffer, sizeof(buffer));  
         
        printf("File Transfer Finished!\n");   
        close(new_server_socket);  
} 
char *my_encrypt(char *str,char *path_key){
    char *p_en;
    RSA *p_rsa;
    FILE *file;
    int flen,rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;    
    }   
    if((p_rsa=PEM_read_RSA_PUBKEY(file,NULL,NULL,NULL))==NULL){
    //if((p_rsa=PEM_read_RSAPublicKey(file,NULL,NULL,NULL))==NULL){   换成这句死活通不过，无论是否将公钥分离源文件
        ERR_print_errors_fp(stdout);
        return NULL;
    }   
    flen=strlen(str);
    rsa_len=RSA_size(p_rsa);
    p_en=(unsigned char *)malloc(rsa_len+1);
    memset(p_en,0,rsa_len+1);
    if(RSA_public_encrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_en,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_en;
}
char *my_decrypt(char *str,char *path_key){
    char *p_de;
    RSA *p_rsa;
    FILE *file;
    int rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;
    }
    if((p_rsa=PEM_read_RSAPrivateKey(file,NULL,NULL,NULL))==NULL){
        ERR_print_errors_fp(stdout);
        return NULL;
    }
    rsa_len=RSA_size(p_rsa);
    p_de=(unsigned char *)malloc(rsa_len+1);
    memset(p_de,0,rsa_len+1);
    if(RSA_private_decrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_de,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_de;
}

运行结果如下：

技术分享图片

任务二

混合密码系统示意图如下所示：

技术分享图片

伪代码

客户端实现思路：
- 利用c语言中的rand()函数生成32字节的伪随机数数组构成会话密钥
- 用预先生成的RSA私钥加密会话密钥
- 将会话密钥发送给服务器
- 用会话密钥加密指定文件
- 将密文发送给服务器
- 调用mywc()函数计算文件中单词数
服务器实现思路：
- 接收客户端发来的会话密钥密文
- 利用预先生成的RSA公钥解密得到会话密钥
- 接收客户端发来的密文
- 用会话密钥解密密文得到明文
- 将明文存入文件
- 调用mywc()函数计算文件中单词数
  
  代码
客户端

#include<netinet/in.h>                         // for sockaddr_in  
#include<sys/types.h>                          // for socket  
#include<sys/socket.h>                         // for socket  
#include<stdio.h>                              // for printf  
#include<stdlib.h>                             // for exit  
#include<string.h>                 // for bzero 
#include<memory.h> 
#include<time.h>                            
#include<openssl/rsa.h>
#include<openssl/pem.h>
#include<openssl/err.h>
#include <openssl/aes.h>
#pragma comment(lib,"libeay32.lib")
#define OPENSSLKEY "test.key"
#define PUBLICKEY "test_pub.key"
#define BUFFSIZE 1024  
#define HELLO_WORLD_SERVER_PORT       6000 
#define BUFFER_SIZE                   1024  
#define FILE_NAME_MAX_SIZE            512  
int mywc(char file_name[],int choose);
char* my_encrypt(char *str,char *path_key);//rsa加密
char* my_decrypt(char *str,char *path_key);//rsa解密
void aes_encrypt(char *str,char aes_keybuf[],char buf[]);//aes加密
void aes_decrypt(char *str,char aes_keybuf[],char buf[]);//aes解密
int main(int argc, char **argv)  
{  
    
    FILE *fp;
    if (argc != 2)  
    {  
        printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
        exit(1);  
    }  

// 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口  
    struct sockaddr_in client_addr;  
    bzero(&client_addr, sizeof(client_addr));  
    client_addr.sin_family = AF_INET;   
    client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址  
    client_addr.sin_port = htons(0); 

// 创建字节流socket，用client_socket代表客户端socket  
    int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    if (client_socket < 0)  
    {  
        printf("Create Socket Failed!\n");  
        exit(1);  
    }  

// 把客户端的socket和客户端的socket地址结构绑定   
    if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    {  
        printf("Client Bind Port Failed!\n");  
        exit(1);  
    }  

// 设置一个socket地址结构server_addr,代表服务器的internet地址和端口  
    struct sockaddr_in  server_addr;  
    bzero(&server_addr, sizeof(server_addr));  
    server_addr.sin_family = AF_INET;  

// 服务器的IP地址来自程序的参数   
    if (inet_aton(argv[1], &server_addr.sin_addr) == 0) //一个字符串IP地址转换为一个32位的网络序列IP地址，也可以用inet_addr
    {  
        printf("Server IP Address Error!\n");  
        exit(1);  
    }                                                                                                               
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    int server_addr_length = sizeof(server_addr);   

        // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接  
        if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length)==-1)  
        {  
            printf("Can Not Connect To %s!\n", argv[1]);  
            exit(1);  
        }  

        char file_name[FILE_NAME_MAX_SIZE];  
        bzero(file_name, sizeof(file_name));  
        printf("Please Input File Name.\t");  
        scanf("%s", file_name);  
        if((fp = fopen(file_name,"r"))==NULL)
            {
                printf("Failure to open %s\n",file_name);
                exit(0);
        }
    
        char buffer[BUFFER_SIZE];  
        bzero(buffer, sizeof(buffer));  
        strcpy(buffer,file_name);
        if(send(client_socket,buffer,BUFFER_SIZE,0)==-1)
        {
            printf("发送文件名失败\n");
        }
        printf("发送文件名成功\n");
        bzero(buffer, sizeof(buffer)); 
        //利用伪随机数生成32字节会话密钥:
        unsigned char aes_keybuf[32];
        int i;
        srand((unsigned) time(NULL));
        for(i=0;i<32;i++)
        {
            aes_keybuf[i]=rand()%10+48;
        }
        //用rsa对会话密钥加密
        char *aeskey_en;
        aeskey_en=my_encrypt(aes_keybuf,PUBLICKEY);
        printf("会话密钥:%s\n加密后的会话密钥为%s\n\n\n",aes_keybuf,aeskey_en);
        if((send(client_socket, aeskey_en, strlen(aeskey_en)+1, 0))==-1)
        {
            printf("发送文件失败\n");
        }
        printf("发送密钥完毕,长度为%d\n",strlen(aeskey_en)+1);
        printf("是否发送密文？y or n\n");
        char choose;
        char ch;while((ch=getchar())!=‘\n‘&&ch!=EOF);
        scanf("%c",&choose);
        if(choose==‘y‘)
    {//使用会话密钥对消息进行aes加密
        char ptr_en[512],ptr_de[512];       
        char ch;
        
        i=0;
        while((ch=fgetc(fp))!=EOF)
        {
            buffer[i++]=ch;
            if(i>=BUFFER_SIZE)
            {
                printf("加密前 %s\n",buffer);
                aes_encrypt(buffer,aes_keybuf,ptr_en);              
                
                //printf("加密后发送密文 %s\n",ptr_en);
                                     
                if((send(client_socket, ptr_en, strlen(ptr_en), 0))==-1)
                {
                    printf("发送文件失败\n");
                }
                printf("发送密文长度 ：%d\n",strlen(ptr_en));
                bzero(ptr_en, sizeof(ptr_en));
                bzero(buffer, sizeof(buffer));
                i=0;
            }
        }
        if(i<BUFFER_SIZE)
        {
            
            printf("加密前消息 %s\n",buffer);            
            aes_encrypt(buffer,aes_keybuf,ptr_en);          
            
            printf("加密后发送密文 %s\n",ptr_en);
            //ptr_de=my_decrypt(buffer,OPENSSLKEY);//解密buffer
            
            if((send(client_socket, ptr_en, strlen(ptr_en), 0))==-1)
            {
                printf("发送文件失败\n");
            }
            printf("发送密文长度 ：%d\n",strlen(ptr_en));
            
        }
        bzero(buffer, sizeof(buffer));
        printf("发送密文完毕\n");
        }
        /*
        if(ptr_en!=NULL){
                free(ptr_en);
            } */ 
        mywc(file_name,1);
        mywc(file_name,2);

        bzero(buffer, sizeof(buffer));

        fclose(fp);
     
        close(client_socket); // 传输完毕，关闭socket  
        return 0;  

}  
int mywc(char file_name[],int choose)
{
    FILE *fp;
        char ch;
        int flag=0,num=0;
       // int choose;
       //  printf("统计单词个数还是实现“wc -w”?(1or2)\n");
       // scanf("%d",&choose);
    if((fp = fopen(file_name,"r"))==NULL)
    {
         printf("Failure to open %s\n",file_name);
             exit(0);
        }
             
    if(choose==1)
    {
        while((ch=fgetc(fp))!=EOF)
        {
            if(ch==‘ ‘ || ch==‘\n‘ || ch==‘\t‘ ||  ch==‘\!‘ || ch==‘\?‘ || ch==‘\"‘ || ch==‘\.‘ || ch== ‘\,‘ || ch==‘\:‘ || ch==‘\(‘ || ch==‘\)‘ || ch==‘\;‘     || ch==‘\-‘)
            {
                flag=0;
            }
            else
            {
                if(flag==0)
                {
                    flag=1;
                    num++;
                }
                          
            }

        }

    }
    else if(choose==2)
    {
        while((ch=fgetc(fp))!=EOF)
        {
            if(ch==‘ ‘ || ch==‘\n‘ || ch==‘\t‘ || ch==‘\r‘)
                flag=0;
            else
            {
                if(flag==0)
                {
                    flag=1;
                    num++;
                }
            }
        }
    }
    printf("单词个数为：%d_用方式%d计算\n",num,choose);
    fclose(fp);
    return num;
}
char *my_encrypt(char *str,char *path_key){
    char *p_en;
    RSA *p_rsa;
    FILE *file;
    int flen,rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;    
    }   
    if((p_rsa=PEM_read_RSA_PUBKEY(file,NULL,NULL,NULL))==NULL){
    //if((p_rsa=PEM_read_RSAPublicKey(file,NULL,NULL,NULL))==NULL){   换成这句死活通不过，无论是否将公钥分离源文件
        ERR_print_errors_fp(stdout);
        return NULL;
    }   
    flen=strlen(str);
    rsa_len=RSA_size(p_rsa);
    p_en=(unsigned char *)malloc(rsa_len+1);
    memset(p_en,0,rsa_len+1);
    if(RSA_public_encrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_en,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_en;
}
char *my_decrypt(char *str,char *path_key){
    char *p_de;
    RSA *p_rsa;
    FILE *file;
    int rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;
    }
    if((p_rsa=PEM_read_RSAPrivateKey(file,NULL,NULL,NULL))==NULL){
        ERR_print_errors_fp(stdout);
        return NULL;
    }
    rsa_len=RSA_size(p_rsa);
    p_de=(unsigned char *)malloc(rsa_len+1);
    memset(p_de,0,rsa_len+1);
    if(RSA_private_decrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_de,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_de;
}
void aes_encrypt(char *str,char aes_keybuf[],char buf[]){
    
    AES_KEY aeskey;
    AES_set_encrypt_key(aes_keybuf,256,&aeskey);
    for(int i=0;i<sizeof(str);i+=16)
    AES_encrypt(str+i,buf+i,&aeskey);
    //printf("\n\nin_加密后：%s\n\n\n",buf);
       
}
void aes_decrypt(char *str,char aes_keybuf[],char buf[]){
    
    AES_KEY aeskey;
    AES_set_decrypt_key(aes_keybuf,256,&aeskey);
    for(int i=0;i<sizeof(str);i+=16)
    AES_decrypt(str+i,buf+i,&aeskey);
    

}

服务器

#include<netinet/in.h>   
#include<sys/types.h>   
#include<sys/socket.h>   
#include<stdio.h>   
#include<stdlib.h>   
#include<string.h>   
#include<pthread.h> 
#include<memory.h> 
#include<openssl/rsa.h>
#include<openssl/pem.h>
#include<openssl/err.h>
#include <openssl/aes.h>
#pragma comment(lib,"libeay32.lib")
#define OPENSSLKEY "test.key"
#define PUBLICKEY "test_pub.key"
#define BUFFSIZE 1024
#define HELLO_WORLD_SERVER_PORT    6000 
#define LENGTH_OF_LISTEN_QUEUE     20  
#define BUFFER_SIZE                1024  
#define FILE_NAME_MAX_SIZE         512  
char* my_encrypt(char *str,char *path_key);//rsa加密
char* my_decrypt(char *str,char *path_key);//rsa解密
void aes_encrypt(char *str,char aes_keybuf[],char buf[]);//aes加密
void aes_decrypt(char *str,char aes_keybuf[],char buf[]);//aes解密
void *process_client(void *new_server_socket);
int mywc(char file_name[])
{
    char ch;
    int flag=0,num=0;
    int choose;
    FILE *fp;
    printf("统计单词个数还是实现“wc -w”?(1or2)\n");
    scanf("%d",&choose);
    if((fp = fopen(file_name,"r"))==NULL)
    {
        printf("Failure to open %s\n",file_name);
        exit(0);
    }

    if(choose==1)
    {
    while((ch=fgetc(fp))!=EOF)
    {
        if(ch==‘ ‘ || ch==‘\n‘ || ch==‘\t‘ ||  ch==‘\!‘ || ch==‘\?‘ || ch==‘\"‘ || ch==‘\.‘ || ch== ‘\,‘ || ch==‘\:‘ || ch==‘\(‘ || ch==‘\)‘ || ch==‘\;‘ || ch==‘\-‘)
        {
            flag=0;
        }
        else
        {
            if(flag==0)
            {
                flag=1;
                num++;
            }

        }          
    }
    }
    else if(choose==2)
    {
        while((ch=fgetc(fp))!=EOF)
        {
            if(ch==‘ ‘ || ch==‘\n‘ || ch==‘\t‘ || ch==‘\r‘)
                flag=0;
            else
            {
                if(flag==0)
                {
                    flag=1;
                    num++;
                }
            }
        }
    }
    printf("单词个数为：%d\n",num);
    fclose(fp);
    return num;
}
int main(int argc, char **argv)  
{  
 
// 设置一个socket地址结构server_addr,代表服务器的IP地址和端口  
    struct sockaddr_in   server_addr;  
    bzero(&server_addr, sizeof(server_addr));  
    server_addr.sin_family = AF_INET;  
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);  
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  

// 创建字节流socket:server_socket 
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);  
    if (server_socket ==-1)  
    {  
        printf("Create Socket Failed!\n");  
        exit(1);  
    }  

// 把socket和socket地址结构绑定   
    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr))==-1)  
    {  
        printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);  
        exit(1);  
    }  

// server_socket用于监听   
    if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE)==-1)  
    {  
        printf("Server Listen Failed!\n");  
        exit(1);  
    }  
// 服务器端一直运行用以持续为客户端提供服务   
      
    while(1)
    {
// 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept  
 
        struct sockaddr_in client_addr;  
        int length = sizeof(client_addr);    
// accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信  
        int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);         
        if (new_server_socket ==-1)  
        {  
            printf("Server Accept Failed!\n"); 
            exit(0); 
        }
        printf("连接到客户端\n");
        pthread_t pid;
        if(pthread_create(&pid, NULL, process_client,(void *) &new_server_socket) < 0){
              printf("pthread_create error\n");
        }
        
    }
//  close(server_socket);
}
void *process_client(void *new_server_socket)
{
        int sockid=*(int *)new_server_socket;
        FILE *fp;
        //接受来自客户端的文件
        char buffer[BUFFER_SIZE]; 
        char file_name[FILE_NAME_MAX_SIZE];
        bzero(buffer, sizeof(buffer));  
        int length=0;
        if(recv(sockid,buffer,BUFFER_SIZE, 0)==-1)
        {
            printf("接受文件名%s失败\n",buffer);
        }
        strcpy(file_name,buffer);
        strcat(file_name,"_server");
        printf("创建文件夹%s\n",file_name);
        if((fp = fopen(file_name,"w"))==NULL)
        {
            printf("Failure to open %s\n",file_name);
            exit(0);
        }
        bzero(buffer, sizeof(buffer));
        //接收密钥密文
        unsigned char *aes_keybuf;
int lenn;
        if((lenn=recv(sockid, buffer,BUFFER_SIZE, 0))<0)
        {
            printf("接受密钥出错\n");
        }
        printf("接受密钥密文  %s\n\n",buffer);
printf("接受密钥length  %d\n\n",lenn);
        aes_keybuf=my_decrypt(buffer,OPENSSLKEY);//解密buffer
        printf("解密得会话密钥  %s\n\n\n",aes_keybuf);
        bzero(buffer, sizeof(buffer));
        char ptr_en[512],ptr_de[512];
        //length = recv(sockid, buffer,BUFFER_SIZE, 0);
        //printf(" recv length :%d\n",length);
        while( length = recv(sockid, buffer,BUFFER_SIZE, 0))
        {
            if(length<0)
            {
                printf("接受文件出错\n");
                exit(0);
            }
            printf("接受密文  %s\n\n\n",buffer);
            aes_decrypt(buffer,aes_keybuf,ptr_de);//解密buffer
                    
            printf("解密密文  %s\n",ptr_de);
            fwrite(ptr_de,sizeof(char),strlen(ptr_de),fp)<length;
            
            bzero(buffer, sizeof(buffer));
            bzero(ptr_de, sizeof(ptr_de));
        }
        fclose(fp);
        /*if(ptr_de!=NULL){
                free(ptr_de);
            } */
        printf("接收密文完毕\n");
        bzero(buffer, BUFFER_SIZE);
        int number=0;
        number=mywc(file_name);
        //bzero(buffer, BUFFER_SIZE);  
        //buffer[0]=number+48;

            bzero(buffer, sizeof(buffer));  
         
        printf("File Transfer Finished!\n");   
        close(new_server_socket);  
} 
char *my_encrypt(char *str,char *path_key){
    char *p_en;
    RSA *p_rsa;
    FILE *file;
    int flen,rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;    
    }   
    if((p_rsa=PEM_read_RSA_PUBKEY(file,NULL,NULL,NULL))==NULL){
    //if((p_rsa=PEM_read_RSAPublicKey(file,NULL,NULL,NULL))==NULL){   换成这句死活通不过，无论是否将公钥分离源文件
        ERR_print_errors_fp(stdout);
        return NULL;
    }   
    flen=strlen(str);
    rsa_len=RSA_size(p_rsa);
    p_en=(unsigned char *)malloc(rsa_len+1);
    memset(p_en,0,rsa_len+1);
    if(RSA_public_encrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_en,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_en;
}
char *my_decrypt(char *str,char *path_key){
    char *p_de;
    RSA *p_rsa;
    FILE *file;
    int rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;
    }
    if((p_rsa=PEM_read_RSAPrivateKey(file,NULL,NULL,NULL))==NULL){
        ERR_print_errors_fp(stdout);
        return NULL;
    }
    rsa_len=RSA_size(p_rsa);
    p_de=(unsigned char *)malloc(rsa_len+1);
    memset(p_de,0,rsa_len+1);
    if(RSA_private_decrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_de,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_de;
}
void aes_encrypt(char *str,char aes_keybuf[],char buf[]){
    
    AES_KEY aeskey;
    AES_set_encrypt_key(aes_keybuf,256,&aeskey);
    for(int i=0;i<sizeof(str);i+=16)
    AES_encrypt(str+i,buf+i,&aeskey);
    
}
void aes_decrypt(char *str,char aes_keybuf[],char buf[]){
    
    AES_KEY aeskey;
    AES_set_decrypt_key(aes_keybuf,256,&aeskey);
    for(int i=0;i<sizeof(str);i+=16)
    AES_decrypt(str+i,buf+i,&aeskey);
    
}

运行结果

技术分享图片

问题及解决过程

问题1：gcc -o to test_openssl.c -I /usr/local/ssl/inlcude /usr/local/ssl/lib -ldl -lpthread指令如何理解？
解决方案：查询gcc命令参数-I如下所述

-l参数就是用来指定程序要链接的库，-l参数紧接着就是库名。
放在/lib和/usr/lib和/usr/local/lib里的库直接用-l参数就能链接了。

与-L命令的区别：

如果库文件
没放在这三个目录里，而是放在其他目录里,链接程序ld在那3个目录里找不到libxxx.so,参数-L就派上用场了，比如常用的X11的库，它放在/usr/X11R6/lib目录下，我们编译时就要用-L/usr/X11R6/lib -lX11参数，-L参数跟着的是库文件所在的目录名。

-- 引用自《GCC常用参数详解》

这条指令用-I参数指定了两个链接库 /usr/local/ssl/inlcude 和/usr/local/ssl/lib。接着对后面选项-ldl -lpthread进行了查询，结果如下：

如果你的程序中使用dlopen、dlsym、dlclose、dlerror 显示加载动态库，需要设置链接选项 -ldl。

-- 引用自《gcc -ldl 选项作用》

其中dlopen用于打开动态链接库，dlsym用于取函数执行地址，dlclose用于关闭动态链接库，dlerror为动态库错误函数，他们的函数原型如下：

void *dlopen (const char *filename, int flag); 
//dlopen用于打开指定名字(filename)的动态链接库，并返回操作句柄
void *dlsym(void *handle, char *symbol);
// dlsym根据动态链接库操作句柄(handle)与符号(symbol)，返回符号对应的函数的执行代码地址
int dlclose (void *handle);
//dlclose用于关闭指定句柄的动态链接库，只有当此动态链接库的使用计数为0时,才会真正被系统卸载
const char *dlerror(void);
//当动态链接库操作函数执行失败时，dlerror可以返回出错信息，返回值为NULL时表示操作函数执行成功

-lpthread选项——链接POSIX thread库

问题2：编译安装OpenSSL 1.1.0alpha时出现两个错误，如下图所示：

技术分享图片

解决方案：去官网上重新下载了“openssl-master.zip”，删除了原来的压缩包和解压后的文件夹。
- 解压压缩包：unzip openssl-master.zip
- 进入目录openssl-master：cd openssl-master
- 使用以下命令编译安装：

$ ./config
$ make
$ make test
$ make install

问题3：使用make install命令安装时出现下图所示找不到路径的错误：

技术分享图片

解决方案：在make install前加上“sudo” 增加权限，最终安装成功，如下图所示：

技术分享图片

问题4：在完成任务二时出现了客户端与服务器发送接收数据不同步的问题，客户端发送密钥的密文和消息密文，但是服务器将后部分消息密文也作为密钥密文读入，如下图所示：

技术分享图片

解决过程：在客户端发送密钥密文后，增加一个确认是否发送的环节，接收用户输入，再根据输入选择是否发送密文。
- 但出现了未等用户输入就直接将缓冲区中数据读入的问题。
- 解决：利用语句char ch;while((ch=getchar())!=‘\n‘&&ch!=EOF);清空缓冲区

技术分享图片

最终通过增加输入解决了同步问题，如下图所示：

技术分享图片

参考资料

openssl几个加密算法使用介绍
......

2017-2018-1 20155312 实验五通讯协议设计

标签：cpe 密钥 publickey 简单应用缓冲区 local create 处理 turn

原文地址：http://www.cnblogs.com/zjy1997/p/8030357.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

2017-2018-1 20155312 实验五 通讯协议设计

2017-2018-1 20155312 实验四 外设驱动程序设计

实验内容

任务一

任务二

实验步骤

任务一

准备工作

课后作业：

学习openssl几个加密算法

在socket编程中的简单应用

任务二

伪代码

代码

运行结果

问题及解决过程

参考资料

2017-2018-1 20155312 实验五通讯协议设计

2017-2018-1 20155312 实验四外设驱动程序设计