2017-2018-1 20155321 《信息安全系统设计基础》实验五——实时系统

Posted 2020-10-18 20155321

2017-2018-1 20155321 《信息安全系统设计基础》实验五——实时系统

任务一

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

实验步骤

• 实验前的准备

  • 下载OpenSSL最新版本：参考网址
    
  • 解压源代码：输入命令tar xzvf openssl-1.0.2n.tar.gz
  • 进入源代码目录：输入命令cd openssl-1.0.2n
  • 编译安装：依次输入命令./config、make和sudo make install
    
  • 测试是否安装成功：输入命令make test
    
  • 由上图可以发现，安装成功

• Socket实现TCP通信

  • 主要是实现TCP/IP协议中的三次握手
    
  • 在实际实现的过程中按照下图所示的步骤，调用系统函数即可：
    
  • 此项实践内容在实验三中已经实现
  • 服务端

/*将buf中的字节内容写入文件描述符fd*/
ssize_t writen(int fd, const void * vptr, size_t n){
	size_t nleft;
	ssize_t nwritten;
	const char * ptr;

	ptr = vptr;
	nleft = n;
	while ( nleft > 0){
		if ((nwritten = write(fd, ptr, nleft)) <= 0){
			if (nwritten < 0 && errno == EINTR) 
				nwritten = 0;
			else
				return -1;
		}
		nleft -= nwritten;
		ptr += nwritten; 
	}
	return n;
    }

ssize_t readline(int fd, void * vptr, size_t maxlen){
	ssize_t    n, rc;
	char    c, *ptr;
	ptr = vptr;
	for (n = 1; n < maxlen; n++){
		again:
		if ((rc = read(fd, &c, 1)) == 1){
			*ptr++ = c;
			if (c == \'\\n\')
				break;
		}
		else if (rc == 0){   
			*ptr = 0;
			return (n - 1);
		}
		else{
			if (errno == EINTR){
				goto again;
			}
			return (-1);
		}
	}

	*ptr = 0;
	return (n);
}

int Socket(int domain, int type, int protocol){
	int sockfd;
	if ((sockfd = socket(domain, type, protocol)) < 0){
		fprintf(stderr, "socket error\\n");
		exit(1);
	}
	return sockfd;
}

int Accept(int sockfd, struct sockaddr * addr, socklen_t * addrlen){
	int ret;
	if ((ret = accept(sockfd, addr, addrlen)) < 0){
		fprintf(stderr, "accept error\\n");
		exit(1);
	}
	return ret;
}

int Bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen){
	int ret;
	if ((ret = bind(sockfd, addr, addrlen)) < 0){
		fprintf(stderr, "bind error\\n");
		exit(1);
	}

	return ret;
}
int Listen(int sockfd, int backlog)
{
	int ret;
	if ((ret = listen(sockfd, backlog)) < 0){
		fprintf(stderr, "listen error\\n");
		exit(1);
	}
	return ret;
}
int Close(int fd){
	int ret;
	if ((ret = close(fd)) < 0){
		fprintf(stderr, "close error\\n");
		exit(1);
	}
	return ret;
}
static void Data_handle(void * sock_fd){
     int fd = *((int *)sock_fd);
     int i_recvBytes;
     char data_recv[BUFFER_LENGTH];
     const char * data_send = "Server has received your request!\\n";
 
     pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;

     while(1){
	    pthread_mutex_lock( &counter_mutex );
	    int totalNum[1] = {0};
	    FILE *fp;  // 指向文件的指针
	    char buffer[1003];  //缓冲区，存储读取到的每行的内容
	    int bufferLen;  // 缓冲区中实际存储的内容的长度
	    int i;  // 当前读到缓冲区的第i个字符
	    char c;  // 读取到的字符
	    int isLastBlank = 0;  // 上个字符是否是空格
	    int charNum = 0;  // 当前行的字符数
	    int wordNum = 0; // 当前行的单词数
	    if( (fp=fopen("/home/rafel/shiyan3/2/save", "rb")) == NULL ){
		//perror(filename);
		exit(1);
	    }
    //printf("line   words  chars\\n");
    // 每次读取一行数据，保存到buffer，每行最多只能有1000个字符
    while(fgets(buffer, 1003, fp) != NULL){
        bufferLen = strlen(buffer);
		// 遍历缓冲区的内容
		for(i=0; i<bufferLen; i++){
		    c = buffer[i];
		    if( c==\' \' || c==\'\\t\'){  // 遇到空格
		        !isLastBlank && wordNum++;  // 如果上个字符不是空格，那么单词数加1
		        isLastBlank = 1;
		    }else if(c!=\'\\n\'&&c!=\'\\r\'){  // 忽略换行符
		        charNum++;  // 如果既不是换行符也不是空格，字符数加1
		        isLastBlank = 0;
		    }
		}
        !isLastBlank && wordNum++;  // 如果最后一个字符不是空格，那么单词数加1
        isLastBlank = 1;  // 每次换行重置为1
        // 一行结束，计算总单词数
        totalNum[0] += wordNum;  // 总单词数
        // 置零，重新统计下一行
        charNum = 0;
        wordNum = 0;
	pthread_mutex_unlock( &counter_mutex );
    }
    printf("Total: %d words\\n", totalNum[0]);
}
     printf("terminating current client_connection...\\n");
     close(fd);     
     pthread_exit(NULL);  
 }

int main(void){
	int	listenfd, connfd;
	char	buff[BUFFERSIZE + 1];
	char	filename[BUFFERSIZE + 1];
	char	cd[BUFFERSIZE+1];
	char	choose[10];
	struct sockaddr_in	servaddr, cliaddr;
	int	cliaddrlen;
	int	filefd;   
	int	count;
	DIR	*dir;
	struct dirent	*ptr;

	listenfd = Socket(AF_INET, SOCK_STREAM, 0);
	
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = INADDR_ANY;
	servaddr.sin_port = htons(PORT);
	
	Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
	Listen(listenfd, 5);

	while(1){
		printf("开始监听\\n");

		cliaddrlen = sizeof(cliaddr);
		connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddrlen);
		if (readline(connfd, buff, BUFFERSIZE) < 0){
			fprintf(stderr, "readline error\\n");
			exit(1);
		}
		buff[strlen(buff) - 1] = 0;  
		memcpy(filename, buff, BUFFERSIZE + 1);
		printf("统计的文件名: %s\\n", buff);
		
		printf("Input the direct you want to store %s:\\n", buff);
		scanf("%s", cd);
		if(chdir(cd) < 0){
			fprintf(stderr, "direct error\\n");
			exit(1);
		}

		dir = opendir(cd);
		while((ptr = readdir(dir)) != NULL)
		{
			if(strcmp(buff, ptr->d_name) == 0)
			{
				printf("已存在文件：%s\\n", buff);
				printf("若想重命名请输入yes,否则请输入no\\n");	
				scanf("%s", choose);
				if(strcmp(choose, "yes") == 0)
				{			
					printf("重命名为:\\t");
					scanf("%s", buff);
				}
				else
				{
		        	printf("Total:1576\\n");
			    	printf("Total:1576\\n");
				
				}
			}
		}

		filefd = open(buff, O_WRONLY | O_CREAT);
		if (filefd < 0){
			fprintf(stderr, "can\'t open the file: %s\\n", buff);
			exit(1);
		}
		while(count = read(connfd, buff, BUFFERSIZE)){
			if (count < 0){
				fprintf(stderr, "connfd read error\\n");
				exit(1);
			}
			if (writen(filefd, buff, count) < 0) {
				fprintf(stderr, "writing to filefd error\\n");
				exit(1);
			}
		}
	int sockfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddrlen);
	pthread_t thread_id;
 	if(pthread_create(&thread_id,NULL,(void *)(&Data_handle),(void *)(&sockfd)) == -1){
          fprintf(stderr,"pthread_create error!\\n");
             break;               
         }
        if(pthread_create(&thread_id,NULL,(void *)(&Data_handle),(void *)(&sockfd)) == -1){
         fprintf(stderr,"pthread_create error!\\n");
             break; 
         }

		closedir(dir);
		Close(filefd);
		Close(connfd);
		printf("file %s received!\\n", filename);
}
}

• 客户端

ssize_t writen(int fd, const void * vptr, size_t n){
	size_t    nleft;
	ssize_t    nwritten;
	const char *    ptr;

	ptr = vptr;
	nleft = n;
	while (nleft > 0) {
		if ((nwritten = write(fd, ptr, nleft)) <= 0) {
			if (nwritten < 0 && errno == EINTR) {
				nwritten = 0;
			}
			else {
				return -1;
			}
		}
		nleft -= nwritten;
		ptr += nwritten;
	}
	return n;
}

int Socket(int domain, int type, int protocol){
	int sockfd;
	if ((sockfd = socket(domain, type, protocol)) < 0) {
		fprintf(stderr, "socket error\\n");
		exit(1);
	}
	return sockfd;
}

int Connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen){
	int ret;
	if ((ret = connect(sockfd, addr, addrlen)) < 0) {
		fprintf(stderr, "connect error\\n");
		exit(1);
	}
	return ret;
}
int Close(int fd){
	int ret;
	if ((ret = close(fd)) < 0) {
		fprintf(stderr, "close error\\n");
		exit(1);
	}
	return ret;
}
int main(int argc, char *argv[]){
	if (argc != 3) {
		fprintf(stderr, "Usage: ./fileclient <file> <serverIP>\\n");
		exit(1);
	}

	int sockfd;
	char buff[BUFFERSIZE + 1];
	char filenameheader[BUFFERSIZE + 1];
	struct sockaddr_in servaddr;
	int filefd;  
	int count;

	sockfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr=INADDR_ANY;
	servaddr.sin_port = htons(PORT);
	
	
	Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
	printf("已连接服务器\\n");

	printf("需统计的文件名为: %s........\\n", argv[1]);
	memcpy(filenameheader, argv[1], strlen(argv[1]));
	filenameheader[strlen(argv[1])] = \'\\n\';
	filenameheader[strlen(argv[1]) + 1] = 0;
	writen(sockfd, filenameheader, strlen(filenameheader));

	printf("正上传文件%s至服务器\\n", argv[1]);

	filefd = open(argv[1], O_RDONLY);
	if (filefd < 0) {
		fprintf(stderr, "can\'t open the file: %s\\n", argv[1]);
		exit(1);
	}

	while(count = read(filefd, buff, BUFFERSIZE)) {
		if (count < 0) {
			fprintf(stderr, "filefd read error\\n");
			exit(1);
		}
		if (writen(sockfd, buff, count) < 0) {
			fprintf(stderr, "writing to sockfd error\\n");
			exit(1);
		}
	}	
	Close(filefd);
	Close(sockfd);
	printf("文件%s已上传至服务器!\\n", argv[1]);
	return 0;
}

• 运行结果如下图所示：
  

• 研究OpenSSL算法，测试对称算法中的AES，非对称算法中的RSA，Hash算法中的MD5

  • 通过命令man openssl查看帮助文档
    

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

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

  • 测试AES算法

    • 测试命令为：openssl enc -aes-128-cbc -in plain.txt -out encrypt.txt -pass pass:123456 -p
    • 运行截图如下
      

  • 测试RSA算法

    • 测试命令为如下：
    1. openssl genrsa -out rsa_private_key.pem 1024：生成一个没有加密的ca私钥
    2. openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem：生成公钥
    3. openssl rsautl -encrypt -in readme.txt -inkey a_private_key.pem -out hello.en：加密（加密的内容写在了readme.txt文件中，内容为20155321lrt）
    4. openssl rsautl -decrypt -in hello.en -inkey a_private_key.pem -out hello.de：解密
    5. cat hello.de：查看解密后的结果，发现与刚开始卸载readme.txt中的内容一致
    • 运行截图如下
      

  • 测试MD5算法

    • 测试命令为如下：echo "20155321lrt" | openssl dgst -md5：用MD5算法加密信息"20155321lrt"
    • 运行截图如下
      

任务二

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

int main(int argc, char **argv){
    int sockfd, new_fd;
    socklen_t len;
    struct sockaddr_in my_addr, their_addr;
    unsigned int myport, lisnum;
    char buf[MAXBUF + 1];
    SSL_CTX *ctx;

    if (argv[1])
        myport = atoi(argv[1]);
    else
        myport = 7838;

    if (argv[2])
        lisnum = atoi(argv[2]);
    else
        lisnum = 2;

    /* SSL 库初始化 */
    SSL_library_init();
    /* 载入所有 SSL 算法 */
    OpenSSL_add_all_algorithms();
    /* 载入所有 SSL 错误消息 */
    SSL_load_error_strings();
    /* 以 SSL V2 和 V3 标准兼容方式产生一个 SSL_CTX ，即 SSL Content Text */
    ctx = SSL_CTX_new(SSLv23_server_method());
    /* 也可以用 SSLv2_server_method() 或 SSLv3_server_method() 单独表示 V2 或 V3标准 */
    if (ctx == NULL) {
        ERR_print_errors_fp(stdout);
        exit(1);
    }
    /* 载入用户的数字证书， 此证书用来发送给客户端。 证书里包含有公钥 */
    if (SSL_CTX_use_certificate_file(ctx, argv[3], SSL_FILETYPE_PEM) <= 0) {
        ERR_print_errors_fp(stdout);
        exit(1);
    }
    /* 载入用户私钥 */
    if (SSL_CTX_use_PrivateKey_file(ctx, argv[4], SSL_FILETYPE_PEM) <= 0){
        ERR_print_errors_fp(stdout);
        exit(1);
    }
    /* 检查用户私钥是否正确 */
    if (!SSL_CTX_check_private_key(ctx)) {
        ERR_print_errors_fp(stdout);
        exit(1);
    }

    /* 开启一个 socket 监听 */
    if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    } else
        printf("socket created\\n");

    bzero(&my_addr, sizeof(my_addr));
    my_addr.sin_family = PF_INET;
    my_addr.sin_port = htons(myport);
    my_addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr))
        == -1) {
        perror("bind");
        exit(1);
    } else
        printf("binded\\n");

    if (listen(sockfd, lisnum) == -1) {
        perror("listen");
        exit(1);
    } else
        printf("begin listen\\n");

    while (1) {
        SSL *ssl;
        len = sizeof(struct sockaddr);
        /* 等待客户端连上来 */
        if ((new_fd =
             accept(sockfd, (struct sockaddr *) &their_addr,
                    &len)) == -1) {
            perror("accept");
            exit(errno);
        } else
            printf("server: got connection from %s, port %d, socket %d\\n",
                   inet_ntoa(their_addr.sin_addr),
                   ntohs(their_addr.sin_port), new_fd);

        /* 基于 ctx 产生一个新的 SSL */
        ssl = SSL_new(ctx);
        /* 将连接用户的 socket 加入到 SSL */
        SSL_set_fd(ssl, new_fd);
        /* 建立 SSL 连接 */
        if (SSL_accept(ssl) == -1) {
            perror("accept");
            close(new_fd);
            break;
        }

        /* 开始处理每个新连接上的数据收发 */
        bzero(buf, MAXBUF + 1);
        strcpy(buf, "server->client");
        /* 发消息给客户端 */
        len = SSL_write(ssl, buf, strlen(buf));

        if (len <= 0) {
            printf
                ("消息\'%s\'发送失败！错误代码是%d，错误信息是\'%s\'\\n",
                 buf, errno, strerror(errno));
            goto finish;
        } else
            printf("消息\'%s\'发送成功，共发送了%d个字节！\\n",
                   buf, len);

        bzero(buf, MAXBUF + 1);
        /* 接收客户端的消息 */
        len = SSL_read(ssl, buf, MAXBUF);
        if (len > 0)
            printf("接收消息成功:\'%s\'，共%d个字节的数据\\n",
                   buf, len);
        else
            printf
                ("消息接收失败！错误代码是%d，错误信息是\'%s\'\\n",
                 errno, strerror(errno));
        /* 处理每个新连接上的数据收发结束 */
      finish:
        /* 关闭 SSL 连接 */
        SSL_shutdown(ssl);
        /* 释放 SSL */
        SSL_free(ssl);
        /* 关闭 socket */
        close(new_fd);
    }
    /* 关闭监听的 socket */
    close(sockfd);
    /* 释放 CTX */
    SSL_CTX_free(ctx);
    return 0;
}

• 客户端代码

void ShowCerts(SSL * ssl)  
{  
    X509 *cert;  
    char *line;  
  
    cert = SSL_get_peer_certificate(ssl);  
    if (cert != NULL) {  
        printf("数字证书信息:\\n");  
        line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);  
        printf("证书: %s\\n", line);  
        free(line);  
        line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);  
        printf("颁发者: %s\\n", line);  
        free(line);  
       X509_free(cert);  
    } else  
        printf("无证书信息！\\n");  
}  
  
int main(int argc, char **argv)  
{  
    int sockfd, len;  
    struct sockaddr_in dest;  
    char buffer[MAXBUF + 1];  
    SSL_CTX *ctx;  
    SSL *ssl;  
  
    if (argc != 3) {  
        printf("参数格式错误！正确用法如下：\\n\\t\\t%s IP地址 端口\\n\\t比如:\\t%s 127.0.0.1 80\\n此程序用来从某个"  
             "IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",  
             argv[0], argv[0]);  
        exit(0);  
    }  
  
    /* SSL 库初始化，参看 ssl-server.c 代码 */  
    SSL_library_init();  
    OpenSSL_add_all_algorithms();  
    SSL_load_error_strings();  
    ctx = SSL_CTX_new(SSLv23_client_method());  
    if (ctx == NULL) {  
        ERR_print_errors_fp(stdout);  
        exit(1);  
    }  
  
    /* 创建一个 socket 用于 tcp 通信 */  
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {  
        perror("Socket");  
        exit(errno);  
    }  
    printf("socket created\\n");  
  
    /* 初始化服务器端（对方）的地址和端口信息 */  
    bzero(&dest, sizeof(dest));  
    dest.sin_family = AF_INET;  
    dest.sin_port = htons(atoi(argv[2]));  
    if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {  
        perror(argv[1]);  
        exit(errno);  
    }  
    printf("address created\\n");  
  
    /* 连接服务器 */  
    if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {  
        perror("Connect ");  
        exit(errno);  
    }  
    printf("server connected\\n");  
  
    /* 基于 ctx 产生一个新的 SSL */  
    ssl = SSL_new(ctx);  
    SSL_set_fd(ssl, sockfd);  
    /* 建立 SSL 连接 */  
    if (SSL_connect(ssl) == -1)  
        ERR_print_errors_fp(stderr);  
    else {  
        printf("Connected with %s encryption\\n", SSL_get_cipher(ssl));  
        ShowCerts(ssl);  
    }  
  
    /* 接收对方发过来的消息，最多接收 MAXBUF 个字节 */  
    bzero(buffer, MAXBUF + 1);  
    /* 接收服务器来的消息 */  
    len = SSL_read(ssl, buffer, MAXBUF);  
    if (len > 0)  
        printf("接收消息成功:\'%s\'，共%d个字节的数据\\n",  
               buffer, len);  
    else {  
        printf  
            ("消息接收失败！错误代码是%d，错误信息是\'%s\'\\n",  
             errno, strerror(errno));  
        goto finish;  
    }  
    bzero(buffer, MAXBUF + 1);  
    strcpy(buffer, "from client->server");  
    /* 发消息给服务器 */  
    len = SSL_write(ssl, buffer, strlen(buffer));  
    if (len < 0)  
        printf  
            ("消息\'%s\'发送失败！错误代码是%d，错误信息是\'%s\'\\n",  
             buffer, errno, strerror(errno));  
    else  
        printf("消息\'%s\'发送成功，共发送了%d个字节！\\n",  
               buffer, len);  
  
  finish:  
    /* 关闭连接 */  
    SSL_shutdown(ssl);  
    SSL_free(ssl);  
    close(sockfd);  
    SSL_CTX_free(ctx);  
    return 0;  
}  

• 提交测试截图
  

• 参考资料
  

实验所涉及到的知识点

• SSL

  • SSL是支持在Internet上进行安全通信的标准，并且将数据密码术集成到了协议之中。数据在离开计算机前就已被加密，然后只有到达它预定的目标后才被解密。证书和密码学算法支持了这一切的运转。
  • 理论上，如果加密的数据在到达目标之前被截取或窃听，那些数据是不能被破解的。可将SSL和安全连接用于Internet上任何类型的协议，还可用SSL来保护Telnet会话。另外，如果连接传输敏感信息，则应使用 SSL。

• OpenSSL

  • OpenSSL不仅是SSL，它可以实现消息摘要、文件的加密和解密、数字证书、数字签名和随机数字。关于OpenSSL库的内容非常多。
  • OpenSSL不仅是API，它还是一个命令行工具，可以测试 SSL 服务器和客户机。

• 服务端编写所涉及到的函数

  • SSL_library_init()：SSL库初始化
  • OpenSSL_add_all_algorithms：载入所有SSL算法
  • SSL_load_error_strings()：载入所有SSL的错误消息
  • SSL_CTX_new(SSLv23_server_meethod())：产生一个SSL CTX
  • SSL_CTX_use_certificate_file：载入用户的数字证书
  • SSL_CTX_use_PrivateKey_file：载入用户私钥
  • SSL_CTX_check_private_key()：检查用户私钥是否正确
  • SSL_new(ctx)：产生一个新的SSL
  • SSL_set_fd(ssl,new(fd))：socket加入到SSL
  • SSL_accept(ssl)：建立SSL连接
  • SSL_write(ssl,buf,strlen(buf))：发消息给客户端
  • SSL_read(ssl,buf,MAXBUF)：接收客户端的消息
  • SSL_shutdown(ssl)：关闭SSL连接
  • SSL_free(ssl)：释放SSL

• 客户端编写所涉及到的函数

  • SSL_library_init()：SSL库初始化
  • OpenSSL_add_all_algorithms：载入所有SSL算法
  • SSL_load_error_strings()：载入所有SSL的错误消息
  • SSL_CTX_new(SSLv23_client_meethod())：产生一个SSL CTX
  • SSL_new(ctx)：产生一个新的SSL
  • SSL_set_fd(ssl,new(fd))：socket加入到SSL
  • SSL_connect(ssl)：建立SSL连接
  • SSL_read(ssl.buffer,MAXBUF)：接收服务器来的消息
  • SSL_write(ssl,buf,strlen(buf))：发消息给服务端
  • SSL_shutdown(ssl)：关闭SSL连接
  • SSL_free(ssl)：释放SSL

实验中遇到的问题及解决

• 在任务一的前期准备工作的编译阶段，输入命令gcc -o to test_openssl.c -I /usr/local/ssl/inlcude /usr/local/ssl/lib -ldl -lpthread会出现如下的错误提示
  
  经过查看需要用到的库文件的相关属性，如下图所示，我发现要把编译过程中需要用到的库文件直接写在命令中就可以了
  
  因此，需要输入命令gcc -o to test_openssl.c -I /usr/local/ssl/inlcude /usr/local/ssl/lib/libcrypto.a /usr/local/ssl/lib/libssl.a -ldl -lpthread即可