> ## 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 configurer vos applications pour utiliser le SSO natif vers le Web.
# Configurer et mettre en œuvre le SSO natif vers le Web
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}
;
};
## Configurer le SSO natif vers le Web
Pour utiliser le SSO natif vers le Web, configurez vos applications natives et Web (Single Page App ou Regular Web App) pour créer et gérer des sessions avec la Management API d’Auth0.
Vous devez disposer d’un [jeton d’accès](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens) pour utiliser la Management API ou Auth0 CLI.
Pour configurer le SSO natif vers le Web, vous devez créer et gérer des session\_transfer\_tokens et configurer vos applications natives et Web.
Le SSO natif vers le Web prend en charge les SDK suivants : [Auth0 Android SDK](https://github.com/auth0/auth0.android/blob/main/EXAMPLES.md#native-to-web-sso-login-ea), [Auth0 Swift SDK](https://github.com/auth0/Auth0.swift/blob/master/EXAMPLES.md#sso-credentials-ea) et [Auth0 React Native SDK](https://github.com/auth0/react-native-auth0/blob/master/EXAMPLES.md#native-to-web-sso-early-access).
La prise en charge du SSO natif vers le Web est offerte dans les outils suivants : [Auth0 Deploy CLI](/fr-CA/docs/deploy-monitor/deploy-cli-tool), [Auth0 Terraform Provider](/fr-CA/docs/deploy-monitor/auth0-terraform-provider) et [Auth0 CLI](https://auth0.github.io/auth0-cli/).
Le SSO natif vers le Web prend en charge tout flux d’authentification qui renvoie un jeton d’actualisation, comme [Resource Owner Password Flow](/fr-CA/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa) et [Authorization Code Flow with Proof Key for Code Exchange](/fr-CA/docs/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce).
### Créer et gérer des jetons de transfert de session
Le premier appel à la Management API permet à vos applications natives et web de :
* Créer et gérer des `session_transfer_tokens`
* Créer des sessions dans un navigateur web au moyen de cookies ou d’un paramètre d’URL
* Lier la session à l’appareil d’un utilisateur à l’aide d’une adresse IP ou d’un ASN
Pour les applications existantes, effectuez un appel `PATCH` au point de terminaison [Update a Client](https://auth0.com/docs/api/management/v2/clients/patch-clients-by-id). Pour créer une nouvelle application, effectuez un appel `POST` au point de terminaison [Create a Client](https://auth0.com/docs/api/management/v2/clients/post-clients) :
```json lines theme={null}
{
"session_transfer": {
"can_create_session_transfer_token": false,
"allowed_authentication_methods": ["cookie", "query"],
"enforce_device_binding": "ip", // aussi "none" ou "asn",
"allow_refresh_token": false,
"enforce_cascade_revocation": true,
"enforce_online_refresh_tokens": true
}
}
```
### Configurer les applications natives
Une fois l’utilisateur authentifié, Auth0 renvoie un [jeton d’accès](/fr-CA/docs/secure/tokens/access-tokens), un [jeton d’identité](/fr-CA/docs/secure/tokens/id-tokens) et, éventuellement, un [jeton d’actualisation](/fr-CA/docs/secure/tokens/refresh-tokens).
Vous pouvez configurer votre application native pour échanger un jeton d’actualisation contre un jeton de transfert de session. Si votre application Web ne prend pas en charge l’injection de cookies, votre application native doit aussi configurer l’**URI de connexion** de votre application Web afin d’injecter le jeton de transfert de session en tant que paramètre d’URI.
* Mettez à jour votre application native à l’aide de Auth0 Dashboard :
1. Accédez à [Dashboard > Applications](https://manage.auth0.com/dashboard/#/applications) :
2. Sélectionnez ou [créez votre application](/fr-CA/docs/get-started/auth0-overview/create-applications#create-applications).
3. Sélectionnez l’onglet **Settings**.
4. Sous **Session Transfer**, activez **Allow Native to Web SSO**.
5. Sélectionnez **Require Cascade Revocation** pour révoquer automatiquement la session de l’application Web et les jetons associés.
6. Sélectionnez **Save** pour mettre à jour votre application.
* Mettez à jour votre application native à l’aide de votre jeton d’accès pour la Management API avec le point de terminaison [Update a Client](https://auth0.com/docs/api/management/v2/clients/patch-clients-by-id) :
export const codeExample1 = `curl --request PATCH \
--url 'https://{yourDomain}/api/v2/clients/{yourClientId}' \
--header 'authorization: Bearer {yourMgmtApiAccessToken}' \
--header 'content-type: application/json' \
--data '{
"session_transfer": {
"can_create_session_transfer_token": true,
"enforce_cascade_revocation": true
}
}'`;
* Mettez à jour votre application native avec [Auth0 CLI](https://auth0.github.io/auth0-cli/auth0_apps_session-transfer_update.html) :
export const codeExample2 = `auth0 apps session-transfer update {yourClientId} --can-create-token=true`;
### Configurer les applications Web
Avant d’activer le jeton de transfert de session, assurez-vous d’avoir configuré l’**URI de connexion de l’application** de votre application Web pour accepter des paramètres supplémentaires. Pour en savoir plus sur les URI, consultez [Paramètres de l’application](/fr-CA/docs/get-started/applications/application-settings#application-uris).
* Mettez à jour votre application Web à l’aide d’Auth0 Dashboard :
1. Accédez à [Dashboard > Applications](https://manage.auth0.com/dashboard/#/applications) :
2. Sélectionnez ou créez votre application Web.
3. Sélectionnez l’onglet **Settings**.
4. Sous **Session Transfer**, activez **Native to Web SSO Methods**.
5. Sélectionnez **Cookie Authentication** et **Query Authentication**.
6. Activez **Device Binding Method** en choisissant **None**, **ASN Binding** ou **IP Address Binding**.
7. Activez **Allow Refresh Token Requests** pour émettre de nouveaux jetons d’actualisation après un transfert de session.
8. Sélectionnez **Use online refresh tokens**.
9. Sélectionnez **Save** pour mettre à jour votre application Web.
* Mettez à jour votre application Web à l’aide du jeton d’accès de la Management API avec le point de terminaison [Mettre à jour une application](https://auth0.com/docs/api/management/v2/clients/patch-clients-by-id) :
export const codeExample3 = `curl --request PATCH \
--url '{yourDomain}/api/v2/clients//{yourClientId}' \
--header 'authorization: Bearer {yourMgmtApiAccessToken}' \
--header 'content-type: application/json' \
--data '{
"session_transfer": {
"allowed_authentication_methods": ["cookie", "query"],
"enforce_device_binding": "ip", // peut aussi être "none" ou "asn",
"allow_refresh_token": false,
"enforce_online_refresh_tokens": true
}
}'`;
* Mettez à jour votre application web à l’aide d’[Auth0 CLI](https://auth0.github.io/auth0-cli/auth0_apps_session-transfer_update.html) :
export const codeExample4 = `auth0 apps session-transfer update {yourClientId} --allowed-auth-methods=cookie,query --enforce-device-binding=ip`;
## Implémenter le SSO natif vers le Web
Le SSO unique natif vers le Web offre une expérience fluide en permettant de faire passer les utilisateurs authentifiés de votre application native à votre application Web.
Pour ce faire, votre application native doit échanger un Jeton d’actualisation contre un jeton de transfert de session, puis transmettre ce jeton de transfert de session à votre application Web, au moyen d’une URL ou d’un témoin, afin d’autoriser la session.
* Si `allow_refresh_token` est désactivé dans l’application, mais que l’application demande `offline_access`, Auth0 n’émet pas de `refresh_token`, mais l’authentification fonctionne quand même.
* Si la rotation des Jetons d’actualisation est activée, Auth0 renvoie un nouveau `refresh_token` dans l’appel d’échange de jeton. L’échange du Jeton d’actualisation doit avoir lieu immédiatement avant que votre code n’ouvre l’application Web.
### Dans votre application native
#### Étape 1 : Échanger un jeton d’actualisation contre un jeton de transfert de session
Utilisez le point de terminaison [/token](https://auth0.com/docs/api/authentication/authorization-code-flow-with-pkce/get-token-pkce) avec votre application native pour échanger le jeton d’actualisation contre un jeton de transfert de session.
* Échangez un jeton d’actualisation contre un jeton de transfert de session à l’aide des SDK Swift, Android ou React Native :
```swift lines theme={null}
credentialsManager.ssoCredentials { result in
switch result {
case .success(let ssoCredentials):
print("Obtained SSO credentials: \(ssoCredentials)")
case .failure(let error):
print("Failed with: \(error)")
}
}
// Ou, avec async/await
do {
let ssoCredentials = try await credentialsManager.ssoCredentials()
print("Obtained SSO credentials: \(ssoCredentials)")
} catch {
print("Failed with: \(error)")
}
```
```kotlin lines theme={null}
secureCredentialsManager.getSsoCredentials(
mapOf(), // paramètres facultatifs
object : Callback {
override fun onSuccess(result: SSOCredentials) {
// Utilisez result.sessionTransferToken pour authentifier
// l’utilisateur dans une session web de votre application
}
override fun onFailure(error: CredentialsManagerException) {
// Gérer l’erreur
}
}
)
```
```typescript lines theme={null}
// Utilisation de Hooks
import { useAuth0 } from 'react-native-auth0';
function MyComponent() {
const { getSSOCredentials } = useAuth0();
const openWebApp = async () => {
try {
const ssoCredentials = await getSSOCredentials();
// Utilisez ssoCredentials.sessionTransferToken pour authentifier
// l’utilisateur dans une session web de votre application
console.log('Session Transfer Token:', ssoCredentials.sessionTransferToken);
} catch (error) {
console.error('Failed to get SSO credentials:', error);
}
};
}
// Utilisation de la classe Auth0
import Auth0 from 'react-native-auth0';
const auth0 = new Auth0({
domain: '{yourDomain}',
clientId: '{yourClientId}',
});
const ssoCredentials = await auth0.credentialsManager.getSSOCredentials();
console.log('Session Transfer Token:', ssoCredentials.sessionTransferToken);
```
* Échangez un jeton d’actualisation contre un jeton de transfert de session à l’aide d’HTTP :
export const codeExample5 = `curl -X POST https://{yourDomain}/oauth/token \
-H 'Content-type: application/json' \
-d '{"grant_type":"refresh_token",
"client_id":{yourClientId}",
"refresh_token":"YOUR_REFRESH_TOKEN",
"audience":"urn:YOUR_AUTH0_TENANT_DOMAIN:session_transfer"}'`;
Ces exemples utilisent des espaces réservés pour les valeurs dynamiques. Remplacez-les par votre domaine Auth0, votre client\_id et un refresh\_token existant.
Le locataire Auth0 renvoie un session\_transfer\_token à usage unique, de courte durée (valide pendant une minute).
```json lines theme={null}
{
"access_token": "{session_transfer_token}",
"issued_token_type": "urn:auth0:params:oauth:token-type:session_transfer_token",
"token_type": "N_A",
"expires_in": 60
}
```
Si la rotation des jetons d’actualisation est activée, l’échange renverra également un jeton d’actualisation.
Si vous avez demandé un ID Token pendant l’authentification, cet appel renverra aussi un ID Token.
#### Étape 2 : Envoyez le jeton de transfert de session par URL ou par cookie
Il existe deux façons de transmettre le `session_transfer_token` à votre application web, selon les `allowed_authentication_methods` configurées.
##### Option 1 : Envoyer le session\_transfer\_token comme cookie
Si votre application web qui utilise WebView ou un navigateur prend en charge l’injection de cookies, vous pouvez configurer votre application native pour :
* Ajouter le session\_transfer\_token dans un cookie.
* Ouvrir l’application web au moyen de WebView ou d’un navigateur.
* Connecter l’application web à votre locataire Auth0 ou à votre Domaine personnalisé. Comme le `session_transfer_token` est inclus dans le cookie, l’utilisateur n’a pas à s’authentifier avec le premier facteur.
export const codeExample6 = `curl --cookie auth0_session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN
https://{yourDomain}/authorize?{authorize_params}`;
##### Option 2 : Envoyer le session\_transfer\_token en tant que paramètre d’URL
Si votre application web ne prend pas en charge l’injection de cookies, vous pouvez configurer votre application native à l’aide de paramètres d’URL pour :
* Ajouter le session\_transfer\_token en tant que paramètre d’URL.
* Ouvrir l’application web à l’aide de WebView ou d’un navigateur.
* Ouvrir une session dans l’application web en ajoutant le `session_transfer_token` comme paramètre d’URL au point de terminaison [/authorize](https://auth0.com/docs/api/authentication/authorization-code-flow/authorize-application). Le locataire Auth0 authentifie l’utilisateur sans exiger d’authentification du premier facteur, puisque le session\_transfer\_token est valide et approuvé.
```bash cURL lines theme={null}
curl --request GET \
--url 'https://your_web_app_login_url/?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN'
```
```csharp C# lines theme={null}
var client = new RestClient("https://your_web_app_login_url/?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```
```go Go lines theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://your_web_app_login_url/?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}
```
```java Java lines theme={null}
HttpResponse response = Unirest.get("https://your_web_app_login_url/?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN")
.asString();
```
```javascript Node.JS lines theme={null}
var axios = require("axios").default;
var options = {
method: 'GET',
url: 'https://your_web_app_login_url/',
params: {session_transfer_token: 'YOUR_SESSION_TRANSFER_TOKEN'}
};
axios.request(options).then(function (response) {
console.log(response.data);
}).catch(function (error) {
console.error(error);
});
```
```php PHP lines theme={null}
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://your_web_app_login_url/?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
```
```python Python lines theme={null}
import http.client
conn = http.client.HTTPSConnection("your_web_app_login_url")
conn.request("GET", "/?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```ruby Ruby lines theme={null}
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://your_web_app_login_url/?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_body
```
### Dans votre application web
Lorsque le jeton de transfert de session est envoyé sous forme de cookie, aucune configuration supplémentaire n’est requise, puisque le navigateur envoie le cookie dans la requête au point de terminaison `/authorize`.
Implémentez le SSO Native to Web Web Single dans votre application web à l’aide de paramètres d’URL :
#### Option 1 : Ajouter le jeton de transfert de session à la requête de votre application web
Depuis l’URL de connexion de l’application, redirigez vers le point de terminaison `/authorize` lorsque le paramètre d’URL `session_transfer_token` est transmis.
```bash cURL theme={null}
curl --request GET \
--url 'https://{yourDomain}/authorize?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN&client_ID={yourClientId}&redirect_uri=YOUR_REDIRECT_URI&response_type=code'
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/authorize?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN&client_ID={yourClientId}&redirect_uri=YOUR_REDIRECT_URI&response_type=code");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```
```go Go theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://{yourDomain}/authorize?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN&client_ID={yourClientId}&redirect_uri=YOUR_REDIRECT_URI&response_type=code"
req, _ := http.NewRequest("GET", url, nil)
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.get("https://{yourDomain}/authorize?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN&client_ID={yourClientId}&redirect_uri=YOUR_REDIRECT_URI&response_type=code")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'GET',
url: 'https://{yourDomain}/authorize',
params: {
session_transfer_token: 'YOUR_SESSION_TRANSFER_TOKEN',
client_ID: '{yourClientId}',
redirect_uri: 'YOUR_REDIRECT_URI',
response_type: 'code'
}
};
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}/authorize?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN&client_ID={yourClientId}&redirect_uri=YOUR_REDIRECT_URI&response_type=code",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$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("")
conn.request("GET", "/{yourDomain}/authorize?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN&client_ID={yourClientId}&redirect_uri=YOUR_REDIRECT_URI&response_type=code")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
#### Option 2 : Ajouter le jeton de transfert de session aux applications web à l’aide des SDK Auth0
Les SDK Auth0 ne prennent pas automatiquement en charge la fonctionnalité Native to Web Single SSO et n’incluent pas le `session_transfer_token` dans la requête adressée au point de terminaison `/authorize`.
Vous trouverez ci-dessous des exemples d’applications web utilisant les SDK Auth0 pour transmettre le `session_transfer_token` dans la requête adressée au point de terminaison `/authorize` :
##### Node (Express.js)
Si votre application Web utilise [Express.js](https://expressjs.com/) ou le [SDK Auth0 Express](https://github.com/auth0/express-openid-connect), vous pouvez utiliser le code ci-dessous pour ajouter la prise en charge du middleware `session_transfer_token`.
```javascript javascript lines theme={null}
const baseConfig = {
authRequired: false,
auth0Logout: true
};
// Extension du middleware pour détecter automatiquement session_transfer_token
app.use((req, res, next) => {
const { session_transfer_token } = req.query;
// Créer une nouvelle configuration pour chaque requête afin d'éviter les fuites de state
const config = { ...baseConfig };
if (session_transfer_token) {
config.authorizationParams = {
session_transfer_token,
};
}
auth(config)(req, res, next);
});
```
##### SDK SPA d’Auth0 (@auth0/auth0-spa-js)
Si votre application web utilise le [SDK SPA d’Auth0](https://github.com/auth0/auth0-spa-js), vous pouvez transmettre le `session_transfer_token` à `loginWithRedirect()` dans `authorizationParams`.
```typescript typescript lines theme={null}
import { Auth0Client } from '@auth0/auth0-spa-js';
const auth0 = new Auth0Client({
domain: '{yourDomain}',
clientId: '{yourClientId}',
});
// Récupérer le session_transfer_token depuis les paramètres de requête URL (transmis depuis l'application native)
const urlParams = new URLSearchParams(window.location.search);
const sessionTransferToken = urlParams.get('session_transfer_token');
// Utiliser loginWithRedirect avec le session_transfer_token
if (sessionTransferToken) {
await auth0.loginWithRedirect({
authorizationParams: {
session_transfer_token: sessionTransferToken,
redirect_uri: window.location.origin,
},
});
}
```
##### SDK React d’Auth0 (@auth0/auth0-react)
Si votre application web utilise le [SDK React d’Auth0](https://github.com/auth0/auth0-react), vous pouvez utiliser `loginWithRedirect` du hook `useAuth0` pour transmettre le `session_transfer_token`.
```typescript typescript lines theme={null}
import { useEffect } from 'react';
import { useAuth0 } from '@auth0/auth0-react';
function App() {
const { loginWithRedirect, isAuthenticated, isLoading } = useAuth0();
useEffect(() => {
if (isLoading || isAuthenticated) return;
const urlParams = new URLSearchParams(window.location.search);
const sessionTransferToken = urlParams.get('session_transfer_token');
if (sessionTransferToken) {
loginWithRedirect({
authorizationParams: {
session_transfer_token: sessionTransferToken,
},
});
}
}, [loginWithRedirect, isLoading, isAuthenticated]);
return ...
;
}
```
##### SAML et WS-Federation
Si votre application web utilise un fournisseur de services SAML ou WS-Fed et Auth0 comme IdP, vous pouvez transmettre le `session_transfer_token` en tant que paramètre d’URL au point de terminaison Auth0 `/authorize`, et le `redirect_uri` correspond à l’URL de connexion SAML ou WS-Fed.
```bash cURL theme={null}
curl --request GET \
--url 'https://{yourDomain}/samlp//{yourClientId}?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN' \
--header 'cookie: session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN' \
--cookie session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN
```
```csharp C# theme={null}
var client = new RestClient("https://{yourDomain}/samlp//{yourClientId}?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN");
var request = new RestRequest(Method.GET);
request.AddHeader("cookie", "session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN");
IRestResponse response = client.Execute(request);
```
```go Go theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://{yourDomain}/samlp//{yourClientId}?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("cookie", "session_transfer_token=YOUR_SESSION_TRANSFER_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.get("https://{yourDomain}/samlp//{yourClientId}?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN")
.header("cookie", "session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN")
.asString();
```
```javascript Node.JS theme={null}
var axios = require("axios").default;
var options = {
method: 'GET',
url: 'https://{yourDomain}/samlp//{yourClientId}',
params: {session_transfer_token: 'YOUR_SESSION_TRANSFER_TOKEN'},
headers: {cookie: 'session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN'}
};
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}/samlp//{yourClientId}?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"cookie: session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN"
],
]);
$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("")
headers = { 'cookie': "session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN" }
conn.request("GET", "/{yourDomain}/samlp//{yourClientId}?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN", headers=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}/samlp//{yourClientId}?session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Get.new(url)
request["cookie"] = 'session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN'
response = http.request(request)
puts response.read_body
```
## SSO natif vers le Web avec les Organisations
Le SSO natif vers le Web prend en charge les [Organisations](/fr-CA/docs/manage-users/organizations). Lorsqu’un utilisateur s’authentifie auprès d’une organisation dans votre application native, le jeton de transfert de session inclut le contexte de l’organisation.
Lorsque vous utilisez les Organisations avec le SSO natif vers le Web, le paramètre `organization` de la requête `/authorize` de l’application Web doit correspondre à l’organisation associée au jeton de transfert de session. En cas de non-correspondance, l’authentification échouera et l’utilisateur devra se reconnecter.
Pour utiliser les Organisations avec le SSO natif vers le Web :
1. Authentifiez l’utilisateur dans votre application native auprès d’une organisation :
```javascript javascript lines theme={null}
// Connexion à l'application native avec une organisation
await authorize({
organization: 'org_abc123',
scope: 'openid profile email offline_access'
});
```
2. Lors de la redirection vers l’application web, incluez la même organisation dans la requête `/authorize` :
```bash bash lines theme={null}
https://{yourDomain}/authorize?
client_id={yourWebClientId}&
redirect_uri={yourRedirectUri}&
response_type=code&
organization=org_abc123&
session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN
```
Si l’organisation dans la requête `/authorize` ne correspond pas à l’organisation dans le jeton de transfert de session, le jeton de transfert de session est rejeté et l’utilisateur est redirigé vers la page de connexion pour se réauthentifier. Un avertissement est consigné dans les journaux de votre locataire avec la description d’événement "Échec de l’authentification unique : non-correspondance de l’organisation détectée dans le jeton de transfert de session."
## Jeton de transfert de session avec Actions
L’utilisation de `session_transfer_token` avec [Actions](/fr-CA/docs/customize/actions) vous permet de configurer des fonctionnalités de détection et de réponse aux risques après l’authentification afin de renforcer la protection des utilisateurs.
À cette fin, l’objet d’Action post-login **event.session\_transfer\_token** fournit des informations pertinentes, notamment le `client_id` unique, le `scope`, des informations sur la `request`, comme `ip`, `asn`, `user_agent`, ainsi que des informations `geoip`, comme `cityName` et `countryCode`, entre autres. Pour en savoir plus, consultez [Déclencheurs d’Actions : post-login - objet Event](/fr-CA/docs/customize/actions/explore-triggers/signup-and-login-triggers/login-trigger/post-login-event-object).
Le code d’Action ci-dessous vous permet de refuser dynamiquement une transaction en fonction des informations de géolocalisation :
```javascript javascript lines theme={null}
/**
* Gestionnaire qui sera appelé lors de l'exécution d'un flux PostLogin.
*
* @param {Event} event - Détails sur l'utilisateur et le contexte dans lequel il se connecte.
* @param {PostLoginAPI} api - Interface dont les méthodes peuvent être utilisées pour modifier le comportement de la connexion.
*/
exports.onExecutePostLogin = async (event, api) => {
if(
event.session_transfer_token &&
event.session_transfer_token.request.geoip.countryCode !== event.request.geoip.countryCode
) {
api.access.deny("Network mismatch detected")
}
};
```
### Accéder aux métadonnées du jeton d’actualisation parent
Le SSO natif vers le Web vous permet d’accéder aux métadonnées du jeton d’actualisation parent utilisé pour lancer le flux SSO. Vous pouvez ainsi transmettre à la session Web créée à partir du `session_transfer_token` des informations contextuelles recueillies dans l’application native (comme l’intégrité de l’appareil, des signaux de risque ou un contexte personnalisé).
Auth0 expose ces informations dans les Actions Post Login par l’intermédiaire de l’objet `event.session.session_transfer.parent_refresh_token.metadata`. Cela permet une propagation sécurisée et normalisée des métadonnées entre les plateformes.
**Exemple de cas d’utilisation :** Une application mobile recueille des données de risque (score de l’appareil, emplacement, etc.) et les stocke dans les métadonnées du jeton d’actualisation. Lorsque l’application native lance un flux SSO natif vers le Web, ces métadonnées sont automatiquement accessibles dans la session Web correspondante via Actions.
Le code de l’Action ci-dessous vous permet d’appliquer une logique d’accès conditionnel en fonction des métadonnées de confiance de l’appareil provenant de l’application native :
```javascript javascript lines theme={null}
/**
* Gestionnaire qui sera appelé lors de l'exécution d'un flux PostLogin.
*
* @param {Event} event - Détails sur l'utilisateur et le contexte dans lequel il se connecte.
* @param {PostLoginAPI} api - Interface dont les méthodes peuvent être utilisées pour modifier le comportement de la connexion.
*/
exports.onExecutePostLogin = async (event, api) => {
// Accéder aux métadonnées du jeton d'actualisation parent (application native)
const parentMetadata = event.session?.session_transfer?.parent_refresh_token?.metadata;
if (parentMetadata) {
const deviceTrustLevel = parentMetadata.device_trust;
if (deviceTrustLevel !== 'high') {
api.access.deny("Device trust level insufficient.");
}
// Vous pouvez aussi ajouter des revendications selon le contexte de l'application native
if (parentMetadata.subscription_tier) {
api.idToken.setCustomClaim('subscription_tier', parentMetadata.subscription_tier);
}
}
};
```
## Surveillance
Vous pouvez surveiller l’activité de SSO natif vers le Web en consultant les [journaux](/fr-CA/docs/deploy-monitor/logs) du locataire.
### Journaux d’échange de jetons
* `sertft` : Échange réussi du Jeton d’actualisation. Ce journal correspond à un échange SSO du natif vers le Web lorsque le champ `audience` est `"audience":"urn:$auth0Domain:session_transfer"`
* `fertft`: Échec de l’échange du Jeton d’actualisation. Ce journal correspond à un échange SSO du natif vers le Web lorsque le champ `audience` est `"audience": "urn:$auth0Domain:session_transfer"`
### Journaux d’avertissement de validation du transfert de session
Auth0 génère des journaux d’avertissement (`w`) lorsque la validation du jeton de transfert de session échoue lors de la requête `/authorize`. Ces journaux vous aident à résoudre les problèmes de SSO du natif vers le Web :
| Description de l’événement | Cause |
| ------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `Single Sign-On failed: Session Transfer Token not found or expired. This may indicate token reuse or expiration.` | Le jeton de transfert de session est introuvable, a déjà été utilisé ou a expiré (les jetons sont à usage unique et expirent après 1 minute). |
| `Single Sign-On failed: Session Transfer Token device binding validation failed due to IP/ASN mismatch.` | L’adresse IP ou l’ASN de la requête web ne correspond pas à la liaison de l’appareil configurée pour le jeton de transfert de session. |
| `Single Sign-On failed: Session Transfer Token organization mismatch detected.` | Le paramètre `organization` dans la requête `/authorize` ne correspond pas à l’organisation du jeton de transfert de session. |
| `Single Sign-On failed: Session Transfer Token user mismatch detected.` | Une session Auth0 préexistante appartient à un utilisateur différent de celui associé au jeton de transfert de session. |
| `Single Sign-On failed: Parent refresh token not found. Session Transfer Token won't be used for session establishment.` | Le jeton d’actualisation parent utilisé pour créer le jeton de transfert de session a été révoqué ou supprimé. |