Skip to content

Recipe: Hardened Cryptographic Links with Noise (cais.noise)

This recipe demonstrates how to establish an end-to-end encrypted, mutually authenticated channel between two processes using cais.noise and cais.socket.

Unlike TLS, there are no certificates, certificate authorities, or complex configuration files. Each party is identified solely by a 32-byte Curve25519 public key.


C89 Implementation: Hardened TCP Client & Server

Both peers perform the standard Noise_XX handshake (mutual authentication with identity hiding), followed by framed, encrypted message transfers.

Server (server.c)

#include <stdio.h>
#include <string.h>
#include <cais/cais.h>

int main(void)
{
    char err[128];
    unsigned char server_priv[32], server_pub[32];
    cais_socket_t *listener, *client_sock;
    cais_noise_t *noise;
    unsigned char buf[1024];
    size_t received = 0;

    /* Generate or load persistent server keypair */
    cais_noise_keygen(server_priv, server_pub, err, sizeof(err));

    /* Bind TCP listener on port 9000 */
    listener = cais_socket_bind("0.0.0.0", 9000, 5, CAIS_SOCK_BLOCKING, err, sizeof(err));
    if (!listener) {
        fprintf(stderr, "Bind failed: %s\n", err);
        return 1;
    }
    printf("Server listening for Noise connections on port 9000...\n");

    client_sock = cais_socket_accept(listener, NULL, NULL, err, sizeof(err));
    if (!client_sock) {
        fprintf(stderr, "Accept failed: %s\n", err);
        return 1;
    }

    /* Initialize Noise_XX responder session */
    noise = cais_noise_create(CAIS_NOISE_XX, CAIS_NOISE_RESPONDER, err, sizeof(err));
    cais_noise_set_static_key(noise, server_priv, err, sizeof(err));
    cais_noise_start(noise, err, sizeof(err));

    /* Execute automated framed handshake over TCP socket */
    if (cais_noise_handshake_socket(noise, client_sock, err, sizeof(err)) != CAIS_OK) {
        fprintf(stderr, "Handshake failed: %s\n", err);
        return 1;
    }
    printf("Noise handshake completed successfully!\n");

    /* Authenticate remote peer's static key against an authorized list */
    {
        const unsigned char *client_pub = cais_noise_get_remote_static(noise);
        printf("Client authenticated with public key: ");
        for (int i = 0; i < 32; i++) printf("%02x", client_pub[i]);
        printf("\n");
    }

    /* Receive encrypted, authenticated payload */
    if (cais_noise_recv_socket(noise, client_sock, buf, sizeof(buf) - 1, &received, err, sizeof(err)) == CAIS_OK) {
        buf[received] = '\0';
        printf("Received secure payload: '%s'\n", (char *)buf);

        /* Send encrypted echo response */
        cais_noise_send_socket(noise, client_sock, "ACK: Message received securely", 30, err, sizeof(err));
    }

    cais_noise_free(noise);
    cais_socket_close(client_sock);
    cais_socket_close(listener);
    return 0;
}

Client (client.c)

#include <stdio.h>
#include <string.h>
#include <cais/cais.h>

int main(void)
{
    char err[128];
    unsigned char client_priv[32], client_pub[32];
    cais_socket_t *sock;
    cais_noise_t *noise;
    unsigned char reply[1024];
    size_t reply_len = 0;

    /* Generate or load client keypair */
    cais_noise_keygen(client_priv, client_pub, err, sizeof(err));

    sock = cais_socket_connect("127.0.0.1", 9000, CAIS_SOCK_BLOCKING, err, sizeof(err));
    if (!sock) {
        fprintf(stderr, "Connect failed: %s\n", err);
        return 1;
    }

    /* Initialize Noise_XX initiator session */
    noise = cais_noise_create(CAIS_NOISE_XX, CAIS_NOISE_INITIATOR, err, sizeof(err));
    cais_noise_set_static_key(noise, client_priv, err, sizeof(err));
    cais_noise_start(noise, err, sizeof(err));

    /* Perform automated framed handshake */
    if (cais_noise_handshake_socket(noise, sock, err, sizeof(err)) != CAIS_OK) {
        fprintf(stderr, "Handshake failed: %s\n", err);
        return 1;
    }

    /* Send secure payload */
    cais_noise_send_socket(noise, sock, "Secret payload from C89 client", 30, err, sizeof(err));

    /* Receive secure response */
    if (cais_noise_recv_socket(noise, sock, reply, sizeof(reply) - 1, &reply_len, err, sizeof(err)) == CAIS_OK) {
        reply[reply_len] = '\0';
        printf("Server replied: '%s'\n", (char *)reply);
    }

    cais_noise_free(noise);
    cais_socket_close(sock);
    return 0;
}

Lua Implementation: Fast 1-RTT WireGuard Pattern (Noise_IK)

In scenarios where the client already has the server's static public key pre-configured, Noise_IK allows establishing the authenticated session in a single network round-trip (1 RTT):

local cais = require("cais")
local noise = cais.noise
local socket = cais.socket

-- 1. Helper function to frame messages with uint16 big-endian length prefix
local function send_frame(sock, data)
    local len = #data
    local hdr = string.char(math.floor(len / 256), len % 256)
    sock:send(hdr .. data)
end

local function recv_frame(sock)
    local hdr = sock:recv(2)
    if not hdr or #hdr < 2 then return nil, "eof" end
    local len = hdr:byte(1) * 256 + hdr:byte(2)
    return sock:recv(len)
end

-- 2. Client Side: Connect and perform 1-RTT handshake
local function run_client(server_pub)
    local c_priv, c_pub = noise.keygen()
    local sock = socket.connect("127.0.0.1", 9001)

    local client = noise.create({
        pattern = "IK",
        role = "initiator",
        private_key = c_priv,
        remote_key = server_pub
    })

    -- Message 1: -> e, es, s, ss (Client sends encrypted identity in 1st packet)
    local m1 = client:write_message()
    send_frame(sock, m1)

    -- Message 2: <- e, ee, se (Server confirms)
    local m2 = recv_frame(sock)
    client:read_message(m2)

    assert(client:is_complete())
    print("Channel secured in 1 RTT!")

    -- Transmit encrypted payload
    local ciphertext = client:encrypt("Fast encrypted record")
    send_frame(sock, ciphertext)

    sock:close()
end