zoukankan html css js c++ java

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

OpenSSL简介

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

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算法。

非对称加密算法

OpenSSL一共实现了4种非对称加密算法，包括DH算法、RSA算法、DSA算法和椭圆曲线算法（ECC）。DH算法一般用户密钥交换。RSA算法既可以用于密钥交换，也可以用于数字签名，当然，如果你能够忍受其缓慢的速度，那么也可以用于数据加密。DSA算法则一般只用于数字签名。

信息摘要算法

OpenSSL实现了5种信息摘要算法，分别是MD2、MD5、MDC2、SHA（SHA1）和RIPEMD。SHA算法事实上包括了SHA和SHA1两种信息摘要算法，此外，OpenSSL还实现了DSS标准中规定的两种信息摘要算法DSS和DSS1。

密钥和证书管理

密钥和证书管理是PKI的一个重要组成部分，OpenSSL为之提供了丰富的功能，支持多种标准。

首先，OpenSSL实现了ASN.1的证书和密钥相关标准，提供了对证书、公钥、私钥、证书请求以及CRL等数据对象的DER、PEM和BASE64的编解码功能。OpenSSL提供了产生各种公开密钥对和对称密钥的方法、函数和应用程序，同时提供了对公钥和私钥的DER编解码功能。并实现了私钥的 PKCS#12和PKCS#8的编解码功能。OpenSSL在标准中提供了对私钥的加密保护功能，使得密钥可以安全地进行存储和分发。

在此基础上，OpenSSL实现了对证书的X.509标准编解码、PKCS#12格式的编解码以及PKCS#7的编解码功能。并提供了一种文本数据库，支持证书的管理功能，包括证书密钥产生、请求产生、证书签发、吊销和验证等功能。

事实上，OpenSSL提供的CA应用程序就是一个小型的证书管理中心（CA），实现了证书签发的整个流程和证书管理的大部分机制。

SSL和TLS协议

OpenSSL实现了SSL协议的SSLv2和SSLv3，支持了其中绝大部分算法协议。OpenSSL也实现了TLSv1.0，TLS是SSLv3的标准化版，虽然区别不大，但毕竟有很多细节不尽相同。

虽然已经有众多的软件实现了OpenSSL的功能，但是OpenSSL里面实现的SSL协议能够让我们对SSL协议有一个更加清楚的认识，因为至少存在两点：一是OpenSSL实现的SSL协议是开放源代码的，我们可以追究SSL协议实现的每一个细节；二是OpenSSL实现的SSL协议是纯粹的SSL协议，没有跟其它协议（如HTTP）协议结合在一起，澄清了SSL协议的本来面目。

应用程序

OpenSSL的应用程序已经成为了OpenSSL重要的一个组成部分，其重要性恐怕是OpenSSL的开发者开始没有想到的。现在OpenSSL的应用中，很多都是基于OpenSSL的应用程序而不是其API的，如OpenCA，就是完全使用OpenSSL的应用程序实现的。OpenSSL的应用程序是基于OpenSSL的密码算法库和SSL协议库写成的，所以也是一些非常好的OpenSSL的API使用范例，读懂所有这些范例，你对OpenSSL的 API使用了解就比较全面了，当然，这也是一项锻炼你的意志力的工作。

OpenSSL的应用程序提供了相对全面的功能，在相当多的人看来，OpenSSL已经为自己做好了一切，不需要再做更多的开发工作了，所以，他们也把这些应用程序成为OpenSSL的指令。OpenSSL的应用程序主要包括密钥生成、证书管理、格式转换、数据加密和签名、SSL测试以及其它辅助配置功能。

Engine机制

Engine机制的出现是在OpenSSL的0.9.6版的事情，开始的时候是将普通版本跟支持Engine的版本分开的，到了OpenSSL的 0.9.7版，Engine机制集成到了OpenSSL的内核中，成为了OpenSSL不可缺少的一部分。 Engine机制目的是为了使OpenSSL能够透明地使用第三方提供的软件加密库或者硬件加密设备进行加密。 OpenSSL的Engine机制成功地达到了这个目的，这使得OpenSSL已经不仅仅使一个加密库，而是提供了一个通用地加密接口，能够与绝大部分加密库或者加密设备协调工作。当然，要使特定加密库或加密设备更OpenSSL协调工作，需要写少量的接口代码，但是这样的工作量并不大，虽然还是需要一点密码学的知识。Engine机制的功能跟 Windows提供的CSP功能目标是基本相同的。目前，OpenSSL的0.9.7版本支持的内嵌第三方加密设备有8种，包括： CryptoSwift、nCipher、Atalla、Nuron、UBSEC、Aep、SureWare以及IBM 4758 CCA的硬件加密设备。现在还出现了支持PKCS#11接口的Engine接口，支持微软CryptoAPI的接口也有人进行开发。当然，所有上述 Engine接口支持不一定很全面，比如，可能支持其中一两种公开密钥算法。

辅助功能

BIO机制是OpenSSL提供的一种高层IO接口，该接口封装了几乎所有类型的IO接口，如内存访问、文件访问以及Socket等。这使得代码的重用性大幅度提高，OpenSSL提供API的复杂性也降低了很多。

OpenSSL对于随机数的生成和管理也提供了一整套的解决方法和支持API函数。随机数的好坏是决定一个密钥是否安全的重要前提。

OpenSSL还提供了其它的一些辅助功能，如从口令生成密钥的API，证书签发和管理中的配置文件机制等等。如果你有足够的耐心，将会在深入使用OpenSSL的过程慢慢发现很多这样的小功能，让你不断有新的惊喜。

Heartbleed漏洞简介

Heartbleed Bug是流行的OpenSSL加密软件库中的一个严重漏洞。这种弱点允许在正常情况下通过用于保护因特网的SSL / TLS加密来窃取受保护的信息。

Heartbleed错误允许Internet上的任何人读取由易受攻击的OpenSSL软件版本保护的系统的内存。这就损害了用于识别服务提供商的秘密密钥，并加密了流量，用户的名字和密码以及实际的内容。这使得攻击者可以窃听通信，直接从服务和用户处窃取数据，模仿服务和用户。

这是一个实现问题，即流行的OpenSSL库中的编程错误，它向应用程序和服务提供SSL / TLS等加密服务。

使用OpenSSL的最广泛的软件是Apache和nginx这样的开源Web服务器。据Netcraft公司2014年4月的网络服务器调查显示，互联网上仅有的两家网站的市场份额超过了66％。此外，OpenSSL用于保护例如电子邮件服务器（SMTP，POP和IMAP协议），聊天服务器（XMPP协议），虚拟专用网络（SSL VPN），网络设备和各种客户端软件。幸运的是，许多大型的消费者网站都是通过保守的SSL / TLS终端设备和软件来节省的。讽刺的是，更小更先进的服务或升级到最新和最好加密的服务将受到最大的影响。而且，OpenSSL在客户端软件中非常受欢迎，并且在网络设备中很受欢迎，这些设备在获取更新方面具有最大的惯性。

实验内容

任务一

在Ubuntu中完成 http://www.cnblogs.com/rocedu/p/5087623.html 中的作业

AES

代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <openssl/aes.h>
 
int main(int argc, char** argv) {
    AES_KEY aes;
    unsigned char key[AES_BLOCK_SIZE];        // AES_BLOCK_SIZE = 16
    unsigned char iv[AES_BLOCK_SIZE];        // init vector
    unsigned char* input_string;
    unsigned char* encrypt_string;
    unsigned char* decrypt_string;
    unsigned int len;        // encrypt length (in multiple of AES_BLOCK_SIZE)
    unsigned int i;
 
    // check usage
    if (argc != 2) {
        fprintf(stderr, "%s <plain text>
", argv[0]);
        exit(-1);
    }
 
    // set the encryption length
    len = 0;
    if ((strlen(argv[1]) + 1) % AES_BLOCK_SIZE == 0) {
        len = strlen(argv[1]) + 1;
    } else {
        len = ((strlen(argv[1]) + 1) / AES_BLOCK_SIZE + 1) * AES_BLOCK_SIZE;
    }
 
    // set the input string
    input_string = (unsigned char*)calloc(len, sizeof(unsigned char));
    if (input_string == NULL) {
        fprintf(stderr, "Unable to allocate memory for input_string
");
        exit(-1);
    }
    strncpy((char*)input_string, argv[1], strlen(argv[1]));
 
    // Generate AES 128-bit key
    for (i=0; i<16; ++i) {
        key[i] = 32 + i;
    }
 
    // Set encryption key
    for (i=0; i<AES_BLOCK_SIZE; ++i) {
        iv[i] = 0;
    }
    if (AES_set_encrypt_key(key, 128, &aes) < 0) {
        fprintf(stderr, "Unable to set encryption key in AES
");
        exit(-1);
    }
 
    // alloc encrypt_string
    encrypt_string = (unsigned char*)calloc(len, sizeof(unsigned char));    
    if (encrypt_string == NULL) {
        fprintf(stderr, "Unable to allocate memory for encrypt_string
");
        exit(-1);
    }
 
    // encrypt (iv will change)
    AES_cbc_encrypt(input_string, encrypt_string, len, &aes, iv, AES_ENCRYPT);
 
    // alloc decrypt_string
    decrypt_string = (unsigned char*)calloc(len, sizeof(unsigned char));
    if (decrypt_string == NULL) {
        fprintf(stderr, "Unable to allocate memory for decrypt_string
");
        exit(-1);
    }
 
    // Set decryption key
    for (i=0; i<AES_BLOCK_SIZE; ++i) {
        iv[i] = 0;
    }
    if (AES_set_decrypt_key(key, 128, &aes) < 0) {
        fprintf(stderr, "Unable to set decryption key in AES
");
        exit(-1);
    }
 
    // decrypt
    AES_cbc_encrypt(encrypt_string, decrypt_string, len, &aes, iv, 
            AES_DECRYPT);
 
    // print
    printf("input_string = %s
", input_string);
    printf("encrypted string = ");
    for (i=0; i<len; ++i) {
        printf("%x%x", (encrypt_string[i] >> 4) & 0xf, 
                encrypt_string[i] & 0xf);    
    }
    printf("
");
    printf("decrypted string = %s
", decrypt_string);
 
    return 0;
}

运行结果截图

RSA

代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <openssl/bn.h>
#include <openssl/rsa.h>
 
int main(int argc, char** argv) {
    RSA* rsa;
    unsigned char* input_string;
    unsigned char* encrypt_string;
    unsigned char* decrypt_string;
    int i;
 
    if (argc != 2) {
        fprintf(stderr, "%s <plain text>
", argv[0]);
        exit(-1);
    }
 
    input_string = (unsigned char*)calloc(strlen(argv[1]) + 1, sizeof(unsigned char));
    if (input_string == NULL) {
        fprintf(stderr, "Unable to allocate memory for input_string
");
        exit(-1);
    }
    strncpy((char*)input_string, argv[1], strlen(argv[1]));
 
    
    rsa = RSA_generate_key(1024, 3, NULL, NULL);
        
    // set encryption RSA instance (with only n and e), to resemble
    // the key distribution process
    unsigned char* n_b = (unsigned char*)calloc(RSA_size(rsa), 
            sizeof(unsigned char));
    unsigned char* e_b = (unsigned char*)calloc(RSA_size(rsa), 
            sizeof(unsigned char));
    int n_size = BN_bn2bin(rsa->n, n_b);
    int b_size = BN_bn2bin(rsa->e, e_b);
    // assume the byte strings are sent over the network
    RSA* encrypt_rsa = RSA_new();
    encrypt_rsa->n = BN_bin2bn(n_b, n_size, NULL);
    encrypt_rsa->e = BN_bin2bn(e_b, b_size, NULL);
 
    // alloc encrypt_string
    encrypt_string = (unsigned char*)calloc(RSA_size(encrypt_rsa), 
            sizeof(unsigned char));    
    if (encrypt_string == NULL) {
        fprintf(stderr, "Unable to allocate memory for encrypt_string
");
        exit(-1);
    }
 
    // encrypt (return the size of the encrypted data)
    // note that if RSA_PKCS1_OAEP_PADDING is used, 
    // flen must be < RSA_size - 41 
    int encrypt_size = RSA_public_encrypt(strlen((char*)input_string),
            input_string, encrypt_string, encrypt_rsa, RSA_PKCS1_OAEP_PADDING);
 
    // alloc decrypt_string
    decrypt_string = (unsigned char*)calloc(RSA_size(rsa), 
            sizeof(unsigned char));
    if (decrypt_string == NULL) {
        fprintf(stderr, "Unable to allocate memory for decrypt_string
");
        exit(-1);
    }
 
    // decrypt
    int decrypt_size = RSA_private_decrypt(encrypt_size,
            encrypt_string, decrypt_string, rsa, RSA_PKCS1_OAEP_PADDING);
 
    // print
    printf("input_string = %s
", input_string);
    printf("encrypted string = ");
    for (i=0; i<encrypt_size; ++i) {
        printf("%x%x", (encrypt_string[i] >> 4) & 0xf, 
                encrypt_string[i] & 0xf);    
    }
    printf("
");
    printf("decrypted string (%d) = %s
", decrypt_size, decrypt_string);
     
    return 0;
}

运行结果截图

MD5

代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <openssl/md5.h>
 
int main(int argc, char** argv) {
    MD5_CTX hash_ctx;
    char input_string[128];
    unsigned char hash_ret[16];
    int i;
 
    // check usage
    if (argc != 2) {
        fprintf(stderr, "%s <input string>
", argv[0]);
        exit(-1);
    }
 
    // set the input string
    snprintf(input_string, sizeof(input_string), "%s
", argv[1]);
 
    // initialize a hash context 
    MD5_Init(&hash_ctx);
 
    // update the input string to the hash context (you can update
    // more string to the hash context)
    MD5_Update(&hash_ctx, input_string, strlen(input_string));
 
    // compute the hash result
    MD5_Final(hash_ret, &hash_ctx);
 
    // print
    printf("Input string: %s", input_string);
    printf("Output string: ");
    for (i=0; i<32; ++i) {
        if (i % 2 == 0) {
            printf("%x", (hash_ret[i/2] >> 4) & 0xf);
        } else {
            printf("%x", (hash_ret[i/2]) & 0xf);
        }
    }
    printf("
");
 
    return 0;
}

运行结果截图

任务二

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

服务器端代码

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <openssl/ssl.h>
#include <openssl/err.h>

#define MYPORT 155212

int main(int argc, char **argv)
{
    int sockfd, new_fd;
    socklen_t len;
    struct sockaddr_in my_addr, their_addr;
    char buffer[BUFSIZ];
    SSL_CTX *ctx;
    
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();
    ctx = SSL_CTX_new(SSLv23_server_method());
    if (ctx == NULL)
    {
        ERR_print_errors_fp(stdout);
        exit(1);
    }
    if (SSL_CTX_use_certificate_file(ctx, "cacert.pem", SSL_FILETYPE_PEM) <= 0)
    {
        ERR_print_errors_fp(stdout);
        exit(1);
    }
    if (SSL_CTX_use_PrivateKey_file(ctx, "privkey.pem", 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);
    }
    if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket");
        exit(1);
    }
    else
        printf("socket created
");

    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
");

    if (listen(sockfd, 5) == -1)
    {
        perror("listen");
        exit(1);
    }

    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("accept client %s
", inet_ntoa(their_addr.sin_addr));

        ssl = SSL_new(ctx);
        SSL_set_fd(ssl, new_fd);
        if (SSL_accept(ssl) == -1)
        {
            perror("accept");
            close(new_fd);
            break;
        }

        int length, i;
        long wordscount=0;
		int flag=1;

		while(1){
			bzero(buffer, BUFSIZ);
			if((length=SSL_read(ssl, buffer, BUFSIZ))>0){
				for(i=0; i<len; i++){
					if(flag==0){
						switch(buffer[i]){
							case ' ':
								wordscount++;
								break;
							case '
':
								wordscount++;
								break;
							case '
':
								wordscount++;
								break;
							default:
								break;
						}
					}
					if(buffer[i]== ' ' || buffer[i]=='
' || buffer[i]=='
') flag=1;
					else flag=0;
				}
			}
			if(length<1024) break;
		}

        len = SSL_write(ssl, &wordscount, sizeof(long));

        SSL_shutdown(ssl);
        SSL_free(ssl);
        close(new_fd);
    }
    close(sockfd);
    SSL_CTX_free(ctx);
    return 0;
}

客户端代码

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <openssl/ssl.h>
#include <openssl/err.h>

#define MYPORT 155212

void ShowCerts(SSL * ssl)
{
    X509 *cert;
    char *line;

    cert = SSL_get_peer_certificate(ssl);
    if (cert != NULL)
    {
        printf("num cert messsage:
");
        line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
        printf("cert: %s
", line);
        free(line);
        line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
        printf("Issuer: %s
", line);
        free(line);
        X509_free(cert);
    }
    else
        printf("no cert message 
");
}

int main(int argc, char **argv)
{
    int sockfd, len;
    struct sockaddr_in dest;
    char buffer[BUFSIZ];
    SSL_CTX *ctx;
    SSL *ssl;

    
    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);
    }

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("Socket");
        exit(errno);
    }

    bzero(&dest, sizeof(dest));
    dest.sin_family = AF_INET;
    dest.sin_port = htons(MYPORT);
    if (inet_aton("127.0.0.1", (struct in_addr *) &dest.sin_addr.s_addr) == 0)
    {
        perror("127.0.0.1");
        exit(errno);
    }
    if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0)
    {
        perror("Connect ");
        exit(errno);

    }

    ssl = SSL_new(ctx);
    SSL_set_fd(ssl, sockfd);

    if (SSL_connect(ssl) == -1)
        ERR_print_errors_fp(stderr);

    FILE *fp;
    char path[20];
    gets(path);
    fp=fopen(path, "r");
    char readch;
    int i=0;
    bzero(buffer, BUFSIZ);
    while((readch=fgetc(fp))!=EOF){
        if(i<1024){
            buffer[i]=readch;
            i++;
        }
        else{
            i=0;
            int n=SSL_write(ssl, buffer, 1024);
        }
    }
    fclose(fp);
    if(i!=0) SSL_write(ssl, buffer, i);

    long wordscount;
    bzero(buffer, BUFSIZ);
    SSL_read(ssl, &wordscount, sizeof(long));
    printf("%ld
", wordscount);

    SSL_shutdown(ssl);
    SSL_free(ssl);
    close(sockfd);
    SSL_CTX_free(ctx);
    return 0;
}

运行结果截图

参考资料

查看全文

相关阅读:
二测试组织
 如何编写测试计划
 C#三种字符串拼接方法的效率对比
 CSS内容溢出时，显示省略号
 JQuery文件上传控件Uploadify文档
 LINQ to Entities 不识别方法“Boolean Like(System.String, System.String)”，因此该方法无法转换为存储表达式。
Linux 各目录的作用
 服务器注释事项
 资料：mnist.pkl.gz数据包的下载以及数据内容解释
 RockPaperScissorsLizardSpock Python实现

原文地址：https://www.cnblogs.com/dky20155212/p/8045285.html

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

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

OpenSSL简介

对称加密算法

非对称加密算法

信息摘要算法

密钥和证书管理

SSL和TLS协议

应用程序

Engine机制

辅助功能

Heartbleed漏洞简介

实验内容

任务一

AES

RSA

MD5

任务二

参考资料

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

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