Exploitation responsable d'un produit de chatbot pour adultes : liste de contrôle pour les développeurs

Qui est responsable de quoi

Pensez à la pile en deux couches. L'API sert du contenu adulte légal, de la fiction et des sujets controversés sans refus, pour les utilisateurs âgés de 18 ans et plus. Tout ce qui entoure le modèle, les personnes qui y ont accès, les règles qu'elles acceptent et ce qui se passe en cas de problème, vous appartient. Cette séparation est libérante, mais uniquement si vous prenez votre part au sérieux.

Voici un tableau récapitulatif des responsabilités à afficher.

Préoccupation	Plateforme	Votre application
Contenu sexuel impliquant des mineurs	Toujours bloqué (403)	L'expliquer, mettre fin à la scène, empêcher les contournements
Âge de vos utilisateurs	Réservé aux adultes selon les conditions	Filtrer et vérifier à l'entrée
Règles internes au-delà de la loi	Non appliqué	Rédiger, publier et faire respecter les règles
Abus par utilisateur	300 requêtes par minute par clé	Limites par utilisateur et par jour
Clé secrète	La délivre	Gardez-la sur votre serveur

Il s'agit de conseils techniques, pas de conseils juridiques ; les règles varient selon les lieux, donc vérifiez les exigences là où vos utilisateurs vivent.

Vérification de l'âge qui fonctionne réellement

Une bannière avec un bouton « J'ai 18 ans » est le minimum, et un mineur déterminé peut cliquer dessus. Cela reste important, car cela enregistre une déclaration affirmative et maintient l'honnêteté de votre politique. La clé est là où vous l'imposez. Si la vérification se contente de masquer le chat dans le navigateur, n'importe qui peut appeler votre endpoint directement. Faites en sorte que le serveur refuse de répondre tant qu'un marqueur signé n'existe pas.

Copyimport crypto from "node:crypto";

// Minimal 18+ gate: the user must confirm before the chat routes work.
// Replace the confirmation with a real verification step when your market requires it.
const SECRET = process.env.GATE_SECRET;   // random string kept on the server

function sign(value) {
  return crypto.createHmac("sha256", SECRET).update(value).digest("hex");
}

export function issueAdultCookie(res, userId) {
  const stamp = String(Date.now());
  const payload = `${userId}.${stamp}`;
  res.cookie("adult_ok", `${payload}.${sign(payload)}`, {
    httpOnly: true, sameSite: "strict", secure: true, maxAge: 30 * 24 * 3600 * 1000,
  });
}

export function requireAdult(req, res, next) {
  const raw = req.cookies?.adult_ok || "";
  const [userId, stamp, sig] = raw.split(".");
  if (!sig || sign(`${userId}.${stamp}`) !== sig) {
    return res.status(403).json({ state: "age_required" });
  }
  req.userId = userId;
  next();
}

Ajoutez requireAdult devant chaque route de chat. Ajoutez une vérification plus stricte lorsque votre marché ou votre niveau de risque l'exige, comme une vérification d'âge par un tiers, et gardez le marqueur assez éphémère pour que vous puissiez re-prompter. Ne ciblez jamais les étudiants ou les écoles dans votre marketing, et placez le portail avant que tout contenu adulte ne soit affiché, y compris les aperçus et les conversations d'exemple.

Rédaction de votre propre politique de contenu

Le modèle n'accepte pas le contenu adulte légal, donc vous décidez ce que votre produit autorise. Une politique d'une page suffit. Couvrez ce qui est bienvenu, ce qui est hors limites dans votre communauté même si c'est légal (par exemple le harcèlement de personnes réelles ou le doxxing), comment les utilisateurs peuvent signaler des problèmes, et quelles actions vous entreprenez : avertissements, silences temporaires, bannissements.

1. Publiez-la là où les utilisateurs s'inscrivent, dans un langage clair.
2. Mettez-la en miroir dans votre prompt système. Une ligne telle que « Tous les personnages sont des adultes ; mettez fin à toute scène qui devient non consensuelle ou implique des personnes réelles nommées » garde le bot aligné sur vos règles.
3. Rendez l'application des règles ennuyeuse. Définissez les seuils à l'avance pour que les modérateurs n'improvisent pas.
4. Révisez la politique tous les trimestres à mesure que votre produit évolue.

Un chemin de signalement accessible aux utilisateurs

Fournissez à chaque message un petit contrôle de signalement, et faites-le fonctionner sans détour de connexion. Lorsqu'un utilisateur signale une réponse, capturez le minimum nécessaire pour agir : l'identifiant de l'utilisateur, l'identifiant du message, une courte raison et un horodatage. Acheminez-le vers une file d'attente surveillée par vos modérateurs.

Copyapp.post("/api/report", requireAdult, express.json(), (req, res) => {
  const { messageId, reason } = req.body;
  // Store only what you need to act on: who, which message, why, when.
  queueForModerator({ userId: req.userId, messageId, reason: String(reason).slice(0, 500), at: Date.now() });
  res.json({ ok: true });
});

Gardez vos promesses limitées. Dites aux utilisateurs exactement ce qu'un signalement déclenche, et ne stockez que ce que votre propre politique et les règles applicables exigent. Révisez la durée de conservation des signalements, et supprimez-les selon un calendrier. Accusez réception de chaque signalement à la personne qui l'a déposé, même avec un simple message de remerciement, car les utilisateurs cessent de signaler quand rien ne semble se passer. Suivez la rapidité avec laquelle vos modérateurs clôturent les éléments, et fixez-vous un objectif que vous pouvez réellement atteindre.

Conception pour le blocage 403 des mineurs

Le contenu sexuel impliquant des mineurs est toujours bloqué, y compris dans la fiction et le jeu de rôle, et l'API répond avec un 403 et le code content_blocked. Ne le réessayez pas et n'essayez pas de reformuler pour le compte de l'utilisateur. Traitez-le plutôt comme un moment produit qui mérite une conception claire.

• Traduisez-le côté serveur dans un état que votre interface utilisateur connaît, afin que le texte brut de l'amont n'atteigne jamais l'écran.
• Dites ce qui s'est passé en une phrase calme et nommez la règle.
• Terminez ou réinitialisez la scène. L'option « continuer quand même » annule l'intérêt.
• Journalisez l'événement avec l'identifiant utilisateur afin que les tentatives répétées puissent déclencher vos propres mécanismes de contrôle.
• Ne devinez pas l'intention. Certains blocages proviennent de formulations ambiguës ; le message neutre convient aux deux cas.

Copy// server: translate upstream outcomes into states your UI understands
if (upstream.status === 403) {
  return res.status(403).json({
    state: "content_blocked",
    message: "That request breaks our rules, so we can't continue this scene.",
  });
}
if (upstream.status === 402) return res.status(503).json({ state: "paused" });
if (upstream.status === 503) return res.status(503).json({ state: "busy" });

Copy// browser: show a calm, specific message for each state
const MESSAGES = {
  content_blocked: "This scene can't continue. Sexual content involving minors is never allowed. Start a new chat any time.",
  age_required: "Please confirm you are 18 or older to use the chat.",
  slow_down: "You're sending messages quickly. Give it a few seconds.",
  daily_limit: "You've reached today's message allowance. Come back tomorrow.",
  paused: "Chat is briefly unavailable. We're on it.",
  busy: "The service is busy. Try again in a moment.",
};

async function send(messages) {
  const res = await fetch("/api/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ messages }),
  });
  if (!res.ok) {
    const info = await res.json().catch(() => ({}));
    showBanner(MESSAGES[info.state] || "Something went wrong.");
    if (info.state === "content_blocked") endCurrentScene();
    return null;
  }
  return res;
}

Contrôle des abus et des débits par utilisateur

Votre unique clé API autorise 300 requêtes par minute au total, partagées par tous les utilisateurs. Un compte automatisé peut asphyxier les autres, donc imposez des limites d'utilisation équitable vous-même, bien en deçà de ce plafond. L'exemple limite chaque utilisateur à 12 messages par minute et lui alloue un budget quotidien de tokens mesuré à partir de la valeur usage dans le dernier chunk de streaming.

Copyconst WINDOW_MS = 60_000;
const PER_USER_PER_MIN = 12;       // your product rule, far below the key's 300
const DAILY_TOKEN_BUDGET = 60_000; // per user, tracked from the usage chunk

const hits = new Map();            // userId -> array of timestamps
const spent = new Map();           // userId -> tokens used today

export function userLimit(req, res, next) {
  const now = Date.now();
  const recent = (hits.get(req.userId) || []).filter((t) => now - t < WINDOW_MS);
  if (recent.length >= PER_USER_PER_MIN) {
    return res.status(429).json({ state: "slow_down" });
  }
  if ((spent.get(req.userId) || 0) >= DAILY_TOKEN_BUDGET) {
    return res.status(429).json({ state: "daily_limit" });
  }
  recent.push(now);
  hits.set(req.userId, recent);
  next();
}

export function recordUsage(userId, totalTokens) {
  spent.set(userId, (spent.get(userId) || 0) + totalTokens);
}

Pour la production, stockez les compteurs dans un magasin partagé plutôt qu'en mémoire de processus, afin que les limites survivent aux redémarrages et fonctionnent sur plusieurs serveurs. Ajoutez une limite max_tokens modeste à chaque requête pour borner le pire cas, et surveillez les erreurs 402 sur votre solde. Un crédit d'essai gratuit de $0,50 pendant 7 jours est un bon moyen de tester ces contrôles avant l'arrivée du trafic réel.

Conservez la clé sur le serveur

Ne livrez jamais la clé dans les bundles front-end, les applications mobiles ou les dépôts publics. Stockez-la en tant que variable d'environnement ou dans un gestionnaire de secrets, chargez-la uniquement dans votre backend et excluez-la des journaux et des rapports d'erreur. Si vous suspectez une exposition, régénérez-la depuis votre compte ; l'ancienne clé devient immédiatement invalide, donc préparez un déploiement. Rappelez-vous qu'il n'y a qu'une seule clé par compte, ce qui rend une couche proxy encore plus précieuse. Le tutoriel de chat web montre le schéma de bout en bout, et la documentation liste les codes d'erreur que votre wrapper doit mapper.

Liste de contrôle avant le lancement

Parcourez cette liste la veille de l'ouverture. Chaque élément prend quelques minutes et évite une catégorie de problèmes douloureux à corriger après l'arrivée des utilisateurs.

1. Essayez de briser le portail. Appelez votre route de chat avec curl et sans cookie. Elle doit répondre 403 avec age_required, jamais une réponse du modèle.
2. Déclenchez chaque état. Simulez le service amont pour retourner 402, 403, 429 et 503 à tour de rôle, et confirmez que chaque affichage montre la bonne bannière et ne fuit jamais de texte d'erreur brut.
3. Lisez votre propre politique à haute voix. Si un modérateur ne peut pas décider d'un cas à partir de celle-ci en une minute, serrez le texte.
4. Testez le bouton de signalement depuis un écran de téléphone. Un contrôle difficile d'accès ne compte pas comme un chemin de signalement.
5. Recherchez la clé dans votre dépôt. Cherchez dans les dossiers front-end, les sorties de compilation, les configurations d'exemple et l'historique des commits. Régénérez-la si vous la trouvez n'importe où en public.
6. Configurez les alertes. Pagez-vous en cas d'erreur 402, d'un pic de blocages 403 provenant d'un seul utilisateur et d'une augmentation de l'utilisation quotidienne de tokens.
7. Préparez l'interrupteur de pause. Un seul indicateur qui désactive le chat proprement est inestimable lors d'un incident.

La sécurité n'est jamais terminée, et la liste non plus ; ajoutez des éléments chaque fois qu'un incident vous enseigne quelque chose de nouveau, et partagez-les avec quiconque rejoint votre équipe. Revisitez la liste lorsque vous ajoutez des fonctionnalités telles que les téléchargements d'images dans votre propre interface, les salles de groupe ou le partage public de personnages, car chacune ouvre de nouvelles voies d'abus. Pour aider à façonner les personnages eux-mêmes, lisez le guide de conception des personas, et gardez les bases de vos notes d'intégration dans la documentation à portée de main à mesure que votre équipe grandit.