init

server.cpp

@@ -0,0 +1,159 @@
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+// open ssl
+#include <openssl/conf.h>
+#include <openssl/evp.h>
+#include <openssl/err.h>
+
+#include <errno.h>  // for perror()
+#include <unistd.h> // for close()
+
+#include <string>
+#include <cstring>
+#include <cstdlib> // for atoi()
+#include <vector>
+
+// load environment variables from .env file, and additional helper functions
+#include "helper.h"
+
+using std::string;
+using std::vector;
+
+int main(void)
+{
+    printf("Server starting...\n");
+    load_env(".env");
+
+    // Declare variables
+    const char *server_ip = getenv("SERVER_IP");
+    const int server_port = atoi(getenv("SERVER_PORT"));
+    char client_message[2048];
+    char server_message[2048];
+    const char *custom_message_success = "Server: Hello from server, message authenticated!\n";
+    const char *custom_message_failed = "Server: Hello from server, message failed authentication!\n";
+
+    // debug
+    printf("Server starting at IP: %s, Port: %d\n", server_ip, server_port);
+
+    // Create socket
+    const int server_socket = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_socket == -1)
+    {
+        perror("Failed to create socket");
+        return 1;
+    }
+
+    // Bind to the set port and IP
+    struct sockaddr_in server_addr;
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_port = htons(server_port);
+    inet_pton(AF_INET, server_ip, &server_addr.sin_addr);
+
+    if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1)
+    {
+        perror("Failed to bind socket");
+        close(server_socket);
+        return 1;
+    }
+    printf("Done with binding with IP: %s, Port: %d\n", server_ip, server_port);
+
+    // Listen for clients:
+    const char *client_ip = getenv("CLIENT_IP");
+    if (listen(server_socket, 1) == -1)
+    {
+        perror("Failed to listen on socket");
+        close(server_socket);
+        return 1;
+    }
+    printf("Listening for incoming connections...\n");
+
+    // Accept an incoming connection
+    struct sockaddr_in client_addr;
+    socklen_t client_addr_len = sizeof(client_addr);
+    int client_socket = accept(server_socket, (struct sockaddr *)&client_addr, &client_addr_len);
+    if (client_socket == -1)
+    {
+        perror("Failed to accept connection");
+        close(server_socket);
+        return 1;
+    }
+    printf("Client connected at IP: %s \n", client_ip);
+
+    // clean exising buffer
+    memset(client_message, 0, sizeof(client_message));
+
+    // store message history, for HMAC calculation
+    // msg on odd is msg, and on even is corresponding HMAC
+    vector<string> message_history;
+
+    // Receive client's message
+    while (1)
+    {
+        // clean exising buffer
+        memset(client_message, 0, sizeof(client_message));
+
+        ssize_t n = recv(client_socket, client_message, sizeof(client_message), 0);
+        if (n == 0)
+            break;
+        if (n < 0)
+        {
+            perror("recv");
+            break;
+        }
+
+        if (strcmp((char *)client_message, "\\exit\n") == 0)
+            break;
+
+        printf("Msg from client: %s \n", byte_to_hex((unsigned char *)client_message, n));
+        // store message history for HMAC calculation
+        message_history.push_back(string((char *)client_message, n));
+
+        // only respond after receiving both msg and HMAC
+        if (message_history.size() % 2 == 1)
+            continue;
+
+        // check HMAC
+        const string expected_hmac_str = message_history.back();
+        unsigned char expected_hmac[20];
+        memcpy(expected_hmac, expected_hmac_str.c_str(), 20);
+        const string plaintext_str = message_history[message_history.size() - 2];
+        char plaintext_cstr[2048];
+        strcpy(plaintext_cstr, plaintext_str.c_str());
+        printf("Plaintext: %s, string length: %d\n", byte_to_hex((unsigned char *)plaintext_cstr, strlen(plaintext_cstr)), strlen(plaintext_cstr));
+
+        unsigned char calculated_hmac[20];
+        memset(calculated_hmac, 0, sizeof(calculated_hmac));
+        cal_hmac(calculated_hmac, plaintext_cstr);
+
+        if (memcmp(expected_hmac, calculated_hmac, 20) != 0)
+        {
+            fprintf(stderr, "HMAC mismatch\n, expected: %s, calculated: %s\n", byte_to_hex(expected_hmac, 20), byte_to_hex(calculated_hmac, 20));
+            memcpy(server_message, custom_message_failed, strlen(custom_message_failed));
+            ;
+        }
+        else
+        {
+            memcpy(server_message, custom_message_success, strlen(custom_message_success));
+            ;
+        }
+        // Respond to client
+        // prepare server message
+
+        size_t reply_len = strlen(server_message);
+        if (send(client_socket, server_message, reply_len, 0) == -1)
+        {
+            perror("Send failed");
+            break;
+        }
+
+        printf("Response sent to client: %s\n", server_message);
+    }
+    // Close the socket
+    close(client_socket);
+    close(server_socket);
+
+    return 0;
+}