Crear un JWT

Marketplace APIs are limited access

En este momento, el proceso de integración en Marketplace se encuentra al máximo de su capacidad. No estamos aceptando nuevos socios por ahora, ya que estamos desarrollando herramientas de autogestión para la incorporación de tiendas. Completa el formulario para interesados en la integración de Marketplace para ponerte en contacto con DoorDash antes de realizar tu integración.

Los token web JSON (JWT) son una forma de token para autenticación que se usan para comunicarse con las API de DoorDash. Permiten que dos partes se comuniquen de forma segura al firmar la información. Los JWT permiten a los usuarios establecer confianza con el servicio sin tener que enviar un “secret” por la red. Además, la creación de JWT tiene asistencia en todos los lenguajes de programación comunes.

Usar un JWT para la autenticación con la API

Para realizar la autenticación con la API, proporciona el JWT como token Bearer en el encabezado de autenticación.

Authorization: Bearer [JWT]
auth-version: v2

Anatomía de un JWT

Los JWT constan de tres partes separadas por puntos que son:

• Encabezado
• Carga
• Firma

Los resultados son un token que se parece a aaa.bbb.ccc.

Encabezado

El encabezado especifica el algoritmo que se usa para firmar el token - HMAC SHA 265 (HS265) y la versión (v1) de JWT de DoorDash

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

El encabezado está codificado en Base64url y constituye la primera parte del JWT.

Carga

El contenido del token es un objeto json. El destinatario puede confiar en este contenido.

Formato de la carga

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

aud\: Audience (Audiencia). Siempre establecido en "doordash".

iss\: Issuer (Emisor). Se establece en la ID del desarrollador (formato UUID).

kid\: Key ID (ID principal). Se establece en la ID principal (formato UUID) que se usó para firmar el JWT.

iat\: Issued At (Emitido el). Cuando se creó el token. Formateado como segundos desde el Epoch. iat no puede ser en el futuro.

exp\: Expiration (Vencimiento). Cuando expira el token. Formateado como segundos desde el Epoch. exp tiene un valor máximo de 30 minutos (1800 segundos) más allá del momento en que se emitió.

EJEMPLO

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

La carga está codificada en Base64url y constituye la segunda parte del JWT.

Firma

La firma se utiliza para verificar la autenticidad del contenido. Solo alguien con el “secret” que permite firmar puede realizar la firma correcta. La firma se calcula mediante el algoritmo HMAC SHA256 (HS256).

La firma está codificada en Base64url y constituye la tercera parte del JWT.

Cómo proteger tu “secret”

Trata tu “secret” que permite firmar como una contraseña. Guarda tu “secret” en un almacén seguro o en una caja de seguridad para protegerlo de robos y usos indebidos.

Creación de un JWT

Requisitos previos

Antes de comenzar, asegúrate de haber creado y guardado una clave de acceso en el Portal para desarrolladores.

Para continuar, necesitarás developer_id, key_id y 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

Cómo generar 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);