Créer un JWT

Marketplace APIs are limited access

Notre pipeline d’intégration Marketplace est actuellement au maximum de sa capacité. Nous n’acceptons pas de nouveaux partenaires pour le moment pendant que nous développons des outils libre-service pour l’intégration des commerçants. Veuillez remplir le formulaire d’intérêt pour l’intégration de Marketplace pour communiquer avec DoorDash avant de développer votre intégration.

Les JWT (JSON Web Tokens) sont un format de jeton d'authentification utilisé pour communiquer avec les API DoorDash. Ils permettent à deux parties de communiquer en toute sécurité en signant les informations. Les JWT permettent aux utilisateurs d'établir la confiance avec le service sans nécessiter l’envoie d’une clé secrète par voie électronique. De plus, tous les langages de programmation couramment utilisés prennent en charge la création de JWT.

Un JWT comme méthode d’authentification dans l’API

Afin de vous authentifier auprès de l’API, fournissez le JWT en tant que jeton du porteur dans l’en-tête d’authentification.

Authorization: Bearer [JWT]
auth-version: v2

Structure d'un JWT

Les JWT sont constitués de trois parties séparées par des points, soit les suivantes :

• En-tête
• Charge utile
• Signature

Le résultat est un jeton qui ressemble à aaa.bbb.ccc

En-tête

L'en-tête spécifie l'algorithme utilisé pour signer le jeton – HMAC SHA 265 (HS265) et la version DoorDash du JWT (v1)

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

L'en-tête, la première partie du JWT, est chiffrée selon la méthode base64url.

Charge utile

Le contenu du jeton en tant qu'objet json. Le destinataire peut faire confiance à ce contenu.

Format de la charge utile

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

aud – audience. Toujours régler comme "doordash".

iss – créateur. Indiquer l'identifiant du développeur (format UUID).

kid – Identifiant de clé. Indiquer l'identifiant de clé (format UUID) utilisé pour signer le JWT.

iat – date d’émission du JWT. Le moment de création du jeton. Le nombre de secondes depuis l’époque. La valeur d’iat ne peut pas être dans le futur.

exp – expiration. Le moment d’expiration du jeton. Le nombre de secondes depuis l’époque. La valeur maximale d’exp est 30 minutes (1 800 secondes) après la valeur d’iat (le moment d’émission).

Exemple

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

La charge utile est encodée base64url et constitue la deuxième partie du JWT.

Signature

La signature est utilisée pour vérifier l'authenticité du contenu. Seule une personne possédant la clé secrète peut produire la signature appropriée. La signature est calculée à l'aide de l'algorithme HMAC SHA256 (HS256).

La signature, la troisième partie du JWT, est chiffrée selon la méthode base64url.

Protection de votre clé secrète

Traitez votre clé secrète de signature comme un mot de passe. Placez votre clé secrète dans un endroit sécurisé ou un coffre-fort pour empêcher le vol et l’utilisation frauduleuse.

Créer un JWT

Conditions préalables

Avant de commencer, assurez-vous d'avoir créé et enregistré une clé d'accès à partir du Portail des développeurs.

Pour continuer, vous aurez besoin de : developer_id , key_id et signature_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

Comment générer un JWT

JavaScript

const jwt = require('jsonwebtoken')

const data = {
  aud: 'doordash',
  iss: '{developer_id}',
  kid: '{key_id}',
  exp: Math.floor(Date.now() / 1000 + 300),
  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() + 300)),
        "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() + 300,
    '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(5).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(300),
    issuedAt: System.DateTime.UtcNow);

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