> ## 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 à l'aide d'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. Puisque le processus est *toujours* semblable, nous montrons seulement comment protéger *une* méthode en particulier, `LoginWithCustomID`.

<Info>
  Le chiffrement des connexions est destiné à être utilisé pour *tous* les joueurs dès la création du titre, ou pas du tout. Il ne s'agit *pas* d'une fonctionnalité que vous pouvez activer plus tard. Vous devez l'utiliser dès le *tout début* ou pas du tout. En particulier, les joueurs *chiffrés* ne pourront jamais se connecter de façon *non chiffrée*, 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é par les joueurs.
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 qu'il utilise une clé partagée par les joueurs 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 façon sécuritaire 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é par les joueurs

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

<Note>
  La création d'un nouveau secret partagé sous un certain nom remplace la clé existante portant le même nom, le cas échéant. De plus, 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é par les joueurs à 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-CA/services/playfab/live-service-management/gamemanager/secret-key-management).

Cette application devrait afficher un secret partagé par les joueurs nouvellement créé. *Assurez-vous de l'enregistrer*. Si vous le perdez, vous devrez générer un nouveau secret en exécutant l'application de nouveau.

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, ce code connecterait l'utilisateur sans problème. Cependant, cet appel d'API est *maintenant* *protégé*, et le code générera une erreur `Not Authorized` (à ne pas confondre avec `Not Authenticated`).

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

1. Utiliser le secret partagé par les joueurs 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é par les joueurs est créé, il doit être codé en dur dans le code de votre client, car il n'existe *aucun moyen* de le récupérer ou de le demander au moyen d'un appel d'API.


## Related topics

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