Obtenir les clés de chiffrement

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

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.Keys.Encryption.ListAsync(
            new ListEncryptionKeysRequestParameters {
                Page = 1,
                PerPage = 1,
                IncludeTotals = true
            }
        );
    }

}

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.ListEncryptionKeysRequestParameters{
        Page: management.Int(
            1,
        ),
        PerPage: management.Int(
            1,
        ),
        IncludeTotals: management.Bool(
            true,
        ),
    }
    mgmt.Keys.Encryption.List(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.keys.types.ListEncryptionKeysRequestParameters;

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

        client.keys().encryption().list(
            ListEncryptionKeysRequestParameters
                .builder()
                .page(1)
                .perPage(1)
                .includeTotals(true)
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Keys\Encryption\Requests\ListEncryptionKeysRequestParameters;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->keys->encryption->list(
    new ListEncryptionKeysRequestParameters([
        'page' => 1,
        'perPage' => 1,
        'includeTotals' => true,
    ]),
);

from auth0.management import ManagementClient

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

client.keys.encryption.list(
    page=1,
    per_page=1,
    include_totals=True,
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.keys.encryption.list({
        page: 1,
        perPage: 1,
        includeTotals: true,
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.keys.encryption.list({
        page: 1,
        perPage: 1,
        includeTotals: true,
    });
}
main();

[
  {
    "created_at": "2023-11-07T05:31:56Z",
    "kid": "<string>",
    "updated_at": "2023-11-07T05:31:56Z",
    "parent_kid": "<string>",
    "public_key": "<string>"
  }
]

GET

https://{tenantDomain}/api/v2

keys

encryption

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

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.Keys.Encryption.ListAsync(
            new ListEncryptionKeysRequestParameters {
                Page = 1,
                PerPage = 1,
                IncludeTotals = true
            }
        );
    }

}

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.ListEncryptionKeysRequestParameters{
        Page: management.Int(
            1,
        ),
        PerPage: management.Int(
            1,
        ),
        IncludeTotals: management.Bool(
            true,
        ),
    }
    mgmt.Keys.Encryption.List(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.keys.types.ListEncryptionKeysRequestParameters;

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

        client.keys().encryption().list(
            ListEncryptionKeysRequestParameters
                .builder()
                .page(1)
                .perPage(1)
                .includeTotals(true)
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\Keys\Encryption\Requests\ListEncryptionKeysRequestParameters;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->keys->encryption->list(
    new ListEncryptionKeysRequestParameters([
        'page' => 1,
        'perPage' => 1,
        'includeTotals' => true,
    ]),
);

from auth0.management import ManagementClient

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

client.keys.encryption.list(
    page=1,
    per_page=1,
    include_totals=True,
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.keys.encryption.list({
        page: 1,
        perPage: 1,
        includeTotals: true,
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.keys.encryption.list({
        page: 1,
        perPage: 1,
        includeTotals: true,
    });
}
main();

[
  {
    "created_at": "2023-11-07T05:31:56Z",
    "kid": "<string>",
    "updated_at": "2023-11-07T05:31:56Z",
    "parent_kid": "<string>",
    "public_key": "<string>"
  }
]

Autorisations

Authorization

string

header

requis

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

Paramètres de requête

page

integer

Index de la page de résultats à renvoyer. La première page est 0.

Plage requise: x >= 0

per_page

integer

Nombre de résultats par page. La valeur par défaut est de 50 et la valeur maximale est de 100.

Plage requise: 1 <= x <= 100

include_totals

boolean

Renvoyer les résultats dans un objet contenant le nombre total de résultats (true) ou comme tableau direct de résultats (false, par défaut).

Réponse

Les clés ont été récupérées avec succès.

object[]
object

Clé de chiffrement

created_at

string<date-time>

requis

Horodatage de création de la clé

kid

string

requis

ID de la clé

state

enum<string>

requis

État de la clé

Options disponibles:

pre-activation,

active,

deactivated,

destroyed

type

enum<string>

requis

Type de clé

Options disponibles:

customer-provided-root-key,

environment-root-key,

tenant-master-key,

tenant-encryption-key

updated_at

string<date-time>

requis

Horodatage de mise à jour de la clé

parent_kid

string | null

ID de la clé d’encapsulation parente

public_key

string | null

Clé publique au format PEM