Aller au contenu
FR

REST API v1

Des liens à usage unique depuis votre code.

Créez des secrets et des demandes depuis votre application, votre helpdesk ou un script. L’API est disponible avec les forfaits Pro et Pro Plus.

Créer une clé API Forfaits avec API

Authentification

Créez une clé API dans Mon compte → API. Envoyez-la dans l’en-tête Authorization comme jeton Bearer. Toutes les requêtes passent par HTTPS.

Authorization: Bearer kx_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

GET https://kriptano.com/api/v1/me

La limite de requêtes dépend du forfait (Pro 60/min, Pro Plus 300/min). Les secrets créés sont décomptés du quota mensuel du forfait.

Créer un secret

Le plus simple : envoyez le texte en clair via HTTPS – le serveur le chiffre avec le même algorithme que le navigateur, ne conserve pas la clé et renvoie le lien complet avec la clé.

curl -X POST https://kriptano.com/api/v1/secrets \
  -H "Authorization: Bearer $KRIPTANO_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "secret": "User: anna\nPassword: Gx7!pQ2m",
    "expires": 604800,
    "views": 1,
    "passphrase": "",
    "label": "Hosting – client Smith",
    "notify": true
  }'

Réponse (201) :

{
  "id": "7GkQ2mPzr9XtWbHa",
  "url": "https://kriptano.com/s/7GkQ2mPzr9XtWbHa/#k9Xv3…Qe1s",
  "status": "active",
  "views": 0,
  "max_views": 1,
  "expires_at": "2026-11-13T09:00:00+00:00"
}
ChampDescription
secretTexte secret (jusqu’à ~90 000 caractères).
filesFacultatif : [{"name","type","data"(base64)}] – pièces jointes, si le forfait les permet.
expiresDurée de vie en secondes : 3600, 86400, 259200, 604800, 1209600, 2592000, 7776000, 15552000, 31536000 (dans la limite du forfait).
viewsNombre d’ouvertures (1 par défaut).
passphraseFacultatif : phrase secrète supplémentaire que le destinataire doit saisir.
labelLibellé interne (visible par vous seul ; n’y mettez pas de données secrètes).
notifytrue = notification par e-mail à l’ouverture du secret.
uploadsFacultatif : [{"id","token"}] – pièces jointes volumineuses déjà envoyées (voir Pièces jointes volumineuses) ; uniquement avec ciphertext.
deliver_toFacultatif (Pro, Pro Plus) : jusqu’à 5 adresses auxquelles Kriptano envoie aussitôt le lien par e-mail. Fonctionne lorsque vous envoyez le texte en clair (secret).
deliver_noteFacultatif : court message au destinataire (500 caractères max., sans HTML). N’y mettez pas de données confidentielles – le message n’est pas chiffré.

Pour un zero-knowledge complet, chiffrez de votre côté (section suivante) – le serveur ne voit alors jamais le texte en clair ni la clé.

Générateur de mots de passe

GET ou POST /password renvoie des mots de passe, phrases de passe ou codes PIN aléatoires. Fonctionne avec tous les forfaits : sans clé API (limité par adresse IP) ou avec une clé sur Pro et Pro Plus (limite de votre forfait). Rien n’est stocké ni journalisé ; la réponse comporte Cache-Control: no-store. Pour une confidentialité maximale, générez dans le navigateur sur la page Générateur de mot de passe.

curl "https://kriptano.com/api/v1/password?length=20&count=3"

curl "https://kriptano.com/api/v1/password?type=passphrase&words=6&separator=-&capitalize=first&wordlist=fr&format=text"

Réponse (201) :

{
  "type": "password",
  "passwords": ["q7#Vt9…", "…", "…"],
  "password": "q7#Vt9…",
  "length": 20,
  "entropy_bits": 131.1,
  "strength": "very_strong",
  "charset_size": 94
}
ChampDescription
typepassword (par défaut), passphrase, pin ou pronounceable.
lengthLongueur : password 4–128 (20), pin 4–12 (6), pronounceable 6–64 (18).
countCombien générer à la fois : 1–100.
lowercase, uppercase, numbers, symbolsJeux de caractères (true/false ; tous activés par défaut). Au moins un caractère de chaque jeu activé.
symbol_set, extended_symbols, exclude, exclude_similarVotre propre liste de symboles, symboles étendus, caractères à exclure, sans caractères semblables (I l 1 | O 0 o).
min_numbers, min_symbols, start_with_letterMinimum de chiffres et de symboles (1 par défaut), premier caractère une lettre.
words, separator, capitalize, include_number, include_symbol, wordlistPhrase de passe : 3–20 mots, séparateur (- . _ space none digit symbol), capitalize (none, first, upper, random), chiffre et symbole, liste de mots en, de, fr, it, es, bcms ou sl.
formatjson (par défaut) ou text – un mot de passe par ligne.

Générer et envoyer en un seul appel : "generate" au lieu de "secret" dans POST /secrets (Pro, Pro Plus). Le serveur crée le mot de passe, le chiffre comme secret à usage unique et renvoie le lien et le mot de passe (sauf "return_password": false).

curl -X POST https://kriptano.com/api/v1/secrets \
  -H "Authorization: Bearer $KRIPTANO_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "generate": { "type": "password", "length": 24 }, "expires": 86400, "views": 1, "deliver_to": ["anna@client.com"] }'

→ { "id": "…", "url": "https://kriptano.com/s/…#…", "password": "…", "status": "active", … }

Limites sans clé : 30 requêtes par minute et 1 000 par jour par adresse IP (HTTP 429 en cas de dépassement). Avec une clé : 60 (Pro) ou 300 (Pro Plus) par minute.

Chiffrer de votre côté

Format : AES-256-GCM, clé de 32 octets, IV de 12 octets, texte chiffré = "v1." + base64url(IV) + "." + base64url(texte chiffré+tag). Le contenu est un JSON {"v":1,"t":"texte"}. Le jeton « auth » = base64url(SHA-256(clé ‖ "kriptano-auth")). Recommandé : le champ « link » = base64url(SHA-256(clé ‖ "kriptano-link")) – preuve de possession du lien ; sans lui, une phrase secrète erronée consomme des tentatives même pour qui ne connaît que l’identifiant.

// Node.js 18+ / browser (Web Crypto)
const te = new TextEncoder();
const b64u = (b) => Buffer.from(b).toString('base64url');
const raw = crypto.getRandomValues(new Uint8Array(32));          // key – stays with you
const iv  = crypto.getRandomValues(new Uint8Array(12));
const key = await crypto.subtle.importKey('raw', raw, 'AES-GCM', false, ['encrypt']);
const body = te.encode(JSON.stringify({ v: 1, t: 'Password: Gx7!pQ2m' }));
const ct  = new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, body));
const auth = b64u(new Uint8Array(await crypto.subtle.digest('SHA-256',
  new Uint8Array([...raw, ...te.encode('kriptano-auth')]))));

const res = await fetch('https://kriptano.com/api/v1/secrets', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.KRIPTANO_KEY}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({ ciphertext: `v1.${b64u(iv)}.${b64u(ct)}`, auth, expires: 86400, views: 1 })
}).then(r => r.json());

console.log(res.url + '#' + b64u(raw));   // link for the recipient

Avec une phrase secrète : clé finale = PBKDF2-SHA256(phrase, sel = clé du lien, 600 000 itérations, 32 octets) ; utilisez-la pour chiffrer et calculer « auth », et ajoutez "passphrase": true, "kdf": 600000 à la requête.

Liste, statut et suppression

GET    https://kriptano.com/api/v1/secrets?status=active&page=1&per_page=25
GET    https://kriptano.com/api/v1/secrets/{id}
DELETE https://kriptano.com/api/v1/secrets/{id}

La réponse ne contient que des métadonnées (statut, nombre d’ouvertures, dates) – jamais le contenu. Le nombre total figure dans l’en-tête X-Total-Count.

<?php
$ch = curl_init( 'https://kriptano.com/api/v1/secrets' );
curl_setopt_array( $ch, [
  CURLOPT_POST           => true,
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER     => [ 'Authorization: Bearer ' . getenv( 'KRIPTANO_KEY' ), 'Content-Type: application/json' ],
  CURLOPT_POSTFIELDS     => json_encode( [ 'secret' => 'PIN: 4821', 'expires' => 3600 ] ),
] );
$res = json_decode( curl_exec( $ch ), true );
echo $res['url'];

Pièces jointes volumineuses (jusqu’à 10 Go)

Les petites pièces jointes peuvent être envoyées dans le champ files (base64, jusqu’à 25 Mo, chiffrées par le serveur). Les fichiers plus volumineux sont chiffrés de votre côté par fragments et envoyés directement vers le stockage via des liens signés – le serveur Kriptano ne voit jamais le contenu ni la clé. Si la connexion est interrompue, demandez de nouveaux liens uniquement pour les fragments manquants.

POST https://kriptano.com/kx-api/uploads            (Authorization: Bearer kx_live_…)
{ "files": [ { "size": 734003200 } ] }
→ { "chunk": 16777216, "tag": 16, "ttl": 10800,
    "uploads": [ { "id": "…", "token": "…", "parts": 44, "urls": [ "https://…", … ] } ] }

PUT  urls[n-1]          ← encrypted chunk n (chunk + 16 B; the last one may be shorter)
POST https://kriptano.com/kx-api/uploads/{id}/urls     { "token": "…", "parts": [7, 8] }   (new links)
POST https://kriptano.com/kx-api/uploads/{id}/complete { "token": "…" }

POST https://kriptano.com/api/v1/secrets
{ "ciphertext": "v1.…", "auth": "…", "uploads": [ { "id": "…", "token": "…" } ] }

Format : chaque fragment est chiffré en AES-256-GCM avec la clé du fichier (256 bits), nonce = 3 octets nuls ‖ index du fragment (64 bits, big-endian) ‖ 1 octet (1 pour le dernier fragment), AAD = « kriptano-file-v1 ». La clé et les données du fichier (id, nom, type, taille, taille de fragment) vont dans le contenu chiffré du secret sous la forme {"f":[{"v":2,"id","n","m","s","k","c"}]}. Implémentation de référence : assets/js/files.js.

Envoi par e-mail

Avec deliver_to, Kriptano envoie lui-même le lien au destinataire – depuis votre domaine e-mail ou via votre serveur SMTP (Pro Plus), sinon depuis une adresse Kriptano. La clé figure dans le lien : l’e-mail n’est donc envoyé que si le serveur la connaît (texte en clair) ; pour les secrets chiffrés de votre côté, envoyez le lien vous-même. La réponse contient delivered et, en cas d’échec, delivery_error – le secret est créé dans tous les cas.

POST https://kriptano.com/api/v1/secrets
{ "secret": "VPN: user / password", "expires": 86400,
  "deliver_to": [ "anna@client.com" ], "deliver_note": "Access for the new office." }
→ { "id": "…", "url": "https://…/s/…#…", "delivered": true, … }

POST https://kriptano.com/api/v1/requests
{ "label": "FTP access", "public_key": "…", "deliver_to": [ "mark@client.com" ] }

Demandes de secret

Une demande chiffre les réponses avec votre clé publique RSA. Vous générez vous-même la paire de clés ; la clé privée reste chez vous et sert à déchiffrer les réponses.

POST https://kriptano.com/api/v1/requests
{ "label": "FTP access", "instructions": "Please send the host, username and password.",
  "public_key": "<SPKI RSA-OAEP 2048, base64url>", "expires_days": 14, "max_responses": 1 }

GET  https://kriptano.com/api/v1/requests/{id}/responses
→ [ { "id": "…", "ciphertext": "r1.<RSA-OAEP(AES key)>.<iv>.<AES-GCM ciphertext>", "created_at": "…" } ]

Journal d’audit

Les événements de votre compte (Pro, Pro Plus) pour un SIEM ou un archivage : période (from, to), type, jusqu’à 500 par page. Le journal ne contient jamais le contenu des secrets, ni les clés ou les liens ; le pays provient d’une base de géolocalisation locale. Mêmes données que le CSV : Mon compte → Journal d’audit → Exporter en CSV.

GET https://kriptano.com/api/v1/log?from=2026-11-01&to=2026-11-30&type=secret_viewed&page=1&per_page=100
→ [ { "id": 812, "time": "2026-11-08T09:14:02+00:00", "type": "secret_viewed", "event": "Secret opened",
      "user": null, "country": "HR", "object_id": "…", "message": "…" } ]      (X-Total-Count: 37)

Webhooks

Pro et Pro Plus : ajoutez une URL HTTPS dans Mon compte → Webhooks et choisissez les événements. Kriptano envoie un POST JSON juste après l’événement ; le contenu du secret, la clé et le lien ne sont jamais inclus (le serveur ne les possède pas).

Événements : secret.created, secret.viewed, secret.locked, secret.deleted, secret.expired, request.created, request.answered, team.member_joined, team.member_removed, ping.

POST https://example.com/hooks/kriptano
Content-Type: application/json; charset=utf-8
Kriptano-Event: secret.viewed
Kriptano-Delivery: evt_3kT9…
Kriptano-Signature: t=1762770000,v1=5f2c…e91a

{ "id": "evt_3kT9…", "type": "secret.viewed", "created": "2026-11-10T09:14:02Z",
  "data": { "secret": { "id": "Qm7x…", "label": "Hosting – client Smith", "status": "burned",
            "views": 1, "max_views": 1, "has_passphrase": true, "files": false, "source": "web",
            "created_at": "…", "expires_at": "…", "viewed_at": "…" },
            "viewer": { "country": "HR" } } }

Vérifiez la signature : le HMAC-SHA256 de « t.body » avec le secret whsec_… doit être égal à v1, et t ne doit pas dater de plus de 5 minutes. Utilisez le corps brut de la requête (avant l’analyse JSON).

// Node.js
const crypto = require('crypto');
function verify(rawBody, header, secret) {           // header = req.headers['kriptano-signature']
  const p = Object.fromEntries(header.split(',').map(s => s.split('=')));
  if (Math.abs(Date.now() / 1000 - Number(p.t)) > 300) return false;
  const mac = crypto.createHmac('sha256', secret).update(p.t + '.' + rawBody).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(mac), Buffer.from(p.v1));
}

# PHP
$p = []; parse_str(str_replace(',', '&', $_SERVER['HTTP_KRIPTANO_SIGNATURE']), $p);
$ok = abs(time() - (int) $p['t']) <= 300
   && hash_equals(hash_hmac('sha256', $p['t'] . '.' . file_get_contents('php://input'), $secret), $p['v1']);

Répondez avec un statut 2xx en moins de 10 secondes. En cas d’erreur ou de délai dépassé, nous réessayons après 1 min, 5 min, 30 min, 2 h, 6 h et 12 h ; le statut 410 arrête la livraison. Après 50 échecs consécutifs, le webhook est désactivé. Un même événement peut arriver deux fois – utilisez le champ id (Kriptano-Delivery) pour dédoublonner.

Erreurs

HTTPDescription
400Données non valides (message dans le champ "message").
401Clé API manquante ou non valide.
402Le forfait n’inclut pas l’API.
403Limite du forfait dépassée (durée de vie, nombre d’ouvertures, pièces jointes).
404 / 410Le secret n’existe pas, a été ouvert ou a expiré.
413Le contenu est trop volumineux.
429Trop de requêtes ou quota mensuel épuisé.

Intégrations

Quand utiliser l’API REST

L’intégration s’adresse aux équipes qui envoient des mots de passe depuis leurs propres systèmes : un helpdesk qui envoie un mot de passe temporaire, un CRM qui transmet des identifiants à un nouveau client ou un script qui envoie un lien à usage unique après la mise en service d’un serveur.

Vous pouvez chiffrer le secret vous-même (Web Crypto, AES-256-GCM – voir la documentation MDN) et n’envoyer que le texte chiffré, ou envoyer le texte en clair via HTTPS : le serveur le chiffre au même format et ne conserve jamais la clé.

Créez une clé API dans Mon compte avec les forfaits Pro et Pro Plus (comparer les forfaits). Les secrets créés sont décomptés du quota mensuel du forfait.

La réponse contient le lien avec la clé après le #, la date d’expiration et le nombre d’ouvertures restantes. Vous transmettez le lien à l’utilisateur comme n’importe quel autre – par e-mail, message ou dans l’interface de votre application. Lorsque l’utilisateur ouvre le secret, le texte chiffré est supprimé et votre liste de secrets l’indique comme ouvert.

Une demande de secret fonctionne dans l’autre sens : votre système crée un lien où le client saisit les données, et la réponse est chiffrée avec une clé publique que vous avez générée de votre côté. Les réponses restent ainsi illisibles pour tout le monde, sauf pour vous.

  1. API REST Kriptano – secret, chiffrement, lien et ouverture uniqueSaisissez le secret
  2. Chiffré dans le navigateurChiffré dans le navigateur
  3. Envoyez le lienEnvoyez le lien
  4. Ouvert une fois, puis effacéOuvert une fois, puis effacé