Ein JWT erstellen

Marketplace APIs are limited access

Unsere Pipeline für Marktplatz-Integration ist derzeit ausgelastet. Wir nehmen im Moment keine neuen Partner an, sind aber dabei, Self-Service-Tools für das Onboarding von Anbietern zu entwickeln. Bitte fülle das Formular für Interessenten der Marktplatz-Integration aus, um mit DoorDash in Kontakt zu treten, bevor du deine Integration erstellst.

JSON Web Tokens (JWTs) sind ein Token-Format für die Authentifizierung, das für die Kommunikation mit DoorDash-APIs verwendet wird. Sie ermöglichen die sichere Kommunikation zwischen zwei Parteien, indem sie die Informationen signieren. JWTs ermöglichen den Benutzer:innen, sich beim Service zu authentifizieren, ohne jemals ein Geheimnis über die Leitung senden zu müssen. Die Erstellung von JWTs wird in allen gängigen Programmiersprachen unterstützt.

Ein JWT zur Authentifizierung mit der API verwenden

Damit du dich mit der API authentifizieren kannst, musst du das JWT als Bearer-Token im Authentifizierungs-Header angeben.

Authorization: Bearer [JWT]
auth-version: v2

Aufbau eines JWT

JWTs bestehen aus drei Teilen, die durch Punkte getrennt sind:

• Header
• Payload
• Signatur

Das Ergebnis ist ein Token nach dem Muster aaa.bbb.ccc.

Header

Der Header gibt den Algorithmus an, der zum Signieren des Tokens verwendet wird – HMAC SHA 265 (HS265) und die DoorDash JWT-Version (v1).

{
  "alg": "HS256",
  "typ": "JWT",
  "dd-ver": "DD-JWT-V1"
}

Der Header ist Base64url-kodiert und bildet den ersten Teil des JWT.

Payload

Der Inhalt des Tokens als JSON-Objekt. Dieser Inhalt kann von Empfänger:innen als vertrauenswürdig eingestuft werden.

Payload-Format

{
  "aud": "doordash",
  "iss": DEVELOPER ID,
  "kid": KEY ID,
  "iat": ISSUED AT,
  "exp": EXPIRATION
}

aud – Audience (Zielgruppe). Lege dies immer auf "doordash" fest.

iss – Issuer (Aussteller). Lege dies auf die Entwickler-ID (UUID-Format) fest.

kid – Key ID (ID des Schlüssels). Lege dies auf die ID des Schlüssels (UUID-Format) fest, der zum Signieren des JWT verwendet wurde.

iat – Issued At (Ausgestellt um). Wann das Token erstellt wurde. Formatiert als Sekunden seit der Epoche. iat darf nicht in der Zukunft liegen.

exp – Expiration (Ablaufdatum). Wann das Token abläuft. Formatiert als Sekunden seit der Epoche. exp hat einen maximalen Wert von 30 Minuten (1800 Sekunden) nach dem Zeitpunkt der Ausstellung.

Beispiel

{
  "aud": "doordash",
  "iss": "582e4f20-0f48-4bc2-99c2-e094675e2919",
  "kid": "585698aa-2aa6-4bb4-8b3f-dd9d3f47dc28",
  "iat": 1636463841,
  "exp": 1636465641
}

Die Payload ist Base64url-kodiert und bildet den zweiten Teil des JWT.

Signatur

Die Signatur dient zur Überprüfung der Authentizität des Inhalts. Nur jemand, der das Signaturgeheimnis kennt, ist in der Lage, die richtige Signatur zu erzeugen. Die Signatur wird mit dem Algorithmus HMAC SHA256 (HS256) berechnet.

Die Signatur ist Base64url-kodiert und bildet den dritten Teil des JWT.

Schutz deines Geheimnisses

Behandle dein Signaturgeheimnis wie ein Passwort. Bewahre dein Geheimnis in einem sicheren Speicher oder Tresor auf, um es vor Diebstahl und Missbrauch zu schützen.

Erstellen eines JWT

Voraussetzungen

Bevor du loslegst, solltest du sicherstellen, dass du einen Zugriffsschlüssel im Entwicklerportal erstellt und gespeichert hast.

Zum Fortfahren benötigst du Folgendes: developer_id, key_id und signing_secret

JavaScript

npm install jsonwebtoken

Python

pip install pyjwt

Kotlin

gradle.properties:

    # JWT
    jjwtVersion=0.10.6

build.gradle.kts:

    dependencies {
        testImplementation(kotlin("test"))
        val jjwtVersion: String by project
        implementation("io.jsonwebtoken:jjwt-api:$jjwtVersion")
        implementation("io.jsonwebtoken:jjwt-impl:$jjwtVersion")
        implementation("io.jsonwebtoken:jjwt-jackson:$jjwtVersion")
    }

C#

dotnet add package System.IdentityModel.Tokens.Jwt

So erstellst du ein JWT

JavaScript

const jwt = require('jsonwebtoken')

const data = {
  aud: 'doordash',
  iss: '{developer_id}',
  kid: '{key_id}',
  exp: Math.floor(Date.now() / 1000 + 60),
  iat: Math.floor(Date.now() / 1000),
}

const headers = {
  algorithm: 'HS256',
  header: { 'dd-ver': 'DD-JWT-V1' },
}

const token = jwt.sign(data, Buffer.from('{signing_secret}', 'base64'), headers)

Python

import jwt.utils
import time
import math

token = jwt.encode(
    {
        "aud": "doordash",
        "iss": "{developer_id}",
        "kid": "{key_id}",
        "exp": str(math.floor(time.time() + 60)),
        "iat": str(math.floor(time.time())),
    },
    jwt.utils.base64url_decode("{signing_secret}"),
    algorithm="HS256",
    headers={"dd-ver": "DD-JWT-V1"})

PHP

function base64UrlEncode(string $data): string
{
    $base64Url = strtr(base64_encode($data), '+/', '-_');

    return rtrim($base64Url, '=');
}

function base64UrlDecode(string $base64Url): string
{
    return base64_decode(strtr($base64Url, '-_', '+/'));
}

$header = json_encode([
    'alg' => 'HS256',
    'typ' => 'JWT',
    'dd-ver' => 'DD-JWT-V1'
]);

$payload = json_encode([
    'aud' => 'doordash',
    'iss' => '{developer_id}',
    'kid' => '{key_id}',
    'exp' => time() + 60,
    'iat' => time()
]);

$base64UrlHeader = base64UrlEncode($header);
$base64UrlPayload = base64UrlEncode($payload);

$signature = hash_hmac('sha256', $base64UrlHeader . "." . $base64UrlPayload, base64UrlDecode({signing_secret}), true);
$base64UrlSignature = base64UrlEncode($signature);

$jwt = $base64UrlHeader . "." . $base64UrlPayload . "." . $base64UrlSignature;

Kotlin

import io.jsonwebtoken.Header
import io.jsonwebtoken.Jwts
import io.jsonwebtoken.io.Decoders
import io.jsonwebtoken.security.Keys
import java.security.Key
import java.time.ZoneOffset
import java.time.ZonedDateTime
import kotlin.collections.HashMap

val claims = HashMap<String, Any?>();

claims["aud"] = "doordash";
claims["iss"] = "{developer_id}";
claims["kid"] = "{key_id}";
claims["exp"] = ZonedDateTime.now(ZoneOffset.UTC).plusMinutes(1).toEpochSecond()
claims["iat"] = ZonedDateTime.now(ZoneOffset.UTC).toEpochSecond();

val keyBytes = Decoders.BASE64URL.decode("{signing_secret}")
val key: Key = Keys.hmacShaKeyFor(keyBytes)

val jwt: String = Jwts.builder()
    .setHeaderParam("dd-ver", "DD-JWT-V1")
    .setHeaderParam("typ", "JWT")
    .setClaims(claims)
    .signWith(key)
    .compact();

C#

using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;

var decodedSecret = Base64UrlEncoder.DecodeBytes("{signing_secret}");
var securityKey = new SymmetricSecurityKey(decodedSecret);
var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
var header = new JwtHeader(credentials);
header["dd-ver"] = "DD-JWT-V1";

var payload = new JwtPayload(
    issuer: "{developer_id}",
    audience: "doordash",
    claims: new List<Claim> { new Claim("kid", "{key_id}") },
    notBefore: null,
    expires: System.DateTime.UtcNow.AddSeconds(60),
    issuedAt: System.DateTime.UtcNow);

var securityToken = new JwtSecurityToken(header, payload);
var token = new JwtSecurityTokenHandler().WriteToken(securityToken);