> ## 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 l’authentification unique Native to Web.
# Configurer et Implement Native to Web SSO
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}
;
};
## Configurer Native to Web SSO
Pour utiliser Native to Web authentification unique (SSO), configurez vos applications natives et Web (Single Page App ou application Web traditionnelle) pour créer et gérer des sessions avec la Management API d’Auth0.
Il vous faut un [jeton d’accès](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) pour utiliser la Management API ou Auth0 CLI.
Pour configurer Native to Web SSO, vous devez créer et gérer des session\_transfer\_tokens, puis configurer vos applications natives et Web.
Native to Web SSO 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 de Native to Web SSO est offerte dans les outils suivants : [Auth0 Deploy CLI](/docs/fr-ca/deploy-monitor/deploy-cli-tool), [Auth0 Terraform Provider](/docs/fr-ca/deploy-monitor/auth0-terraform-provider) et [Auth0 CLI](https://auth0.github.io/auth0-cli/).
Native to Web SSO prend en charge tout flux d’authentification qui renvoie un jeton d’actualisation, comme le [flux de mot de passe du propriétaire de la ressource](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa) et le [flux de code d’autorisation avec clé de preuve pour l’échange de code](/docs/fr-ca/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 à l’aide de cookies ou d’un paramètre d’URL
* Associer la session à l’appareil d’un utilisateur au moyen d’une adresse IP ou d’un ASN
Pour les applications existantes, faites une requête `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, faites une requête `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](/docs/fr-ca/secure/tokens/access-tokens), un [jeton ID](/docs/fr-ca/secure/tokens/id-tokens) et, facultativement, un [jeton d’actualisation](/docs/fr-ca/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 cookie, 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 du Auth0 Dashboard :
1. Accédez à [Dashboard > Applications](https://manage.auth0.com/dashboard/#/applications):
2. Sélectionnez ou [créez votre application](/docs/fr-ca/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 à l’aide d’[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’**Application Login URI** de votre application Web pour prendre en charge des paramètres supplémentaires. Pour en savoir plus sur les URI, consultez [Application Settings](/docs/fr-ca/get-started/applications/application-settings#application-uris).
* Mettez à jour votre application Web dans l’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** : **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 [Update a Client](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", // également "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`;
## Implement Native to Web SSO
Native to Web Single SSO offre une expérience utilisateur fluide en permettant de faire passer des 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 et transmettre ce jeton de transfert de session, au moyen d’une URL ou d’un cookie, à votre application Web afin d’autoriser la session.
* Si `allow_refresh_token` est désactivé dans le client, mais que l’application demande `offline_access`, Auth0 n’émet pas de `refresh_token`, mais l’authentification continue de fonctionner.
* Si la rotation des jetons d’actualisation est activée, Auth0 renvoie un nouveau `refresh_token` dans la requête d’échange de jeton. L’échange du jeton d’actualisation doit avoir lieu juste 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 du SDK Swift, du SDK Android ou du SDK 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érez l'erreur
}
}
)
```
```typescript lines theme={null}
// Avec 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);
}
};
}
// Avec 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 de 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 valeurs de remplacement pour les variables dynamiques. Remplacez-les par votre domaine Auth0, votre client\_id et un refresh\_token existant.
Le tenant Auth0 renvoie un session\_transfer\_token à usage unique et de courte durée (durée de vie de 1 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 lors de l’authentification, cette requête renverra également un ID Token.
#### Étape 2 : Envoyer le jeton de transfert de session au moyen d’une URL ou d’un cookie
Il existe deux façons d’envoyer le `session_transfer_token` à votre application web, selon les `allowed_authentication_methods` configurées.
##### Option 1 : Envoyer le session\_transfer\_token dans un cookie
Si votre application web qui utilise WebView ou un navigateur prend en charge l’injection de cookie, vous pouvez configurer votre application native pour :
* Ajouter le session\_transfer\_token dans un cookie.
* Ouvrir l’application web à l’aide de WebView ou d’un navigateur.
* Connecter l’application web à votre tenant Auth0 ou à votre Domaine personnalisé. Comme le `session_transfer_token` est inclus dans le cookie, l’utilisateur n’a pas à effectuer l’authentification du 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 comme paramètre d’URL
Si votre application web ne prend pas en charge l’injection de cookie, vous pouvez configurer votre application native à l’aide de paramètres d’URL pour :
* Ajouter le session\_transfer\_token comme paramètre d’URL.
* Ouvrir l’application web dans WebView ou dans 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 tenant Auth0 authentifie l’utilisateur sans exiger d’authentification de 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_PEER
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 nécessaire, puisque le navigateur envoie le cookie dans la requête à l’endpoint `/authorize`.
Implémentez le SSO Web unique Native to Web 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 `session_transfer_token` est envoyé en tant que paramètre d’URL.
```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 Auth0 SDKs
Les Auth0 SDKs ne prennent pas automatiquement en charge Native to Web Single SSO et n’incluent pas le `session_transfer_token` dans la requête du point de terminaison `/authorize`.
Vous trouverez ci-dessous des exemples d’applications Web utilisant les Auth0 SDKs pour rediriger le `session_transfer_token` dans la requête du 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 de `session_transfer_token` dans le middleware.
```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 d'état
const config = { ...baseConfig };
if (session_transfer_token) {
config.authorizationParams = {
session_transfer_token,
};
}
auth(config)(req, res, next);
});
```
##### Auth0 SPA SDK (@auth0/auth0-spa-js)
Si votre application Web utilise le [Auth0 SPA SDK](https://github.com/auth0/auth0-spa-js), vous pouvez transmettre le `session_transfer_token` à `loginWithRedirect()` au moyen de `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,
},
});
}
```
##### Auth0 React SDK (@auth0/auth0-react)
Si votre application web utilise le [Auth0 React SDK](https://github.com/auth0/auth0-react), vous pouvez utiliser `loginWithRedirect` à partir 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 `/authorize` d’Auth0, et le `redirect_uri` est 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_PEER
request = Net::HTTP::Get.new(url)
request["cookie"] = 'session_transfer_token=YOUR_SESSION_TRANSFER_TOKEN'
response = http.request(request)
puts response.read_body
```
## Native to Web SSO avec Organizations
Native to Web SSO prend en charge [Organizations](/docs/fr-ca/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 Organizations avec Native to Web SSO, le paramètre `organization` dans la requête `/authorize` de l’application web doit correspondre à l’organisation associée au jeton de transfert de session. En cas d’incompatibilité, l’authentification échouera et l’utilisateur devra se connecter à nouveau.
Pour utiliser Organizations avec Native to Web SSO :
1. Authentifiez l’utilisateur dans votre application native avec 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 indiquée dans la requête `/authorize` ne correspond pas à celle du jeton de transfert de session, le jeton de transfert de session est rejeté et l’utilisateur est redirigé vers la page de connexion pour s’authentifier de nouveau. Une entrée d’avertissement est consignée dans les journaux du locataire avec la description d’événement "Échec de l’authentification unique : incompatibilité d’organisation détectée dans le jeton de transfert de session."
## Session Transfer Token avec Actions
L’utilisation de `session_transfer_token` avec [Actions](/docs/fr-ca/customize/actions) vous permet de configurer des capacités de détection et de réponse aux risques après l’authentification afin de mieux protéger les utilisateurs.
À cette fin, l’objet **event.session\_transfer\_token** de l’Action post-login fournit des renseignements pertinents, 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 [Actions Triggers: post-login - Event Object](/docs/fr-ca/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 données 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
Native to Web SSO vous permet d’accéder aux métadonnées du jeton d’actualisation parent utilisé pour lancer le flux SSO. Vous pouvez ainsi transmettre des informations contextuelles recueillies dans l’application native (comme l’intégrité de l’appareil, des signaux de risque ou un contexte personnalisé) à la session Web créée à partir du `session_transfer_token`.
Auth0 expose ces informations dans les Actions Post Login au moyen 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 Native to Web SSO, ces métadonnées sont automatiquement accessibles dans la session Web correspondante via les Actions.
Le code de l’Action ci-dessous vous permet d’exécuter une logique d’accès conditionnel fondée sur les métadonnées de confiance de l’appareil provenant de l’application native :
```javascript javascript lines theme={null}
/**
* Handler 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 refresh token 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 également ajouter des claims 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é Native to Web SSO en consultant les [journaux](/docs/fr-ca/deploy-monitor/logs) du tenant.
### Journal de Token Exchange
* `sertft` : échange de jeton d’actualisation réussi. Ce journal correspond à un échange Native to Web SSO lorsque le champ `audience` est `"audience":"urn:$auth0Domain:session_transfer"`
* `fertft`: échange de jeton d’actualisation Failed. Ce journal correspond à un échange Native to Web SSO lorsque le champ `audience` est `"audience": "urn:$auth0Domain:session_transfer"`
### Journaux d’avertissement de validation du transfert de session
Auth0 émet 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 à diagnostiquer les problèmes liés à Native to Web SSO :
| 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 à l’association à 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 existante appartient à un autre utilisateur que celui du 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 refresh token parent utilisé pour créer le jeton de transfert de session a été révoqué ou supprimé; le jeton de transfert de session ne sera donc pas utilisé pour établir la session. |