using Auth0.ManagementApi;
using System.Threading.Tasks;
using Auth0.ManagementApi.Clients;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.Clients.Credentials.CreateAsync(
            clientId: "client_id",
            request: new PostClientCredentialRequestContent {
                CredentialType = ClientCredentialTypeEnum.PublicKey
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    request := &management.PostClientCredentialRequestContent{
        CredentialType: management.ClientCredentialTypeEnumPublicKey,
    }
    mgmt.Clients.Credentials.Create(
        context.TODO(),
        "client_id",
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.clients.types.PostClientCredentialRequestContent;
import com.auth0.client.mgmt.types.ClientCredentialTypeEnum;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.clients().credentials().create(
            "client_id",
            PostClientCredentialRequestContent
                .builder()
                .credentialType(ClientCredentialTypeEnum.PUBLIC_KEY)
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Clients\Credentials\Requests\PostClientCredentialRequestContent;
use Auth0\SDK\API\Management\Types\ClientCredentialTypeEnum;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->clients->credentials->create(
    'client_id',
    new PostClientCredentialRequestContent([
        'credentialType' => ClientCredentialTypeEnum::PublicKey->value,
    ]),
);

from auth0.management import ManagementClient

client = ManagementClient(
    domain="{YOUR_DOMAIN}",
    token="<token>",
)

client.clients.credentials.create(
    client_id="client_id",
    credential_type="public_key",
)

require "auth0"

client = Auth0::Management.new(token: "<token>", base_url: "https://{YOUR_DOMAIN}/api/v2")

client.clients.credentials.create(
  client_id: "client_id",
  credential_type: "public_key"
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.clients.credentials.create("client_id", {
        credentialType: "public_key",
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.clients.credentials.create("client_id", {
        credentialType: "public_key",
    });
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/clients/{client_id}/credentials \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "alg": "RS256",
  "expires_at": "2023-02-07T12:40:17.807Z",
  "kid": "<string>",
  "name": "",
  "parse_expiry_from_cert": false,
  "pem": "-----BEGIN PUBLIC KEY-----\r\nMIIBIjANBg...\r\n-----END PUBLIC KEY-----\r\n",
  "subject_dn": "<string>"
}
'

{
  "alg": "RS256",
  "created_at": "2023-11-07T05:31:56Z",
  "expires_at": "2023-11-07T05:31:56Z",
  "id": "cred_1m7sfABoNTTKYwTQ8qt6tX",
  "kid": "IZSSTECp...",
  "name": "",
  "subject_dn": "<string>",
  "thumbprint_sha256": "<string>",
  "updated_at": "2023-11-07T05:31:56Z"
}

Identifiants POST

Créez des informations d’authentification du client associées à votre application. Ces informations d’authentification peuvent servir à configurer les méthodes d’authentification Private Key JWT et mTLS, ainsi que les requêtes Authorization sécurisées par JWT.

Clé publique

Les informations d’authentification de clé publique peuvent servir à configurer l’authentification du client Private Key JWT et les requêtes Authorization sécurisées par JWT.

Exemple :

{
  "credential_type": "public_key",
  "name": "string",
  "pem": "string",
  "alg": "RS256",
  "parse_expiry_from_cert": false,
  "expires_at": "2022-12-31T23:59:59Z"
}

Certificat (signé par une AC et auto-signé)

Les informations d’authentification de certificat peuvent servir à configurer l’authentification du client mTLS. Les certificats signés par une AC peuvent être configurés soit avec un certificat signé, soit uniquement avec le Subject DN du certificat.

Exemple de certificat signé par une AC (pem) :

{
  "credential_type": "x509_cert",
  "name": "string",
  "pem": "string"
}

Exemple de certificat signé par une AC (subject_dn) :

{
  "credential_type": "cert_subject_dn",
  "name": "string",
  "subject_dn": "string"
}

Exemple de certificat auto-signé :

{
  "credential_type": "cert_subject_dn",
  "name": "string",
  "pem": "string"
}

Les informations d’authentification seront créées, mais ne seront pas encore activées tant que vous n’aurez pas défini les propriétés correspondantes sur le client :

Pour activer ces informations d’authentification pour les méthodes d’authentification Private Key JWT ou mTLS, définissez la propriété client_authentication_methods sur le client. Pour en savoir plus, consultez Configure Private Key JWT Authentication et Configure mTLS Authentication
Pour activer ces informations d’authentification pour les requêtes Authorization sécurisées par JWT, définissez la propriété signed_request_object sur le client. Pour en savoir plus, consultez Configure JWT-secured Authorization Requests (JAR)

POST

https://{tenantDomain}/api/v2

clients

{client_id}

credentials

using Auth0.ManagementApi;
using System.Threading.Tasks;
using Auth0.ManagementApi.Clients;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.Clients.Credentials.CreateAsync(
            clientId: "client_id",
            request: new PostClientCredentialRequestContent {
                CredentialType = ClientCredentialTypeEnum.PublicKey
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    request := &management.PostClientCredentialRequestContent{
        CredentialType: management.ClientCredentialTypeEnumPublicKey,
    }
    mgmt.Clients.Credentials.Create(
        context.TODO(),
        "client_id",
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.clients.types.PostClientCredentialRequestContent;
import com.auth0.client.mgmt.types.ClientCredentialTypeEnum;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.clients().credentials().create(
            "client_id",
            PostClientCredentialRequestContent
                .builder()
                .credentialType(ClientCredentialTypeEnum.PUBLIC_KEY)
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Clients\Credentials\Requests\PostClientCredentialRequestContent;
use Auth0\SDK\API\Management\Types\ClientCredentialTypeEnum;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->clients->credentials->create(
    'client_id',
    new PostClientCredentialRequestContent([
        'credentialType' => ClientCredentialTypeEnum::PublicKey->value,
    ]),
);

from auth0.management import ManagementClient

client = ManagementClient(
    domain="{YOUR_DOMAIN}",
    token="<token>",
)

client.clients.credentials.create(
    client_id="client_id",
    credential_type="public_key",
)

require "auth0"

client = Auth0::Management.new(token: "<token>", base_url: "https://{YOUR_DOMAIN}/api/v2")

client.clients.credentials.create(
  client_id: "client_id",
  credential_type: "public_key"
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.clients.credentials.create("client_id", {
        credentialType: "public_key",
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.clients.credentials.create("client_id", {
        credentialType: "public_key",
    });
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/clients/{client_id}/credentials \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "alg": "RS256",
  "expires_at": "2023-02-07T12:40:17.807Z",
  "kid": "<string>",
  "name": "",
  "parse_expiry_from_cert": false,
  "pem": "-----BEGIN PUBLIC KEY-----\r\nMIIBIjANBg...\r\n-----END PUBLIC KEY-----\r\n",
  "subject_dn": "<string>"
}
'

{
  "alg": "RS256",
  "created_at": "2023-11-07T05:31:56Z",
  "expires_at": "2023-11-07T05:31:56Z",
  "id": "cred_1m7sfABoNTTKYwTQ8qt6tX",
  "kid": "IZSSTECp...",
  "name": "",
  "subject_dn": "<string>",
  "thumbprint_sha256": "<string>",
  "updated_at": "2023-11-07T05:31:56Z"
}

Autorisations

Authorization

string

header

requis

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Paramètres de chemin

client_id

string

requis

ID du client.

Corps

credential_type

enum<string>

requis

Type d’information d’authentification.

Options disponibles:

public_key,

cert_subject_dn,

x509_cert

alg

enum<string>

défaut:RS256

Algorithme qui sera utilisé avec le justificatif. Peut être l’un des suivants : RS256, RS384, PS256. S’il n’est pas précisé, RS256 sera utilisé. S’applique au type de justificatif public_key.

Options disponibles:

RS256,

RS384,

PS256

expires_at

string<date-time>

défaut:2023-02-07T12:40:17.807Z

Date au format ISO 8601 représentant l’expiration du credential. Si elle n’est pas précisée (non recommandé), le credential n’expire jamais. S’applique au type de credential public_key.

kid

string

kid (Key ID) facultatif, utilisé pour identifier de façon unique le credential. S’il n’est pas précisé, une valeur kid sera générée automatiquement. Le paramètre d’en-tête kid dans les JWT envoyés par votre client doit correspondre à cette valeur. Le format valide est [0-9a-zA-Z-_]{10,64}

Required string length: 10 - 64

Pattern: ^([0-9a-zA-Z-_]{10,64})$

name

string

défaut:""

Nom convivial d’un credential.

Maximum string length: 128

parse_expiry_from_cert

boolean

défaut:false

Analyse la date d’expiration à partir du certificat X.509. Si true, tente d’analyser la date d’expiration à partir du PEM fourni. S’applique au type de credential public_key.

pem

string

défaut:-----BEGIN PUBLIC KEY----- MIIBIjANBg... -----END PUBLIC KEY-----

Clé publique au format PEM (SPKI et PKCS1) ou certificat X.509. Doit être échappé en JSON.

subject_dn

string

Nom distinctif du sujet. Mutuellement exclusif avec la propriété pem. S’applique au type de credential cert_subject_dn.

Required string length: 1 - 256

Réponse

Informations d’authentification créées avec succès.

alg

enum<string>

défaut:RS256

Algorithme qui sera utilisé avec l’information d’authentification. Algorithmes pris en charge : RS256,RS384,PS256

Options disponibles:

RS256,

RS384,

PS256

created_at

string<date-time>

Date de création du credential au format ISO 8601.

credential_type

enum<string>

Type d’information d’authentification.

Options disponibles:

public_key,

cert_subject_dn,

x509_cert

expires_at

string<date-time>

Date au format ISO 8601 représentant l’expiration du credential.

string

défaut:cred_1m7sfABoNTTKYwTQ8qt6tX

ID du credential. Généré à la création.

kid

string

défaut:IZSSTECp...

Identificateur de clé du credential, généré à la création.

name

string

défaut:""

Nom donné au credential par l’utilisateur.

subject_dn

string

Nom distinctif du sujet du certificat X.509

thumbprint_sha256

string

Empreinte SHA256 du certificat X.509

updated_at

string<date-time>

Date de mise à jour du credential au format ISO 8601.