Strona główna/Blog/Bezpieczeństwo płatności
Bezpieczeństwo płatnościOpublikowano · Zaktualizowano ⚡ 15 min czytania

Stripe i PCI-DSS 4.0: jak spiąć flow płatności w Next.js, który naprawdę przechodzi audyty

Słuchaj, przejście PCI-DSS 4.0 w Next.js ze Stripe to potężny ból w tyłku. Oto dokładnie, jak wypchnęliśmy to na produkcję, nie rozwalając współczynnika konwersji.

VG
Vladyslav Gusarov
DevSecOps Lead w Bryxe
Stripe i PCI-DSS 4.0: projektujemy kuloodporny flow płatności w Next.js [Przewodnik 2026]

PCI-DSS 4.0 wszedł w życie. Zmienia wszystko. Nie możesz już po prostu wrzucić na stronę iframe’a Stripe Elements i uznać sprawy za zamkniętą. Audytorzy ostro biorą się za bezpieczeństwo frontendu, a to oznacza, że pod maską cała Twoja architektura Next.js musi uwzględniać ciągły monitoring i zasady zero trust, które szczerze mówiąc wydają się przesadą, dopóki nie zobaczysz struktury kar.

Rzecz w tym: budujemy flow płatności. Używamy Next.js i Stripe. Musimy go uszczelnić na amen. Przeprowadzę Cię przez dokładne strojenie CSP, matematykę podpisów webhooków i ukryte pułapki, które zaskakują większość zespołów.

Dlaczego PCI-DSS 4.0 to udręka dla devów Next.js

Przeczytaj specyfikację. Jest ciężka. Od marca 2024 te rzeczy są obowiązkowe. Jeśli nie uważasz, rozwala to bezpośrednio Twój standardowy deployment frontendu.

  1. Wymaganie 6.4.3: zarządzanie wszystkimi skryptami strony płatności, które są ładowane i wykonywane w przeglądarce klienta.
  2. Wymaganie 11.6.1: mechanizmy wykrywania manipulacji na stronach płatności.
  3. Targeted Risk Analysis (TRA): przejście od okresowego do ciągłego monitorowania zgodności.

Finansowe skutki naruszeń w płatnościach

Naruszenia są drogie. Kary Cię zbankrutują. Spójrz na surowe liczby, kiedy próbujesz uzasadnić, dlaczego ten sprint trzeba poświęcić na bezpieczeństwo zamiast wypychać kolejną koślawą funkcję produktu.

Oto brutalna prawda. Jeśli platforma przetwarzająca 10 000 transakcji miesięcznie padnie ofiarą naruszenia, które ujawni 5 000 rekordów: * Bezpośredni koszt naruszenia danych: $825 000 * Kary PCI (szacunkowo 3 miesiące): $150 000 * Łączny początkowy wpływ: $975 000

Wydaj pieniądze teraz. Napraw pipeline devops. Nie chcesz tłumaczyć zarządowi, dlaczego to pominąłeś.

Spinamy Next.js ze Stripe

Używamy Stripe Elements. To standard. Stripe przejmuje surowe dane PAN, więc nasze bazy nigdy ich nie widzą, i tylko dlatego zostajemy poza Scope A. Ale zgadnij co? Wciąż dostarczamy iframe, co wrzuca nas prosto na terytorium SAQ A, gdzie musimy udowodnić, że nasza aplikacja hostująca nie jest kompletnie skompromitowana.

1. Utwardzanie Content Security Policy (CSP)

Wymaganie 6.4.3 to potężna pułapka. Potrzebujesz absolutnej kontroli nad każdym skryptem na stronie płatności. Middleware Next.js to dosłownie jedyne rozsądne miejsce, żeby dynamicznie wstrzykiwać te nagłówki CSP tak, by faktycznie działały, nie powodując ogromnej blokady renderowania w edge functions Vercela.

typescriptKod źródłowy
// 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
}

Oto brutalna prawda. Zablokowanie CSP zabija Magecarta na miejscu. Żadne przypadkowe śmieci od stron trzecich nie mogą się tu wykonać.

2. Bezpieczne tworzenie PaymentIntent (backend)

Nie ufaj klientowi. Nigdy. Jeśli liczysz ceny w przeglądarce, ktoś zmieni payload i kupi Twój plan premium za grosz. Logika PaymentIntent musi żyć głęboko w trasie po stronie serwera, która pobiera prawdziwą cenę bezpośrednio z Twojej bazy, zanim w ogóle odezwie się do API Stripe.

typescriptKod źródłowy
// 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. Implementacja interfejsu klienta

Wyrenderuj formularz. Niech będzie prosty. Wciągamy @stripe/react-stripe-js i montujemy element.

tsxKod źródłowy
// 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>
  );
}

Zabezpieczanie odbiorcy webhooków

Webhooki to absolutny strzał w stopę. Jeśli nie weryfikujesz poprawnie podpisów, dosłownie każdy może puścić curl na Twój endpoint i oznaczyć faktury jako opłacone.

Checklista wymagań bezpieczeństwa webhooków

WymaganieSzczegóły implementacjiPrzed czym chroni
Weryfikacja podpisuKryptograficzna weryfikacja nagłówka Stripe-SignatureAtaki spoofingowe
IdempotentnośćPrzetwarzanie zdarzeń dokładnie raz z użyciem ID zdarzeń StripeAtaki replay / race conditions
Ochrona przed replayWalidacja znacznika czasu w podpisie (domyślna tolerancja 5 min)Opóźnione ataki replay
Integralność payloaduUżycie surowego bufora treści żądania do obliczenia podpisuModyfikacja typu man-in-the-middle

Kuloodporna trasa webhooka

Mam dość oglądania tego w PR-ach. App Router w Next.js próbuje automatycznie sparsować za Ciebie JSON. Wywal to. Potrzebujesz surowego bufora treści, żeby zrobić kryptograficzną weryfikację podpisu względem klucza Stripe, inaczej hashe nigdy się nie zgodzą, a Ty zmarnujesz trzy dni na debugowanie.

typescriptKod źródłowy
// 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
}

Wymaganie 11.6.1: wykrywanie manipulacji

Musisz wykrywać modyfikacje na bieżąco. Teraz to obowiązek. SRI i CSP pokrywają podstawy, ale 11.6.1 naprawdę oczekuje aktywnego monitoringu, który patrzy na Twój produkcyjny DOM i łapie wstrzyknięcia w sekundzie, gdy się pojawią.

Weź Datadog albo Sentry. Skonfiguruj je, żeby: 1. Monitorowały zmiany w nagłówkach HTTP (w szczególności CSP). 2. Alarmowały o nieautoryzowanym wykonaniu skryptów zablokowanym przez CSP. 3. Prowadziły ciągłe zewnętrzne skanowanie DOM strony płatności, żeby wykrywać wstrzyknięte elementy.

Integracja z pipeline’em DevSecOps

Zautomatyzuj ten syf. Jeśli polegasz na ludziach przy sprawdzaniu nagłówków bezpieczeństwa, to się zepsuje.

Hooki pre-commit

Bądźmy szczerzy. Przestań commitować klucze API. Skonfiguruj lokalnie trufflehog albo git-secrets, zanim ktoś wypchnie produkcyjny klucz Stripe do publicznego repo i zepsuje Ci weekend.

bashKod źródłowy
# 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)

Wrzuć Semgrep do swoich GitHub Actions. Niech krzyczy na developerów, kiedy zapomną zweryfikować podpis webhooka.

yamlKod źródłowy
# .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

Podsumowanie

Uruchomienie Stripe w Next.js jest łatwe. Przejście audytu PCI-DSS 4.0 jest trudne. Musisz zablokować CSP, wymusić idempotentność, żeby webhooki nie obciążały klientów podwójnie, i przenieść całą faktyczną matematykę na backend, gdzie atakujący nie mogą jej dotknąć.

Nie odhaczamy tylko pól w checkliście compliance. Budujemy systemy, przez które nikt nie wyrwie nas z łóżka o 3 w nocy, gdy ktoś spróbuje odpalić skrypt Magecart na naszych stronach checkoutu.

AUTOMATYCZNA OCHRONA

Nie czekaj na exploit, żeby zrobić audyt kodu

Przejrzyj obsługiwane ryzyka w kodzie, ujawnione sekrety i wyniki dla zależności z Bryxe Shield. Przed wydaniem zweryfikuj poprawki w swojej aplikacji.

Potrzebujesz praktycznego kolejnego kroku? Zajrzyj do praktycznych poradników bezpieczeństwa lub przeczytaj naszą politykę redakcyjną i zasady doboru źródeł.

Polecane badania bezpieczeństwa