> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Découvrez comment effectuer une importation groupée d’utilisateurs avec la Management API.
# Schéma et exemples d’importation groupée d’utilisateurs
Le fichier d’utilisateurs doit contenir un tableau JSON avec les informations des utilisateurs.
La taille maximale du fichier pour une importation groupée est de 500KB. Vous devrez lancer plusieurs importations si vos données dépassent cette limite.
## Schéma JSON d’un utilisateur
Le schéma JSON suivant décrit les objets utilisateur valides :
```json lines expandable theme={null}
{
"type": "object",
"properties": {
"email": {
"type": "string",
"description": "The user's email address.",
"format": "email"
},
"email_verified": {
"type": "boolean",
"default": false,
"description": "Indicates whether the user has verified their email address."
},
"user_id": {
"type": "string",
"description": "The user's unique identifier. This will be prepended by the connection strategy."
},
"username": {
"type": "string",
"description": "The user's username."
},
"given_name": {
"type": "string",
"description": "The user's given name."
},
"family_name": {
"type": "string",
"description": "The user's family name."
},
"name": {
"type": "string",
"description": "The user's full name."
},
"nickname": {
"type": "string",
"description": "The user's nickname."
},
"picture": {
"type": "string",
"description": "URL pointing to the user's profile picture."
},
"blocked": {
"type": "boolean",
"description": "Indicates whether the user has been blocked."
},
"password_hash": {
"type": "string",
"description": "Hashed password for the user. Passwords should be hashed using bcrypt $2a$ or $2b$ and have 10 saltRounds."
},
"custom_password_hash": {
"type": "object",
"description": "A more generic way to provide the users password hash. This can be used in lieu of the password_hash field when the users password hash was created with an alternate algorithm. Note that this field and password_hash are mutually exclusive.",
"properties": {
"algorithm": {
"type": "string",
"enum": [
"argon2",
"bcrypt",
"hmac",
"ldap",
"md4",
"md5",
"sha1",
"sha256",
"sha512",
"pbkdf2",
"scrypt"
],
"description": "The algorithm that was used to hash the password."
},
"hash": {
"type": "object",
"properties": {
"value": {
"type": "string",
"description": "The password hash."
},
"encoding": {
"type": "string",
"enum": [
"base64",
"hex",
"utf8"
],
"description": "The encoding of the provided hash. Note that both upper and lower case hex variants are supported, as well as url-encoded base64."
},
"digest": {
"type": "string",
"description": "The algorithm that was used to generate the HMAC hash",
"enum": [
"md4",
"md5",
"ripemd160",
"sha1",
"sha224",
"sha256",
"sha384",
"sha512",
"whirlpool"
]
},
"key": {
"type": "object",
"description": "The key that was used to generate the HMAC hash",
"required": [
"value"
],
"properties": {
"value": {
"type": "string",
"description": "The key value"
},
"encoding": {
"type": "string",
"enum": [
"base64",
"hex",
"utf8"
],
"default": "utf8",
"description": "The key encoding"
}
}
}
}
},
"salt": {
"type": "object",
"properties": {
"value": {
"type": "string",
"description": "The salt value used to generate the hash."
},
"encoding": {
"type": "string",
"enum": [
"base64",
"hex",
"utf8"
],
"default": "utf8",
"description": "The encoding of the provided salt. Note that both upper and lower case hex variants are supported, as well as url-encoded base64."
},
"position": {
"type": "string",
"enum": [
"prefix",
"suffix"
],
"default": "prefix",
"description": "The position of the salt when the hash was calculated. For example; MD5('salt' + 'password') = '67A1E09BB1F83F5007DC119C14D663AA' would have \"position\":\"prefix\"."
}
},
"required": [
"value"
]
},
"password": {
"type": "object",
"properties": {
"encoding": {
"type": "string",
"enum": [
"ascii",
"utf8",
"utf16le",
"ucs2",
"latin1",
"binary"
],
"default": "utf8",
"description": "The encoding of the password used to generate the hash. On login, the user-provided password will be transcoded from utf8 before being checked against the provided hash. For example; if your hash was generated from a ucs2 encoded string, then you would supply \"encoding\":\"ucs2\"."
}
}
},
"keylen": {
"type": "integer",
"description": "Desired key length in bytes for the scrypt hash. Must be an integer greater than zero. Required when algorithm is set to scrypt."
},
"cost": {
"type": "integer",
"default": 16384,
"description": "CPU/memory cost parameter used for the scrypt hash. Must be a power of two greater than one. Only used when algorithm is set to scrypt."
},
"blockSize": {
"type": "integer",
"default": 8,
"description": "Block size parameter used for the scrypt hash. Must be a positive integer. Only used when algorithm is set to scrypt."
},
"parallelization": {
"type": "integer",
"default": 1,
"description": "Parallelization parameter used for the scrypt hash. Must be a positive integer. Only used when algorithm is set to scrypt."
}
},
"required": [
"algorithm",
"hash"
],
"additionalProperties": false
},
"app_metadata": {
"type": "object",
"description": "Data related to the user that does affect the application's core functionality."
},
"user_metadata": {
"type": "object",
"description": "Data related to the user that does not affect the application's core functionality."
},
"mfa_factors": {
"type": "array",
"items": {
"type": "object",
"properties": {
"totp": {
"type": "object",
"properties": {
"secret": {
"type": "string",
"pattern": "^[A-Z2-7]+$",
"description": "The OTP secret is used with authenticator apps (Google Authenticator, Microsoft Authenticator, Authy, 1Password, LastPass). It must be supplied in un-padded Base32 encoding, such as: JBTWY3DPEHPK3PNP"
}
},
"additionalProperties": false,
"required": [
"secret"
]
},
"phone": {
"type": "object",
"properties": {
"value": {
"type": "string",
"pattern": "^\\+[0-9]{1,15}$",
"description": "The phone number for SMS MFA. The phone number should include a country code and begin with +, such as: +12125550001"
}
},
"additionalProperties": false,
"required": [
"value"
]
},
"email": {
"type": "object",
"properties": {
"value": {
"type": "string",
"format": "email",
"description": "The email address for MFA"
}
},
"additionalProperties": false,
"required": [
"value"
]
}
},
"maxProperties": 1,
"additionalProperties": false
},
"minItems": 1,
"maxItems": 10
}
},
"required": [
"email"
],
"additionalProperties": false
}
```
Pour en savoir plus sur le schéma JSON, consultez [jsonschema.org](http://json-schema.org).
## Propriétés
Vous pouvez importer des utilisateurs avec les propriétés suivantes :
| Propriété | Type | Description | Upsert pendant l’importation ? |
| ---------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------ |
| `app_metadata` | object | Données pouvant affecter les fonctionnalités de base de l’application ou les éléments auxquels l’utilisateur peut accéder. Les données stockées dans `app_metadata` ne peuvent pas être modifiées par les utilisateurs. Cela peut inclure, par exemple, des forfaits de soutien, des rôles ou des groupes d’accès. | Oui |
| `blocked` | boolean | Indique si l’utilisateur a été bloqué. | Non |
| `email` | string | L’adresse de courriel de l’utilisateur. | Non |
| `email_verified` | boolean | Indique si l’utilisateur a vérifié son adresse de courriel. La valeur par défaut est `false` si `email` est mis à jour par upsert, mais pas `email_verified`. | Oui |
| `family_name` | string | Le nom de famille de l’utilisateur. | Oui |
| `given_name` | string | Le prénom de l’utilisateur. | Oui |
| `name` | string | Le nom complet de l’utilisateur. | Oui |
| `nickname` | string | Le surnom de l’utilisateur. | Oui |
| `picture` | string | URL pointant vers l’image de profil de l’utilisateur. | Oui |
| `user_id` | string | L’identifiant unique de l’utilisateur. Il sera préfixé par la stratégie de connexion. | Non |
| `user_metadata` | object | Données qui n’ont pas d’incidence sur les éléments auxquels les utilisateurs peuvent ou non accéder, comme l’adresse professionnelle, l’adresse du domicile ou les préférences de l’utilisateur. | Oui |
| `username` | string | Le nom d’utilisateur de l’utilisateur. | Non |
| `password_hash` | string | Mot de passe haché pour la connexion de l’utilisateur. Lorsqu’un utilisateur est créé, Auth0 utilise [bcrypt](https://auth0.com/blog/hashing-in-action-understanding-bcrypt/) pour sécuriser le mot de passe. L’importation de mots de passe hachés permet aux utilisateurs de conserver leurs mots de passe, pour une expérience plus fluide. Les mots de passe compatibles doivent être hachés à l’aide de bcrypt $2a$ ou $2b$ et utiliser 10 `saltRounds`. Cette propriété ne peut être fournie que lors de la première importation de l’utilisateur et ne peut pas être mise à jour par la suite. | Non |
| `custom_password_hash` | object | Une façon plus générique de fournir le hachage du mot de passe de l’utilisateur. Cette propriété peut être utilisée à la place du champ `password_hash` lorsque le hachage du mot de passe de l’utilisateur a été créé avec un autre algorithme. Pendant le processus d’importation groupée, vous pouvez mettre à jour `custom_password_hash` si l’utilisateur ne s’est pas connecté à l’aide du `custom_password_hash` importé initialement. | Oui |
| `mfa_factors` | array | Les facteurs MFA qui peuvent être utilisés pour authentifier cet utilisateur. | Non |
Pour en savoir plus sur `app_metadata` et `user_metadata`, consultez [Comprendre le fonctionnement des métadonnées dans les profils utilisateur](/fr-CA/docs/manage-users/user-accounts/metadata).
## Métadonnées de l’application
L’objet `user.app_metadata` ne doit **pas** contenir les propriétés suivantes :
* `__tenant`
* `_id`
* `blocked`
* `clientID`
* `created_at`
* `email_verified`
* `email`
* `globalClientID`
* `global_client_id`
* `identities`
* `lastIP`
* `lastLogin`
* `loginsCount`
* `metadata`
* `multifactor_last_modified`
* `multifactor`
* `updated_at`
* `user_id`
## Hachage personnalisé du mot de passe
L’objet `user.custom_password_hash` peut être utilisé à la place de la propriété `user.password_hash` lorsque le hachage du mot de passe de l’utilisateur a été créé avec un autre algorithme. Notez que ce champ et `password_hash` sont mutuellement exclusifs.
L’objet `user.custom_password_hash` possède les propriétés suivantes :
| Propriété | Type | Description |
| ------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `algorithm` | chaîne | L’algorithme utilisé pour hacher le mot de passe. Doit être l’un des suivants : - `argon2`
- `bcrypt`
- `hmac`
- `ldap`
- `md4`
- `md5`
- `sha1`
- `sha256`
- `sha512`
- `pbkdf2`
- `scrypt`
|
| `hash` | objet | |
| `hash.value` | chaîne | Le hachage du mot de passe. |
| `hash.encoding` | chaîne | L’encodage du hachage fourni. Doit être l’un des suivants : Les variantes hexadécimales en majuscules et en minuscules sont prises en charge, ainsi que le base64 encodé dans l’URL. |
| `hash.digest` | chaîne | L’algorithme utilisé pour générer le hachage HMAC. Doit être l’un des suivants : - `md4`
- `md5`
- `ripemd160`
- `sha1`
- `sha224`
- `sha256`
- `sha384`
- `sha512`
- `whirlpool`
|
| `hash.key` | objet | La clé utilisée pour générer le hachage HMAC. |
| `hash.key.value` | chaîne | La valeur de la clé. |
| `hash.key.encoding` | chaîne | L’encodage de la clé. Doit être l’un des suivants : Par défaut, `hash.key.encoding` est `utf8`. |
| `salt` | objet | |
| `salt.value` | chaîne | La valeur du sel utilisée pour générer le hachage. |
| `salt.encoding` | chaîne | L’encodage du sel fourni. Doit être l’un des suivants : Les variantes hexadécimales en majuscules et en minuscules sont prises en charge, ainsi que le base64 encodé dans l’URL. Par défaut, `salt.encoding` est `utf8`. |
| `salt.position` | chaîne | La position du sel au moment du calcul du hachage. Par défaut, `salt.position` est `prefix`. |
| `password.encoding` | chaîne | L’encodage du mot de passe utilisé pour générer le hachage. Doit être l’un des suivants : - `ascii`
- `utf8`
- `utf16le`
- `ucs2`
- `latin1`
- `binary`
À la connexion, le mot de passe fourni par l’utilisateur sera transcodé depuis `password.encoding` avant d’être vérifié par rapport au hachage fourni. Par exemple, si votre hachage a été généré à partir d’une chaîne encodée en `ucs2`, vous devez définir : ` "encoding": "ucs2"` |
| `keylen` | entier | Longueur de clé souhaitée, en octets, pour le hachage scrypt. Doit être un entier supérieur à zéro.
Ce paramètre est requis lorsque `algorithm` est défini sur `scrypt`. |
| `cost` | entier | Paramètre de coût CPU/mémoire utilisé pour le hachage scrypt. Doit être une puissance de deux supérieure à un. Par défaut, `cost` est 16384.
Ce paramètre est utilisé uniquement lorsque `algorithm` est défini sur `scrypt`. |
| `blockSize` | entier | Paramètre de taille de bloc utilisé pour le hachage scrypt. Doit être un entier positif. Par défaut, `blockSize` est 8.
Ce paramètre est utilisé uniquement lorsque `algorithm` est défini sur `scrypt`. |
| `parallelization` | entier | Paramètre de parallélisation utilisé pour le hachage scrypt. Doit être un entier positif. Par défaut, `parallelization` est 1.
Ce paramètre est utilisé uniquement lorsque `algorithm` est défini sur `scrypt`. |
### Mettre à jour le hachage personnalisé du mot de passe
Pendant le processus d’importation groupée, vous pouvez mettre à jour le `custom_password_hash` si l’utilisateur ne s’est pas connecté à l’aide du `custom_password_hash` importé initialement. Par exemple, vous pouvez soumettre le JSON ci-dessous deux fois à l’endpoint [`/api/v2/jobs/users-imports`](https://auth0.com/docs/api/management/v2?_ga=2.169020323.346193905.1601302257-746691936.1587131255#!/Jobs/post_users_imports) avec des valeurs différentes pour `custom_password_hash`. Lors du deuxième envoi, définissez l’indicateur `upsert` sur `true`.
```json lines theme={null}
[
{
"user_id": "2000",
"email": "examplecouser20@gmail.com",
"given_name": "ExampleCo User",
"name" : "ExampleCoUser20",
"custom_password_hash": {
"algorithm": "bcrypt",
"hash": {
"value": "$2a$10$aHF7mbpWT6tZ7PJVtwtjNelaKbszikcYBCB2jibvbFcGFmOsu/s4K"
}
}
}
]
```
Vous pouvez utiliser le [Bcrypt Password Generator](https://www.browserling.com/tools/bcrypt) de browserling.com pour générer des hachages bcrypt de mots de passe.
### Algorithmes de hachage pris en charge
Auth0 prend actuellement en charge l’importation de mots de passe d’utilisateurs hachés avec :
* [Argon2](https://github.com/p-h-c/phc-winner-argon2)
* [bcrypt](https://auth0.com/blog/hashing-in-action-understanding-bcrypt/)
* [LDAP](https://tools.ietf.org/html/rfc2307#section-5.3) (`RFC-2307 "userPassword"`)
* [HMAC](https://tools.ietf.org/html/rfc2104)
* [MD4](https://tools.ietf.org/html/rfc1320)
* [MD5](https://tools.ietf.org/html/rfc1321)
* [SHA1](https://tools.ietf.org/html/rfc3174)
* [SHA256 et SHA512](https://tools.ietf.org/html/rfc4634)
* [PBKDF2](https://tools.ietf.org/html/rfc2898#section-5.2)
* [scrypt](https://datatracker.ietf.org/doc/rfc7914/)
Veuillez consulter les sections suivantes lorsque vous fournissez un `custom_password_hash`.
#### Argon2
Lorsque `algorithm` est défini à `argon2` :
* `hash.encoding` doit être `utf8`.
* `hash.salt` n’est pas autorisé.
* `hash.value` doit être au format de chaîne PHC, comme indiqué dans [P-H-C / phc-string-format](https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md) sur GitHub. Il doit également respecter les exigences précisées dans [Auth0 / magic](https://github.com/auth0/magic#magicpasswordhash--magicverifypassword) sur GitHub.
* `hash.value` doit inclure le sel encodé en base64 (comme indiqué dans la documentation `PHC`).
#### bcrypt
Lorsque `algorithm` est défini sur `bcrypt` :
* `hash.encoding` doit être `utf8`.
* `hash.salt` est autorisé en combinaison avec l’encodage et la position du sel.
* `hash.value` doit inclure l’un de ces préfixes :
* `$2a$`
* `$2b$`
* `$2y$`
Les autres préfixes, comme `$2$`, `$sha1$` et `$2x$`, ne sont pas pris en charge pour le moment.
Par exemple, la valeur suivante a été générée à partir de la chaîne `hello` à l’aide d’un paramètre de coût de 10 :
`$2b$10$nFguVi9LsCAcvTZFKQlRKeLVydo8ETv483lkNsSFI/Wl1Rz1Ypo1K`
L’algorithme `bcrypt` traite au maximum 72 octets en entrée lors du calcul des hachages de mot de passe ou des comparaisons, et la longueur de `salt.value` compte dans cette limite de 72 octets. Toute entrée qui dépasse cette limite est tronquée; par exemple, si le sel consomme 10 octets, la longueur maximale du mot de passe pour le hachage ou la comparaison est de 62 octets.
Les mots de passe qui dépassent cette limite réduite sont tronqués, ce qui peut affaiblir la force du mot de passe ou provoquer des collisions de hachage. Validez toujours la longueur des mots de passe avant le hachage.
#### HMAC
Lorsque `algorithm` est défini à `hmac` :
* `hash.encoding` doit être `hex` ou `base64`.
* `hash.digest` est requis et doit correspondre à l’une des valeurs suivantes :
* `md4`
* `md5`
* `ripemd160`
* `sha1`
* `sha224`
* `sha256`
* `sha384`
* `sha512`
* `whirlpool`
* `hash.key.value` est requis.
* `hash.key.encoding` doit être `base64`, `hex` ou `utf8`.
#### LDAP
Lorsque `algorithm` est défini à `ldap` :
* `hash.encoding` doit être `utf8`.
* `salt` n’est pas autorisé.
* `hash.value` doit respecter le format indiqué dans la [section 5.3 de la RFC-2307](https://tools.ietf.org/html/rfc2307#section-5.3) sur IETF Datatracker.
* Le schéma doit être l’un des suivants : `md5|smd5|sha*|ssha*` ; consultez [ce document](https://www.openldap.org/faq/data/cache/347.html) pour en savoir plus.
* Notez que le schéma [crypt](https://www.openldap.org/faq/data/cache/344.html) n’est **pas pris en charge** en raison d’un comportement qui dépend du système ou de l’implémentation. Pour en savoir plus, consultez [Open LDAP Admin Guide - 14.4.2. CRYPT password storage scheme](https://www.openldap.org/doc/admin24/guide.html#CRYPT%20password%20storage%20scheme).
#### MD ou SHA
Lorsque `algorithm` est défini à `md4`, `md5`, `sha1`, `sha256` ou `sha512` :
* `hash.encoding` doit être `hex` ou `base64`.
#### PBKDF2
Lorsque `algorithm` est défini à `pbkdf2` :
* `hash.encoding` doit être `utf8`.
* `hash.salt` n'est pas permis.
* `hash.value` doit être au format de chaîne PHC, comme indiqué dans [P-H-C / phc-string-format](https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md) sur GitHub.
* `hash.value` doit inclure le sel encodé en B64 (base64 sans les caractères de remplissage `=`, comme indiqué dans la documentation `PHC`).
* `hash.value` devrait inclure les paramètres `i` (itérations) et `l` (longueur de clé). Si ces paramètres sont omis, les valeurs par défaut seront `i=100000` et `l=64`.
* L'`id` doit être au format `pbkdf2-` (`pbkdf2-sha512`, `pbkdf2-md5`, etc.). Les condensés pris en charge sont :
* `RSA-MD4`
* `RSA-MD5`
* `RSA-MDC2`
* `RSA-RIPEMD160`
* `RSA-SHA1`
* `RSA-SHA1-2`
* `RSA-SHA224`
* `RSA-SHA256`
* `RSA-SHA384`
* `RSA-SHA512`
* `md4`
* `md4WithRSAEncryption`
* `md5`
* `md5WithRSAEncryption`
* `mdc2`
* `mdc2WithRSA`
* `ripemd`
* `ripemd160`
* `ripemd160WithRSA`
* `rmd160`
* `sha1`
* `sha1WithRSAEncryption`
* `sha224`
* `sha224WithRSAEncryption`
* `sha256`
* `sha256WithRSAEncryption`
* `sha384`
* `sha384WithRSAEncryption`
* `sha512`
* `sha512WithRSAEncryption`
* `ssl3-md5`
* `ssl3-sha1`
* `whirlpool`
#### scrypt
Lorsque `algorithm` est défini sur `scrypt` :
* `hash.encoding` doit être soit `hex`, soit `base64`.
* Le paramètre `keylen` est obligatoire.
* Le paramètre `cost` peut être spécifié; sinon, la valeur par défaut sera 16384.
* Le paramètre `blockSize` peut être spécifié; sinon, la valeur par défaut sera 8.
* Le paramètre `parallelization` peut être spécifié; sinon, la valeur par défaut sera 1.
### Facteurs MFA
Le tableau `user.mfa_factors` contient les inscriptions MFA de l’utilisateur. Pour en savoir plus, consultez [l’authentification multifacteur dans Auth0](/fr-CA/docs/secure/multi-factor-authentication). L’importation des inscriptions évite aux utilisateurs d’avoir à se réinscrire à l’authentification multifacteur après l’importation. Les types d’inscription pris en charge sont :
| Propriété | Type | Description |
| ------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `email` | object | |
| `email.value` | string | L’adresse de courriel utilisée pour l’authentification MFA. |
| `phone` | object | |
| `phone.value` | string | Le numéro de téléphone utilisé pour l’authentification MFA par SMS. Il doit inclure un code de pays et commencer par `+`, par exemple : `"+12125550001"` |
| `totp` | object | |
| `totp.secret` | string | Le secret OTP utilisé pour l’authentification MFA avec des applications d’authentificateur (Google Authenticator, Microsoft Authenticator, Authy, 1Password, LastPass). Il doit être encodé en Base32 sans remplissage, par exemple : `"JBTWY3DPEHPK3PNP"` |
## Exemples
### Exemple de base
Un fichier dont le contenu est le suivant est valide :
```json lines theme={null}
[
{
"email": "john.doe@contoso.com",
"email_verified": false,
"app_metadata": {
"roles": ["admin"],
"plan": "premium"
},
"user_metadata": {
"theme": "light"
}
}
]
```
### Exemples de hachages de mots de passe personnalisés
Voici quelques exemples d’utilisateurs pour lesquels des hachages sont fournis :
```json lines expandable theme={null}
[
{
"email": "antoinette@contoso.com",
"email_verified": false,
"custom_password_hash": {
"algorithm": "md4",
"hash": {
"value": "AbuUujgF0pPPkJPSFRTpmA==",
"encoding": "base64"
}
}
},
{
"email": "mary@contoso.com",
"email_verified": false,
"custom_password_hash": {
"algorithm": "sha256",
"hash": {
"value": "d24e794fce503c3ddb1cd1ba1dd5d9b250cf9917336a0316fefd87fecf79200f",
"encoding": "hex"
},
"salt": {
"value": "abc123",
"position": "prefix"
}
}
},
{
"email": "velma@contoso.com",
"email_verified": false,
"custom_password_hash": {
"algorithm": "bcrypt",
"hash": {
"value": "$2b$10$C9hB01.YxRSTcn/ZOOo4j.TW7xCKKFKBSF.C7E0xiUwumqIDqWUXG"
}
}
},
{
"email": "edward@contoso.com",
"email_verified": false,
"custom_password_hash": {
"algorithm": "argon2",
"hash": {
"value": "$argon2id$v=19$m=65536,t=2,p=1$J6Q/82PCyaNpYKRELJyTZg$m04qUAB8rexWDR4+/0f+SFB+4XMFxt7YAvAq2UycYos"
}
}
},
{
"email": "terrell@contoso.com",
"email_verified": false,
"custom_password_hash": {
"algorithm": "pbkdf2",
"hash": {
"value": "$pbkdf2-md4$i=100000,l=64$+N375B8q0Fw$fp2R9KAM4hK/votGHC5Fu+jhqbxUD8+Nic/EMSGvNC3UP/k7wSHI0uXluHRSkZfl/BOheYqNOemayG90ZaSSQw",
"encoding": "utf8"
}
}
},
{
"email": "cecil@contoso.com",
"email_verified": false,
"custom_password_hash": {
"algorithm": "pbkdf2",
"hash": {
"value": "$pbkdf2-sha512$i=100000,l=64$KNyFsA2rWoE$I2CQGI9H0JxdDf3kERRI97kPCGxh0KWBIV3MxyaS191gDGfzVBGyS4BibhgqWQ0/ails8mHuU9ckASxHOOq58w"
}
}
},
{
"email": "sean@contoso.com",
"email_verified": false,
"custom_password_hash": {
"algorithm": "ldap",
"hash": {
"value": "{SSHA384}/cgEjdoZh85DhurDeOQEMO1rMlAur93SVPbYe5XSD4lF7nNuvrBju5hUeg9A6agRemgSXGl5YuE=",
"encoding": "utf8"
}
}
},
{
"email": "peter@contoso.com",
"email_verified": false,
"custom_password_hash": {
"algorithm": "hmac",
"hash": {
"value": "cg7f42jH39/2EaAU4wNd4s2lKIk=",
"encoding": "base64",
"digest": "sha1",
"key": {
"value": "736868",
"encoding": "hex"
}
}
}
},
{
"email": "carmella@contoso.com",
"email_verified": false,
"custom_password_hash": {
"algorithm": "scrypt",
"hash": {
"value": "097f6197e1b41538f723e32aa7a68e8d76227d8e432ce5faa4882a913032db29",
"encoding": "hex"
},
"salt": {
"value": "abc123",
"encoding": "utf8"
},
"keylen": 32,
"cost": 4096
}
}
]
```
### Exemples de facteurs MFA
Comme on peut s’y attendre, le tableau `user.mfa_factors` vous permet d’indiquer les inscriptions MFA de l’utilisateur. Les types d’inscription pris en charge sont :
* Téléphone : utilisé pour la vérification par SMS.
* TOTP : secret OTP à utiliser avec des applications d’authentification MFA (Google Authenticator, Microsoft Authenticator, Authy, 1Password, LastPass).
* Courriel : utilisé pour la vérification par courriel.
Voici quelques exemples d’utilisateurs avec des facteurs MFA :
```json lines expandable theme={null}
[
{
"email": "antoinette@contoso.com",
"mfa_factors": [
{
"totp": {
"secret": "2PRXZWZAYYDAWCD"
}
},
{
"phone": {
"value": "+15551112233"
}
},
{
"email": {
"value": "antoinette@antoinette.biz"
}
}
]
},
{
"email": "mary@contoso.com",
"mfa_factors": [
{
"totp": {
"secret": "JBTWY3DPEHPK3PNP"
}
}
]
},
{
"email": "velma@contoso.com",
"mfa_factors": [
{
"phone": {
"value": "+15551234567"
}
},
]
},
{
"email": "edward@contoso.com",
"mfa_factors": [
{
"email": {
"value": "edward@edward.biz"
}
}
]
}
]
```
## En savoir plus
* [Importation groupée d’utilisateurs](/fr-CA/docs/manage-users/user-migration/bulk-user-imports)
* [Exportation groupée d’utilisateurs](/fr-CA/docs/manage-users/user-migration/bulk-user-exports)
* [Configurer la migration automatique à partir de votre base de données](/fr-CA/docs/manage-users/user-migration/configure-automatic-migration-from-your-database)