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.
- Wymaganie 6.4.3: zarządzanie wszystkimi skryptami strony płatności, które są ładowane i wykonywane w przeglądarce klienta.
- Wymaganie 11.6.1: mechanizmy wykrywania manipulacji na stronach płatności.
- 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.
- Średni koszt jednego skradzionego rekordu: $165 (IBM Cost of a Data Breach Report)
- Kary za brak zgodności z PCI: od $5 000 do $100 000 miesięcznie
- Utracone przychody: średnio 3,4% churnu po naruszeniu w firmach SaaS
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.
// 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.
// 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.
// 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
| Wymaganie | Szczegóły implementacji | Przed czym chroni |
|---|---|---|
| Weryfikacja podpisu | Kryptograficzna weryfikacja nagłówka Stripe-Signature | Ataki spoofingowe |
| Idempotentność | Przetwarzanie zdarzeń dokładnie raz z użyciem ID zdarzeń Stripe | Ataki replay / race conditions |
| Ochrona przed replay | Walidacja znacznika czasu w podpisie (domyślna tolerancja 5 min) | Opóźnione ataki replay |
| Integralność payloadu | Użycie surowego bufora treści żądania do obliczenia podpisu | Modyfikacja 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.
// 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.
# 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.
# .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: truePodsumowanie
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.
![Stripe i PCI-DSS 4.0: projektujemy kuloodporny flow płatności w Next.js [Przewodnik 2026]](/_next/image?url=%2Fblog%2Ftest-mockup.jpg&w=3840&q=75&dpl=dpl_4APdW92RmtTARbNBj4X6xdJXX9hA)