API

Uses .NET 8+ built-in crypto APIs. No external dependencies.

using System.Security.Cryptography;
using System.Text;
using System.Text.Json;

var baseUrl = "https://ifgone.io";
var accountId = "acc_xxxxxxxxxxxx";
var privateKeyPem = await File.ReadAllTextAsync("private-key.pem");

// --- 1. Sign a request (ECDSA-SHA256, P-256, DER-encoded) ---

(byte[] sig, string ts) SignRequest(string body)
{
    var ts = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
    var bodyHash = Convert.ToHexString(
        SHA256.HashData(Encoding.UTF8.GetBytes(body)))
        .ToLowerInvariant();
    var message = $"{ts}:{bodyHash}";

    using var ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP256);
    ecdsa.ImportFromPem(privateKeyPem);
    return (ecdsa.SignData(
        Encoding.UTF8.GetBytes(message),
        HashAlgorithmName.SHA256), ts);
}

// --- 2. Encrypt slot data (ECIES: ECDH + HKDF-SHA256 + AES-256-GCM) ---

EncryptedSlot EncryptSlot(string plaintext, string publicKeyPem)
{
    // Import recipient public key into ECDH
    using var ecdsaPub = ECDsa.Create();
    ecdsaPub.ImportFromPem(publicKeyPem);
    var pubParams = ecdsaPub.ExportParameters(false);

    using var recipientEcdh =
        ECDiffieHellman.Create(pubParams.Curve);
    recipientEcdh.ImportParameters(new ECParameters {
        Q = pubParams.Q, Curve = pubParams.Curve });

    // Generate ephemeral key pair
    using var eph = ECDiffieHellman.Create(
        ECCurve.NamedCurves.nistP256);

    // Derive shared secret
    var sharedSecret = eph.DeriveRawSecret(recipientEcdh.PublicKey);

    // HKDF-SHA256
    var salt = RandomNumberGenerator.GetBytes(16);
    var aesKey = HKDF.DeriveKey(HashAlgorithmName.SHA256,
        sharedSecret, 32, salt,
        Encoding.UTF8.GetBytes("ifgone-slot-encryption"));

    // AES-256-GCM
    var iv = RandomNumberGenerator.GetBytes(12);
    var ptBytes = Encoding.UTF8.GetBytes(plaintext);
    var ciphertext = new byte[ptBytes.Length];
    var tag = new byte[16];
    using var aes = new AesGcm(aesKey, 16);
    aes.Encrypt(iv, ptBytes, ciphertext, tag);

    // Export ephemeral public key (raw uncompressed point, 65 bytes)
    var ephP = eph.ExportParameters(false);
    var rawPoint = new byte[1 + ephP.Q.X!.Length + ephP.Q.Y!.Length];
    rawPoint[0] = 0x04;
    ephP.Q.X.CopyTo(rawPoint, 1);
    ephP.Q.Y.CopyTo(rawPoint, 1 + ephP.Q.X.Length);

    return new EncryptedSlot(
        Convert.ToBase64String(ciphertext.Concat(tag).ToArray()),
        Convert.ToBase64String(rawPoint),
        Convert.ToBase64String(iv),
        Convert.ToBase64String(salt));
}

record EncryptedSlot(
    string EncryptedData, string EncryptedDek,
    string Iv, string Salt);

// --- 3. Update a slot ---

// Use the public key stored locally from account creation
// (The public account lookup endpoint has been removed for security)
var publicKey = LOCAL_PUBLIC_KEY;

var encrypted = EncryptSlot("My encrypted content", publicKey);

// accountId goes in X-Account-Id header, not the body
var body = JsonSerializer.Serialize(new Dictionary<string, object> {
    ["encryptedData"] = encrypted.EncryptedData,
    ["encryptedDek"] = encrypted.EncryptedDek,
    ["iv"] = encrypted.Iv,
    ["salt"] = encrypted.Salt,
});

var (sig, ts) = SignRequest(body);
var request = new HttpRequestMessage(HttpMethod.Post,
    $"{baseUrl}/api/v1/slot/0/update");
request.Headers.Add("X-Account-Id", accountId);
request.Headers.Add("X-Signature", Convert.ToBase64String(sig));
request.Headers.Add("X-Timestamp", ts);
request.Content = new StringContent(body, Encoding.UTF8,
    "application/json");

var response = await http.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

Requires p256, aes-gcm, hkdf, sha2, reqwest, and base64 crates.

use aes_gcm::{aead::Aead, Aes256Gcm, KeyInit, Nonce};
use base64::{engine::general_purpose::STANDARD as B64, Engine};
use hkdf::Hkdf;
use p256::{
    ecdsa::{signature::Signer, DerSignature, SigningKey},
    ecdh::EphemeralSecret,
    EncodedPoint, PublicKey,
};
use rand::rngs::OsRng;
use sha2::{Digest, Sha256};

const BASE_URL: &str = "https://ifgone.io";
const ACCOUNT_ID: &str = "acc_xxxxxxxxxxxx";

// --- 1. Sign a request (ECDSA-SHA256, P-256, DER-encoded) ---

fn sign_request(
    body: &str,
    signing_key: &SigningKey,
) -> (String, String) {
    let ts = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_secs()
        .to_string();
    let body_hash = hex::encode(Sha256::digest(body.as_bytes()));
    let message = format!("{ts}:{body_hash}");

    let sig: DerSignature = signing_key.sign(message.as_bytes());
    (B64.encode(sig.to_bytes()), ts)
}

// --- 2. Encrypt slot data (ECIES: ECDH + HKDF-SHA256 + AES-256-GCM) ---

struct EncryptedSlot {
    encrypted_data: String,
    encrypted_dek: String,
    iv: String,
    salt: String,
}

fn encrypt_slot(plaintext: &str, recipient_pub: &PublicKey) -> EncryptedSlot {
    // Generate ephemeral ECDH key pair
    let eph_secret = EphemeralSecret::random(&mut OsRng);
    let eph_public = eph_secret.public_key();

    // Derive shared secret via ECDH
    let shared = eph_secret.diffie_hellman(recipient_pub);

    // HKDF-SHA256 to derive AES-256 key
    let salt: [u8; 16] = rand::random();
    let hkdf = Hkdf::<Sha256>::new(
        Some(&salt), shared.raw_secret_bytes());
    let mut aes_key = [0u8; 32];
    hkdf.expand(b"ifgone-slot-encryption", &mut aes_key).unwrap();

    // AES-256-GCM
    let iv: [u8; 12] = rand::random();
    let cipher = Aes256Gcm::new_from_slice(&aes_key).unwrap();
    let ciphertext = cipher
        .encrypt(Nonce::from_slice(&iv), plaintext.as_bytes())
        .unwrap();

    // Export ephemeral public key (raw uncompressed, 65 bytes)
    let eph_bytes = eph_public.to_encoded_point(false);

    EncryptedSlot {
        encrypted_data: B64.encode(&ciphertext),
        encrypted_dek: B64.encode(eph_bytes.as_bytes()),
        iv: B64.encode(iv),
        salt: B64.encode(salt),
    }
}

// --- 3. Update a slot (using reqwest) ---

async fn update_slot(
    slot_id: u8,
    content: &str,
    signing_key: &SigningKey,
) -> serde_json::Value {
    let client = reqwest::Client::new();

    // Use the public key stored locally from account creation
    // (The public account lookup endpoint has been removed for security)
    let pub_key: PublicKey = LOCAL_PUBLIC_KEY.parse().unwrap();

    // Encrypt and sign (accountId goes in header, not body)
    let enc = encrypt_slot(content, &pub_key);
    let body = serde_json::json!({
        "encryptedData": enc.encrypted_data,
        "encryptedDek": enc.encrypted_dek,
        "iv": enc.iv,
        "salt": enc.salt,
    });
    let body_str = serde_json::to_string(&body).unwrap();
    let (sig, ts) = sign_request(&body_str, signing_key);

    client.post(format!("{BASE_URL}/api/v1/slot/{slot_id}/update"))
        .header("X-Account-Id", ACCOUNT_ID)
        .header("X-Signature", sig)
        .header("X-Timestamp", ts)
        .header("Content-Type", "application/json")
        .body(body_str)
        .send().await.unwrap()
        .json().await.unwrap()
}

Uses JDK 17+ built-in crypto. Includes a self-contained HKDF implementation (no external dependencies required).

import java.math.BigInteger;
import java.net.URI;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.*;
import java.util.*;
import javax.crypto.*;
import javax.crypto.spec.*;

public class IfGoneApi {
    static final String BASE_URL = "https://ifgone.io";
    static final String ACCOUNT_ID = "acc_xxxxxxxxxxxx";

    // --- 1. Sign a request (ECDSA-SHA256, P-256, DER-encoded) ---

    static String[] signRequest(String body, PrivateKey signKey)
            throws Exception {
        String ts = String.valueOf(
            Instant.now().getEpochSecond());
        var sha256 = MessageDigest.getInstance("SHA-256");
        String bodyHash = hexEncode(
            sha256.digest(body.getBytes(StandardCharsets.UTF_8)));
        String message = ts + ":" + bodyHash;

        var ecdsa = Signature.getInstance("SHA256withECDSA");
        ecdsa.initSign(signKey);
        ecdsa.update(message.getBytes(StandardCharsets.UTF_8));
        String sig = Base64.getEncoder()
            .encodeToString(ecdsa.sign()); // DER-encoded by default
        return new String[] { sig, ts };
    }

    // --- 2. Encrypt slot data (ECIES: ECDH + HKDF-SHA256 + AES-256-GCM) ---

    static String[] encryptSlot(String plaintext, PublicKey recipientPub)
            throws Exception {
        // Generate ephemeral EC key pair
        var kpg = KeyPairGenerator.getInstance("EC");
        kpg.initialize(new ECGenParameterSpec("secp256r1"));
        var eph = kpg.generateKeyPair();

        // ECDH key agreement
        var ka = KeyAgreement.getInstance("ECDH");
        ka.init(eph.getPrivate());
        ka.doPhase(recipientPub, true);
        byte[] sharedSecret = ka.generateSecret();

        // HKDF-SHA256 key derivation
        byte[] salt = new byte[16];
        SecureRandom.getInstanceStrong().nextBytes(salt);
        byte[] aesKey = hkdfSha256(sharedSecret, salt,
            "ifgone-slot-encryption"
                .getBytes(StandardCharsets.UTF_8), 32);

        // AES-256-GCM
        byte[] iv = new byte[12];
        SecureRandom.getInstanceStrong().nextBytes(iv);
        var cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE,
            new SecretKeySpec(aesKey, "AES"),
            new GCMParameterSpec(128, iv));
        byte[] ctAndTag = cipher.doFinal(
            plaintext.getBytes(StandardCharsets.UTF_8));

        // Export ephemeral public key (raw uncompressed, 65 bytes)
        byte[] ephPubDer = eph.getPublic().getEncoded();
        byte[] ephPubRaw = Arrays.copyOfRange(
            ephPubDer, ephPubDer.length - 65, ephPubDer.length);

        var enc = Base64.getEncoder();
        return new String[] {
            enc.encodeToString(ctAndTag),  // encryptedData
            enc.encodeToString(ephPubRaw), // encryptedDek
            enc.encodeToString(iv),        // iv
            enc.encodeToString(salt),      // salt
        };
    }

    // HKDF-SHA256 (extract-then-expand)
    static byte[] hkdfSha256(byte[] ikm, byte[] salt,
            byte[] info, int length) throws Exception {
        // Extract: PRK = HMAC-SHA256(salt, IKM)
        var hmac = Mac.getInstance("HmacSHA256");
        hmac.init(new SecretKeySpec(
            salt.length == 0 ? new byte[32] : salt, "HmacSHA256"));
        byte[] prk = hmac.doFinal(ikm);

        // Expand: output blocks
        hmac = Mac.getInstance("HmacSHA256");
        hmac.init(new SecretKeySpec(prk, "HmacSHA256"));
        byte[] result = new byte[length];
        byte[] t = new byte[0];
        int off = 0;
        for (int i = 1; off < length; i++) {
            hmac.reset();
            hmac.update(t);
            hmac.update(info);
            hmac.update((byte) i);
            t = hmac.doFinal();
            System.arraycopy(t, 0, result, off,
                Math.min(t.length, length - off));
            off += t.length;
        }
        return result;
    }

    static String hexEncode(byte[] bytes) {
        var sb = new StringBuilder();
        for (byte b : bytes) sb.append(String.format("%02x", b));
        return sb.toString();
    }

    // --- 3. Update a slot ---

    public static void main(String[] args) throws Exception {
        var client = HttpClient.newHttpClient();

        // Load private key
        var keyPem = Files.readString(Path.of("private-key.pem"));
        var b64 = keyPem.replace("[REDACTED PRIVATE KEY]", "")
            .replaceAll("\\s", "");
        var privKey = KeyFactory.getInstance("EC")
            .generatePrivate(new PKCS8EncodedKeySpec(
                Base64.getDecoder().decode(b64)));

        // Use the public key stored locally from account creation
        // (The public account lookup endpoint has been removed for security)
        var pubB64 = LOCAL_PUBLIC_KEY_B64;
        var pubKey = KeyFactory.getInstance("EC")
            .generatePublic(new X509EncodedKeySpec(
                Base64.getMimeDecoder().decode(pubB64)));

        // Encrypt, sign, and send (accountId goes in header, not body)
        var enc = encryptSlot("My encrypted content", pubKey);
        var body = String.format(
            "{\"encryptedData\":\"%s\","
            + "\"encryptedDek\":\"%s\",\"iv\":\"%s\",\"salt\":\"%s\"}",
            enc[0], enc[1], enc[2], enc[3]);
        var sigTs = signRequest(body, privKey);

        var req = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/api/v1/slot/0/update"))
            .header("Content-Type", "application/json")
            .header("X-Account-Id", ACCOUNT_ID)
            .header("X-Signature", sigTs[0])
            .header("X-Timestamp", sigTs[1])
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        var res = client.send(req,
            HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
    }
}