Verify Playtcha from Go

package main

import (
  "bytes"
  "encoding/json"
  "net/http"
  "os"
)

func verifyPlaytcha(token string) map[string]any {
  if token == "" {
    return map[string]any{
      "success": false,
      "error": map[string]string{
        "code": "missing_token",
        "message": "Missing result token",
      },
    }
  }

  body, _ := json.Marshal(map[string]string{
    "secret": os.Getenv("PLAYTCHA_SECRET"),
    "token": token,
  })

  res, err := http.Post(
    "https://playtcha.com/v1/verify",
    "application/json",
    bytes.NewReader(body),
  )
  if err != nil {
    return map[string]any{
      "success": false,
      "error": map[string]string{
        "code": "network_error",
        "message": "Couldn't reach Playtcha verify",
      },
    }
  }
  defer res.Body.Close()

  var out map[string]any
  _ = json.NewDecoder(res.Body).Decode(&out)
  return out
}

package main

import (
  "bytes"
  "context"
  "encoding/json"
  "log"
  "net/http"
  "os"
  "time"
)

// VerifySuccess is exactly what the server returns on 2xx.
type VerifySuccess struct {
  Success        bool     `json:"success"`
  ChallengeTS    string   `json:"challenge_ts,omitempty"`
  Hostname       string   `json:"hostname,omitempty"`
  Degraded       bool     `json:"degraded,omitempty"`
  DegradedReason *string  `json:"degraded_reason,omitempty"`
  Score          *float64 `json:"score,omitempty"`
  Action         string   `json:"action,omitempty"`
}

// VerifyError is the inner shape of the error envelope on 4xx/5xx.
type VerifyError struct {
  Code      string `json:"code"`
  Message   string `json:"message"`
  RequestID string `json:"request_id,omitempty"`
  Hint      string `json:"hint,omitempty"`
  Host      string `json:"host,omitempty"`
}

// VerifyFailure is OUR helper shape. The server returns only { error: {...} } on
// failure — there is no success: false field on the wire. The bool here is a
// local discriminator we set ourselves.
type VerifyFailure struct {
  Status      int         // HTTP status. 0 for network errors.
  Unavailable bool        // true on 5xx / network — caller may fail open.
  Error       VerifyError
}

func verifyPlaytcha(token string) (VerifySuccess, *VerifyFailure) {
  if token == "" {
    return VerifySuccess{}, &VerifyFailure{
      Error: VerifyError{Code: "missing_token", Message: "Missing result token"},
    }
  }

  body, _ := json.Marshal(map[string]string{
    "secret": os.Getenv("PLAYTCHA_SECRET"),
    "token":  token,
  })

  ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
  defer cancel()

  req, _ := http.NewRequestWithContext(ctx, http.MethodPost, "https://playtcha.com/v1/verify", bytes.NewReader(body))
  req.Header.Set("Content-Type", "application/json")

  res, err := http.DefaultClient.Do(req)
  if err != nil {
    return VerifySuccess{}, &VerifyFailure{
      Unavailable: true,
      Error:       VerifyError{Code: "network_error", Message: err.Error()},
    }
  }
  defer res.Body.Close()

  if res.StatusCode >= 500 {
    return VerifySuccess{}, &VerifyFailure{
      Status: res.StatusCode, Unavailable: true,
      Error: VerifyError{Code: "verifier_unavailable", Message: "5xx"},
    }
  }

  if res.StatusCode >= 400 {
    // 4xx: upstream returns the error envelope { error: { code, message, request_id, ... } }.
    var env struct{ Error VerifyError `json:"error"` }
    _ = json.NewDecoder(res.Body).Decode(&env)
    if env.Error.Code == "" {
      env.Error = VerifyError{Code: "unknown_error", Message: "Verify failed without an error envelope"}
    }
    return VerifySuccess{}, &VerifyFailure{Status: res.StatusCode, Error: env.Error}
  }

  var ok VerifySuccess
  if err := json.NewDecoder(res.Body).Decode(&ok); err != nil {
    return VerifySuccess{}, &VerifyFailure{
      Status: res.StatusCode, Unavailable: true,
      Error: VerifyError{Code: "bad_response", Message: "Malformed JSON"},
    }
  }
  return ok, nil
}

var failClosed = os.Getenv("PLAYTCHA_FAIL_CLOSED") == "1"

// submitHandler implements the fail-open contract:
//   5xx / network -> log + treat as verified (unless PLAYTCHA_FAIL_CLOSED=1)
//   4xx           -> reject deterministically
//   429           -> reject + honor Retry-After (don't tighten retries)
func submitHandler(w http.ResponseWriter, r *http.Request) {
  result, failed := verifyPlaytcha(r.FormValue("playtcha-token"))
  if failed != nil {
    if failed.Unavailable {
      log.Printf("playtcha.verify.unavailable status=%d err=%s", failed.Status, failed.Error.Code)
      if failClosed {
        http.Error(w, "verifier unavailable", http.StatusServiceUnavailable)
        return
      }
      // fall through — treat as verified
    } else {
      // 409 already_redeemed is a security signal: replay, stuck retry, or duplicate POST.
      // Log with request_id at warn level — do not silently retry.
      log.Printf("playtcha.verify.failed status=%d code=%s request_id=%s hint=%s",
        failed.Status, failed.Error.Code, failed.Error.RequestID, failed.Error.Hint)
      http.Error(w, "verification failed", http.StatusBadRequest)
      return
    }
  } else if result.Degraded {
    log.Printf("playtcha.verify.degraded reason=%v", result.DegradedReason)
  }

  w.WriteHeader(http.StatusOK)
}