sodiumTest

client3.c (6245B)

---

 #! /usr/bin/env sheepy
 
 /*
 client2 and server2 are following request/response model.
 
 Steps in client
 - load session key - keep same session key for all sessions
 - connect to server
 - send signature, identity public key, session public key, write 0 for id key and signature if
   the client doesn't have an id
 - check server identity with signature, store nonce
 - store remote public key
 - send encrypted message
 - get encrypted response
 
 Steps in server
 - generate keys
 - setup bloom filter
 - 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* clientFilename              = "client3.bin";
   const char* remoteIdFilename            = "remoteId.bin";
   bool sendClientIdToServer               = yes;
 
   // load client if possible
   if (isPath(clientFilename)) {
     logI("Client already has a session key");
     pError0(bLReadFile(clientFilename, &keys, sizeof(keys)));
   }
   else {
     newKeys();
     pError0(writeFile(clientFilename, &keys, sizeof(keys)));
   }
   newSignKeys();
 
   // load server id if possible
   if (isPath(remoteIdFilename)) {
     logI("Server is known");
     pError0(bLReadFile(remoteIdFilename, remoteId, sizeof(remoteId)));
     isKnownServer = yes;
   }
 
 	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;
 
   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);
   }
 
   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) {
     u8 exchange[crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES + sizeof(keys.publicKey)] = init0Var;
     memcpy(exchange+crypto_sign_BYTES+crypto_sign_PUBLICKEYBYTES, &keys.publicKey, sizeof(keys.publicKey));
     if (not sendClientIdToServer) {
       snd(exchange, sizeof(exchange));
     }
     else {
       // send client id
       // sign keys with id key
       memcpy(exchange+crypto_sign_BYTES, &identityKeys.publicKey, sizeof(identityKeys.publicKey));
       u8 signed_message[sizeof(exchange)] = init0Var;
       unsigned long long signed_message_len = 0;
       crypto_sign(signed_message, &signed_message_len, exchange+crypto_sign_BYTES, sizeof(exchange)-crypto_sign_BYTES, identityKeys.secretKey);
       snd(signed_message, sizeof(signed_message));
     }
 
     u8 serverInfo[crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES + sizeof(keys.remotePublicKey) + crypto_box_NONCEBYTES] = init0Var;
     rcv(serverInfo, sizeof(serverInfo));
 
     // check remote server
     u8 unsigned_message[crypto_sign_PUBLICKEYBYTES + sizeof(keys.remotePublicKey) + crypto_box_NONCEBYTES] = init0Var;
     unsigned long long unsigned_message_len;
     const u8 *idPublicKey = remoteId;
     if (not isKnownServer) {
       // TOFU - trust on first use
       idPublicKey = serverInfo + crypto_sign_BYTES;
     }
 
     if (crypto_sign_open(unsigned_message, &unsigned_message_len, serverInfo, sizeof(serverInfo), idPublicKey) != 0) {
       logE("Incorrect signature!");
     }
     else {
       logP("Correct signature");
     }
 
     memcpy(keys.remotePublicKey, unsigned_message + crypto_sign_PUBLICKEYBYTES, sizeof(keys.remotePublicKey));
     memcpy(sessionKeys.nonce, unsigned_message + crypto_sign_PUBLICKEYBYTES + sizeof(keys.remotePublicKey), crypto_box_NONCEBYTES);
 
     if (not isKnownServer) {
       // store server id key
       pError0(writeFile(remoteIdFilename, (u8*)idPublicKey, crypto_sign_PUBLICKEYBYTES));
       logI("Saved server id");
     }
 
     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*)sessionKeys.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: