sodiumTest

client4.c (6184B)

---

 #! /usr/bin/env sheepy
 
 /*
 client4 and server4 are following request/response model.
 
 Steps in client
 - load key
 - connect to server
 - generate nonce
 - send command, public key and nonce. Command is the first byte,
   0 to request server public key,
   1 to send first encrypted message directly
 - store remote public key
 - send encrypted message
 - get encrypted response
 
 Steps in server
 - generate keys
 - start event loop
 - store remote session public key
 - check identity with signature
 - send signature, identity public key, session public key, nonce
 - get encrypted message
 - send encrypted response
 
 This version uses secret/symetric key encryption after the key exchange.
 
 For more nonce randomness, the server can provide the first nonce with the public keys when the session opens
 
 >> when sending large amount of data, use stream functions
 >> use aead functions only if there are metadata
 >> privelege separation: have a seperate process with the secrets
 >> to change id: sign id public key, sign id public key and signature and the new id public key with the new id key
 
 */
 
 #include "libsheepyObject.h"
 
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netdb.h>
 #include <netinet/in.h>
 
 #include "sel.h"
 
 int main(int ac, char **av) {
 
   setLogMode(LOG_FUNC);
 
   if (not selInit()) ret 1;
 
   // generate keys
   bool isKnownServer                      = no;
   const char* clientSecretFilename        = "client4Secret.bin";
   const char* clientPublicFilename        = "client4Public.bin";
   bool sendClientIdToServer               = yes;
 
   // load client key if possible
   if (isPath(clientPublicFilename)) {
     logI("Client already has a session key");
     pError0(bLReadFile(clientSecretFilename, keys.secretKey, sizeof(keys.secretKey)));
     pError0(bLReadFile(clientPublicFilename, keys.publicKey, sizeof(keys.publicKey)));
   }
   else {
     newKeys();
     pError0(writeFile(clientSecretFilename, keys.secretKey, sizeof(keys.secretKey)));
     pError0(writeFile(clientPublicFilename, keys.publicKey, sizeof(keys.publicKey)));
   }
   newSignKeys();
 
 	char *msg = "Hello";
 
 	logI("message: %s\n", msg);
 
 
   // connect to server
   int sock;
   struct sockaddr_in server;
   struct hostent *hp;
   int mysock;
   char buf[128*1024];
   int rval;
 
   void connectToServer(void) {
     sock = socket(AF_INET, SOCK_STREAM, 0);
     if (sock < 0){
       perror("Failed to create socket");
     }
 
     server.sin_family = AF_INET;
 
     hp = gethostbyname(av[1]);
     if (hp==0) {
       perror("gethostbyname failed");
       close(sock);
       exit(1);
     }
 
     memcpy(&server.sin_addr, hp->h_addr, hp->h_length);
     server.sin_port = htons(5000);
 
     if (connect(sock,(struct sockaddr *) &server, sizeof(server))){
       perror("connect failed");
       close(sock);
       exit(1);
     }
   }
   connectToServer();
 
   void snd(void *buf, size_t sz) {
     logVarG(sz);
     if(send(sock, buf, sz, 0) < 0){
       perror("send failed");
       close(sock);
       exit(1);
     }
   }
 
   void rcv(void *buf, size_t sz) {
     while (sz > 0) {
       rval = recv(sock, buf, sz, MSG_WAITALL);
       if (rval < 0) {
         perror("reading message");
         exit(1);
       }
       else if (rval == 0) {
         logI("Ending connection");
         close(sock);
         exit(0);
       }
       sz -= rval;
     }
     logVarG(rval);
   }
 
   // send public key
   // store remote public key
   void getServerPublicKey(void) {
 	  randombytes_buf(keys.nonce, sizeof(keys.nonce));
     u8 exchange[1 + sizeof(keys.publicKey) + sizeof(keys.nonce)] = init0Var;
     memcpy(exchange + 1, &keys.publicKey, sizeof(keys.publicKey));
     memcpy(exchange + 1 + sizeof(keys.publicKey), &keys.nonce, sizeof(keys.nonce));
     snd(exchange, sizeof(exchange));
 
     u8 serverInfo[sizeof(keys.remotePublicKey)] = init0Var;
     rcv(serverInfo, sizeof(serverInfo));
 
     memcpy(keys.remotePublicKey, serverInfo, sizeof(keys.remotePublicKey));
 
     logD("Remote public key");
     loghex(keys.remotePublicKey, sizeof(keys.remotePublicKey));
     put;
 
     // key exchange
     if (not computeSharedKeys(CLIENT_SESSION_KEYS)) {
       logE("Invalid server key");
       exit(1);
     }
   }
 
   getServerPublicKey();
 
   // send encrypted message
   // *nonce is incremented by after sending or receiving a message
   // *nonce is allowed to wrap from the max value
   u64 *nonce = (u64*)keys.nonce;
   logVarG(*nonce);
   int len = selEncrypt(buf, sizeof(buf), msg, strlen(msg));
   inc *nonce;
 
   logVarG(len);
 
   snd(&len, sizeof(len));
   snd(buf, len);
 
   // get encrypted response
   rcv(&len, sizeof(len));
   rcv(buf, len);
 
 	u8 decrypted[1000];
   logVarG(*nonce);
   len = selDecrypt(decrypted, sizeof(decrypted), buf, len);
   inc *nonce;
 
   if (!len) {
     logE("failed to decrypt");
     ret 1;
   }
 
   decrypted[len] = 0;
 
   logI("decrypted: %s", decrypted);
 
   close(sock);
 
 
   //////////////////////////////////////////
   // second session, server public is known
   {
   msg = "Second client session";
   connectToServer();
 
   // send public key
 	randombytes_buf(keys.nonce, sizeof(keys.nonce));
   u8 exchange[1 + sizeof(keys.publicKey) + sizeof(keys.nonce)] = init0Var;
   // command 1 send encrypted message directly
   exchange[0] = 1;
   memcpy(exchange + 1, &keys.publicKey, sizeof(keys.publicKey));
   memcpy(exchange + 1 + sizeof(keys.publicKey), &keys.nonce, sizeof(keys.nonce));
   snd(exchange, sizeof(exchange));
 
   // key exchange
   if (not computeSharedKeys(CLIENT_SESSION_KEYS)) {
     logE("Invalid server key");
     exit(1);
   }
 
   // send encrypted message
   // *nonce is incremented by after sending or receiving a message
   // *nonce is allowed to wrap from the max value
   u64 *nonce = (u64*)keys.nonce;
   logVarG(*nonce);
   int len = selEncrypt(buf, sizeof(buf), msg, strlen(msg));
   inc *nonce;
 
   logVarG(len);
 
   snd(&len, sizeof(len));
   snd(buf, len);
 
   // get encrypted response
   rcv(&len, sizeof(len));
   rcv(buf, len);
 
 	u8 decrypted[1000];
   logVarG(*nonce);
   len = selDecrypt(decrypted, sizeof(decrypted), buf, len);
   inc *nonce;
 
   if (!len) {
     logE("failed to decrypt");
     ret 1;
   }
 
   decrypted[len] = 0;
 
   logI("decrypted: %s", decrypted);
 
   close(sock);
   }
 
 }
 // vim: set expandtab ts=2 sw=2: