API Reference

git clone https://github.com/tlabs-technology/sml.git
cd sml
make          # → build/libsml.a
make test     # run test suite

CFLAGS  += -I/path/to/sml/include
LDFLAGS += -L/path/to/sml/build -lsml

/* 1. Generate identities */
sml_identity_t alice, bob;
sml_identity_generate(&alice);
sml_identity_generate(&bob);

/* 2. Bob publishes a prekey bundle */
sml_prekey_bundle_t bundle;
sml_prekey_bundle_generate(&bob, &bundle);

/* 3. Alice opens a session with Bob's bundle */
sml_session_t alice_session;
sml_session_init(&alice_session, &alice);
sml_x3dh_initiate(&alice_session, &bundle);

/* 4. Alice encrypts */
uint8_t ciphertext[SML_MAX_MSG];
size_t  ct_len;
sml_encrypt(&alice_session,
            (const uint8_t *)"hello", 5,
            ciphertext, &ct_len);

/* 5. Transmit ciphertext to Bob ... */
/* 6. Bob decrypts (session established from init message) */
uint8_t plaintext[SML_MAX_MSG];
size_t  pt_len;
sml_decrypt(&bob_session, ciphertext, ct_len, plaintext, &pt_len);

/* Generate a new identity keypair */
sml_result_t sml_identity_generate(sml_identity_t *out);

/* Serialize / deserialize */
sml_result_t sml_identity_export(const sml_identity_t *id,
                                   uint8_t *buf, size_t *len);
sml_result_t sml_identity_import(sml_identity_t *out,
                                   const uint8_t *buf, size_t len);

/* Destroy — zeroes all key material */
void         sml_identity_free(sml_identity_t *id);

/* Generate a signed prekey bundle for publication */
sml_result_t sml_prekey_bundle_generate(const sml_identity_t *id,
                                        sml_prekey_bundle_t  *out);

/* Initiator: consume remote bundle, produce init message */
sml_result_t sml_x3dh_initiate(sml_session_t         *s,
                               const sml_prekey_bundle_t *bundle);

/* Responder: process init message, derive same shared secret */
sml_result_t sml_x3dh_respond  (sml_session_t         *s,
                               const sml_init_message_t  *msg);

/* Retrieve the serialized init message for transmission */
sml_result_t sml_session_get_init_msg(const sml_session_t *s,
                                     sml_init_message_t *out);

/* Initialize a new session bound to an identity */
sml_result_t sml_session_init(sml_session_t         *s,
                              const sml_identity_t    *id);

/* Destroy a session — zeroes all ratchet state */
sml_result_t sml_session_free   (sml_session_t *s);

/* Serialize session state to opaque buffer (for storage) */
sml_result_t sml_session_serialize(const sml_session_t *s,
                                   uint8_t *buf, size_t *len);

/* Restore session from serialized buffer */
sml_result_t sml_session_deserialize(sml_session_t *s,
                                     const uint8_t  *buf, size_t len);

/* Query session state */
sml_state_t  sml_session_state(const sml_session_t *s);

/*
 * sml_encrypt — encrypt plaintext using current ratchet state.
 *
 * ciphertext must be at least (pt_len + SML_OVERHEAD) bytes.
 * SML_OVERHEAD = 96 (header 32B + tag 16B + padding 48B max)
 */
sml_result_t sml_encrypt(sml_session_t *s,
                         const uint8_t  *plaintext,  size_t  pt_len,
                               uint8_t  *ciphertext, size_t *ct_len);

/*
 * sml_decrypt — decrypt ciphertext and advance ratchet.
 *
 * Handles out-of-order messages within the skipped-key window
 * (default: SML_MAX_SKIP = 512 messages).
 */
sml_result_t sml_decrypt(sml_session_t *s,
                         const uint8_t  *ciphertext, size_t  ct_len,
                               uint8_t  *plaintext,  size_t *pt_len);

.package(url: "https://github.com/tlabs-technology/sml-swift.git",
         from: "1.0.0")

import SML

let alice = try SMLIdentity()
let bundle = try alice.generatePrekeyBundle()

var session = try SMLSession(identity: alice)
try session.initiateX3DH(with: bundle)

let ciphertext = try session.encrypt(Data("hello".utf8))

dependencies {
    implementation("technology.tlabs:sml-kotlin:1.0.0")
}

import SML from './sml.js';

const sml = await SML();
const alice = sml.identity_generate();
const bundle = sml.prekey_bundle_generate(alice);
const session = sml.session_init(alice);
sml.x3dh_initiate(session, bundle);