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

最新推荐文章于 2024-08-12 20:29:26 发布
最新推荐文章于 2024-08-12 20:29:26 发布
阅读量145 收藏
点赞数
文章标签： 密码学 开发工具 网络
原文链接：http://www.cnblogs.com/rafell/p/8051544.html
版权

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

任务一

  1. 两人一组
  2. 基于Socket实现TCP通信，一人实现服务器，一人实现客户端
  3. 研究OpenSSL算法，测试对称算法中的AES，非对称算法中的RSA，Hash算法中的MD5
  4. 选用合适的算法，基于混合密码系统实现对TCP通信进行机密性、完整性保护。
  5. 学有余力者，对系统进行安全性分析和改进
实验步骤
  • 实验前的准备
    • 下载OpenSSL最新版本：参考网址
      1071532-20171215160656058-551479071.png
    • 解压源代码：输入命令tar xzvf openssl-1.0.2n.tar.gz
    • 进入源代码目录：输入命令cd openssl-1.0.2n
    • 编译安装：依次输入命令./config、make和sudo make install
      1071532-20171215162010980-477191141.png
    • 测试是否安装成功：输入命令make test
      1071532-20171215162049621-1419036418.png
    • 由上图可以发现，安装成功
  • Socket实现TCP通信
    • 主要是实现TCP/IP协议中的三次握手
      1071532-20171217093537046-264177034.png
    • 在实际实现的过程中按照下图所示的步骤，调用系统函数即可：
      1071532-20171217093701530-1188680506.png
    • 此项实践内容在实验三中已经实现
    • 服务端
/*将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;
}

  • 运行结果如下图所示：
    1071532-20171215163233558-1698438024.png

  • 研究OpenSSL算法，测试对称算法中的AES，非对称算法中的RSA，Hash算法中的MD5
    • 通过命令man openssl查看帮助文档
      1071532-20171215162451215-603094652.png
    • 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
      • 运行截图如下
        1071532-20171217100428889-475592077.png
    • 测试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中的内容一致
      • 运行截图如下
        1071532-20171217102245733-1573339707.png
    • 测试MD5算法
      • 测试命令为如下：echo "20155321lrt" | openssl dgst -md5：用MD5算法加密信息"20155321lrt"
      • 运行截图如下
        1071532-20171217103527827-844765599.png

任务二

  • 在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;  
}

  • 提交测试截图
    1071532-20171217104534264-1570368819.png

  • 参考资料
    1071532-20171212154325379-1135519564.png

实验所涉及到的知识点
  • 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会出现如下的错误提示
    1071532-20171217105238108-1283538253.png
    经过查看需要用到的库文件的相关属性，如下图所示，我发现要把编译过程中需要用到的库文件直接写在命令中就可以了
    1071532-20171217105547358-30905114.png
    因此，需要输入命令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即可
    1071532-20171217105806046-811328311.png

转载于:https://www.cnblogs.com/rafell/p/8051544.html

weixin_30739595
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据库课程设计——实验报告管理系统（超详细）
ViolinW的博客
01-05 9万+
数据库课程设计——实验报告管理系统
华中科技大学信息系统安全实验报告.zip
06-11
华中科技大学信息系统安全实验报告，软件安全，web安全，区块链。详细过程图文。
2017-2018-1 20155233 实验三-并发程序
dayang1122334的博客
11-19 110
2017-2018-1 20155233 实验三-并发程序 实验三-并发程序-1 学习使用Linux命令wc(1) 基于Linux Socket程序设计实现wc（1）服务器(端口号是你学号的后6位)和客户端 客户端传一个文本文件给服务器 服务器返加文本文件中的单词数 上方提交代码,附件提交测试截图，至少要测试附件中的两个文件 实现截图 实现代码 客户端 #include&lt...
2017-2018-1 20155308 《信息安全系统设计基础》第八周课上+课下测试
WFS12300的博客
11-12 337
2017-2018-1 20155308 《信息安全系统设计基础》第八周课上+课下测试 课堂测试 任务一 参考 http://www.cnblogs.com/rocedu/p/6766748.html#SECCLA 在Linux下完成“求命令行传入整数参数的和” 测试代码传入自己的8位学号 上方提交代码 附件提交运行测试截图 实验过程 #include <stdio.h&gt...
2017-2018-1 20155321 20155330 《信息安全系统设计基础》实验三——实时系统
weixin_30580341的博客
11-19 85
实验报告连接：2017-2018-1 20155321 20155330 《信息安全系统设计基础》实验三——实时系统 转载于:https://www.cnblogs.com/ashin-kl/p/7860482.html
计算机专业毕业设计题目大全——各种类型系统设计大全
热门推荐
haosen
02-24 13万+
计算机专业毕业设计题目大全 一、ASP类计算机专业毕业设计题目 1.网络留言薄2.客户管理系统3.多媒体积件管理库的开发与应用4.基于WEB的多媒体素材管理库的开发与应用5.网络教学软件中的教学设计与应用6.小型教育网站的开发与建设7.基于图像的风景旅游模拟漫游系统8.网上报名系统9.电脑配件网络购物10.房产网站11.计算机组成原理网站12.软件下载系统网站13.图书管理系统14.网络办公系...
数据结构课程设计——校园导游系统（C语言）
m0_46625346的博客
07-06 4万+
数据结构课程设计——校园导游系统（C语言）欢迎阅读==罡罡同学==的文章（关注不迷路）关于数据结构课程设计程序设计的功能程序源代码总结 欢迎阅读罡罡同学的文章（关注不迷路） （记得点赞关注） 还在为代码无法正常运行而烦恼，关注罡罡同学不迷路，解决你的烦恼。 如果你觉得，本文章对你有那么一丢丢的帮助，记得点赞关注转发，罡罡同学非常感谢哈！ 后续文章是关于数据结构一些基础实验，本人都已经成功运行，如果有问题，欢迎在评论区留言。 我是罡罡同学，一位初入网安的
系统架构设计师【第2章】: 计算机系统基础知识 (核心总结)
数据知道的博客
05-29 5752
计算机系统 (Computer System)是指用于数据管理的计算机硬件、软件及网络组成的系统。它是按人的要求接收和存储信息，自动进行数据处理和计算， 并输出结果信息的机器系统。计算机系统可划分为硬件(子系统)和软件(子 系统)两部分。硬件由机械、电子元器件、磁介质和系统光介质等物理实体构成，例如处理器(含运算单元和 控制单元)、存储器、输入设备和输出设备等。软件是一系列按照特定顺序组织的数据和指令，并控制硬件完成指定的功能。可将计算机软件进一步分为系统软件和应用软件：系统软件。
C语言程序设计课程设计（隐私信息管理系统-结构体数组实现）
有为肥宅的博客
12-06 2389
【HNUST】20级C语言程序设计课程设计（隐私信息管理系统）
机器人操作系统二 ROS2：设计、架构和野外使用 - 机器翻译
zhangrelay的专栏
05-12 6089
SCIENCE ROBOTICS | REVIEW ROBOTS AND SOCIETY Robot Operating System 2: Design, architecture, and uses in the wild 作者：史蒂文· 马琴斯基 塔利 富特 布赖恩· 格基克里斯· 拉兰塞特 和 威廉· 伍德尔 原文链接：www.science.org/doi/10.1126/scirobotics.abm6074 摘要 随着机器人在广泛的商业用例中的部署，机器人革命的下一章正在顺利进行。
杭电操作系统书后实验五——简单文件管理系统.zip
01-20
这些系统通常被设计用来提高效率、减少错误、加强安全性，同时提供数据和信息支持。以下是一些常见类型的管理系统： 学校管理系统： 用于学校或教育机构的学生信息、教职员工信息、课程管理、成绩记录、考勤管理等...
东南大学网络空间安全实验基础——环境变量和Set-UID程序实验
07-07
在网络安全领域，环境变量和Set-UID程序是两个重要的概念，它们与系统安全密切相关。本实验旨在通过一系列任务深入理解这两个概念以及它们如何影响程序执行和权限管理。 环境变量是操作系统中存储信息的一种方式，...
UL61800-5-1-2022 可调速电力驱动系统
05-18
《可调速电力驱动系统——安全要求——电、热和能源》(UL 61800-5-1-2022)是美国国家标准协会(ANSI)与美国保险商实验室(UL)联合发布的一项标准，主要针对可调速电力驱动系统的安全性。这一标准在2022年6月24日更新到...
财经信息管理系统实验报告1——管理信息系统的初步认识-1.doc
06-22
此外，安装的管理信息系统是“顶尖酒店管理信息系统”，这是一款专为酒店业设计的信息管理系统。 三、顶尖酒店管理信息系统功能 1. 预订管理：系统允许用户预订客房，根据客户的需求进行记录。 2. 收据补打印：对于...
湖科大2021JavaWeb实验及课程设计-图书信息管理系统-.zip
07-30
《湖科大2021JavaWeb实验及课程设计——图书信息管理系统》 这是一份来自湖南科技大学的JavaWeb课程的实践项目，旨在帮助学生掌握JavaWeb开发的基本技术和流程。项目名为“图书信息管理系统”，涵盖了从需求分析到...
数据库管理系统——设计实验报告
weixin_45568353的博客
06-20 4236
系统平台 开发工具：C# 数据库：ACCESS 操作系统：win10 需求分析 本系统功能包括：学生注册、学生选课、查询学生可选课程、删除已选课程、打印和输出本学期成绩报表（Excel）、教师选课、新教工注册、学生信息查询、学生成绩查询、学生选课信息查询、教师授课信息查询、学生成绩查询、学生成绩录入功能、学生成绩报表的输出和打印(Excel)、安全性管理(教师权限设置、学生权限设置、密码设置、重新登录和修改密码等)。 E-R图分析 数据库表格 教师授课表 老师信息表 学生信息表 课程表 学生选课表
【密码学】密钥管理：②密钥分配
最新发布
qq_39780701的博客
08-12 926
密钥分配的定义、密钥分配的方法。利用双钥体制建立安全信道传递来实现密钥分配。密码分配的基本模式主要有：点对点密钥分配、密钥分配中心、密钥传递中心三种。
英语写作中“严格的”“启发式的”rigorous、heuristic的用法
michel_2010的博客
08-08 166
In modern cryptography, security analysis is heuristic, while formal security proof is rigorous.（在现代密码学中，安全性分析是启发式的，而形式化安全性证明是严格的。英语科技论文写作中，与“严格”rigorous 对应的是“启发式的”heuristic，例如rigorous/heuristic analysis （proof ）（严格的/启发式的）分析（证明）。
密码学知识点02
2302_77186925的博客
08-11 731
密码学知识点02.对称加密
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值