> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Connexions chiffrées

> Activez le chiffrement personnalisé pour les appels d'API de connexion client PlayFab afin de protéger les charges utiles d'authentification et de renforcer la sécurité de l'application contre la falsification.

PlayFab vous permet de renforcer la sécurité de votre application en protégeant certains appels d'API client avec un chiffrement personnalisé. Ce tutoriel vous montre comment activer le chiffrement pour votre client.

La méthode que nous allons utiliser vous permet de protéger *n'importe quel* appel d'API de connexion. Comme le processus est *toujours* similaire, nous montrons uniquement comment protéger *une* méthode particulière, `LoginWithCustomID`.

<Info>
  Le chiffrement des connexions est destiné à être utilisé pour *tous* les joueurs après la création du titre, ou pas du tout. Ce n'est *pas* une fonctionnalité qui peut être activée ultérieurement. Vous devez l'utiliser *dès le début* ou pas du tout. En particulier, les joueurs *chiffrés* ne pourront jamais se connecter *sans chiffrement*, et les joueurs *non chiffrés* ne pourront jamais devenir des joueurs *chiffrés*.
</Info>

Dans ce guide, nous allons :

1. Créer un secret partagé de joueur.
2. Introduire une règle de stratégie d'API pour activer la protection sur une méthode donnée.
3. Modifier le client pour utiliser une clé partagée de joueur afin de récupérer la clé publique du titre et de chiffrer la charge utile.

<Note>
  PlayFab émet l'avertissement suivant : « Tous nos appels d'API sont déjà chiffrés de manière sécurisée selon les normes modernes, et le chiffrement standard des appels d'API est tout ce dont la plupart des clients auront besoin. Cette fonctionnalité représente une couche de sécurité *supplémentaire* conçue pour rendre plus difficile l'utilisation d'un client non autorisé par les joueurs. Elle n'est *pas* infaillible : elle ne fait qu'augmenter le niveau de difficulté pour les pirates. Pour la plupart des développeurs, ce léger gain de sécurité ne vaudra pas l'effort supplémentaire requis. »
</Note>

## Création d'un secret partagé de joueur

L'API Admin de PlayFab expose une méthode permettant de gérer vos secrets partagés de joueur.

<Note>
  La création d'un nouveau secret partagé portant un certain nom remplace la clé existante portant le même nom, le cas échéant. En outre, vous pouvez avoir *plusieurs* secrets partagés enregistrés sous des noms différents.
</Note>

Exécutez le code suivant pour ajouter un secret partagé de joueur à votre titre.

```csharp theme={null}
PlayFabSettings.staticSettings.DeveloperSecretKey = "__DEVELOPER_KEY__";
PlayFabSettings.staticSettings.TitleId = "__TITLE_ID__";
var response = await PlayFabAdminAPI.CreatePlayerSharedSecretAsync(new CreatePlayerSharedSecretRequest()
{
    FriendlyName = "__KEY_NAME__"
});

if (response.Error != null)
{
    Console.WriteLine(response.Error.GenerateErrorReport());
}
else
{
    Console.WriteLine(response.Result.SecretKey);
}
```

Pour exécuter ce code, vous avez besoin d'une clé secrète de développeur. Pour plus d'informations sur les clés secrètes, consultez [Gestion des clés secrètes](/fr/services/playfab/live-service-management/gamemanager/secret-key-management).

Cette application doit afficher un secret partagé de joueur nouvellement créé. *Veillez à l'enregistrer*. S'il est perdu, vous devrez générer un nouveau secret en exécutant à nouveau l'application.

Le secret ressemble à ceci :

`QC953WQ3TU6ZJTZMAT1FNJQIKR92FPUQTISW4Q6WD8SY841MQQ`

## Mise à jour de la stratégie

Nous avons créé un nouveau secret partagé. Nous devons maintenant indiquer à PlayFab quels appels d'API protéger.

Exécutez le code ci-dessous pour protéger l'appel d'API `LoginWithCustomId` et *retirer la protection* des autres appels d'API.

```csharp theme={null}
// Set development key and title id
PlayFabSettings.DeveloperSecretKey = "__DEVELOPER_KEY__";
PlayFabSettings.TitleId = "__TITLE_ID__";

public static async Task SetApiPermission(bool restrictCustomId)
{
    // The first statement denies every call to LoginWithCustomID that is not properly encrypted
    var filterCustom = new PermissionStatement
    {
        // Statement effects any action
        Action = "*",
        // Filter the case where there is no signature and payload is not encrypted
        ApiConditions = new ApiCondition()
        {
            HasSignatureOrEncryption = Conditionals.False
        },
        Comment = "Deny every request to LoginWithCustomID that is not properly encrypted",
        // Specify the resource name
        Resource = "pfrn:api--/Client/LoginWithCustomID", // Resource name
        // Deny any of such requests
        Effect = EffectType.Deny,
        // For any user
        Principal = "*"
    };
    // The second statement allows every other API call
    var filterNothing = new PermissionStatement()
    {
        // Statement effects any action
        Action = "*",
        Comment = "Allow the rest API calls",
        // For any resource name
        Resource = "pfrn:api--*",
        // Allow any request
        Effect = EffectType.Allow,
        // For any user
        Principal = "*"
    };

    // Update the policy
    var request = new UpdatePolicyRequest()
    {
        // ApiPolicy controls access to API methods
        PolicyName = "ApiPolicy",
        // In this example we overwrite the policy. Consider appending to the existing policy instead.
        OverwritePolicy = true,
        // Introduce policy statements
        Statements = new List<PermissionStatement> { filterNothing }
    };
    if (restrictCustomId)
        request.Statements.Add(filterCustom);
    var result = await PlayFabAdminAPI.UpdatePolicyAsync(request);

    // Handle possible errors
    if (result.Error != null)
        Console.WriteLine(result.Error.GenerateErrorReport());
    else
        Console.WriteLine("Policy updated");
}
```

## Configuration du client

Maintenant que la stratégie est mise à jour, vous ne pouvez plus simplement appeler l'API `LoginWithCustomID`. Examinez le code ci-dessous.

```csharp theme={null}
var result = await PlayFabClientAPI.LoginWithCustomIDAsync(new LoginWithCustomIDRequest()
{
    CreateAccount = true,
    CustomId = "Some_Custom_Id"
});

if (result.Error != null)
{
    Console.WriteLine(result.Error.GenerateErrorReport());
}
else
{
    Console.WriteLine(result.Result.PlayFabId);
}
```

Normalement, cela connecterait l'utilisateur sans problème. Cependant, cet appel d'API est *désormais* *protégé*, et le code renverra une erreur `Not Authorized` (à ne pas confondre avec `Not Authenticated`).

Nous devons modifier le client pour chiffrer correctement la charge utile de l'appel. Cela se fait en 2 étapes :

1. Utiliser le secret partagé de joueur pour récupérer la clé publique du titre.
2. Utiliser la clé publique du titre pour chiffrer la charge utile.

Le code ci-dessous illustre ce processus.

```csharp theme={null}
public static async Task DoEncryptedLogin()
{
    Console.WriteLine("Begin DoEncryptedLogin");

    // Use Player Shared Secret to get Title Public Key
    var titleKeyResult = await PlayFabClientAPI.GetTitlePublicKeyAsync(new GetTitlePublicKeyRequest
    {
        TitleId = TITLE_ID,
        TitleSharedSecret = CLIENT_SECRET_KEY
    });

    Console.WriteLine("Encrypt request");
    // Convert public key to bytes
    var cspBlob = Convert.FromBase64String(titleKeyResult.Result.RSAPublicKey);

    // Serialize certain part of the model into string (this will be encrypted).
    var encryptionModel = JsonWrapper.SerializeObject(new LoginWithCustomIDRequest { CustomId = "SOME_PLAYER_ID_ENCRYPTED" });
    string encryptedPayload;

    // RSA encryption
    using (var rsa = new RSACryptoServiceProvider())
    {
        rsa.ImportCspBlob(cspBlob);
        var bytesToEncrypt = Encoding.UTF8.GetBytes(encryptionModel);
        var encryptedBytes = rsa.Encrypt(bytesToEncrypt, false);
        encryptedPayload = Convert.ToBase64String(encryptedBytes);
    }

    // Use encrypted payload to construct a model
    var model = new LoginWithCustomIDRequest
    {
        EncryptedRequest = encryptedPayload,
        PlayerSecret = CLIENT_SECRET_KEY,
        CreateAccount = true
    };

    Console.WriteLine("Call LoginWithCustomIDAsync");
    // Finally execute the call
    var result = await PlayFabClientAPI.LoginWithCustomIDAsync(model);
    Console.WriteLine("LoginWithCustomIDAsync done");
    bool successful = result.Error == null && result.Result != null;
    if (!successful)
        Console.WriteLine(result.Error.GenerateErrorReport());
    else
        Console.WriteLine("Login Successful" + result.Result.PlayFabId);
}
```

Une fois le code exécuté, vous devriez pouvoir vous connecter. N'oubliez pas qu'une fois qu'un secret partagé de joueur est créé, il doit être codé en dur dans votre code client, car il n'existe *aucun moyen* de le récupérer ou de le demander à l'aide d'un appel d'API.


## Related topics

- [Services de chiffrement des joueurs](/fr/services/playfab/identity/player-identity/encryption/player-encryption-services.md)
- [Guide FAQ et dépannage de XBOX PC Remote Tools](/fr/tools/tools-pc/xbox-pc-remote-tools/faq.md)
- [XBOX PC Remote Tools : notes de version de mars 2026 (2603)](/fr/tools/tools-pc/xbox-pc-remote-tools/release-notes/2603.md)
- [Captures de jeu de longue durée (wdcapturesession.exe)](/fr/tools/tools-console/console_commandlinetools/wdcapturesession.md)
- [XAG 109 : Clarté des objectifs](/fr/build/game-principles/accessibility/xag-deep-dives/xag-109-objective-clarity.md)