ALTCHA
e CapMonster Cloud

Risoluzione dei captcha, installazione sul sito e test.

Prezzi della soluzione ALTCHA

CAPTCHA
Prezzo (USD)
$ 0.80
1000 gettoni
Hai ereditato un sito con una captcha o un'altra protezione ma senza accesso al codice sorgente? È normale chiedersi quale soluzione sia installata, se sia configurata correttamente e come testarla.

In questo articolo abbiamo cercato di rispondere a tutte le domande principali. Il primo passo per risolvere il problema è capire quale sistema di protezione viene utilizzato. A questo scopo puoi consultare l’elenco dei captcha e dei sistemi di protezione antibot più diffusi, dove trovi esempi visivi e caratteristiche chiave che ti aiutano a identificare rapidamente con cosa hai a che fare.

Se scopri che sul tuo sito viene utilizzato ALTCHA, il passo successivo è analizzarne più nel dettaglio le proprietà e il funzionamento. In questo stesso articolo puoi anche studiare la guida all’integrazione di ALTCHA, per comprendere a fondo come opera sul tuo sito. Questo ti permetterà non solo di capire la protezione attuale, ma anche di pianificarne correttamente la manutenzione.

Cos'è ALTCHA
Cos'è ALTCHA
ALTCHA (Alternative CAPTCHA) è un sistema di protezione dei siti web contro bot e spam. Aiuta a distinguere gli utenti reali dai programmi automatizzati, garantendo che il sito funzioni in modo sicuro e stabile. ALTCHA è un'alternativa moderna ai CAPTCHA tradizionali: utilizza una sfida crittografica leggera (proof-of-work) e non raccoglie cookie né traccia gli utenti.
Background
Esempi di ALTCHA
Proof-of-Work (PoW)
Proof-of-Work (PoW)
Il sistema utilizza di default il metodo di verifica Proof-of-Work (PoW), eliminando puzzle visivi e controlli invasivi. Questo approccio combina sicurezza e comodità per l'utente, offrendo una soluzione captcha discreta adatta alla maggior parte dei visitatori.
Code Captcha
Code Captcha
La protezione può essere rafforzata fino a richiedere un captcha testuale.
Invisible Captcha
Invisible Captcha
La verifica avviene senza widget visibile e non richiede alcuna azione da parte dell'utente.

Come risolvere ALTCHA tramite CapMonster Cloud

Quando testi form che includono ALTCHA devi spesso verificare che la captcha funzioni e sia integrata correttamente.

Puoi verificare manualmente la captcha inserita nel tuo sito.

  • Apri la pagina del form e assicurati che la captcha venga visualizzata.
  • Prova a inviare il form senza risolverla: il server dovrebbe restituire un errore.
  • Dopo una soluzione corretta il form deve essere inviato senza problemi.

Per la risoluzione automatica puoi usare strumenti come CapMonster Cloud, che accetta i parametri della captcha, li elabora sui propri server e restituisce un token pronto all'uso. Inserisci quel token nel form per superare il controllo senza intervento dell'utente.

Lavorare con CapMonster Cloud via API di solito prevede i seguenti passaggi:

Creazione della taskCreazione della task
arrow
Invio della richiesta APIInvio della richiesta API
arrow
Ricezione del risultatoRicezione del risultato
arrow
Inserimento del token nella paginaInserimento del token nella pagina
arrow
Risoluzione, inserimento del token e invio del form
Esempio in Node.js per un ciclo completo di riconoscimento del captcha sulla tua pagina web. Possibili approcci: usare richieste HTTP per ottenere HTML e parametri del captcha, inviare la risposta e gestire il risultato; oppure utilizzare strumenti di automazione (es. Playwright) — aprire la pagina, attendere il captcha, inviare i parametri (per test puoi inviare dati corretti o errati), ottenere il risultato tramite il client CapMonster Cloud, inserire il token nel form e vedere il risultato.
// npm install playwright
// npx playwright install chromium

const { chromium } = require("playwright");

const API_KEY = "YOUR_API_KEY";
const ALTCHA_PAGE = "https://example.com"; // Il tuo sito con ALTCHA

(async () => {
  const browser = await chromium.launch({ headless: false, devtools: true });
  const context = await browser.newContext();
  const page = await context.newPage();

  // Catturando tutte le risposte dall'endpoint Altcha
  let challengeResp = null;
  page.on("response", async (response) => {
    try {
      const url = response.url();
      if (url.startsWith("https://captcha.example.com/altcha")) { // Endpoint Altcha
        challengeResp = await response.json();
        console.log("Captured Altcha response:", challengeResp);
      }
    } catch (err) {
      console.warn("Error parsing Altcha response:", err);
    }
  });

  await page.goto(ALTCHA_PAGE, { waitUntil: "networkidle" });

  // Clic sul widget, se presente
  const widgetHandle = await page.$("altcha-widget");
  if (widgetHandle) {
    try {
      await widgetHandle.click();
    } catch {}
  }

  // Attesa della comparsa del challenge
  const start = Date.now();
  while (!challengeResp && Date.now() - start < 60000) { // Timeout aumentato
    await new Promise((r) => setTimeout(r, 300));
  }

  if (!challengeResp) {
    console.error("Failed to capture Altcha challenge.");
    await browser.close();
    return;
  }

  const { challenge, salt, signature, maxnumbers } = challengeResp;

  // Creazione task su CapMonster Cloud
  const createTaskBody = {
    clientKey: API_KEY,
    task: {
      type: "CustomTask",
      class: "altcha",
      websiteURL: ALTCHA_PAGE,
      websiteKey: "",
      userAgent:"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36",
      metadata: {
        challenge,
        iterations: maxnumbers || 100000,
        salt,
        signature,
      },
    },
  };

  const taskResp = await fetch("https://api.capmonster.cloud/createTask", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(createTaskBody),
  }).then((r) => r.json());

  console.log("CreateTask response:", taskResp);
  if (!taskResp?.taskId) {
    console.error("CreateTask failed:", taskResp);
    await browser.close();
    return;
  }

  const taskId = taskResp.taskId;

  // Recupero soluzione
  let fullSolution = null;
  const pollStart = Date.now();
  while (Date.now() - pollStart < 120000) {
    const res = await fetch("https://api.capmonster.cloud/getTaskResult", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ clientKey: API_KEY, taskId }),
    }).then((r) => r.json());

    if (res.status === "ready") {
      fullSolution = res.solution;
      console.log("Solution:", fullSolution);
      break;
    }
    await new Promise((r) => setTimeout(r, 3000));
  }

  if (!fullSolution) {
    console.error("No solution received in time.");
    await browser.close();
    return;
  }

  const token = fullSolution?.data?.token || fullSolution?.token || fullSolution?.data;

  if (!token) {
    console.error("Token not found in solution:", fullSolution);
    await browser.close();
    return;
  }

  //Inserimento token
  await page.evaluate((t) => {
    let input = document.querySelector("#captchaParaValidar");
    if (!input) {
      input = document.createElement("input");
      input.type = "hidden";
      input.id = "captchaParaValidar";
      input.name = "captchaParaValidar";
      (document.querySelector("form") || document.body).appendChild(input);
    }
    input.value = t;

    let alt = document.querySelector('input[name="altcha"]');
    if (!alt) {
      alt = document.createElement("input");
      alt.type = "hidden";
      alt.name = "altcha";
      (document.querySelector("form") || document.body).appendChild(alt);
    }
    alt.value = t;

    const widget = document.querySelector("altcha-widget");
    if (widget) {
      widget.setAttribute("data-state", "verified");
      const checkbox = widget.querySelector("input[type='checkbox']");
      if (checkbox) {
        checkbox.checked = true;
        checkbox.dispatchEvent(new Event("change", { bubbles: true }));
      }
      const label = widget.querySelector(".altcha-label");
      if (label) label.textContent = "Verified";
    }
  }, token);

  console.log("Token injected:", token);
})();
Come collegare ALTCHA al tuo sito
Per comprendere appieno il funzionamento del captcha sul tuo sito, la logica di verifica, ricollegarlo o riconfigurarlo, ti consigliamo di leggere questa sezione. Descrive il processo di integrazione della protezione e ti aiuta a capire rapidamente tutti i dettagli.

1. Installazione del widget

Opzione 1 — tramite CDN (la più semplice). Aggiungi questo nel <head> del tuo HTML:

<script async defer src="https://cdn.jsdelivr.net/gh/altcha-org/altcha/dist/altcha.min.js" type="module"></script>

Opzione 2 — tramite npm:

npm install altcha

Importa il widget nel tuo file JS:

import "altcha";

2. Aggiunta del widget nel form.

Inserisci il componente <altcha-widget> nel form dove serve protezione:


<form method="POST" action="/submit">
  <altcha-widget challengeurl="/altcha/challenge"></altcha-widget>
  <button type="submit">Send</button>
</form>

challengeurl — il tuo endpoint server per emettere il challenge.

Se utilizzi ALTCHA Sentinel (protezione server pronta contro bot e spam con machine learning e analisi del traffico), usa il suo URL invece del tuo server:


<altcha-widget 
  challengeurl="https://sentinel.example.com/v1/challenge?apiKey=YOUR_API_KEY">
</altcha-widget>

3. Verifica lato server.

Come avviene la verifica:

  • 1) Il widget genera un payload — JSON codificato in Base64, solitamente inviato come campo form altcha.
  • 2) Sul server, verifichi il payload in modo crittografico (senza ulteriori richieste API).
  • 3) Dopo verifica riuscita, il form può essere elaborato.

Verifica tramite ALTCHA Sentinel:

Usando la libreriaUsando la libreria
arrow

Attraverso l'API HTTP di Sentinel (se la libreria non è disponibile):Attraverso l'API HTTP di Sentinel (se la libreria non è disponibile):
arrow

4. Verifica senza Sentinel (server proprio)

Generazione del challenge:


import { createChallenge } from 'altcha-lib';

const hmacKey = '$ecret.key'; // La tua chiave segreta HMAC

const challenge = await createChallenge({ hmacKey });

// Restituiamo il challenge in JSON per il widget

Verifica del payload al submit del form:


import { verifySolution } from 'altcha-lib';

const hmacKey = '$ecret.key'; // La tua chiave segreta HMAC

const verified = await verifySolution(payload, hmacKey);

if (verified) {
  // Verifica riuscita — elaborazione dati del form
}

In questo caso, crei tu stesso l'endpoint /altcha/challenge per emettere i task e verificarli sul server.

Background
Possibili errori e debug
Bug Icon
challengeurl o API Key non validi
Il widget non si carica o restituisce errore durante la validazione.
Bug Icon
Timeout di risoluzione
Il server non ha avuto tempo di verificare il payload. Aumentare il tempo di attesa o assicurarsi che la verifica lato server funzioni correttamente.
Bug Icon
Payload vuoto
Errore nell'invio del risultato dal widget al server.
Bug Icon
Verification failed
Il payload è scaduto, riutilizzato o manomesso. Per la diagnostica, abilita il logging e verifica i campi verified e verificationData nella risposta del server o Sentinel.
Verifiche della resilienza della protezione
Dopo l'integrazione assicurati che il sistema protegga davvero il sito dalle azioni automatizzate.
Suggerimenti di sicurezza e ottimizzazione
<span class="font-bold">Conserva le chiavi segrete</span> (HMAC o API Key per Sentinel) solo sul server — non inviarle al frontend.
<span class="font-bold">Registra errori</span> e eventi di verifica (<span class="font-bold">verified: false</span> e <span class="font-bold">verificationData</span>) per capire i motivi dei controlli falliti.
Per trasparenza e fiducia degli utenti, <span class="font-bold">aggiungi link alla privacy policy</span> e ai <span class="font-bold">termini di utilizzo di ALTCHA</span> se richiesto.
Conclusione

Se ti è capitato un sito con un captcha o un altro sistema di protezione già installato e senza accesso al codice, nessun problema! È piuttosto facile capire quale tecnologia viene utilizzata. Per verificare che tutto funzioni correttamente, puoi usare il servizio di riconoscimento CapMonster Cloud in un ambiente di test isolato, così da assicurarti che il meccanismo di elaborazione dei token e la logica di verifica funzionino correttamente.

Nel caso di ALTCHA, è sufficiente individuare il sistema, analizzarne il comportamento e assicurarsi che la protezione funzioni correttamente. Nell’articolo abbiamo mostrato come riconoscere ALTCHA e dove trovare le istruzioni per la sua integrazione o riconfigurazione, in modo da poter mantenere la protezione in modo affidabile e controllarne il funzionamento.

Conclusion
Link utili
DocIconDocumentazione ALTCHADocIconCodice sorgente ALTCHADocIconDocumentazione CapMonster Cloud (lavoro con ALTCHA)

Domande frequenti su ALTCHA

I widget ALTCHA possono funzionare senza sitekey tradizionali, per questo CapMonster Cloud accetta una stringa vuota ("") per il parametro websiteKey.

Importante: questo campo resta obbligatorio nel payload JSON. Anche se il sito usa ALTCHA Sentinel ed espone un apiKey nella challengeurl, non estrarlo — invia semplicemente "websiteKey": "".

Il parametro iterations nell'attività CapMonster Cloud corrisponde direttamente al valore maxnumber (numero massimo per i calcoli) nell'oggetto challenge restituito dall'endpoint ALTCHA sulla pagina di destinazione. Devi passare esattamente questo valore per evitare fallimenti silenziosi nella risoluzione.

La risposta getTaskResult fornisce contemporaneamente il number semplice e il token completo codificato in base64 nello stesso payload. Lo sviluppatore estrae semplicemente il valore richiesto dal sito di destinazione per la validazione.

Alcuni moduli richiedono solo il numero calcolato, altri si aspettano l'insieme completo dei parametri cifrati in formato base64.

CapMonster Cloud supporta tutte e tre le varianti ALTCHA:

  • Proof-of-Work — il widget ALTCHA predefinito che esegue un challenge computazionale nel browser.
  • Code Captcha — richiede all'utente o allo script di inserire un codice breve.
  • Invisible Captcha — funziona in background senza widget visibile o interazione dell'utente.

Scopri come trovare tutti i parametri necessari per creare l'attività

Dopo l'invio del challenge dal client, il backend verifica i dati (salt, signature, numero calcolato e difficulty). Puoi implementarlo in due modi:

  • Sentinel API: valida automaticamente il payload e previene attacchi replay (deduplicazione e scadenza).
  • Server personalizzato: usa la funzione verifySolution per controllare manualmente il booleano verified e il payload.

Vedi il capitolo Come collegare ALTCHA al tuo sito (passaggi 3–4) sopra per i dettagli.

Nota: se la validazione fallisce (es. 403 Forbidden), di solito è dovuto a un payload scaduto o riutilizzato (attacco replay), non a un calcolo PoW errato.