Enviar OTP — Verificacion por SMS y WhatsApp

<?php
/**
 * Enviar OTP por WhatsApp o SMS
 * Requiere: PHP 7.4+ con cURL
 */

function enviarOTP(
    string $telefono,
    string $canal = "whatsapp",
    int $expiracion = 300
): array {
    $params = [
        "secret"  => "TU_API_KEY",
        "type"    => $canal,
        "phone"   => $telefono,
        "expire"  => $expiracion,
        "message" => "Tu codigo de verificacion es: {{otp}}. Expira en " . ($expiracion / 60) . " minutos. No compartas este codigo."
    ];

    // Parametros adicionales segun el canal
    if ($canal === "whatsapp") {
        $params["account"]  = "WA_ACCOUNT_UNIQUE";
        $params["priority"] = 1; // Inmediato para OTP
    } elseif ($canal === "sms") {
        $params["mode"]    = "credits";
        $params["gateway"] = "1";
    }

    $ch = curl_init("//whatsboost.netapi/send/otp");
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 30,
        CURLOPT_POSTFIELDS     => $params
    ]);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    $result = json_decode($response, true);

    if ($result["status"] === 200) {
        // Almacenar OTP en sesion para verificacion posterior
        $_SESSION["otp_code"]    = $result["data"]["otp"];
        $_SESSION["otp_phone"]   = $telefono;
        $_SESSION["otp_expires"] = time() + $expiracion;

        echo "OTP enviado al $telefono. Codigo: " . $result["data"]["otp"] . PHP_EOL;
    } else {
        echo "Error enviando OTP: " . $result["message"] . PHP_EOL;
    }

    return $result;
}

// Uso: enviar OTP por WhatsApp
$resultado = enviarOTP("+34612345678", "whatsapp", 300);

// Uso: enviar OTP por SMS
$resultado = enviarOTP("+34612345678", "sms", 600);

/**
 * Enviar OTP por WhatsApp o SMS
 * Compatible con Node.js y navegador (server-side recomendado)
 */

// Almacen temporal de OTPs (en produccion usa Redis o base de datos)
const otpStore = new Map();

async function enviarOTP(telefono, canal = "whatsapp", expiracion = 300) {
  const params = {
    secret: "TU_API_KEY",
    type: canal,
    phone: telefono,
    expire: expiracion.toString(),
    message: `Tu codigo de verificacion es: {{otp}}. Expira en ${ Math.floor(expiracion / 60) } minutos.`
  };

  // Parametros adicionales segun el canal
  if (canal === "whatsapp") {
    params.account = "WA_ACCOUNT_UNIQUE";
    params.priority = "1";
  } else if (canal === "sms") {
    params.mode = "credits";
    params.gateway = "1";
  }

  const response = await fetch("//whatsboost.netapi/send/otp", {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams(params)
  });

  const data = await response.json();

  if (data.status === 200) {
    // Almacenar OTP para verificacion posterior
    otpStore.set(telefono, {
      code: data.data.otp,
      expiresAt: Date.now() + (expiracion * 1000)
    });

    console.log(`OTP enviado al ${ telefono }. Codigo: ${ data.data.otp }`);
  } else {
    console.error(`Error enviando OTP: ${ data.message }`);
  }

  return data;
}

// Uso
await enviarOTP("+34612345678", "whatsapp", 300);
await enviarOTP("+34612345678", "sms", 600);

import requests
import time

# Almacen temporal de OTPs (en produccion usa Redis o base de datos)
otp_store = {}

def enviar_otp(telefono: str, canal: str = "whatsapp", expiracion: int = 300) -> dict:
    """
    Enviar OTP por WhatsApp o SMS.
    Requiere: pip install requests
    """
    params = {
        "secret": "TU_API_KEY",
        "type": canal,
        "phone": telefono,
        "expire": expiracion,
        "message": f"Tu codigo de verificacion es: {{otp}}. Expira en {expiracion // 60} minutos."
    }

    # Parametros adicionales segun el canal
    if canal == "whatsapp":
        params["account"] = "WA_ACCOUNT_UNIQUE"
        params["priority"] = 1  # Inmediato para OTP
    elif canal == "sms":
        params["mode"] = "credits"
        params["gateway"] = "1"

    response = requests.post(
        "//whatsboost.netapi/send/otp",
        data=params,
        timeout=30
    )

    result = response.json()

    if result["status"] == 200:
        # Almacenar OTP para verificacion posterior
        otp_store[telefono] = {
            "code": result["data"]["otp"],
            "expires_at": time.time() + expiracion
        }
        print(f"OTP enviado al {telefono}. Codigo: {result['data']['otp']}")
    else:
        print(f"Error enviando OTP: {result['message']}")

    return result


# Uso: OTP por WhatsApp
resultado = enviar_otp("+34612345678", "whatsapp", 300)

# Uso: OTP por SMS
resultado = enviar_otp("+34612345678", "sms", 600)

/**
 * Verificar codigo OTP introducido por el usuario
 * Utiliza el otpStore definido en el ejemplo de envio
 */

function verificarOTP(telefono, codigoUsuario) {
  const otpData = otpStore.get(telefono);

  // Verificar que existe un OTP pendiente
  if (!otpData) {
    return {
      success: false,
      error: "No se encontro un codigo OTP pendiente para este numero."
    };
  }

  // Verificar que no ha expirado
  if (Date.now() > otpData.expiresAt) {
    otpStore.delete(telefono);
    return {
      success: false,
      error: "El codigo OTP ha expirado. Solicita uno nuevo."
    };
  }

  // Incrementar intentos
  otpData.attempts = (otpData.attempts || 0) + 1;

  // Bloquear tras 5 intentos fallidos
  if (otpData.attempts > 5) {
    otpStore.delete(telefono);
    return {
      success: false,
      error: "Demasiados intentos fallidos. Solicita un nuevo codigo."
    };
  }

  // Comparar codigos
  if (parseInt(codigoUsuario) !== otpData.code) {
    return {
      success: false,
      error: "Codigo incorrecto.",
      attemptsRemaining: 5 - otpData.attempts
    };
  }

  // Verificacion exitosa: limpiar datos
  otpStore.delete(telefono);

  return {
    success: true,
    message: "Telefono verificado correctamente."
  };
}

// Uso: verificar el codigo
const resultado = verificarOTP("+34612345678", 847291);

if (resultado.success) {
  console.log("Verificacion exitosa!");
  // Continuar con el flujo
} else {
  console.error("Error:", resultado.error);
}

import time

def verificar_otp(telefono: str, codigo_usuario: int) -> dict:
    """
    Verificar codigo OTP introducido por el usuario.
    Utiliza el otp_store definido en el ejemplo de envio.
    """
    # Verificar que existe un OTP pendiente
    if telefono not in otp_store:
        return {
            "success": False,
            "error": "No se encontro un codigo OTP pendiente para este numero."
        }

    otp_data = otp_store[telefono]

    # Verificar que no ha expirado
    if time.time() > otp_data["expires_at"]:
        del otp_store[telefono]
        return {
            "success": False,
            "error": "El codigo OTP ha expirado. Solicita uno nuevo."
        }

    # Incrementar intentos
    otp_data["attempts"] = otp_data.get("attempts", 0) + 1

    # Bloquear tras 5 intentos fallidos
    if otp_data["attempts"] > 5:
        del otp_store[telefono]
        return {
            "success": False,
            "error": "Demasiados intentos fallidos. Solicita un nuevo codigo."
        }

    # Comparar codigos
    if int(codigo_usuario) != otp_data["code"]:
        return {
            "success": False,
            "error": "Codigo incorrecto.",
            "attempts_remaining": 5 - otp_data["attempts"]
        }

    # Verificacion exitosa: limpiar datos
    del otp_store[telefono]

    return {
        "success": True,
        "message": "Telefono verificado correctamente."
    }


# Uso: verificar el codigo
resultado = verificar_otp("+34612345678", 847291)

if resultado["success"]:
    print("Verificacion exitosa!")
    # Continuar con el flujo: registro, login, etc.
else:
    print(f"Error: {resultado['error']}")