Partager via

Écriture d’un client SSPI authentifié

  • Article

Toutes les sessions client/serveur RPC nécessitent une liaison entre le client et le serveur. Pour ajouter de la sécurité aux applications client/serveur, les programmes doivent utiliser une liaison authentifiée. Cette section décrit le processus de création d’une liaison authentifiée entre le client et le serveur.

Pour plus d’informations, consultez Procédures utilisées avec la plupart des packages et protocoles de sécurité dans le Kit de développement logiciel (SDK) de plateforme.

Création de handles de liaison côté client

Pour créer une session authentifiée avec un programme serveur, les applications clientes doivent fournir des informations d’authentification avec leur handle de liaison. Pour configurer un handle de liaison authentifié, les clients appellent la fonction RpcBindingSetAuthInfo ou RpcBindingSetAuthInfoEx . Ces deux fonctions sont presque identiques. La seule différence entre eux est que le client peut spécifier la qualité de service avec la fonction RpcBindingSetAuthInfoEx .

Le fragment de code suivant montre à quoi peut ressembler un appel à RpcBindingSetAuthInfo .

// This code fragment assumes that rpcBinding is a valid binding 
// handle between the client and the server. It also assumes that
// pAuthCredentials is a valid pointer to a data structure which
// contains the user's authentication credentials.

dwStatus = DsMakeSpn(
    "ldap",
    "ServerName.domain.com",
    NULL,
    0,
    NULL,
    &pcSpnLength,
    pszSpn);

//...

rpcStatus = RpcBindingSetAuthInfo(
    rpcBinding,                       // Valid binding handle
    pszSpn,                           // Principal name 
    RPC_C_AUTHN_LEVEL_PKT_INTEGRITY,  // Authentication level
    RPC_C_AUTHN_GSS_NEGOTIATE,        // Use Negotiate SSP
    NULL,                             // Authentication credentials <entity type="ndash"/> use current thread credentials
    RPC_C_AUTHZ_NAME);                // Authorization service

Une fois que le client a correctement appelé les fonctions RpcBindingSetAuthInfo ou RpcBindingSetAuthInfoEx , la bibliothèque d’exécution RPC authentifie automatiquement tous les appels RPC sur la liaison. Le niveau de sécurité et d’authentification sélectionné par le client s’applique uniquement à ce handle de liaison. Les handles de contexte dérivés du handle de liaison utilisent les mêmes informations de sécurité, mais les modifications ultérieures apportées au handle de liaison ne seront pas reflétées dans les handles de contexte. Pour plus d’informations, consultez Handles de contexte.

Le niveau d’authentification reste en vigueur jusqu’à ce que le client choisisse un autre niveau ou jusqu’à ce que le processus se termine. La plupart des applications ne nécessitent pas de modification du niveau de sécurité. Le client peut interroger n’importe quel handle de liaison pour obtenir ses informations d’autorisation en appelant RpcBindingInqAuthClient et en lui transmettant le handle de liaison.

Fourniture d’informations d’identification client au serveur

Les serveurs utilisent les informations de liaison du client pour appliquer la sécurité. Les clients passent toujours un handle de liaison comme premier paramètre d’un appel de procédure distante. Toutefois, les serveurs ne peuvent pas utiliser le handle, sauf s’il est déclaré en tant que premier paramètre des procédures distantes dans le fichier IDL ou dans le fichier de configuration d’application (ACF) du serveur. Vous pouvez choisir de répertorier le handle de liaison dans le fichier IDL, mais cela force tous les clients à déclarer et manipuler le handle de liaison plutôt que d’utiliser une liaison automatique ou implicite. Pour plus d’informations, consultez Les fichiers IDL et ACF.

Une autre méthode consiste à laisser les handles de liaison hors du fichier IDL et à placer l’attribut explicit_handle dans l’ACF du serveur. De cette façon, le client peut utiliser le type de liaison le mieux adapté à l’application, tandis que le serveur utilise le handle de liaison comme s’il avait été déclaré explicitement.

Le processus d’extraction des informations d’identification du client à partir du handle de liaison se produit comme suit :

  • Les clients RPC appellent RpcBindingSetAuthInfo et incluent leurs informations d’authentification dans le cadre des informations de liaison transmises au serveur.
  • En règle générale, le serveur appelle RpcImpersonateClient pour se comporter comme s’il s’agissait du client. Si le handle de liaison n’est pas authentifié, l’appel échoue avec RPC_S_NO_CONTEXT_AVAILABLE. Pour obtenir le nom d’utilisateur du client, appelez RpcBindingInqAuthClient lors de l’emprunt d’identité, ou sur Windows XP ou des versions ultérieures de Windows, appelez RpcGetAuthorizationContextForClient pour obtenir le contexte d’autorisation, puis utilisez les fonctions Authz pour récupérer le nom.
  • Le serveur appelle normalement CreatePrivateObjectSecurity pour créer des objets avec des listes de contrôle d’accès. Une fois cette opération effectuée, les vérifications de sécurité ultérieures deviennent automatiques.