i've created a server with openssl encryption and i'm gonna test it. the server is tested with a client but somehow when i try to reconnect it back the server will crash in the second time. please help me.
/* Client Side */
- Code: Select all
sufi@NL-4869:~$ cd Desktop/Working/Finish\ Today/
sufi@NL-4869:~/Desktop/Working/Finish Today$ ls
ChangeLogs client client.c MultiServer.bak1 MultiServer.bak3 server.c
ChangeLogs~ client.bak1 MultiServer MultiServer.bak2 MultiServer.c
sufi@NL-4869:~/Desktop/Working/Finish Today$ ./client
Enter PEM pass phrase:
Connected with AES256-SHA encryption
Server certificates:
Subject: /C=MY/ST=Kulim/L=Kulim/O=MIMOS/OU=MIMOS/CN=mohana/[email protected]
Issuer: /C=MY/ST=Kulim/L=Kulim/O=MIMOS/OU=MIMOS/CN=mohana/[email protected]
Received: "Siap Harini"
Received Data from dostuff: "Siap Harini"
sufi@NL-4869:~/Desktop/Working/Finish Today$ ./client
Enter PEM pass phrase:
sufi@NL-4869:~/Desktop/Working/Finish Today$ /*Second time no result??!! *
/* Server Side */
- Code: Select all
sufi@NL-4869:~$ cd Desktop/Working/Finish\ Today/
sufi@NL-4869:~/Desktop/Working/Finish Today$ ls
ChangeLogs client client.c MultiServer.bak1 MultiServer.bak3 server.c
ChangeLogs~ client.bak1 MultiServer MultiServer.bak2 MultiServer.c
sufi@NL-4869:~/Desktop/Working/Finish Today$ ./MultiServer
Enter PEM pass phrase:
pid=2693
Connection: 127.0.0.1:32808
Server certificates:
Subject: /C=MY/ST=Kulim/L=Kulim/O=MIMOS/OU=MIMOS/CN=mohana/[email protected]
Issuer: /C=MY/ST=Kulim/L=Kulim/O=MIMOS/OU=MIMOS/CN=mohana/[email protected]
Client msg: "client-192.168.1.1
"
read from socket: client-192.168.1.1
received buffer - mohana: client-192.168.1.1pid=2695
Connection: 127.0.0.1:32809
Segmentation fault (core dumped)
sufi@NL-4869:~/Desktop/Working/Finish Today$
The Code for server.c
- Code: Select all
/* A simple server in the internet domain using TCP
The port number is passed as an argument
This version runs forever, forking off a separate
process for each connection
gcc server2.c -lsocket
*/
#include <stdio.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <resolv.h>
#include "openssl/ssl.h"
#include "openssl/err.h"
#define MAXBUF 1024
#define FAIL -1
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void dostuff(int,int, SSL*); /* function prototype */
void error(char *msg)
{
perror(msg);
exit(1);
}
SSL_CTX* InitServerCTX(void)
{ SSL_METHOD *method;
SSL_CTX *ctx;
OpenSSL_add_all_algorithms(); /* load & register all cryptos, etc. */
SSL_load_error_strings(); /* load all error messages */
method = SSLv3_server_method(); /* create new server-method instance */
ctx = SSL_CTX_new(method); /* create new context from method */
if ( ctx == NULL )
{
ERR_print_errors_fp(stderr);
abort();
}
return ctx;
}
void LoadCertificates(SSL_CTX* ctx, char* CertFile, char* KeyFile)
{
//New lines
if (SSL_CTX_load_verify_locations(ctx, CertFile, KeyFile) != 1)
ERR_print_errors_fp(stderr);
if (SSL_CTX_set_default_verify_paths(ctx) != 1)
ERR_print_errors_fp(stderr);
//End new lines
/* set the local certificate from CertFile */
if (SSL_CTX_use_certificate_file(ctx, CertFile, SSL_FILETYPE_PEM) <= 0)
{
ERR_print_errors_fp(stderr);
abort();
}
/* set the private key from KeyFile (may be the same as CertFile) */
if (SSL_CTX_use_PrivateKey_file(ctx, KeyFile, SSL_FILETYPE_PEM) <= 0)
{
ERR_print_errors_fp(stderr);
abort();
}
/* verify private key */
if (!SSL_CTX_check_private_key(ctx))
{
fprintf(stderr, "Private key does not match the public certificate\n");
abort();
}
//New lines - Force the client-side have a certificate
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);
SSL_CTX_set_verify_depth(ctx, 4);
//End new lines
}
void ShowCerts(SSL* ssl)
{ X509 *cert;
char *line;
cert = SSL_get_peer_certificate(ssl); /* Get certificates (if available) */
if ( cert != NULL )
{
printf("Server certificates:\n");
line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
printf("Subject: %s\n", line);
free(line);
line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
printf("Issuer: %s\n", line);
free(line);
X509_free(cert);
}
else
printf("No certificates.\n");
}
int main(int argc, char *argv[])
{
SSL_CTX *ctx;
//int server =0;
int sockfd, newsockfd, portno, clilen, pid;
struct sockaddr_in serv_addr, cli_addr;
char CertFile[] = "/home/sufi/OpenSSL/myCA/newkey/clientcert.pem";
char KeyFile[] = "/home/sufi/OpenSSL/myCA/newkey/client.pem";
SSL_library_init();
ctx = InitServerCTX(); /* initialize SSL */
LoadCertificates(ctx, CertFile, KeyFile); /* load certs */
/* Creating Socket */
/*if (argc < 2) {
fprintf(stderr,"ERROR, no port provided\n");
exit(1);
}*/
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
error("ERROR opening socket");
bzero((char *) &serv_addr, sizeof(serv_addr));
portno = 5000;
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);
if (bind(sockfd, (struct sockaddr *) &serv_addr,
sizeof(serv_addr)) < 0)
error("ERROR on binding");
listen(sockfd,5);
signal(SIGCHLD,SIG_IGN);
clilen = sizeof(cli_addr);
// server = OpenListener(5000);
/* while (1)
{ struct sockaddr_in addr;
socklen_t len = sizeof(addr);
SSL *ssl;
// int client = accept(server, (struct sockaddr*)&addr, &len);
int client = accept(sockfd, (struct sockaddr*)&addr, &len);
printf("Connection: %s:%d\n",inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
ssl = SSL_new(ctx);
SSL_set_fd(ssl, client);
Servlet(ssl);
}
//close(server);
close(sockfd);
SSL_CTX_free(ctx); */
/* Creating Threadable Socket */
while (1) {
//Need to convert the normal socket into OpenSSL socket after newsockfd launch
SSL *ssl;
newsockfd = accept(sockfd,
(struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0)
error("ERROR on accept");
pid = fork();
if (pid < 0)
error("ERROR on fork");
if (pid == 0) {
close(sockfd);
while(1)
{
// In the dostuff need to change the read/write into ssl read write
// dostuff(newsockfd,pid);
printf("Connection: %s:%d\n",inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
ssl = SSL_new(ctx);
SSL_set_fd(ssl, newsockfd);
//Servlet(ssl);
dostuff(newsockfd,pid,ssl);
}
exit(0);
}
else
{
printf("pid=%d\n",pid);
close(newsockfd);
SSL_CTX_free(ctx);
}
}
/* end of while */
return 0; /* we never get here */
}
/* Finish Creating Socket */
// assume that length of a line will not exceed MAXBUF
// assume that buf has length MAXBUF
ssize_t readline(int sock, char *sockBuff, int *len, char *buff, SSL* ssl)
{
int sockBuffLen = *len;
int hasNewLine = 0;
int buffLen = 0;
char reply_client[1024];
while (!hasNewLine)
{
int i;
// copy from sockBuff to buff, until either
// 1. new line is detected
// 2. end of sockBuff
for (i = 0; i < sockBuffLen; i++)
{
if (sockBuff[i] == 13)
{
buff[buffLen] = '\0';
if ((i+1 < sockBuffLen) && (sockBuff[i+1] == 10))
i++;
hasNewLine = 1;
break;
}
else if (sockBuff[i] == 10)
{
buff[buffLen] = '\0';
hasNewLine = 1;
break;
}
else
{
buff[buffLen] = sockBuff[i];
buffLen++;
}
}
if (hasNewLine)
{
// shift unread characters in buf to the front
memmove(sockBuff, sockBuff+i+1, sockBuffLen-i-1);
sockBuffLen = sockBuffLen-i-1;
}
else
{
// end of sockBuff, need to get new data from socket
if ( SSL_accept(ssl) == FAIL ) /* do SSL-protocol accept */
ERR_print_errors_fp(stderr);
else
{
ShowCerts(ssl); /* get any certificates */
sockBuffLen = SSL_read(ssl, sockBuff, MAXBUF); /* get request */
if ( sockBuffLen > 0 )
{
sockBuff[sockBuffLen] = 0;
printf("Client msg: \"%s\"\n", sockBuff);
sprintf(reply_client, "Siap Harini", sockBuff); /* construct reply */
SSL_write(ssl, reply_client, strlen(reply_client)); /* send reply */
}
else
ERR_print_errors_fp(stderr);
}
//sockBuffLen = read(sock, sockBuff, MAXBUF);
if (sockBuffLen <= 0)
return sockBuffLen;
}
}
printf("Read from SOCKET: %s\n", buff);
*len = sockBuffLen;
return buffLen;
SSL_free(ssl); /* release SSL state */
}
/******** DOSTUFF() *********************
There is a separate instance of this function
for each connection. It handles all communication
once a connnection has been established.
*****************************************/
void dostuff (int sock,int pid, SSL* ssl)
{
int dscp;
// int n=0,dscp,len,i,a,camCount=1,ln,count=0;
// char test[MAXBUF]={0};
char buffer[MAXBUF];
char sockBuffer[MAXBUF];
int sockBufferLen = 0;
// char buffer2[MAXBUF]={0};
// char buff[MAXBUF]={0};
// char buff2[MAXBUF]={0};
// char *p,ch;
char getCommand[MAXBUF]={0};
char output[MAXBUF]={0};
// char instruct[MAXBUF]={0};
char warning[MAXBUF]={0};
char res[MAXBUF]={0};
// char ipCam[MAXBUF]={0};
char *pch, *camIP,*ac;
FILE *result;
readline(sock, sockBuffer, &sockBufferLen, buffer, ssl);
printf("Received buffer: %s",buffer);
// exit(1);
while(readline(sock, sockBuffer, &sockBufferLen, buffer, ssl)>0)
{
//printf("start again\n");
if (strstr(buffer,"client")!=NULL)
{
snprintf(getCommand, 1024, "bash /home/mimos/clientMACIP.sh");
result = popen(getCommand,"r");
if(result == NULL)
{
printf("Failed to run command\n");
}
else
{
while(fgets(res,sizeof(res),result) != NULL)
{
strcat(output,res);
}
}
memset(getCommand,'\0',sizeof(getCommand));
memset(buffer,'\0',sizeof(buffer));
fflush(stdin);
strcat(output,"\n");
/*.........................SENDING..........................*/
SSL_write(ssl, output, sizeof(output));
//send(sock,output,sizeof(output),0);
printf("output=%s\n",output);
memset(output,'\0',sizeof(output));
memset(res,'\0',sizeof(res));
pclose(result);
}
else if (strstr(buffer,"nearby")!=NULL)
{
snprintf(getCommand, 1024, "bash /home/mimos/nearby.sh");
result = popen(getCommand,"r");
if(result == NULL)
{
printf("Failed to run command\n");
}
else
{
while(fgets(res,sizeof(res),result) != NULL)
{
strcat(output,res);
}
}
memset(getCommand,'\0',sizeof(getCommand));
memset(buffer,'\0',sizeof(buffer));
fflush(stdin);
strcat(output,"\n");
/*.........................SENDING.....................*/
SSL_write(ssl, output, sizeof(output));
//send(sock,output,sizeof(output),0);
printf("output=%s\n",output);
memset(output,'\0',sizeof(output));
memset(res,'\0',sizeof(res));
pclose(result);
}
else if (strstr(buffer,"sensors")!=NULL)
{
snprintf(getCommand, 1024, "bash /home/mimos/sensors.sh");
result = popen(getCommand,"r");
if(result == NULL)
{
printf("Failed to run command\n");
}
else
{
while(fgets(res,sizeof(res),result) != NULL)
{
strcat(output,res);
}
}
memset(getCommand,'\0',sizeof(getCommand));
memset(buffer,'\0',sizeof(buffer));
fflush(stdin);
strcat(output,"\n");
/*.........................SENDING......................*/
SSL_write(ssl, output, sizeof(output));
//send(sock,output,sizeof(output),0);
printf("output=%s\n",output);
memset(output,'\0',sizeof(output));
memset(res,'\0',sizeof(res));
pclose(result);
}
else if (strstr(buffer,"prio")!=NULL)
{
while(readline(sock, sockBuffer, &sockBufferLen, buffer, ssl)>0)
{
ac = strtok(buffer," ");
printf("ac=%s\n",ac);
camIP = strtok(NULL," ");
printf("camIP=%s\n",camIP);
if(strncmp(ac,"VO",2)==0)
{
dscp=48;
}
else if(strncmp(ac,"VI",2)==0)
{
dscp=32;
}
else if(strncmp(ac,"BE",2)==0)
{
//dscp=0;
printf("BE class\n");
}
else if(strncmp(ac,"BK",2)==0)
{
dscp=8;
}
if(strncmp(ac,"BE",2)!=0)
{
printf("other class,ac=%s, dscp=%d\n",ac,dscp);
snprintf(getCommand, sizeof(getCommand), "bash /home/mimos/changeCamPrio.sh %d %s",dscp,camIP);
}
else if(strncmp(ac,"BE",2)==0)
{
printf("BE class\n");
snprintf(getCommand, sizeof(getCommand), "bash /home/mimos/resetCamPrio.sh %s",camIP);
}
result = popen(getCommand,"r");
if(result == NULL)
{
printf("Failed to run command\n");
}
else
{
while(fgets(res,sizeof(res),result) != NULL)
{
strcat(output,res);
}
}
memset(getCommand,'\0',sizeof(getCommand));
//fflush(stdin);
strcat(output,"\n");
/*..............SENDING..................*/
SSL_write(ssl, output, sizeof(output));
//send(sock,output,sizeof(output),0);
printf("output=%s\n",output);
//fflush(stdin);
fflush(stdout);
//buff[0]='\0';
//output[0]='\0';
memset(buffer,'\0',sizeof(buffer));
memset(output,'\0',sizeof(output));
memset(res,'\0',sizeof(res));
pclose(result);
}
/* read(sock,buff,MAXBUF-1);
printf("buffer=%s,bufferLen=%d\n",buff,strlen(buff));
if(strlen(buff)==2)
{
printf("enter pressed\n");
goto start;
}*/
}
//else if(buff[0]==13&&buff[1]==10)
//break;
else if(strstr(buffer,"clear")!=NULL)
{
snprintf(getCommand, sizeof(getCommand), "bash /home/mimos/clearPrio.sh");
result = popen(getCommand,"r");
if(result == NULL)
{
printf("Failed to run command\n");
}
else
{
while(fgets(res,sizeof(res),result) != NULL){
strcat(output,res);
}
}
memset(getCommand,'\0',sizeof(getCommand));
memset(buffer,'\0',sizeof(buffer));
fflush(stdin);
strcat(output,"\n");
/*......................................SENDING....................................*/
SSL_write(ssl, output, sizeof(output));
//send(sock,output,sizeof(output),0);
printf("output=%s\n",output);
fflush(stdout);
memset(output,'\0',sizeof(output));
memset(res,'\0',sizeof(res));
pclose(result);
}
else if(strstr(buffer,"query")!=NULL)
{
pch=strtok(buffer," ");
pch=strtok(NULL, " ");
ac = pch;
if(ac[strlen(ac)-1] == '\n')
ac[strlen(ac)-1] = '\0';
if(ac[strlen(ac)-2] == 13)
ac[strlen(ac)-2] = '\0';
if(strncmp(ac,"VO",2)==0){
dscp=48;
}else if(strncmp(ac,"VI",2)==0){
dscp=32;
}
else if(strncmp(ac,"BE",2)==0){
dscp=0;
}
else if(strncmp(ac,"BK",2)==0){
dscp=8;
}else
{
snprintf(warning,sizeof(warning),"No such access category\n");
/*.........................SENDING..........................*/
SSL_write(ssl, warning, sizeof(warning));
//send(sock,warning,sizeof(warning),0);
}
printf("buffer=%s\n",buffer);
printf("ac=%s\n",ac);
printf("buffer len=%d\n",strlen(buffer));
printf("ac len=%d\n",strlen(ac));
snprintf(getCommand, sizeof(getCommand), "bash /home/mimos/queryAC.sh %d",dscp);
printf("getcom=%s\n",getCommand);
result = popen(getCommand,"r");
if(result == NULL)
{
printf("Failed to run command\n");
}
else
{
while(fgets(res,sizeof(res),result) != NULL){
strcat(output,res);
}
}
memset(getCommand,'\0',sizeof(getCommand));
memset(buffer,'\0',sizeof(buffer));
fflush(stdin);
strcat(output,"\n");
/*.........................SENDING..........................*/
SSL_write(ssl, output, sizeof(output));
//send(sock,output,sizeof(output),0);
printf("output=%s\n",output);
memset(output,'\0',sizeof(output));
memset(res,'\0',sizeof(res));
pclose(result);
}
else if(strstr(buffer,"exit")!=NULL)
{
close(sock);
}
else
{
//printf("No such command");
memset(buffer,'\0',sizeof(buffer));
//goto start;
}
fflush(stdin);
fflush(stdout);
}
//else if(strlen(buffer)==0)
// {
fflush(stdin);
fflush(stdout);
close(sock);
exit(0);
// }
}
/* Client's Code */
- Code: Select all
//client.c
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <malloc.h>
#include <string.h>
#include <sys/socket.h>
#include <resolv.h>
#include <netdb.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#define FAIL -1
//Added the LoadCertificates how in the server-side makes.
void LoadCertificates(SSL_CTX* ctx, char* CertFile, char* KeyFile)
{
/* set the local certificate from CertFile */
if ( SSL_CTX_use_certificate_file(ctx, CertFile, SSL_FILETYPE_PEM) <= 0 )
{
ERR_print_errors_fp(stderr);
abort();
}
/* set the private key from KeyFile (may be the same as CertFile) */
if ( SSL_CTX_use_PrivateKey_file(ctx, KeyFile, SSL_FILETYPE_PEM) <= 0 )
{
ERR_print_errors_fp(stderr);
abort();
}
/* verify private key */
if ( !SSL_CTX_check_private_key(ctx) )
{
fprintf(stderr, "Private key does not match the public certificate\n");
abort();
}
}
int OpenConnection(const char *hostname, int port)
{ int sd;
struct hostent *host;
struct sockaddr_in addr;
if ( (host = gethostbyname(hostname)) == NULL )
{
perror(hostname);
abort();
}
sd = socket(PF_INET, SOCK_STREAM, 0);
bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = *(long*)(host->h_addr);
if ( connect(sd, (struct sockaddr*)&addr, sizeof(addr)) != 0 )
{
close(sd);
perror(hostname);
abort();
}
return sd;
}
SSL_CTX* InitCTX(void)
{ SSL_METHOD *method;
SSL_CTX *ctx;
OpenSSL_add_all_algorithms(); /* Load cryptos, et.al. */
SSL_load_error_strings(); /* Bring in and register error messages */
method = SSLv3_client_method(); /* Create new client-method instance */
ctx = SSL_CTX_new(method); /* Create new context */
if ( ctx == NULL )
{
ERR_print_errors_fp(stderr);
abort();
}
return ctx;
}
void ShowCerts(SSL* ssl)
{ X509 *cert;
char *line;
cert = SSL_get_peer_certificate(ssl); /* get the server's certificate */
if ( cert != NULL )
{
printf("Server certificates:\n");
line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
printf("Subject: %s\n", line);
free(line); /* free the malloc'ed string */
line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
printf("Issuer: %s\n", line);
free(line); /* free the malloc'ed string */
X509_free(cert); /* free the malloc'ed certificate copy */
}
else
printf("No certificates.\n");
}
int main()
{ SSL_CTX *ctx;
int server;
SSL *ssl;
char buf[1024];
int bytes;
char hostname[]="127.0.0.1";
char portnum[]="5000";
char CertFile[] = "/home/sufi/OpenSSL/myCA/newkey/clientcert.pem";
char KeyFile[] = "/home/sufi/OpenSSL/myCA/newkey/client.pem";
SSL_library_init();
ctx = InitCTX();
LoadCertificates(ctx, CertFile, KeyFile);
server = OpenConnection(hostname, atoi(portnum));
ssl = SSL_new(ctx); /* create new SSL connection state */
SSL_set_fd(ssl, server); /* attach the socket descriptor */
if ( SSL_connect(ssl) == FAIL ) /* perform the connection */
ERR_print_errors_fp(stderr);
else
{ char *msg = "client-192.168.1.1\n";
printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
ShowCerts(ssl); /* get any certs */
SSL_write(ssl, msg, strlen(msg)); /* encrypt & send message */
bytes = SSL_read(ssl, buf, sizeof(buf)); /* get reply & decrypt */
buf[bytes] = 0;
printf("Received: \"%s\"\n", buf);
printf("Received Data from dostuff: \"%s\"\n", buf);
SSL_free(ssl); /* release connection state */
}
close(server); /* close socket */
SSL_CTX_free(ctx); /* release context */
return 0;
}
you can create the public and private keys yourself
