> ## Documentation Index
> Fetch the complete documentation index at: https://storekit.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Signaturen verifizieren

> Sichern Sie Ihre Webhooks ab, indem Sie bei jedem Request die HMAC-Signatur verifizieren. Stellen Sie sicher, dass Payloads von storekit stammen und unterwegs nicht manipuliert wurden.

Die Verifizierung von Webhook-Signaturen ist entscheidend für die Sicherheit. Sie stellt sicher, dass der Webhook tatsächlich von storekit stammt und nicht manipuliert wurde.

## Warum verifizieren?

Da Ihr Webhook-Endpoint öffentlich erreichbar ist, könnte jeder Requests an ihn senden und vorgeben, storekit zu sein. Die Signaturverifizierung verhindert:

* **Gefälschte Requests**: Angreifer, die gefälschte Webhooks senden
* **Replay-Angriffe**: Alte Webhooks, die böswillig erneut gesendet werden
* **Datenmanipulation**: Änderung von Webhook-Payloads während der Übertragung

## Svix-Bibliotheken verwenden (empfohlen)

Wir empfehlen die Verwendung der offiziellen Svix-Bibliotheken zur Verifizierung, da sie Ihnen die gesamte Komplexität abnehmen:

<CodeGroup>
  ```javascript Node.js theme={null}
  import { Webhook } from 'svix';

  const wh = new Webhook(process.env.WEBHOOK_SECRET);

  try {
    const payload = wh.verify(rawBody, headers);
    // Process the verified payload
  } catch (err) {
    // Signature verification failed
    return res.status(400).send('Invalid signature');
  }
  ```

  ```python Python theme={null}
  from svix.webhooks import Webhook

  wh = Webhook(os.environ['WEBHOOK_SECRET'])

  try:
      payload = wh.verify(raw_body, headers)
      # Process the verified payload
  except Exception as e:
      # Signature verification failed
      return Response(status=400)
  ```

  ```go Go theme={null}
  import svix "github.com/svix/svix-webhooks/go"

  wh, _ := svix.NewWebhook(os.Getenv("WEBHOOK_SECRET"))

  err := wh.Verify([]byte(rawBody), headers)
  if err != nil {
      // Signature verification failed
      return
  }
  ```
</CodeGroup>

<Warning>
  Verwenden Sie zur Verifizierung stets den rohen Request-Body. Wenn Sie das JSON zuerst parsen und dann wieder in einen String umwandeln, stimmt die Signatur aufgrund möglicher Formatierungsunterschiede nicht überein.
</Warning>

## Manuelle Verifizierung

Wenn Sie Signaturen lieber manuell ohne die Svix-Bibliothek verifizieren möchten, folgen Sie den untenstehenden Schritten.

### Signaturheader

Jeder Webhook enthält zur Verifizierung diese Header:

| Header           | Beschreibung                                        |
| ---------------- | --------------------------------------------------- |
| `svix-id`        | Eindeutige Nachrichtenkennung                       |
| `svix-timestamp` | Unix-Zeitstempel, wann die Nachricht gesendet wurde |
| `svix-signature` | Die Signatur(en) zur Verifizierung                  |

## Verifizierungsschritte

### 1. Header extrahieren

```javascript theme={null}
const svixId = request.headers['svix-id'];
const svixTimestamp = request.headers['svix-timestamp'];
const svixSignature = request.headers['svix-signature'];
```

### 2. Zeitstempel verifizieren (Replay-Angriffe verhindern)

Weisen Sie Webhooks mit Zeitstempeln, die älter als 5 Minuten sind, zurück:

```javascript theme={null}
const tolerance = 5 * 60; // 5 minutes in seconds
const now = Math.floor(Date.now() / 1000);
const timestamp = parseInt(svixTimestamp, 10);

if (Math.abs(now - timestamp) > tolerance) {
  throw new Error('Webhook timestamp too old');
}
```

### 3. Signierten Inhalt erzeugen

Verknüpfen Sie Webhook-ID, Zeitstempel und Body:

```javascript theme={null}
const signedContent = `${svixId}.${svixTimestamp}.${rawBody}`;
```

### 4. Erwartete Signatur berechnen

Verwenden Sie HMAC-SHA256 mit Ihrem Webhook-Secret:

```javascript theme={null}
const crypto = require('crypto');

// Your secret from the dashboard (remove the 'whsec_' prefix)
const secret = Buffer.from(secretKey.split('_')[1], 'base64');

const expectedSignature = crypto
  .createHmac('sha256', secret)
  .update(signedContent)
  .digest('base64');
```

### 5. Signaturen vergleichen

```javascript theme={null}
const signatures = svixSignature.split(' ');
const isValid = signatures.some(sig => {
  const [version, signature] = sig.split(',');
  return version === 'v1' && signature === expectedSignature;
});

if (!isValid) {
  throw new Error('Invalid webhook signature');
}
```


## Related topics

- [Webhooks-Übersicht](/docs/de/developers/webhooks/overview.md)
- [Einführung für Entwickler](/docs/de/developers/introduction.md)
- [Pay at Table – Überblick](/docs/de/guides/pay-at-table/overview.md)
- [storekit Payments einrichten](/docs/de/guides/payments/storekit-payments-setup.md)
- [Bestellstatus](/docs/de/guides/orders/order-statuses.md)