openSSL的應用

源碼包地址：http://www.openssl.org/source/

編譯源碼包的方法：http://blog.163.com/hancker_31/blog/static/35587361201112125736855/

實例：

資源下載：http://download.csdn.net/detail/hui523hui523hui523/4395929

1.安裝openssl庫:
  sudo sudo apt-get install libssl-dev
2.服務器端實現代碼

#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 MAXBUF 1024

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

2. 客戶端實現代碼

dfa
#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 MAXBUF 1024

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

    cert = SSL_get_peer_certificate(ssl);// 該函數可以從SSL套接字中提取對方的證書信息，這些信息已經被SSL驗證過了。
X509_NAME *X509_get_subject_name(X509 *a);
該函數得到證書所用者的名字。返回值是X509

    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());
當SSL會話環境申請成功後，還要根據實際的需要設置CTX的屬性，通常的設置是指定SSL握手階段證書的驗證方式和加載自己的證書。

    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]));//7838
if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
inet_aton是一個改進的方法來將一個字符串IP地址轉換爲一個32位的網絡序列IP地址
        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套接字
    SSL_set_fd(ssl, sockfd);// //綁定讀寫套接字
    /* 建立 SSL 連接 */
    if (SSL_connect(ssl) == -1)// 而對服務器來講，則應使用函數SSL_ accept ( )替代傳統的函數accept ( )來完成握手過程:
        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;
}

3.編譯方式:

gcc -o ssl_server ssl_server.c -Wall -g –lssl//gcc -Wall sever.c -o server -lssl -lcrypto -ldl

gcc -o ssl_client ssl_client.c -Wall -g -lssl

4.生產私鑰和證書

openssl genrsa -out privkey.pem 1024

openssl req -new -x509 -key privkey.pem -out CAcert.pem -days 1095

5.程序運行方式:

./ssl_server 7838 1 CAcert.pem privkey.pem

./ssl_client 127.0.0.1 7838

本篇文章來源於 Linux公社網站(www.linuxidc.com) 原文鏈接：http://www.linuxidc.com/Linux/2011-04/34523.htm

於OpenSSL的程序可以被分爲兩個部分：客戶機和服務器，使用SSL協議使通信雙方可以相互驗證對方身份的真實性，並且能夠保證數據的完整性和機密性。建立SSL通信的過程如圖2所示。

圖2 SSL通信過程

SSL通信模型採用標準的C/S結構，除了在TCP層上進行傳輸之外，與普通的網絡通信協議沒有太大的區別，基於OpenSSL的程序都要遵循以下幾個步驟：

(1 ) OpenSSL初始化

在使用OpenSSL之前，必須進行相應的協議初始化工作，這可以通過下面的函數實現：

int SSL_library_int(void);

(2 ) 選擇會話協議

在利用OpenSSL開始SSL會話之前，需要爲客戶端和服務器制定本次會話採用的協議，目前能夠使用的協議包括TLSv1.0、SSLv2、SSLv3、SSLv2/v3。

需要注意的是，客戶端和服務器必須使用相互兼容的協議，否則SSL會話將無法正常進行。

(3 ) 創建會話環境

在OpenSSL中創建的SSL會話環境稱爲CTX，使用不同的協議會話，其環境也

不一樣的。申請SSL會話環境的OpenSSL函數是：

SSL_CTX *SSL_CTX_new(SSL_METHOD * method);

當SSL會話環境申請成功後，還要根據實際的需要設置CTX的屬性，通常的設置是指定SSL握手階段證書的驗證方式和加載自己的證書。制定證書驗證方式的函數是：

int SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int(*verify_callback),int(X509_STORE_CTX *));

爲SSL會話環境加載CA證書的函數是：

SSL_CTX_load_verify_location(SSL_CTX *ctx,const char *Cafile,const char *Capath);

爲SSL會話加載用戶證書的函數是：

SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file,int type);

爲SSL會話加載用戶私鑰的函數是：

SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx,const char* file,int type);

在將證書和私鑰加載到SSL會話環境之後，就可以調用下面的函數來驗證私鑰和證書是否相符：

int SSL_CTX_check_private_key(SSL_CTX *ctx);

(4) 建立SSL套接字

SSL套接字是建立在普通的TCP套接字基礎之上，在建立SSL套接字時可以使用下面的一些函數：

SSL *SSl_new(SSL_CTX *ctx);

//申請一個SSL套接字

int SSL_set_fd(SSL *ssl,int fd);)

//綁定讀寫套接字

int SSL_set_rfd(SSL *ssl,int fd);

//綁定只讀套接字

int SSL_set_wfd(SSL *ssl,int fd);

//綁定只寫套接字

(5) 完成SSL握手

在成功創建SSL套接字後，客戶端應使用函數SSL_connect( )替代傳統的函數connect( )來完成握手過程:

int SSL_connect(SSL *ssl);

而對服務器來講，則應使用函數SSL_ accept ( )替代傳統的函數accept ( )來完成握手過程:

int SSL_accept(SSL *ssl);

握手過程完成之後，通常需要詢問通信雙方的證書信息，以便進行相應的驗證，這可以藉助於下面的函數來實現:

X509 *SSL_get_peer_certificate(SSL *ssl);

該函數可以從SSL套接字中提取對方的證書信息，這些信息已經被SSL驗證過了。

X509_NAME *X509_get_subject_name(X509 *a);

該函數得到證書所用者的名字。

(6) 進行數據傳輸

當SSL握手完成之後，就可以進行安全的數據傳輸了，在數據傳輸階段，需要使用SSL_read( )和SSL_write( )來替代傳統的read( )和write( )函數，來完成對套接字的讀寫操作：

int SSL_read(SSL *ssl,void *buf,int num);

int SSL_write(SSL *ssl,const void *buf,int num);

(7 ) 結束SSL通信

當客戶端和服務器之間的數據通信完成之後，調用下面的函數來釋放已經申請的SSL資源：

int SSL_shutdown(SSL *ssl);

//關閉SSL套接字

void SSl_free(SSL *ssl);

//釋放SSL套接字

void SSL_CTX_free(SSL_CTX *ctx);

//釋放SSL會話環境

4 結束語

SSL協議採用數字證書進行雙端實體認證,用非對稱加密算法進行密鑰協商,用對稱加密算法將數據加密後進行傳輸以保證數據的保密性,並且通過計算數字摘要來驗證數據在傳輸過程中是否被篡改和僞造,從而爲敏感數據在Internet上的傳輸提供了一種安全保障手段。

OpenSSL是一個開放源代碼的SSL協議的產品實現，它採用C語言作爲開發語言，具備了跨系統的性能。調用OpenSSL 的函數就可以實現一個SSL加密的安全數據傳輸通道，從而保護客戶端和服務器之間數據的安全。

本示例用多線程實現了一個ssl服務端和一個客戶端。
服務端代碼如下：
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <errno.h>
#ifndef	_WIN32
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#else
#include <winsock2.h>
#include <windows.h>
#endif
#include "pthread.h"
#include <openssl/rsa.h>
#include <openssl/crypto.h>
#include <openssl/x509.h>
#include <openssl/pem.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#define CERTF "certs/sslservercert.pem"
#define KEYF  "certs/sslserverkey.pem" 
#define	CAFILE	"certs/cacert.pem"
pthread_mutex_t	mlock=PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t *lock_cs;
static long *lock_count;
#define CHK_NULL(x) if ((x)==NULL) { printf("null\n"); }
#define CHK_ERR(err,s) if ((err)==-1) { printf(" -1 \n"); }
#define CHK_SSL(err) if ((err)==-1) {  printf(" -1 \n");}
#define	CAFILE	"certs/cacert.pem"

int  verify_callback_server(int ok, X509_STORE_CTX *ctx)
{
		printf("verify_callback_server \n");
        return ok;
}

int	SSL_CTX_use_PrivateKey_file_pass(SSL_CTX *ctx,char *filename,char *pass)
{
	EVP_PKEY	*pkey=NULL;
	BIO			*key=NULL;
	
	key=BIO_new(BIO_s_file());
	BIO_read_filename(key,filename);
	pkey=PEM_read_bio_PrivateKey(key,NULL,NULL,pass);
	if(pkey==NULL)
	{
		printf("PEM_read_bio_PrivateKey err");
		return -1;
	}
	if (SSL_CTX_use_PrivateKey(ctx,pkey) <= 0)
	{
		printf("SSL_CTX_use_PrivateKey err\n");
		return -1;
	}
	BIO_free(key);
	return 1;
}

static int s_server_verify=SSL_VERIFY_NONE;
void * thread_main(void *arg) 
{   
	SOCKET s,AcceptSocket;
	WORD wVersionRequested;
	WSADATA wsaData;
	struct sockaddr_in	service;
	int	err;
  	size_t		client_len;         												SSL_CTX		*ctx;
  	SSL		*ssl;	
  	X509		*client_cert;
  	char		*str;
  	char    	buf[1024];
  	SSL_METHOD 	*meth;
	 
	ssl=(SSL *)arg;
	s=SSL_get_fd(ssl);
	err = SSL_accept (ssl); 
  	if(err<0)
	{
		printf("ssl accerr\n");
		return ;
	}
  	printf ("SSL connection using %s\n", SSL_get_cipher (ssl));
 	client_cert = SSL_get_peer_certificate (ssl);
  	if (client_cert != NULL)
  	{
	   		printf ("Client certificate:\n");
			str = X509_NAME_oneline (X509_get_subject_name (client_cert), 0, 0);
	   		CHK_NULL(str);
	   		printf ("\t subject: %s\n", str);
	   		OPENSSL_free (str);
			str = X509_NAME_oneline (X509_get_issuer_name  (client_cert), 0, 0);
	   		CHK_NULL(str);
	   		printf ("\t issuer: %s\n", str);
	   		OPENSSL_free (str);
			X509_free (client_cert);
  	}
  	else
    		printf ("Client does not have certificate.\n");
	memset(buf,0,1024);
	err = SSL_read (ssl, buf, sizeof(buf) - 1);
	if(err<0)
	{
		printf("ssl read err\n");
		closesocket(s);
		return;
	}
	printf("get : %s\n",buf);
#if 0
  	buf[err] = '\0';
  	err = SSL_write (ssl, "I hear you.", strlen("I hear you."));  CHK_SSL(err);
#endif
  	SSL_free (ssl);
	closesocket(s);
} 

pthread_t pthreads_thread_id(void)
{
	pthread_t ret;

	ret=pthread_self();
	return(ret);
}

void pthreads_locking_callback(int mode, int type, char *file,
	     int line)
{
	if (mode & CRYPTO_LOCK)
		{
		pthread_mutex_lock(&(lock_cs[type]));
		lock_count[type]++;
		}
	else
		{
		pthread_mutex_unlock(&(lock_cs[type]));
		}
}

int main ()
{
	int			err;                	
	int			i;
	SOCKET		s,AcceptSocket;
	WORD		wVersionRequested;
	WSADATA		wsaData;
	struct sockaddr_in	service;
	pthread_t	pid;
  	size_t		client_len; 
 	SSL_CTX		*ctx;
 	SSL			*ssl;
  	X509		*client_cert;
	char		*str;
 	char    	buf[1024];
  	SSL_METHOD 	*meth;

  	SSL_load_error_strings();
  	SSLeay_add_ssl_algorithms();
  	meth = SSLv3_server_method();
  	ctx = SSL_CTX_new (meth);
  	if (!ctx) 
  	{
    		ERR_print_errors_fp(stderr);
    		exit(2);
  	}
	if ((!SSL_CTX_load_verify_locations(ctx,CAFILE,NULL)) ||
                (!SSL_CTX_set_default_verify_paths(ctx)))
    {
		printf("err\n");
		exit(1);
    }
 	if (SSL_CTX_use_certificate_file(ctx, CERTF, SSL_FILETYPE_PEM) <= 0) 
 	{
    	ERR_print_errors_fp(stderr);
    	exit(3);
  	}
  	if (SSL_CTX_use_PrivateKey_file_pass(ctx, KEYF, "123456") <= 0) 
  	{
    		ERR_print_errors_fp(stderr);
    		exit(4);
  	}
	if (!SSL_CTX_check_private_key(ctx)) 
	{
    		fprintf(stderr,"Private key does not match the certificate public key\n");
    		exit(5);
  	}
	s_server_verify=SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT|
                                SSL_VERIFY_CLIENT_ONCE;
	SSL_CTX_set_verify(ctx,s_server_verify,verify_callback_server);
	SSL_CTX_set_client_CA_list(ctx,SSL_load_client_CA_file(CAFILE));
	wVersionRequested = MAKEWORD( 2, 2 );
	err = WSAStartup( wVersionRequested, &wsaData );
	if ( err != 0 ) 
	{
		printf("err\n");       
		return -1;
	}
	s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if(s<0) return -1;
	service.sin_family = AF_INET;
	service.sin_addr.s_addr = inet_addr("127.0.0.1");
	service.sin_port = htons(1111);
	if (bind( s, (SOCKADDR*) &service, sizeof(service)) == SOCKET_ERROR) 
	{
		printf("bind() failed.\n");
		closesocket(s);
		return -1;
	}
    if (listen( s, 1 ) == SOCKET_ERROR)
		printf("Error listening on socket.\n");

	printf("recv .....\n");
	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
	lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
	for (i=0; i<CRYPTO_num_locks(); i++)
	{
		lock_count[i]=0;
		pthread_mutex_init(&(lock_cs[i]),NULL);
	}
	CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);
	CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);
	while(1)
	{
		struct timeval tv;
		fd_set fdset;
		tv.tv_sec = 1;
		tv.tv_usec = 0;
		FD_ZERO(&fdset);
		FD_SET(s, &fdset);
	    select(s+1, &fdset, NULL, NULL, (struct timeval *)&tv);
	    if(FD_ISSET(s, &fdset)) 
		{
			AcceptSocket=accept(s, NULL,NULL);
			ssl = SSL_new (ctx);       
  			CHK_NULL(ssl);
			err=SSL_set_fd (ssl, AcceptSocket);
			if(err>0)
			{
				err=pthread_create(&pid,NULL,&thread_main,(void *)ssl);
				pthread_detach(pid);
			}
			else
				continue;
		}
	}
  	SSL_CTX_free (ctx);
  	return 0;
}
客戶端代碼如下：
#include <stdio.h>
#include <memory.h>
#include <errno.h>
#ifndef	_WIN32
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#else
#include <windows.h>
#endif
#include "pthread.h"
#include <openssl/crypto.h>
#include <openssl/x509.h>
#include <openssl/pem.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#define	MAX_T 1000
#define	CLIENTCERT	"certs/sslclientcert.pem"
#define	CLIENTKEY	"certs/sslclientkey.pem"
#define	CAFILE		"certs/cacert.pem"
static pthread_mutex_t *lock_cs;
static long *lock_count;

pthread_t pthreads_thread_id(void)
{
	pthread_t ret;

	ret=pthread_self();
	return(ret);
}

void pthreads_locking_callback(int mode, int type, char *file,
	     int line)
{
	if (mode & CRYPTO_LOCK)
		{
		pthread_mutex_lock(&(lock_cs[type]));
		lock_count[type]++;
		}
	else
		{
		pthread_mutex_unlock(&(lock_cs[type]));
		}
}

int	verify_callback(int ok, X509_STORE_CTX *ctx)
{
	printf("verify_callback\n");
	return ok;
}

int	SSL_CTX_use_PrivateKey_file_pass(SSL_CTX *ctx,char *filename,char *pass)
{
	EVP_PKEY	*pkey=NULL;
	BIO			*key=NULL;
	
	key=BIO_new(BIO_s_file());
	BIO_read_filename(key,filename);
	pkey=PEM_read_bio_PrivateKey(key,NULL,NULL,pass);
	if(pkey==NULL)
	{
		printf("PEM_read_bio_PrivateKey err");
		return -1;
	}
	if (SSL_CTX_use_PrivateKey(ctx,pkey) <= 0)
	{
		printf("SSL_CTX_use_PrivateKey err\n");
		return -1;
	}
	BIO_free(key);
	return 1;
}

void	*thread_main(void *arg)
{
	int 		err,buflen,read;
  	int 		sd;
	SSL_CTX		*ctx=(SSL_CTX *)arg;
	struct 		sockaddr_in dest_sin;
	SOCKET		sock;
	PHOSTENT	phe;
	WORD		wVersionRequested;
	WSADATA		wsaData;
  	SSL			*ssl;
  	X509		*server_cert;
  	char	   	*str;
  	char		buf [1024];
  	SSL_METHOD 	*meth;
	FILE		*fp;

	wVersionRequested = MAKEWORD( 2, 2 );
	err = WSAStartup( wVersionRequested, &wsaData );
	if ( err != 0 ) 
	{
		printf("WSAStartup err\n");       
		return -1;
	}
	sock = socket(AF_INET, SOCK_STREAM, 0);
	dest_sin.sin_family = AF_INET;
	dest_sin.sin_addr.s_addr = inet_addr( "127.0.0.1" );
	dest_sin.sin_port = htons( 1111 );

again:
	err=connect( sock,(PSOCKADDR) &dest_sin, sizeof( dest_sin));
	if(err<0)
	{
		Sleep(1);
		goto again;
	}
    ssl = SSL_new (ctx);                         
	if(ssl==NULL)
	{
		printf("ss new err\n");
		return ;
	}
	SSL_set_fd(ssl,sock);
  	err = SSL_connect (ssl);                     
  	if(err<0)
	{
		printf("SSL_connect err\n");
		return;
	}
  	printf ("SSL connection using %s\n", SSL_get_cipher (ssl));
  	server_cert = SSL_get_peer_certificate (ssl);       
  	printf ("Server certificate:\n");
  	str = X509_NAME_oneline (X509_get_subject_name (server_cert),0,0);
  	printf ("\t subject: %s\n", str);
  	OPENSSL_free (str);
  	str = X509_NAME_oneline (X509_get_issuer_name  (server_cert),0,0);
  	printf ("\t issuer: %s\n", str);
  	OPENSSL_free (str);  	
  	X509_free (server_cert);
	err = SSL_write (ssl, "Hello World!", strlen("Hello World!"));
	if(err<0)
	{
		printf("ssl write err\n");
		return ;
	}
#if 0
	memset(buf,0,ONE_BUF_SIZE);
  	err = SSL_read (ssl, buf, sizeof(buf) - 1);                   
	if(err<0)
	{
		printf("ssl read err\n");
		return ;
	}
  	buf[err] = '\0';
  	printf ("Got %d chars:'%s'\n", err, buf);
#endif
  	SSL_shutdown (ssl);  /* send SSL/TLS close_notify */ 
  	SSL_free (ssl);
	closesocket(sock);
}

int	main ()
{
	int 		err,buflen,read;
  	int 		sd;

	struct 		sockaddr_in dest_sin;
	SOCKET	sock;
	PHOSTENT phe;
	WORD wVersionRequested;
	WSADATA wsaData;
  	SSL_CTX		*ctx;
  	SSL		*ssl;
  	X509		*server_cert;
  	char	   	*str;
  	char		buf [1024];
  	SSL_METHOD 	*meth;
	int		i;
	pthread_t	pid[MAX_T];
  	
  	SSLeay_add_ssl_algorithms();
  	meth = SSLv3_client_method();
  	SSL_load_error_strings();
  	ctx = SSL_CTX_new (meth);                       
	if(ctx==NULL)
	{
		printf("ssl ctx new eer\n");
		return -1;
	}

	if (SSL_CTX_use_certificate_file(ctx, CLIENTCERT, SSL_FILETYPE_PEM) <= 0)
    {
        ERR_print_errors_fp(stderr);
        exit(3);
    }
    if (SSL_CTX_use_PrivateKey_file_pass(ctx, CLIENTKEY, "123456") <= 0)
    {
         ERR_print_errors_fp(stderr);
         exit(4);
     }
	lock_cs=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
	lock_count=OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
	for (i=0; i<CRYPTO_num_locks(); i++)
	{
		lock_count[i]=0;
		pthread_mutex_init(&(lock_cs[i]),NULL);
	}
	CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);
	CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);
	for(i=0;i<MAX_T;i++)
	{		
		err=pthread_create(&(pid[i]),NULL,&thread_main,(void *)ctx);
		if(err!=0)
		{
			printf("pthread_create err\n");
			continue;
		}
	}
	for (i=0; i<MAX_T; i++)
	{
		pthread_join(pid[i],NULL);
	}
  	SSL_CTX_free (ctx);
  	printf("test ok\n");
	return 0;
}

523回

發佈了41 篇原創文章 · 獲贊 36 · 訪問量 34萬+

私信關注

x264源碼分析

VLC源代碼分析（一）

I2C驅動分析與應用程序編寫

openSSL的應用

嵌入式系統

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結