> ## Documentation Index > Fetch the complete documentation index at: https://auth0.com/llms.txt > Use this file to discover all available pages before exploring further. # Configuration des notifications SMS et vocales pour l’authentification multifacteur (MFA) > Décrit comment configurer des notifications SMS et vocales pour l’authentification multifacteur (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) + "*****MASKED*****"; } 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}
; }; L’expérience téléphonique unifiée centralise toutes les configurations de votre fournisseur de services téléphoniques au même endroit dans votre locataire. Vous n’avez donc pas besoin de configurer plusieurs fois le même fournisseur pour différents facteurs d’authentification. Pour en savoir plus, consultez [Configurer l’expérience téléphonique unifiée pour l’authentification multifacteurs (MFA)](/docs/fr-ca/customize/phone-messages/unified-phone/use-auth0s-unified-phone-experience-for-multi-factor-authentication). Si vous utilisez des notifications par SMS et par appels vocaux comme facteurs d’authentification, lorsqu’un utilisateur final tente de s’authentifier à l’aide de votre application, un code lui est envoyé par SMS ou par appel vocal, qu’il devra saisir pour terminer la transaction. Cela implique qu’ils connaissent leurs identifiants de connexion et qu’ils sont en possession de l’appareil qu’ils ont enregistré pour une utilisation MFA. Vous pouvez configurer le facteur SMS et voix à l’aide du tableau de bord ou de Management API pour envoyer des messages par SMS, voix ou pour permettre aux utilisateurs finaux de choisir comment ils souhaitent que le code soit livré. Vous pouvez configurer votre fournisseur de livraison à l’aide d’Actions, configurer votre compte Twilio ou, si vous souhaitez envoyer uniquement des SMS aux clients, configurer le service de livraison de messages par défaut d’Auth0. Vous devez utiliser l’expérience Universal Login (Connexion universelle) pour activer les notifications vocales pour MFA. L’implémentation propre à votre connexion et votre plan Auth0 ou accord personnalisé que vous utilisez déterminent si cette fonctionnalité est disponible. Pour en savoir plus, lisez [Tarification](https://auth0.com/pricing). ## Fonctionnement Lorsque les SMS et la voix sont activés, les utilisateurs ont ]\(/docs/images/lité de s’inscrire en recevant le code envoyé par SMS ou par voix : Configure SMS and Voice for MFA User Experience Voice Lorsque vous activez uniquement les SMS, le flux est plus si Configure SMS and Voice for MFA User Experience SMS Une fois les utilisateurs inscrits, la prochaine fois qu’ils s’authentifieront, ils recevront un un appel ou un SMS sur leur téléphone enregistré. ## Utiliser le Tableau de bord 1. Allez dans [Dashboard (Tableau de bord) > Security (Sécurité) > Multi-factor Auth (MFA) (Auth. multi-facteurs)](https://manage.auth0.com/#/multifactor-auth). 2. Cliquez sur **Phone Message (Message téléphonique)** et activez l’interrupteur à bascule en haut. 3. Sélectionnez votre fournisseur de messagerie préféré. 4. Pour permettre aux utilisateurs de s’authentifier par SMS et par voix, vous devez activer les facteurs SMS et voix et sélectionner votre méthode de livraison préférée : 1. **Auth0** : Vous ne pouvez pas utiliser ce fournisseur pour envoyer des messages vocaux. Envoie des messages SMS à l’aide du fournisseur de livraison SMS configuré en interne d’Auth0. Il ne peut être utilisé qu’à des fins d’évaluation et de test, avec un maximum de 100 messages par locataire pendant toute la durée de vie du locataire. Au-delà de la limite de 100 messages, les codes ne sont pas reçus. 2. **Twilio** : Envoie les messages en utilisant [l’API Twilio Programmable SMS](https://www.twilio.com/sms) pour les SMS ou [l’API Twilio Programmable Voice](https://www.twilio.com/voice) pour la voix. Utilisez les informations d’identification Twilio Life, et non les informations d’identification de test, qui sont uniquement destinées à envoyer des messages dans un environnement de production. 3. **Personnalisé** : Envoie les messages en invoquant une Action dans le [Flux d’envoi de messages téléphoniques](/docs/fr-ca/customize/actions/explore-triggers/mfa-notifications-trigger). Vous pouvez également sélectionner d’offrir aux utilisateurs la possibilité de recevoir des SMS, des appels vocaux ou les deux. ### Configuration de Twilio Attention, Twilio peut prendre jusqu’à huit (8) semaines pour porter et vérifier les importations en bloc. Pour en savoir plus, visitez le [Centre d’assistance Twilio](https://help.twilio.com/articles/223179468-How-long-does-it-take-to-port-a-number-to-Twilio). Si vous choisissez de distribuer des SMS via Twilio, suivez ces étapes pour configurer votre facteur SMS. 1. Ouvrez un compte avec Twilio. Vous aurez besoin d’un [Twilio Account SID (Identifiant de sécurité de compte Twilio](https://www.twilio.com/help/faq/twilio-basics/what-is-an-application-sid) et d’un [Twilio Auth Token (Jeton d’authentification Twilio)](https://www.twilio.com/help/faq/twilio-basics/what-is-the-auth-token-and-how-can-i-change-it). Il s’agit des informations d’identification de l’API Twilio qu’Auth0 utilisera pour envoyer un SMS à l’utilisateur. 2. Vous devrez peut-être également activer les autorisations pour votre région géographique pour [SMS](https://support.twilio.com/hc/en-us/articles/223181108-How-International-SMS-Permissions-work) ou [voix](https://www.twilio.com/console/voice/calls/geo-permissions). Si vous utilisez la voix, votre compte doit disposer d’un numéro de téléphone Twilio activé pour passer 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 depuis votre compte. 3. Configurer la connexion. Accédez à [Dashboard (Tableau de bord) > Security (Sécurité) > Multi-factor Auth (Authentification multifacteur)](https://manage.auth0.com/#/security/mfa) et sélectionnez **Phone Message (Message téléphonique)**. 4. Sous **Choose your delivery provider (Sélectionnez votre fournisseur de livraison)**, sélectionnez **Twilio** et sélectionnez un mode de livraison. 5. Saisissez votre **Twilio Account SID (Identifiant de sécurité de compte Twilio)** et **Twilio Auth Token (Jeton d’authentification Twilio)** dans les champs appropriés. 6. Sélectionnez votre **SMS Source (Source SMS)**. 1. Si vous sélectionnez **Use From (Utiliser à partir de)**, vous devrez saisir le numéro de téléphone **From (À partir de)** que les utilisateurs verront comme l’expéditeur du SMS. Vous pouvez également configurer ces paramètres dans Twilio. 2. Si vous sélectionnez **Use Messaging Services (Utiliser les services de messagerie)**, vous devrez saisir un [Messaging Service SID (Identifiant de sécurité de service de messagerie)](https://www.twilio.com/docs/sms/services/services-send-messages). 3. Si vous utilisez la voix, vous devez tout de même configurer **From (À partir de)** même si vous utilisez **Message Services (Services de messagerie)** pour SMS. Assurez-vous que le numéro de téléphone est configuré pour envoyer des SMS et des messages vocaux. 7. Cliquez sur **Save (Enregistrer)**. ### Personnalisez les modèles de SMS ou de messages vocaux Vous pouvez personnaliser vos modèles de SMS et de messages vocaux. Pour en savoir plus, consultez [Personnaliser les messages SMS et vocaux](/docs/fr-ca/customize/customize-sms-or-voice-messages). ## Utiliser Management API Vous pouvez utiliser Management API pour configurer les méthodes de livraison de messages activées à 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"]`, or `["sms", "voice"]`. Vous avez besoin d’un [Jeton d’accès à Management API)](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) avec la permission `update:guardian_factors` en tant que jeton du porteur pour appeler l’API : ```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); }); ``` ```objc Obj-C theme={null} #import NSDictionary *headers = @{ @"content-type": @"application/json", @"authorization": @"Bearer MGMT_API_ACCESS_TOKEN" }; NSDictionary *parameters = @{ @"message_types": @[ @"sms", @"voice" ] }; NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil]; NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/api/v2/guardian/factors/phone/message-types"] cachePolicy:NSURLRequestUseProtocolCachePolicy timeoutInterval:10.0]; [request setHTTPMethod:@"PUT"]; [request setAllHTTPHeaderFields:headers]; [request setHTTPBody:postData]; NSURLSession *session = [NSURLSession sharedSession]; NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) { if (error) { NSLog(@"%@", error); } else { NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response; NSLog(@"%@", httpResponse); } }]; [dataTask resume]; ``` ```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_NONE 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 ``` ```swift Swift theme={null} import Foundation let headers = [ "content-type": "application/json", "authorization": "Bearer MGMT_API_ACCESS_TOKEN" ] let parameters = ["message_types": ["sms", "voice"]] as [String : Any] let postData = JSONSerialization.data(withJSONObject: parameters, options: []) let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/api/v2/guardian/factors/phone/message-types")! as URL, cachePolicy: .useProtocolCachePolicy, timeoutInterval: 10.0) request.httpMethod = "PUT" request.allHTTPHeaderFields = headers request.httpBody = postData as Data let session = URLSession.shared let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in if (error != nil) { print(error) } else { let httpResponse = response as? HTTPURLResponse print(httpResponse) } }) dataTask.resume() ``` ## Fournisseurs de messagerie SMS intégrés Auth0 prend par défaut en charge l’envoi de messages via Twilio. Cependant, vous pouvez utiliser un autre fournisseur SMS, et ajouter une logique particulière avant d’envoyer un message ou envoyer un message différent selon l’utilisateur ou l’application. Pour ce faire, vous configurez la MFA SMS pour utiliser l’une de nos [Actions](/docs/fr-ca/customize/actions) dans le [Flux d’envoi de messages téléphoniques](/docs/fr-ca/customize/actions/explore-triggers/mfa-notifications-trigger). Fournisseurs de messagerie SMS intégrés : * [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-provider) * [Vonage](https://marketplace.auth0.com/integrations/vonage-sms-provider) ## Fournisseurs de services téléphoniques personnalisés Vous pouvez également configurer un fournisseur de services téléphoniques personnalisés à l’aide des Actions. Pour en savoir plus, consultez [Configurer un fournisseur de services téléphoniques personnalisé](/docs/fr-ca/customize/phone-messages/configure-phone-messaging-providers/configure-a-custom-phone-provider). ## Considérations relatives à la sécurité Lorsque vous utilisez un fournisseur de services de messagerie téléphonique, il est important de noter que des attaquants abusant le processus d’inscription pourraient entraîner des pertes financières. Auth0 limite un seul utilisateur à envoyer jusqu’à 10 SMS ou messages vocaux par heure, et les flux OTP via courriel ou authentificateurs sont limités à cinq requêtes toutes les cinq minutes. (Le taux de rafale est de 10, mais un seul message vocal par heure sera envoyé pour les nouvelles demandes.) Pour mieux protéger votre compte, pensez à : * Activer [Protection contre les attaques par force brute](/docs/fr-ca/secure/attack-protection/brute-force-protection). Auth0 bloquera une adresse IP si elle tente d’effectuer plus de 50 demandes d’inscription par minute. * Activez [Log Exportation des journaux](/docs/fr-ca/customize/log-streams) et créez des alertes à l’aide de votre outil de surveillance préféré lorsque vous constatez des pics dans le nombre de [événements des journaux](/docs/fr-ca/deploy-monitor/logs/log-event-type-codes), `gd_send_voice` ou `gd_send_voice_failure`. Les fournisseurs de messagerie téléphonique disposent de protections supplémentaires. Si vous utilisez Twilio, veuillez consulter le [Guide du développeur anti-fraude de Twilio](https://www.twilio.com/docs/usage/anti-fraud-developer-guide). Considérez les options suivantes : * Limitez les pays auxquels vous enverrez des messages [SMS](https://support.twilio.com/hc/en-us/articles/223181108-How-International-SMS-Permissions-work) et [Voix](https://support.twilio.com/hc/en-us/articles/223180228-International-Voice-Dialing-Geographic-Permissions-Geo-Permissions-and-How-They-Work). Ceci est particulièrement utile s’il existe des pays présentant un risque plus élevé de [fraude touchant les appels interurbains](https://www.twilio.com/learn/voice-and-video/toll-fraud) ou des tarifs d’appel plus chers avec lesquels vous n’avez pas l’habitude de faire des affaires. * Activez [usage triggers (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 codage. ## En savoir plus * [Facteurs d’authentification SMS et vocaux pour l’inscription et les défis de connexion](/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)