> For the complete documentation index, see [llms.txt](https://docs.payments.thalescloud.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.payments.thalescloud.io/ecom/es/integre-la-api-de-d1/obtenga-un-token-de-acceso-oauth-2.0.md).

# Obtenga un token de acceso OAuth 2.0

Las API entrantes D1 utilizan el flujo OAuth 2.0 JWT bearer (RFC 7523). Su sistema envía un JSON Web Token (JWT) firmado a `/oauth2/token` para obtener un token de acceso.

{% hint style="info" %}
D1 también puede asegurar las API salientes con OAuth 2.0 bajo solicitud. Consulte la especificación OpenAPI de salida para el flujo compatible.
{% endhint %}

<figure><img src="/files/ecb57f131a755387b1909d0c9319545a56fe2042" alt="OAuth 2.0 JWT bearer flow for access token"><figcaption><p>Flujo OAuth 2.0 JWT bearer</p></figcaption></figure>

Use la especificación OpenAPI entrante para la `/oauth2/token` definición completa.

Cada recurso de la API backend a backend está protegido. Para obtener acceso a él, el Token de Acceso generado previamente debe enviarse junto con la solicitud HTTP en el encabezado Authorization usando el esquema Bearer:

`Authorization: Bearer <access_token>`

{% hint style="info" %}
El token de acceso que se genera tiene una duración de 15 minutos, por lo que solo puede usarse durante 15 minutos; después de ese tiempo, el cliente tendrá que llamar nuevamente a la API /oauth2/token para obtener un token nuevo. Por razones de rendimiento, si su token aún está dentro de su período de validez, recomendamos que lo reutilice en lugar de llamar a la API /oauth2/token antes de cada llamada a la API.
{% endhint %}

### JSON Web Token (JWT)

La API REST /oauth2/token requiere autenticación mediante JSON Web Token (JWT) ([rfc7519](https://datatracker.ietf.org/doc/html/rfc7519.html)). Se supone que los clientes de esta API son capaces de emitir tokens JWT válidos.

Los tokens JWT pueden obtenerse solicitándolos a un Proveedor de Identidad (como Keycloak) o crearse manualmente. En ambos casos, la clave pública que se usará para la verificación de la firma debe aprovisionarse en el sistema del proveedor de la API.

En el caso de que no haya un Proveedor de Identidad disponible, la siguiente sección describe cómo generar tokens JWT y las claves criptográficas que se usarán para emitir y verificar el JWT.

#### Algoritmos

Solo se admiten los JWT firmados con el algoritmo "ES256". Vea JSON Web Algorithms (JWA) ([rfc7518](https://datatracker.ietf.org/doc/html/rfc7518)).

La seguridad del JWT se limita a algoritmos de criptografía asimétrica para evitar almacenar secretos compartidos en el servidor de back-end. Como resultado, el servidor de back-end solo almacena las claves públicas utilizadas para verificar la firma de los tokens.

#### Formato JWT

Un JWT consta de tres partes separadas por puntos (.):

* Encabezado
* Carga útil
* Firma

Por lo tanto, un JWT suele verse como lo siguiente: `hhhhhhh.pppppppp.ssssssssss`

#### Encabezado

La parte del encabezado contiene el algoritmo a usar y el tipo de token a generar.

El `kid` es obligatorio y se utilizará para determinar la clave correcta entre múltiples posibles claves públicas del mismo cliente.

Ejemplo de encabezado:

```json
{
  "alg": "ES256",
  "typ": "JWT",
  "kid": "your_tenant_key_id"
}
```

#### Carga útil

La carga útil puede contener los siguientes campos:

| Parámetro | Descripción                                                                                                                                                                                                                                                                                     |
| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| iss       | El emisor del JWT. Debe ser el `merchantGatewayId` para las API entrantes y `d1` para las API salientes y se utiliza para buscar la clave pública incorporada.                                                                                                                                  |
| sub       | El sujeto debe contener el identificador técnico del usuario. Aquí, para la API backend a backend, el sub es el `merchantGatewayId`.                                                                                                                                                            |
| exp       | La hora de expiración del token expresada como el número de segundos desde el 1 de enero de 1970 (tiempo Epoch) en UTC. El valor máximo es la fecha/hora actual + 15 minutos.                                                                                                                   |
| aud       | El campo aud identifica al servidor de autorización como una audiencia prevista. Por su parte, el servidor de autorización debe verificar que es una audiencia prevista para el token. Use la URL del servidor de autorización como valor de la audiencia: staging = `stg` , producción = `prd` |

{% hint style="info" %}

#### Notas sobre la expiración del JWT <a href="#jwt-expiration-notes" id="jwt-expiration-notes"></a>

El `exp` el valor se comprueba frente al periodo máximo de expiración. Si el `exp` valor del JWT excede el periodo máximo de expiración, el JWT se considera automáticamente inválido y la solicitud queda no autenticada.
{% endhint %}

Ejemplo de carga útil

```json
{
  "iss": "d1",
  "sub": "MGW_ID",
  "exp": 1545222654,
  "aud": "stg"
}
```

#### Firma JWT

Un hash criptográfico tanto del encabezado como de la carga útil.

Estas partes se codifican en Base64URL y se concatenan, separadas por puntos simples ('.').

### Cómo generar el par de claves

Puede usar la herramienta openssl para generar un par de claves con los siguientes comandos:

#### Ejemplo (ES256)

Genere la clave privada que se utilizará en el lado emisor y que DEBE protegerse de forma segura en su entorno.

```bash
> openssl ecparam -name prime256v1 -genkey -noout -out customer-jwt-priv-key.pem
```

Genere la clave pública que DEBE configurarse en D1.

```bash
> openssl ec -in customer-jwt-priv-key.pem -pubout > customer-jwt-pub-key.pem
```

La clave privada generada se utilizará para firmar los JWT en el lado del cliente y la clave pública generada se aprovisionará en el lado del servidor con el kid para verificar la firma de esos JWT (intercambiada entre el Cliente y Thales durante el Onboarding).

### Cómo generar el JWT

Hay muchas herramientas disponibles para ayudar con la generación de JWT.

Aquí hay un ejemplo de cómo generarlo usando una pequeña librería de NodeJS:

```js
/*
Por favor instale la biblioteca *jose* en su proyecto.
https://www.npmjs.com/package/jose

Para este ejemplo usamos la 3.19.0
*/
const { SignJWT } = require("jose/jwt/sign");
const { createPrivateKey } = require("crypto");

const alg = "ES256";
const kid = "your_tenant_key_id";
const iss = "your_issuer";
const aud = "your_audience";
const expirationTime = "3mins";
const sub = "our_user_for_audit";

const privateKeyPem = `-----BEGIN EC PRIVATE KEY----- 
MHcCAQEEILlIXMnH1if8EuWykPmWw/LyXZuoNVCzMp3Yhbj9/sEUoAoGCCqGSM49 
AwEHoUQDQgAE6swczLIRn/lPxQPpdUb2pHjCr0YeC02lkG7vMmqCNpalwIQSl+TR 
fZVDwCKJmajRgK3+n5SyAgCp4oH8qNluwQ==
-----END EC PRIVATE KEY-----`;

async function generateJwt() {
  const privateKey = createPrivateKey(privateKeyPem);

  console.log(
    await new SignJWT({})
      .setProtectedHeader({ alg, kid })
      .setIssuedAt()
      .setIssuer(iss)
      .setAudience(aud)
      .setExpirationTime(expirationTime)
      .setSubject(sub)
      .sign(privateKey)
  );
}

(async () => {
  await generateJwt();
})();
```

Ejemplo de salida JWT

```
eyJhbGciOiJFUzI1NiIsImtpZCI6InlvdXJfdGVuYW50X2tleV9pZCJ9.eyJpYXQiOjE2MzYwMzMxODYsImlzcyI6InlvdXJfaXNzdWVyX2lkIiwiYXVkIjoieW91cl9hdWRpZW5jZSIsImV4cCI6MTYzNjAzMzM2Niwic3ViIjoib3VyX3VzZXJfZm9yX2F1ZGl0In0.lgVzN8k9IGcv1s-FZACpEyVxXcS9LAh4ahY3DO5Fg6MRl-Twa_wVAfw_Oe0XiH1Am-RFfafgDrepNi3Jz05Gvg
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.payments.thalescloud.io/ecom/es/integre-la-api-de-d1/obtenga-un-token-de-acceso-oauth-2.0.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
