Inicio/Blog/Seguridad de pagos
Seguridad de pagosPublicado · Actualizado ⚡ 15 min de lectura

Stripe y PCI-DSS 4.0: cómo montar un flujo de pago en Next.js que de verdad pase las auditorías

Mira, superar PCI-DSS 4.0 en Next.js con Stripe es un dolor de cabeza enorme. Así es exactamente como lo llevamos a producción sin hundir nuestras tasas de conversión.

VG
Vladyslav Gusarov
Responsable de DevSecOps en Bryxe
Stripe y PCI-DSS 4.0: cómo construir un flujo de pago a prueba de balas en Next.js [Guía 2026]

Ha llegado PCI-DSS 4.0. Lo cambia todo. Ya no basta con plantar un iframe de Stripe Elements en tu página y dar el trabajo por terminado. Los auditores se han puesto durísimos con la seguridad del frontend, y eso significa que, por debajo, toda tu arquitectura de Next.js tiene que contemplar monitorización continua y principios de zero trust que, sinceramente, parecen exagerados hasta que ves cómo son las multas.

La cuestión es esta: estamos construyendo un flujo de pago. Usamos Next.js y Stripe. Tenemos que dejarlo hermético. Te voy a explicar el ajuste exacto de la CSP, las matemáticas de la firma de los webhooks y las trampas de fondo que pillan desprevenidos a la mayoría de los equipos.

Por qué PCI-DSS 4.0 es un fastidio para los desarrolladores de Next.js

Lee la especificación. Es dura. En marzo de 2024 todo esto pasó a ser obligatorio. Destroza directamente tu despliegue de frontend estándar si no estás atento.

  1. Requisito 6.4.3: gestión de todos los scripts de la página de pago que se cargan y ejecutan en el navegador del consumidor.
  2. Requisito 11.6.1: mecanismos de detección de manipulaciones para las páginas de pago.
  3. Targeted Risk Analysis (TRA): un cambio de la monitorización del cumplimiento periódica a la continua.

Impacto financiero de las brechas en pagos

Las brechas salen caras. Las multas te llevarán a la quiebra. Basta con mirar las cifras en bruto cuando intentas justificar por qué este sprint debe dedicarse a seguridad en lugar de a lanzar otra funcionalidad chapucera.

Esta es la cruda verdad. Si una plataforma que procesa 10.000 transacciones al mes sufre una brecha que expone 5.000 registros: * Coste inmediato de la brecha de datos: $825.000 * Multas de PCI (estimación de 3 meses): $150.000 * Impacto inicial total: $975.000

Gasta el dinero ahora. Arregla el pipeline de DevOps. No querrás tener que explicarle al consejo por qué te saltaste esto.

Conectando Next.js y Stripe

Usamos Stripe Elements. Es el estándar. Stripe se traga los datos PAN en bruto para que nuestras bases de datos nunca los vean, que es la única razón por la que nos quedamos fuera del Scope A. Pero ¿adivina qué? Seguimos sirviendo el iframe, lo que nos mete de lleno en territorio SAQ A, donde tenemos que demostrar que nuestra aplicación anfitriona no está totalmente comprometida.

1. Endurecer la Content Security Policy (CSP)

El requisito 6.4.3 es una trampa enorme. Necesitas control absoluto sobre cada script de la página de pago. El middleware de Next.js es literalmente el único sitio sensato para inyectar estas cabeceras CSP de forma dinámica, de modo que se apliquen de verdad sin provocar un bloqueo de renderizado masivo en las edge functions de Vercel.

typescriptCódigo fuente
// middleware.ts
import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'

export function middleware(request: NextRequest) {
  const nonce = Buffer.from(crypto.randomUUID()).toString('base64')
  
  // Strict CSP for Stripe Integration
  const cspHeader = `
    default-src 'self';
    script-src 'self' 'nonce-${nonce}' https://js.stripe.com;
    connect-src 'self' https://api.stripe.com;
    frame-src 'self' https://js.stripe.com https://hooks.stripe.com;
    style-src 'self' 'unsafe-inline' https://fonts.googleapis.com;
    font-src 'self' https://fonts.gstatic.com;
    img-src 'self' data: https://*.stripe.com;
    object-src 'none';
    base-uri 'self';
    form-action 'self';
    frame-ancestors 'none';
    upgrade-insecure-requests;
  `
  
  const contentSecurityPolicyHeaderValue = cspHeader
    .replace(/\s{2,}/g, ' ')
    .trim()

  const requestHeaders = new Headers(request.headers)
  requestHeaders.set('x-nonce', nonce)
  requestHeaders.set(
    'Content-Security-Policy',
    contentSecurityPolicyHeaderValue
  )

  const response = NextResponse.next({
    request: {
      headers: requestHeaders,
    },
  })

  response.headers.set(
    'Content-Security-Policy',
    contentSecurityPolicyHeaderValue
  )
  
  // HSTS implementation for secure transport
  response.headers.set(
    'Strict-Transport-Security',
    'max-age=31536000; includeSubDomains; preload'
  )

  return response
}

Esta es la cruda verdad. Blindar la CSP acaba de raíz con Magecart. Aquí no se puede ejecutar ninguna porquería aleatoria de terceros.

2. Creación segura del intent (backend)

No confíes en el cliente. Nunca. Si calculas los precios en el navegador, alguien cambiará el payload y comprará tu plan premium por un céntimo. La lógica del PaymentIntent tiene que vivir en una ruta del lado del servidor que consulte directamente tu base de datos para obtener el precio real antes de hablar siquiera con la API de Stripe.

typescriptCódigo fuente
// app/api/create-payment-intent/route.ts
import { NextResponse } from 'next/server';
import Stripe from 'stripe';
import { db } from '@/lib/db';
import { rateLimit } from '@/lib/rate-limit';
import { headers } from 'next/headers';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
  apiVersion: '2023-10-16',
});

export async function POST(req: Request) {
  try {
    // 1. Rate Limiting (DDoS mitigation)
    const ip = headers().get('x-forwarded-for') ?? '127.0.0.1';
    const { success } = await rateLimit.limit(ip);
    if (!success) {
      return NextResponse.json({ error: 'Too many requests' }, { status: 429 });
    }

    const body = await req.json();
    const { productId, customerId } = body;

    // 2. Trust No Client Data - Fetch pricing securely
    const product = await db.product.findUnique({ where: { id: productId } });
    
    if (!product) {
      return NextResponse.json({ error: 'Product not found' }, { status: 404 });
    }

    // 3. Create Intent with strict metadata for reconciliation
    const paymentIntent = await stripe.paymentIntents.create({
      amount: product.priceInCents,
      currency: 'usd',
      customer: customerId,
      automatic_payment_methods: {
        enabled: true,
      },
      metadata: {
        productId: product.id,
        internalTransactionId: crypto.randomUUID(),
      },
    });

    return NextResponse.json({
      clientSecret: paymentIntent.client_secret,
    });
  } catch (error) {
    console.error('PaymentIntent creation failed:', error);
    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    );
  }
}

3. Implementar la interfaz del cliente

Renderiza el formulario. Mantenlo simple. Importamos @stripe/react-stripe-js y montamos el elemento.

tsxCódigo fuente
// components/CheckoutForm.tsx
'use client';

import {
  PaymentElement,
  useStripe,
  useElements,
} from '@stripe/react-stripe-js';
import { useState } from 'react';

export default function CheckoutForm() {
  const stripe = useStripe();
  const elements = useElements();
  const [errorMessage, setErrorMessage] = useState<string | null>(null);
  const [isProcessing, setIsProcessing] = useState(false);

  const handleSubmit = async (event: React.FormEvent) => {
    event.preventDefault();

    if (!stripe || !elements) {
      return;
    }

    setIsProcessing(true);

    const { error } = await stripe.confirmPayment({
      elements,
      confirmParams: {
        return_url: `${window.location.origin}/payment-success`,
      },
    });

    if (error) {
      setErrorMessage(error.message ?? 'An unknown error occurred');
    }
    
    setIsProcessing(false);
  };

  return (
    <form onSubmit={handleSubmit} className="space-y-6 max-w-md mx-auto">
      <PaymentElement 
        options={{
          layout: 'tabs',
        }} 
      />
      <button 
        disabled={!stripe || isProcessing}
        className="w-full bg-blue-600 text-white py-3 px-4 rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 disabled:opacity-50 transition-colors"
      >
        {isProcessing ? 'Processing...' : 'Pay Now'}
      </button>
      {errorMessage && (
        <div className="text-red-500 text-sm mt-2 font-medium" role="alert">
          {errorMessage}
        </div>
      )}
    </form>
  );
}

Proteger el receptor de webhooks

Los webhooks son una trampa absoluta. Si no verificas bien las firmas, literalmente cualquiera puede hacer curl a tu endpoint y marcar facturas como pagadas.

Checklist de requisitos de seguridad de webhooks

RequisitoDetalle de implementaciónAmenaza que mitiga
Verificación de firmaVerificación criptográfica de la cabecera Stripe-SignatureAtaques de suplantación
IdempotenciaProcesar cada evento exactamente una vez usando los IDs de evento de StripeAtaques de replay / condiciones de carrera
Protección contra replayValidar el timestamp dentro de la firma (tolerancia por defecto de 5 min)Ataques de replay diferidos
Integridad del payloadUsar el buffer del cuerpo bruto de la petición para calcular la firmaModificación man-in-the-middle

La ruta de webhook a prueba de balas

Estoy harto de ver esto en los PR. El App Router de Next.js intenta parsear el JSON por ti automáticamente. Elimínalo. Necesitas el buffer del cuerpo bruto para hacer la verificación criptográfica de la firma con la clave de Stripe; si no, los hashes nunca coincidirán y perderás tres días depurándolo.

typescriptCódigo fuente
// app/api/webhooks/stripe/route.ts
import { NextResponse } from 'next/server';
import Stripe from 'stripe';
import { headers } from 'next/headers';
import { db } from '@/lib/db';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
  apiVersion: '2023-10-16',
});

const endpointSecret = process.env.STRIPE_WEBHOOK_SECRET!;

export async function POST(req: Request) {
  const body = await req.text();
  const sig = headers().get('stripe-signature') as string;

  let event: Stripe.Event;

  try {
    // Cryptographic verification of payload integrity
    event = stripe.webhooks.constructEvent(body, sig, endpointSecret);
  } catch (err: any) {
    console.error(`Webhook signature verification failed: ${err.message}`);
    return NextResponse.json({ error: 'Webhook Error' }, { status: 400 });
  }

  // Idempotency check: Have we processed this event?
  const existingEvent = await db.processedEvent.findUnique({
    where: { id: event.id },
  });

  if (existingEvent) {
    console.log(`Event ${event.id} already processed. Skipping.`);
    return NextResponse.json({ received: true });
  }

  try {
    // Process the event
    switch (event.type) {
      case 'payment_intent.succeeded':
        const paymentIntentSucceeded = event.data.object as Stripe.PaymentIntent;
        await handlePaymentSuccess(paymentIntentSucceeded);
        break;
      case 'payment_intent.payment_failed':
        const paymentIntentFailed = event.data.object as Stripe.PaymentIntent;
        await handlePaymentFailure(paymentIntentFailed);
        break;
      // ... handle other event types
      default:
        console.log(`Unhandled event type ${event.type}`);
    }

    // Record the event as processed for idempotency
    await db.processedEvent.create({
      data: {
        id: event.id,
        type: event.type,
      },
    });

    return NextResponse.json({ received: true });
  } catch (error) {
    console.error('Error processing webhook:', error);
    // Return a 500 to tell Stripe to retry
    return NextResponse.json(
      { error: 'Webhook handler failed' },
      { status: 500 }
    );
  }
}

async function handlePaymentSuccess(intent: Stripe.PaymentIntent) {
  const productId = intent.metadata.productId;
  // Fulfill the order in the database
}

Requisito 11.6.1: detección de manipulaciones

Tienes que detectar modificaciones sobre la marcha. Ahora es obligatorio. SRI y CSP cubren lo básico, pero el 11.6.1 realmente quiere monitorización activa que vigile tu DOM de producción para pillar las inyecciones en el segundo en que ocurren.

Hazte con Datadog o Sentry. Configúralos para: 1. Monitorizar los cambios en las cabeceras HTTP (en concreto, la CSP). 2. Alertar sobre ejecuciones de scripts no autorizadas bloqueadas por la CSP. 3. Realizar un escaneo externo continuo del DOM de la página de pago para detectar elementos inyectados.

Integración en el pipeline de DevSecOps

Automatiza esta basura. Si dependes de personas para revisar las cabeceras de seguridad, se romperá.

Hooks de pre-commit

Seamos sinceros. Deja de hacer commit de claves de API. Configura trufflehog o git-secrets en local antes de que alguien suba una clave live de Stripe a un repositorio público y te arruine el fin de semana.

bashCódigo fuente
# Install git-secrets
git secrets --install
git secrets --add 'sk_(test|live)_[0-9a-zA-Z]{24,99}'
git secrets --add 'rk_(test|live)_[0-9a-zA-Z]{24,99}'

SAST (Static Application Security Testing)

Mete Semgrep en tus GitHub Actions. Deja que les grite a los desarrolladores cuando se olviden de verificar la firma de un webhook.

yamlCódigo fuente
# .github/workflows/semgrep.yml
name: Semgrep
on: [push, pull_request]
jobs:
  semgrep:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: returntocorp/semgrep-action@v1
        with:
          config: p/javascript
          generateCodeScanningAlerts: true

En resumen

Poner Stripe en marcha en Next.js es fácil. Superar una auditoría de PCI-DSS 4.0 es difícil. Tienes que blindar la CSP, imponer la idempotencia para que los webhooks no cobren dos veces a los clientes y mover todos los cálculos reales al backend, donde los atacantes no puedan tocarlos.

No nos limitamos a marcar casillas de cumplimiento. Construimos sistemas que no nos despierten con una alerta a las 3 de la madrugada cuando alguien intente lanzar un script de Magecart contra nuestras páginas de checkout.

DEFENSA AUTOMATIZADA

No esperes a un exploit para auditar tu código

Revisa los riesgos de código compatibles, los secretos expuestos y los hallazgos en dependencias con Bryxe Shield. Verifica las correcciones en tu aplicación antes del lanzamiento.

¿Necesitas un siguiente paso práctico? Explora las guías de seguridad o lee nuestra política editorial y de fuentes.

Investigación de seguridad recomendada