> ## Documentation Index
> Fetch the complete documentation index at: https://docs-dev-feat-init-gt-translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Configurez les notifications par SMS et par appel vocal comme facteurs MFA Auth0 avec Twilio, le fournisseur Auth0 intégré ou un fournisseur personnalisé pour envoyer des codes à usage unique.
# Configurer les notifications par SMS et par appel vocal pour MFA
export const AuthCodeGroup = ({children, dropdown}) => {
const [processedChildren, setProcessedChildren] = useState(children);
useEffect(() => {
let unsubscribe = null;
function init() {
unsubscribe = window.autorun(() => {
const processChildren = node => {
if (typeof node === "string") {
let processedNode = node;
for (const [key, value] of window.rootStore.variableStore.values.entries()) {
const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value);
}
return processedNode;
} else if (Array.isArray(node)) {
return node.map(processChildren);
} else if (node && node.props && node.props.children) {
return {
...node,
props: {
...node.props,
children: processChildren(node.props.children)
}
};
}
return node;
};
setProcessedChildren(processChildren(children));
});
}
if (window.rootStore) {
init();
} else {
window.addEventListener("adu:storeReady", init);
}
return () => {
window.removeEventListener("adu:storeReady", init);
unsubscribe?.();
};
}, [children]);
return {processedChildren};
};
export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
const [displayText, setDisplayText] = useState(children);
const [copyText, setCopyText] = useState(children);
const wrapperRef = React.useRef(null);
useEffect(() => {
let unsubscribe = null;
function init() {
if (!window.autorun || !window.rootStore) {
return;
}
unsubscribe = window.autorun(() => {
let processedChildrenForDisplay = children;
let processedChildrenForCopy = children;
for (const [key, value] of window.rootStore.variableStore.values.entries()) {
const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
let displayValue = value;
if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
displayValue = value.substring(0, 3) + "*****MASQUÉ*****";
}
processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
}
setDisplayText(processedChildrenForDisplay);
setCopyText(processedChildrenForCopy);
});
}
if (window.rootStore) {
init();
} else {
window.addEventListener("adu:storeReady", init);
}
return () => {
window.removeEventListener("adu:storeReady", init);
unsubscribe?.();
};
}, [children]);
useEffect(() => {
if (!wrapperRef.current) return;
const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
let isOverriding = false;
const handleClick = e => {
const button = e.target.closest('[data-testid="copy-code-button"]');
if (!button || !wrapperRef.current.contains(button)) return;
isOverriding = true;
navigator.clipboard.writeText = text => {
if (isOverriding) {
isOverriding = false;
navigator.clipboard.writeText = originalWriteText;
return originalWriteText(copyText);
}
return originalWriteText(text);
};
setTimeout(() => {
if (isOverriding) {
isOverriding = false;
navigator.clipboard.writeText = originalWriteText;
}
}, 100);
};
const wrapper = wrapperRef.current;
wrapper.addEventListener('click', handleClick, true);
return () => {
wrapper.removeEventListener('click', handleClick, true);
if (navigator.clipboard.writeText !== originalWriteText) {
navigator.clipboard.writeText = originalWriteText;
}
};
}, [copyText]);
return
{displayText}
;
};
Unified Phone Experience centralise toutes les configurations de votre fournisseur de téléphonie à un seul endroit dans votre tenant. Vous n’avez donc pas à configurer plusieurs fois le même fournisseur pour différents facteurs d’authentification téléphonique. Pour en savoir plus, consultez [Use Auth0's Unified Phone Experience for Multi-Factor Authentication](/docs/fr-ca/customize/phone-messages/unified-phone/use-auth0s-unified-phone-experience-for-multi-factor-authentication).
Si vous utilisez le SMS ou l’appel vocal comme facteurs d’authentification, lorsqu’un utilisateur final tente de s’authentifier auprès de votre application, un code lui est envoyé par SMS ou par appel vocal, qu’il devra saisir pour terminer la transaction. Cela signifie qu’il connaît ses informations de connexion et qu’il a en sa possession l’appareil qu’il a enregistré pour utiliser la MFA.
Vous pouvez configurer le facteur SMS et appel vocal à l’aide du Dashboard ou de la Management API pour envoyer des messages par SMS ou par appel vocal, ou pour permettre aux utilisateurs finaux de choisir comment ils veulent recevoir le code. Vous pouvez configurer votre fournisseur d’envoi de messages à l’aide d’Actions, configurer votre compte Twilio ou, si vous souhaitez envoyer uniquement des SMS à vos clients, configurer le service d’envoi de messages par défaut d’Auth0. Vous devez utiliser l’expérience Universal Login pour activer les notifications par appel vocal pour la MFA.
Votre mise en œuvre de connexion ainsi que votre plan Auth0 ou votre entente personnalisée déterminent si cette fonctionnalité est offerte. Pour en savoir plus, consultez [Pricing](https://auth0.com/pricing).
Fonctionnement
Lorsque SMS and Voice sont activés, les utilisateurs peuvent s’inscrire en recevant le code par SMS ou par appel vocal :
Lorsque vous activez seulement SMS, le processus est plus simple :
Une fois les utilisateurs inscrits, la prochaine fois qu’ils s’authentifieront, ils recevront un appel vocal ou un SMS à leur numéro de téléphone enregistré.
Utiliser le Dashboard
1. Accédez à [**Auth0 Dashboard > Security > Multi-factor Auth**](https://manage.auth0.com/#/security/mfa).
2. Sélectionnez **Phone Message**, puis activez l’interrupteur situé en haut de la page.
3. Indiquez si le fournisseur de messagerie téléphonique configuré sous **[Branding > Phone Provider](https://manage.auth0.com/#/phone/templates/phone/provider)** s’applique à votre locataire. Si c’est le cas, activez **Use Tenant-Level Messaging Provider**.
4. Choisissez votre méthode d’envoi :
* SMS : Envoi du code de vérification par SMS
* SMS et voix : Envoi du code de vérification par SMS ou par message vocal, au choix de l’utilisateur final.
* Voix : Envoi du code de vérification par message vocal.
5. Configurez la longueur et la durée de validité du code :
* Longueur du code : Saisissez une valeur entre 4 et 10 chiffres. La valeur par défaut est de 6 chiffres.
* Durée de validité du code : Saisissez une valeur entre 30 et 3 600 secondes. La valeur par défaut est de 300 secondes, soit 5 minutes.
Les clients sont responsables de toute réduction du niveau de sécurité découlant d’une modification visant à : (i) prolonger la durée d’expiration du code ou la durée du comportement de session « Remember Me » au-delà de la configuration standard recommandée par Okta; ou (ii) réduire la longueur de l’OTP sous le nombre de caractères prévu par la configuration standard recommandée par Okta.
6. Configurez votre fournisseur de messagerie téléphonique, puis accédez à **[Branding > Phone Provider](https://manage.auth0.com/#/phone/templates/phone/provider)** :
1. **Twilio** : Envoie les messages à l’aide de l’[API Twilio Programmable SMS](https://www.twilio.com/sms) pour les SMS ou de l’[API Twilio Programmable Voice](https://www.twilio.com/voice) pour les messages vocaux. Utilisez les identifiants Twilio Live, et non les identifiants de test, qui servent uniquement à envoyer des messages dans un environnement de production. Pour en savoir plus, consultez [Configurer Twilio comme fournisseur de messagerie téléphonique](/docs/fr-ca/customize/phone-messages/configure-phone-messaging-providers/configure-twilio-as-a-phone-messaging-provider).
2. **Personnalisé** : Envoie les messages en appelant une Action dans le [Send Phone Message Flow](/docs/fr-ca/customize/actions/explore-triggers/mfa-notifications-trigger).
* [Configurer un fournisseur téléphonique personnalisé avec Terraform](/docs/fr-ca/customize/phone-messages/configure-phone-messaging-providers/configure-a-custom-phone-provider/configure-a-custom-phone-provider-with-terraform)
* [Configurer un fournisseur téléphonique personnalisé avec Twilio Verify](/docs/fr-ca/customize/phone-messages/configure-phone-messaging-providers/configure-a-custom-phone-provider/configure-a-custom-phone-provider-with-twilio-verify)
Configuration de Twilio
Veuillez noter qu’il peut falloir jusqu’à huit (8) semaines à Twilio pour transférer et vérifier des importations en bloc. Pour en savoir plus, consultez le [Twilio Help Center](https://help.twilio.com/articles/223179468-How-long-does-it-take-to-port-a-number-to-Twilio).
Si vous choisissez d’envoyer des SMS par l’intermédiaire de Twilio, suivez ces étapes pour configurer votre facteur SMS.
1. Ouvrez un compte chez Twilio. Vous aurez besoin d’un [Twilio Account SID](https://www.twilio.com/help/faq/twilio-basics/what-is-an-application-sid) et d’un [Twilio Auth Token](https://www.twilio.com/help/faq/twilio-basics/what-is-the-auth-token-and-how-can-i-change-it). Ce sont les identifiants API Twilio qu’Auth0 utilisera pour envoyer un SMS à l’utilisateur.
2. Vous pourriez aussi devoir activer les permissions pour votre région géographique pour les [SMS](https://support.twilio.com/hc/en-us/articles/223181108-How-International-SMS-Permissions-work) ou la [voix](https://www.twilio.com/console/voice/calls/geo-permissions). Si vous utilisez la voix, votre compte doit avoir un numéro de téléphone Twilio activé pour effectuer des appels vocaux. Il peut s’agir d’un numéro de téléphone externe [vérifié avec Twilio](https://support.twilio.com/hc/en-us/articles/223180048-Adding-a-Verified-Phone-Number-or-Caller-ID-with-Twilio), ou vous pouvez acheter et configurer un numéro de téléphone Twilio dans votre compte.
3. Configurez la connexion. Accédez à [**Auth0 Dashboard > Sécurité > Multi-factor Auth**](https://manage.auth0.com/#/security/mfa) et choisissez **Phone Message**.
4. Sous **Choose your delivery provider**, choisissez **Twilio** et sélectionnez un mode d’envoi.
5. Saisissez votre **Twilio Account SID** et votre **Twilio Auth Token** dans les champs appropriés.
6. Choisissez votre **SMS Source**.
1. Si vous choisissez **Use From**, vous devrez saisir le numéro de téléphone **From** que les utilisateurs verront comme expéditeur du SMS. Vous pouvez aussi le configurer dans Twilio.
2. Si vous choisissez **Use Messaging Services**, vous devrez saisir un [Messaging Service SID](https://www.twilio.com/docs/sms/services/services-send-messages).
3. Si vous utilisez la voix, vous devez toujours configurer **From**, même si vous utilisez **Message Services** pour les SMS. Assurez-vous que le numéro de téléphone est configuré pour envoyer à la fois des SMS et des messages vocaux.
7. Sélectionnez **Save**.
Personnaliser les modèles de messages SMS ou vocaux
Vous pouvez personnaliser vos modèles de messages SMS et vocaux. Pour en savoir plus, consultez [Personnaliser les messages SMS et vocaux](/docs/fr-ca/customize/customize-sms-or-voice-messages).
Utiliser la Management API
Vous pouvez utiliser la Management API pour configurer les modes d’envoi des messages activés à l’aide du point de terminaison `/api/v2/guardian/factors/phone/message-types`. Le paramètre `message_types` est un tableau qui peut contenir `["sms"]`, `["voice"]` ou `["sms", "voice"]`. Vous avez besoin d’un [jeton d’accès à la Management API](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) avec la portée `update:guardian_factors`, sous forme de bearer token, pour effectuer une requête à l’API :
Vous utilisez l’Auth0 CLI ? Si ce n’est pas déjà fait, [configurez et authentifiez votre session CLI](/docs/fr-ca/deploy-monitor/auth0-cli) avant d’exécuter cette commande.
```bash Auth0 CLI theme={null}
auth0 api put "guardian/factors/phone/message-types" \
--data '{ "message_types": ["sms", "voice"] }'
```
```bash cURL theme={null}
curl --request PUT \
--url 'https://{yourDomain}/api/v2/guardian/factors/phone/message-types' \
--header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
--header 'content-type: application/json' \
--data '{ "message_types": ["sms", "voice"] }'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/api/v2/guardian/factors/phone/message-types");
var request = new RestRequest(Method.PUT);
request.AddHeader("content-type", "application/json");
request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
request.AddParameter("application/json", "{ "message_types": ["sms", "voice"] }", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```
```go Go theme={null}
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://{yourDomain}/api/v2/guardian/factors/phone/message-types"
payload := strings.NewReader("{ "message_types": ["sms", "voice"] }")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("content-type", "application/json")
req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}
```
```java Java theme={null}
HttpResponse response = Unirest.put("https://{yourDomain}/api/v2/guardian/factors/phone/message-types")
.header("content-type", "application/json")
.header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
.body("{ "message_types": ["sms", "voice"] }")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'PUT',
url: 'https://{yourDomain}/api/v2/guardian/factors/phone/message-types',
headers: {
'content-type': 'application/json',
authorization: 'Bearer MGMT_API_ACCESS_TOKEN'
},
data: {message_types: ['sms', 'voice']}
};
axios.request(options).then(function (response) {
console.log(response.data);
}).catch(function (error) {
console.error(error);
});
```
```php PHP theme={null}
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://{yourDomain}/api/v2/guardian/factors/phone/message-types",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => "{ "message_types": ["sms", "voice"] }",
CURLOPT_HTTPHEADER => [
"authorization: Bearer MGMT_API_ACCESS_TOKEN",
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
```
```python Python theme={null}
import http.client
conn = http.client.HTTPSConnection("")
payload = "{ "message_types": ["sms", "voice"] }"
headers = {
'content-type': "application/json",
'authorization': "Bearer MGMT_API_ACCESS_TOKEN"
}
conn.request("PUT", "/{yourDomain}/api/v2/guardian/factors/phone/message-types", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```ruby Ruby theme={null}
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://{yourDomain}/api/v2/guardian/factors/phone/message-types")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_PEER
request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
request.body = "{ "message_types": ["sms", "voice"] }"
response = http.request(request)
puts response.read_body
```
Fournisseurs de messagerie SMS intégrés
Par défaut, Auth0 prend en charge l’envoi de messages au moyen de Twilio. Toutefois, vous pouvez utiliser un autre fournisseur SMS, ajouter une logique particulière avant l’envoi d’un message ou envoyer un message différent selon l’utilisateur ou l’application. Pour ce faire, configurez la MFA par SMS pour utiliser l’une de nos [Actions](/docs/fr-ca/customize/actions) intégrées au [Send Phone Message Flow](/docs/fr-ca/customize/actions/explore-triggers/mfa-notifications-trigger).
Les fournisseurs de messagerie SMS intégrés comprennent :
* [Amazon SNS](https://marketplace.auth0.com/integrations/amazon-sms-provider)
* [ClickSend](https://marketplace.auth0.com/integrations/clicksend-sms)
* [Esendex](https://marketplace.auth0.com/integrations/esendex-sms-provider)
* [Infobip](https://marketplace.auth0.com/integrations/infobip-sms-provider)
* [Mitto](https://marketplace.auth0.com/integrations/mitto-sms-provider)
* [Telesign](https://marketplace.auth0.com/integrations/telesign-sms-verification)
Fournisseurs de téléphonie personnalisés
Vous pouvez aussi configurer des fournisseurs de téléphonie personnalisés à l’aide d’Actions. Pour en savoir plus, consultez [Configurer un fournisseur de téléphonie personnalisé](/docs/fr-ca/customize/phone-messages/configure-phone-messaging-providers/configure-a-custom-phone-provider).
Considérations de sécurité
Lorsque vous utilisez un fournisseur de messagerie téléphonique, sachez que des attaquants qui abusent du flux d’inscription pourraient vous causer des pertes financières.
Auth0 limite chaque utilisateur à l’envoi d’un maximum de 10 messages SMS ou vocaux par heure, et les flux OTP par courriel ou au moyen d’authenticators sont limités à cinq requêtes toutes les cinq minutes. (Le taux de rafale est de 10, mais seulement 1 message vocal par heure est envoyé pour les nouvelles requêtes.) Pour mieux protéger votre compte, envisagez ce qui suit :
* Activer [Suspicious IP Throttling](/docs/fr-ca/secure/attack-protection/suspicious-ip-throttling#signup-attempts). Auth0 bloque une adresse IP si elle tente d’effectuer plus de 50 requêtes d’inscription par minute.
* Activer [Log Streaming](/docs/fr-ca/customize/log-streams) et créer des alertes à l’aide de votre outil de surveillance préféré lorsque vous constatez des pics dans le nombre d’[événements de journalisation](/docs/fr-ca/deploy-monitor/logs/log-event-type-codes) `gd_send_voice`, `gd_send_voice_failure`, `gd_send_sms` ou `gd_send_sms_failure`.
Les fournisseurs de messagerie téléphonique offrent des protections supplémentaires. Si vous utilisez Twilio, consultez le [guide Anti-Fraud pour les développeurs de Twilio](https://www.twilio.com/docs/usage/anti-fraud-developer-guide). Envisagez les options suivantes :
* Limitez les pays vers lesquels vous enverrez des messages pour [SMS](https://support.twilio.com/hc/en-us/articles/223181108-How-International-SMS-Permissions-work) et [Voice](https://support.twilio.com/hc/en-us/articles/223180228-International-Voice-Dialing-Geographic-Permissions-Geo-Permissions-and-How-They-Work). Cela est particulièrement utile s’il existe des pays où le risque de [fraude aux appels surtaxés](https://www.twilio.com/learn/voice-and-video/toll-fraud) est plus élevé ou où les tarifs d’appel sont plus coûteux, et avec lesquels vous ne faites habituellement pas affaire.
* Activez les [déclencheurs d’utilisation](https://support.twilio.com/hc/en-us/articles/223132387-Protect-your-Twilio-project-from-Fraud-with-Usage-Triggers) de Twilio pour protéger votre compte contre la fraude et les erreurs de code.
Pour en savoir plus
* [Inscrire des authentificateurs SMS et vocaux et lancer une vérification](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-challenge-sms-voice-authenticators)
* [Protection contre les attaques](/docs/fr-ca/secure/attack-protection)
* [Flux de journaux](/docs/fr-ca/customize/log-streams)