Configuration des notifications SMS et vocales pour l’authentification multifacteur (MFA)

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.

La disponibilité varie selon le plan Auth0

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.

Fonctionnement

Lorsque les SMS et la voix sont activés, les utilisateurs ont la possibilité 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 simple :

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).

  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 pour les SMS ou l’API Twilio Programmable 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.

    Vous pouvez également sélectionner d’offrir aux utilisateurs la possibilité de recevoir des SMS, des appels vocaux ou les deux.

Configuration de 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 et d’un Twilio Auth Token (Jeton d’authentification Twilio). 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 ou voix. 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 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) 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).

    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.

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) avec la permission update:guardian_factors en tant que jeton du porteur pour appeler l’API :




  


  
  
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"] }'
Was this helpful?
/
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);
Was this helpful?
/
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))

}
Was this helpful?
/
HttpResponse<String> 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();
Was this helpful?
/
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);
});
Was this helpful?
/
#import <Foundation/Foundation.h>

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];
Was this helpful?
/
$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;
}
Was this helpful?
/
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"))
Was this helpful?
/
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
Was this helpful?
/
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()
Was this helpful?
/



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 dans le Flux d’envoi de messages téléphoniques.
Fournisseurs de messagerie SMS intégrés :
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é.
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 à :
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. Considérez les options suivantes :
En savoir plus