Client-serveur d'authentification à l'aide de SSPI?

Je suis en train de travailler sur une application client-serveur et je veux que le client de s'authentifier auprès du serveur à l'aide de l'utilisateur, les informations d'identification d'ouverture de session, mais je ne veux pas l'utilisateur d'avoir à entrer leur nom d'utilisateur et mot de passe. Certes, je ne veux pas être responsable de la manipulation en toute sécurité des mots de passe. J'ai seulement besoin de l'utilisateur à me prouver qu'ils sont bien qui ils disent qu'ils sont, et puis mon serveur pouvez aller de l'avant et de l'accorder ou de refuser des commandes comme il lui plaît.

Mes utilisateurs font partie d'un domaine, et donc, je veux être en mesure d'utiliser les informations d'identification d'ouverture de session, ils ont créé lors de l'ouverture de session.

Je ne suis pas en utilisant toute sorte de web services, ni ce que je veux. Je contrôle à la fois le client et le logiciel de serveur, et les deux sont écrits en pur C# et utiliser le bon vieux sockets pour obtenir le travail effectué.

Je préfère le faire avec de la pure C#/.Net, mais je suis ouvert à dangereux à l'aide de C# et pinvokes win32 API si cela signifie que je vais faire le travail.

J'ai lu un peu sur SSPI dans windows, mais je suis une sorte de sentiment autour dans l'obscurité puisque ce genre de développement de l'application est nouveau pour moi.

Quelqu'un sait comment faire cela? Est SSPI le chemin? Comment utiliser SSPI à partir de C#? Est-il un .Net-native moyen pour que mon code peut rester portable?

  • Bien avez-vous regardé à l'aide de l'Authentification Windows? Ce type d'authentification utilisera le domaine de l'utilisateur nom d'utilisateur pour valider l'accès au serveur. la chaîne de connexion doit ressembler à quelque chose comme ceci Serveur=myServerAddress;Database=mabase;Trusted_Connection=True;
  • Je ne pense pas qu'il y est une .NET native façon de le faire. Il y a cependant un échantillon à partir de MS montrant comment utiliser SSPI. Elle implique la création d'un managed C++ qui gère SSPI et fournit une interface pour .NET. Pour être franc, je n'étais pas en mesure de l'exécuter sur Windows 8.1 et n'avait pas l'air dans le débogage, mais il peut être une bonne lecture pour vous. msdn.microsoft.com/en-us/library/ms973911.aspx je recommande que vous repenser votre décision sur l'utilisation de la plaine de sockets lorsque vous avez des solutions plus simples dans .NET.
  • Pour clarifier les choses: Comme WCF peut le faire sans l'aide de IIS/ASP.NET, mais la plaine sockets je devrais aussi être en mesure de le faire. La WCF code source (disponible par le biais de la source de référence de la licence) est confus et difficile à suivre.
InformationsquelleAutor antiduh | 2013-06-21
  1. 22

    Mise à jour:

    SSPI est le droit pour cette approche. L'API n'est pas trop dur à utiliser, mais il est de taille décente du projet de regrouper en C#.

    Dans le processus de la recherche de ce qui est nécessaire pour résoudre cette question, j'ai écrit un projet à offrir en SSPI .Net. Ci-dessous, je décris les principes de base de l'interfaçage avec Windows SSPI API pour que n'importe qui peut reproduire les résultats de ma recherche. Si vous vous trouvez vouloir utiliser en SSPI .Net, je peut vous suggérons d'utiliser le projet que j'ai créé pour résoudre ce problème:

    NSspi - Un .Net de l'interface de la SSPI API

    SSPI vous offre raw tableaux d'octets contenant des jetons d'authentification que vous décidez ensuite de la façon de transmettre - être sur un socket binaire format des messages, un XML personnalisé canal .Net Remoting, une certaine forme de la WCF, heck, même un port série. À vous de décider comment traiter avec eux. Avec SSPI un serveur peut authentifier les clients, identifier en toute sécurité le client, et même d'effectuer des messages de base sur les procédures de manipulation, comme le cryptage/signature en utilisant le contexte de sécurité établi avec le client.

    La SSPI API est décrite ici: SSPI API aperçu

    Spécifiquement de prendre un coup d'oeil à l'une des fonctions suivantes:

    • Laacquirecredentialshandle
      • Acquiert une poignée à une certaine forme d'informations d'identification (par exemple, l'actuelle session de l'utilisateur). Utilisé par les serveurs et les clients.
    • InitializeSecurityContext
      • Utilisé par les clients pour établir un contexte de sécurité d'un serveur.
    • AcceptSecurityContext
      • Utilisé par les serveurs d'établir un contexte de sécurité avec un client.

    Le flux de travail typique est que de chaque côté d'initialiser leurs informations d'identification à l'aide de Laacquirecredentialshandle. L'authentification cycle démarre et progresse comme suit:

    • Le client appelle InitializeSecurityContext, sans fournir d'entrée des jetons, ce qui renvoie en sortie de jetons dans la forme d'un tableau d'octets. ISC renvoie 'ContinueNeeded" pour indiquer que l'authentification du cycle n'est pas complète.
    • Le client envoie les jetons sur le serveur par n'importe quel moyen qu'il désire.
    • Le serveur alimente le reçu des jetons d'entrée à AcceptSecurityContext et produit sa propre sortie de jetons. ASC a également retourne 'ContinueNeeded" pour indiquer que l'authentification
      le cycle n'est pas complète.
    • Ensuite, le serveur envoie sa sortie des jetons pour le client.
    • Le client fournit les serveurs de jetons d'entrée à InitializeSecurityContext, qui renvoie en sortie des jetons.
    • Le client envoie sa nouvelle sortie des jetons pour le serveur.
    • ...

    Ce cycle se poursuit jusqu'à ce que le client voit InitializeSecurityContext return 'OK' et le serveur voit AcceptSecurityContext return 'OK'. Chaque fonction peut retourner " OK " et encore fournir une sortie jeton (comme indiqué par un non-retour null), pour indiquer qu'il a encore à envoyer des données vers l'autre côté. De cette façon, le client sait que sa moitié est fait, mais le serveur est encore incomplète, et vice-versa, si le serveur est terminée avant que le client. De quel côté se termine en premier (renvoie "OK") dépend du package de sécurité utilisé sous le capot en SSPI, et tout SSPI consommateurs doivent être conscients de cela.

    Les informations ci-dessus devrait être suffisant pour quiconque d'être en contact avec le SSPI système afin de fournir 'Authentification Intégrée de Windows" dans leur application et de reproduire les résultats de ma recherche.

    Ci-dessous est ma précédente réponse que j'ai appris à invoquer la SSPI API.

    Je l'avais oublié cette question, et par coïncidence, est retourné à ce problème il y a quelques jours sur un coup de tête. J'ai besoin de résoudre ce problème dans un an ou deux si 🙂

    C'est possible .Net, et je suis en train de développer une .Net SSPI wrapper que j'ai l'intention de publier.

    Je vais baser mon travail sur les SSPI échantillons de Microsoft, je trouve.

    L'échantillon contient un C++/CLI géré assemblée qui implémente les parties nécessaires de la SSPI API (dans le dossier Microsoft\Samples\Security\SSPI\SSPI extrait de l'REMSSPI.exe fichier). Ensuite, ils ont deux interfaces utilisateur, une application client et un serveur d'application écrite en C# qui rendent l'utilisation de cette API pour effectuer l'authentification SSPI.

    L'Isu faire usage de l' .Net remoting installation de lier tout cela ensemble, mais si je comprends la SSPI API correctement, la seule information que le client et le serveur ont besoin d'échanger des se compose de byte[]contenant contexte de sécurité jeton de données, qui peut être facilement intégrée dans toutes les infrastructures de communication que vous souhaitez, dans mon cas, un protocole binaire de ma propre conception.

    Quelques notes sur l'obtention de l'échantillon de travail - ils ont le "SSPI" bibliothèque de la source, qui a le mieux compile sous VS 2005, bien que j'ai eu à le faire fonctionner sous 2008; 2010 ou au-dessus aurait besoin d'un peu retravailler car ils utilisent la langue des constructions qui ont été désapprouvées. Vous pouvez aussi avoir besoin de modifier les fichiers d'en-tête qui font partie de votre kit de développement platform SDK, parce qu'ils font de l'utilisation de const pointeur affectations à unconst variables, et je ne sais pas une meilleure façon de faire le bonheur du compilateur (je n'ai jamais utilisé le C++/CLI avant).

    Ils ne comprennent compilé SSPI dll dans le Microsoft\Samples\Security\SSPI\bin. Pour obtenir le client/serveur de fichiers binaires pour travailler, vous devez copier dll de leur répertoire bin, sinon l'échec de la résolution de l'assemblée.

    Donc, pour résumer:

    • Aller ici pour télécharger le REMSSPI.exe l'échantillon zip auto-extractible.
    • Extrait de l'REMSSPI.exe fichier (deux fois..)
    • Microsoft\Samples\Security\SSPI\
      • bin\ - contient dll compilée Microsoft.Samples.Security.SSPI.dll
      • SSPI\ - contient la source à la dll
      • Sample\ - contient le code source de l'INTERFACE utilisateur
        • bin\ - Contient construire l'INTERFACE utilisateur des échantillons. Copie de la SSPI.dll fichier et exécuter ControlPanel.Client.exe et ControlPanel.Server.exe
    • Ouais. J'ai trouvé que l'échantillon de trop. Mais préférez une solution sans une DLL. Si vous ne pouvez p/invoke les appels d'API et d'obtenir une solution prête à l'emploi, vous serez récompensé avec des points.
    • Cette DLL est géré .Net DLL, écrit en C++/CLI. Je suis en train d'écrire ma propre version de celui-ci en C# pour mes propres raisons, mais je pourrais tout aussi bien utiliser qu'un seul.
    • ahh ok. nice. veuillez la publier 🙂
    • Je pense que nous sommes confus. Microsoft.Samples.Security.SSPI.dll est Géré .Net DLL écrite en C++/CLI. Vous pouvez obtenir le code binaire à partir de l'échantillon de téléchargement. Je suis en train d'écrire ma propre version de cette DLL en C# que j'ai l'intention de publier, mais vous pourriez probablement utiliser simplement Microsoft.Samples.Security.SSPI.dll comme c'est.
    • Avez-vous vu le NegotiateStream dans .NET?
    • Je n'avais pas. Il semble assez proche de ce que nous avons besoin, même si je n'aime pas que je ne peux pas spécifier le contexte SSPI attributs (mutuelle auth, replay, détection de la séquence de détection, d'intégrité, d'identifier). Selon un article de blog, ça va dégrader la connexion à l'authentification NTLM si il ne peut pas le soutien mutuel auth, ce qui semble être l'insécurité chose à faire. Hrrmm.
    • pour ce que ça vaut, j'ai un prototype de travail disponible. Svn angst.csh.rit.edu/svn/nsspi/trunk. C'est encore beaucoup prototype - incompatible organisation, les pauses de moins de 64 bits, dangereux poignée d'utilisation, ne prend pas en charge de nombreuses fonctionnalités, beaucoup d'exposés internes, etc. Je travaille toujours sur les régulièrement si.
    • J'ai publié mon projet. C'est l'alpha de la qualité, puisque je ne pas encore disposer d'un environnement de production pour le tester, mais je serais heureux de recevoir vos commentaires. J'ai inclus mes notes dans mon montage, afin que d'autres puissent reproduire mon travail.
    • Comment vous sentez-vous à propos de le mettre sur nuget.org?
    • question: une fois que le serveur et les clients sont terminées, qui ne vous autorisez l'utilisateur dans un Domaine, dans le cas où vous écrivez un package d'authentification personnalisé (donc pas de NTLM, pas de Kerberos par défaut des paquets)? J'ai vu des exemples de définir un tampon message plein de 'x' ou 'y' ou 'z', mais que signifient-ils? Cette partie n'est pas documenté
    • Si vous avez un package d'authentification personnalisé, vous pouvez appeler votre colis par le biais de la SSPI API simplement par son nom de chaîne - dans le NSspi projet, PackageNames est juste un ensemble de constantes de chaîne qui sont passés à l'information d'Identification classes concrètes. Si vous avez quelques API externe à invoquer pour obtenir un handle vers l'identification en cours, vous pouvez étendre les informations d'Identification/ClientCredential/ServerCredential classes pour le faire vous-même. Est le tampon de la question une question distincte, et pourriez-vous préciser?
    • merci pour la réponse, le tampon question est liée à elle. De toute façon, pour l'instant j'invoque une coutume AP avec LsaCallAuthenticationPackage et d'interagir avec elle. À la fin, je comprends mise en œuvre d'un module SSPI est utile lorsque certains type de l'architecture client/serveur est en cause. Dans mon cas, tout fonctionne en local sur la même machine. Est-il encore une bonne approche ou dois-je mettre en œuvre SSPI de toute façon?
    • merci pour ce merveilleux post. Cependant, j'ai une question. Il faut un processus sur le côté serveur qui utilise SSPI mécanisme de tri complet de l'ensemble de la communication ? quand je vois l'exemple de la documentation de SSPI, je reçois une sensation qu'il nécessite un processus en cours d'exécution sur le serveur aussi ? Je veux réaliser ce de du serveur proxy local, et de réaliser le processus d'authentification. Mais je doute si je peux avoir un processus en cours d'exécution il ! Généralement serveur prend désormais en charge l'authentification basique et console le client peut obtenir des authentifié comme normale navigateur utilise l'authentification basique mécanisme.
    • avec l'authentification, il y a toujours besoin d'être un client et un serveur. Cependant, ce qui est le client et qu'est-ce que le serveur est à vous. Dans mon cas, le serveur est un programme que j'ai écrit qui est à l'écoute sur une socket (et ne pas utiliser le protocole http). Semble que votre programme se veut parler à un serveur web et d'authentifier comme IE n' - qui se passe à l'aide de GSSAPI Kerberos. La SSPI API prend en charge ce, et de nsspi peut/va; regardez: github.com/antiduh/nsspi/issues/3. Que personne en œuvre GSSAPI pour nsspi, ils m'avez dit ils contribuent en retour. Je suis en attente pour eux de le faire.
    • Merci beaucoup pour votre réponse. Oui, vous avez raison, je suis en train de parler à un serveur web, et était à la recherche de la possibilité de NTLM mécanisme destiné à réaliser l'authentification. Si l'authentification NTLM est trop compliqué, je vais aller pour Kerberos. GSSAPI Kerberos utilise kerberos mécanisme ? Je crois que pour Kerberos mécanisme de base d'Active directory est une exigence? En cas de SSPi en fonction de la solution n'est pas d'entraînement pour moi, je pense à mettre en œuvre les 3 poignée de main par moi-même (ou reproduire les scénarios http juste comme il arrive dans basic auth). Pouvez-vous suggérer de mise en œuvre qui serait le mieux pour mon scénario?
    • Il ressemble à NTLM sur le web est possible - semble qu'ils en base 64 encoder les jetons: blogs.msdn.microsoft.com/chiranth/2013/09/20/.... Vous pourriez probablement utiliser le côté client de la SSPI pour effectuer l'authentification du cycle, la farce, les jetons dans la requête http. Veux ouvrir un sujet sur la page github, et nous allons continuer à parler là?
    • J'ai ouvert un litige sur la page github. Maintenant je suis en suivant l'approche que vous avez mentionné que je suis à l'aide de code côté client de puissance alternateur, les jetons et remplissez-le-têtes de requête http avec ces jetons. Cependant, Le type 2 message ne me donne de nouveau l'autorisation de la chaîne, il me donne de nouveau de retour NTLM dans WWW-Authenticate! Ai-je besoin pour coder le jeton dans une manière spécifique, avant de remplir l'en-tête de demande?

    InformationsquelleAutor antiduh
  2. 0

    Nikola est correct; il n'en est pas un .NET-native façon d'accomplir ce que vous êtes en train de faire (au moins, ne pas utiliser de bas niveau .NET de la prise en charge des Sockets). Vous pouvez certainement plongée sous les couvertures pour faire quelques interop la magie noire, mais si à la fois le client et le serveur sont sous votre contrôle, vous pouvez peut-être envisager d'aller jusqu'à la pile un peu et à l'aide d'un niveau plus élevé de l'API comme WCF, qui N'ont .NET-support natif pour l'authentification Intégrée de Windows.

    En fonction de votre question et de votre décrite environnement, vous seriez en mesure d'utiliser le NetTcpBinding, qui offre de hautes performances ainsi que la plomberie pour l'authentification/identification du flux que vous cherchez pour (il propose également un assez propre façon de gérer l'autorisation à l'aide de la ServiceAuthorizationManager classe). Sans connaître les détails de votre application/service que je ne peux pas fournir un "Comment faire" pour mettre en œuvre ce que vous cherchez à faire, mais je peux point vous à la documentation qui ont une assez simple exemple.

    • Je veux utiliser un .NET moyen (pour un même client/serveur). WCF semble être en mesure de le faire en utilisant son netTcpBinding, mais le code est confus et difficile à suivre.
    • Je ne suis pas sûr de ce que vous voulez dire quand vous dites "un .NET moyen" de la WCF est une .NET fonctionnalité. Je ne comprends que la WCF courbe d'apprentissage peut être un défi de taille, mais de ma propre expérience, il est préférable d'apprendre à utiliser les structures existantes plutôt que d'essayer de mettre en place votre propre (en termes de temps de développement et les frais de maintenance).
    • La question est très spécifique. Je ne veux pas utiliser WCF. Je veux être en mesure d'utiliser l'authentification windows dans le cadre d'un client/serveur. WCF peut le faire dans netTcpBinding, donc c'EST possible. Je veux savoir comment l'utiliser .NET sans p/invoque si possible. C'est pour mon propre client/serveur de la bibliothèque blog.gauffin.org/2014/05/.... Je le répète: Aucune réponse, ce qui suggère FMC n'est pas OK en me.
    • Je comprends. Bonne chance!
    • merci, j'ai probablement besoin 🙂
    InformationsquelleAutor Andy Hopper
  3. 0

    Je suis totalement tort avec WindowsIdentity (ce qui est bon pour autorisation) parce que j'ai oublié que WCF gère beaucoup de choses avec des fichiers de configuration de sécurité du point d'extrémité et le message/la sécurité du transport.

    Avez-vous essayé avec NegotiateStream ? L'exemple donné semble mieux adaptée à vos besoins : il utilise Kerberos pour l'authentification avant d'en permettre la lecture/écriture. À l'aide de la CredentialCache.DefaultNetworkCredentials devrait vous éviter de requête pour un mot de passe.

    InformationsquelleAutor xum59
  4. 0

    Vous vous demandez peut - "Comment le serveur confirmer un client qui ils disent qu'ils sont?"

    Réponse: Si tous les allers-retours de la poignée de main pourrait être terminé avec succès, c'est à dire à la fois

    • InitializeSecurityContext renvoie "OK"
    • AcceptSecurityContext renvoie "OK"

    cela signifie que le client Windows identifiants de connexion ont été confirmé pour être vrai.

    AcceptSecurityContext sorties d'un CtxtHandle contexte de sécurité (par le biais de la 6ème paramètre).

    Ce handle de contexte comprend le client de connexion Windows de l'utilisateur nom d'utilisateur. Le serveur peut obtenir du client nom d'utilisateur windows en appelant QueryContextAttributesEx:

    SecPkgContext_NativeNames pinfo;
QueryContextAttributesEx(&m_securitycontext, SECPKG_ATTR_NATIVE_NAMES, &pinfo);

    Ce remplit un Noms Autochtones structure:

    SecPkgContext_NativeNames 
{
   SEC_CHAR *sClientName;
   SEC_CHAR *sServerName;
}

    la valeur pinfo.sClientName du client sont le véritable nom d'utilisateur de connexion.

    Note: de La précédente poignée de main déjà garantir la vérité de contexte de sécurité, de sorte que le serveur ne crois pinfo.sClientName est juste le client réel de nom d'utilisateur windows.

    InformationsquelleAutor winnie_quest
  5. -2

    Jamais essayé de travailler avec WindowsIdentity ?

    Pure C#/.Net, serializable et GetCurrent() retourne l'exécution de compte.

    Jeton De Sécurité

    L'utilisateur fournit une série de revendications à votre demande
    jumelé avec sa demande. Dans un service Web, ces revendications sont
    porté dans l'en-tête de sécurité de l'enveloppe SOAP. Dans un
    navigateur application Web basée sur les revendications arrivent via un HTTP POST à partir de
    le navigateur de l'utilisateur, et plus tard peut être mis en cache dans un cookie si une session
    est souhaitée. Indépendamment de la façon dont ils arrivent, ils doivent être sérialisés
    en quelque sorte, et c'est là que les jetons de sécurité sont en. Un jeton de sécurité
    est sérialisé série de revendications qui est signé numériquement par l'émission
    de l'autorité. La signature est importante: elle vous donne l'assurance que
    l'utilisateur n'a pas seulement un tas de revendications et de les envoyer à vous.
    En bas de sécurité des situations où la cryptographie n'est pas nécessaire ou
    vous le souhaitez, vous pouvez utiliser unsigned jetons, mais ce n'est pas un scénario que je suis
    va se concentrer dans le présent document. Un des éléments de base dans le WIF est
    la capacité de créer et de lire des jetons de sécurité. WIF et le sous-jacent
    plomberie dans le .NET Framework gère toutes les cryptographiques lourd
    de levage, et présente votre application avec un ensemble de revendications que vous
    peut lire.

    cité de Windows Identité De Création Livre Blanc

    Votre question principale était :

    "Est-il un pur C#/.NET moyen d'authentifier les utilisateurs à l'aide de leurs informations d'identification d'ouverture de session ?"

    La WindowsIdentity "est" le jeton d'authentification émis par votre contrôleur de domaine et me semble être la meilleure approche à ce moment.

    Je savais très peu sur WindowsIdentity quand j'ai posté, mais j'ai aussi senti qu'il allait aider avec votre problème et des contraintes. J'ai fait beaucoup de lecture et finalement venu à cet page.

    L'introduction de WIF est auto-explicatif, WindowsIdentity est un nouveau jeu de la .NET framework conçu pour Windows/sécurité basée sur les rôles des préoccupations.

    SSPI, Kerberos sont des parties de l'ensemble du processus d'authentification Windows, le jeton de connexion obtenus par l'utilisateur/machine/processus est accordée par le contrôleur de domaine et ne peut être obtenue par "simplement" instanciating un nouvel objet WindowsIdentity. Si ce genre d'illégal instanciation de l'existence, l'ensemble du modèle de sécurité de Windows (domaines, contrôle de compte d'utilisateur, etc.) serait morte.

    Voici un (très!) petit programme en mode console qui lève une exception si vous n'êtes pas partie de la "BUILTIN\Administrateurs" (modifier le nom du groupe en fonction de vos propres besoins). Chaque fois que "Exécuter en tant qu'Administrateur", le programme se termine sans erreur.

    Il existe un très grand ensemble d'autorisations et chaque demande est basée sur les revendications (qui est de l'identité de memeber de xxx ?)

    using System;
using System.Security;
using System.Security.Permissions;
using System.Security.Principal;

namespace WindowsIdentityTest
{
    class Program
    {
        [PrincipalPermission(SecurityAction.Demand, Authenticated = true)]
        static string SomeServerAction()
        { return "Authenticated users can access"; }

        [PrincipalPermission(SecurityAction.Demand, Role = "BUILTIN\\Administrateurs")]
        static string SomeCriticalServerAction()
        { return "Only Admins can access"; }

        static void Main(string[] args)
        {
            //This allows to perform security checks against the current Identity.   
            AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);

            try
            {
                Console.WriteLine(SomeServerAction());
                Console.WriteLine(SomeCriticalServerAction());

            }
            catch (SecurityException sec)
            {
                Console.WriteLine(string.Format("{0} : {1}\n------------\n{2}"
                    , sec.GetType()
                    , sec.Message
                    , sec.StackTrace));
            }
            catch (Exception ex)
            {
                Console.WriteLine("This shall not appen.");
            }
            Console.WriteLine("Press enter to quit.");
            Console.ReadLine();
        }
    }
}

    J'espère que cela aidera.

    • Pourriez-vous fournir un peu plus de détails? Comment puis-je l'utiliser pour convaincre un service qui s'exécute sur une machine distante qui je suis qui je dis que je suis? Je vois que WindowsIdentity est sérialisable, mais qui ne peuvent pas aider beaucoup, car une bonne conception de la sécurité (kerberos) et SSPI exiger que transmis des jetons être conçu de telle façon que seul le service d'accueil peuvent les utiliser (authentification mutuelle). Je ne vois pas comment l'un quelconque de cette classe ou de classes associées aider avec cela, mais là encore je suis très nouveau pour que la moitié de l'API.
    • Le WindowsIdentity (GetCurrent()) l'objet est l'identification jeton obtenu lorsque l'utilisateur connecté. À l'aide de impersonnation sur le serveur-côté permettra d'ouvrir une connexion SQL Server avec Integrated_Security définie sur true (si l'utilisateur de domaine est accordée), même si le serveur compte du processus de travail ne peut pas. Pour d'autres types de ressources (I/O Autorisations...), il doit travailler tout de même.
    • Vous avez besoin de lire ma question d'origine d'un peu plus près.
    • Vous avez écrit "Mes utilisateurs font partie d'un domaine, et donc, je veux être en mesure d'utiliser les informations d'identification d'ouverture de session, ils ont créé lors de l'ouverture de session." La session de l'utilisateur informations d'identification sont obtenues par le biais de WindowsIdentity.GetCurrent(), je ne sais pas quel genre de preuve que vous essayez d'obtenir en SSPI. Aussi longtemps que vous ne souhaitez pas gérer les logins et mots de passe, je crois qu'en s'appuyant sur Windows Authentification (groupes, permissions, et ainsi de suite) est le meilleur aapproach.
    • L'usurpation d'identité n'est pas d'authentification. Hésitez pas à donner un exemple de travail où le serveur peut authentifier l'identité d'un client à l'aide de WindowsIdentity.
    • Je ne pense pas que vous avez besoin d'une authentification côté serveur comme WindowsIdentity EST le jeton d'authentification fournis à l'utilisateur par votre contrôleur de domaine. Si vous ne voulez pas gérer les mots de passe, vous ne pouvez pas re-authentifier l'utilisateur : mot de passe ne sont pas stockés en aucune façon. L'usurpation d'identité vous permettra seulement d'utiliser les identifiants de l'utilisateur sur le serveur-côté. En fonction de vos besoins, décorer des méthodes avec les PrincipalPermissionAttribute et/ou de l'utilisation explicite PrincipalPermission.De la demande et/ou s'appuient sur la sécurité basée sur les rôles.
    • Je ne pense pas que vous comprenez. Nous voulons que le processus de serveur pour authentifier les clients, de sorte que les gens ne peuvent pas arbitrairement connecter et d'envoyer des commandes qu'ils n'ont pas la permission pour. Vous ne pouvez pas faire confiance au logiciel client dans un système de mise en réseau, car ils pourraient forger les commandes de réseau. Oui, le client peut savoir qui est connecté à l'aide de WindowsPrinciple, mais le client ne peut pas faire confiance.
    • "Je ne pense pas que vous avez besoin d'une authentification côté serveur" - qui est l'antithèse de serveur sécurisé pratiques de développement.
    • Pensez à la manière dont l'authentification est effectuée dans tous les client-serveur logiciel système. Ne les Perspectives Serveur de confiance le client Outlook? Non, sinon, quelqu'un pourrait écrire un personnalisé du client outlook qui prétend être n'importe quel utilisateur, puis à un attaquant de lire tout de messagerie de l'utilisateur. Le client a à prouver pour le serveur que l'utilisateur est bien celui qu'il dit qu'il est. C'est souvent mise en œuvre par demander à l'utilisateur d'envoyer leur nom d'utilisateur et le mot de passe (via un canal crypté, par exemple, SSL), pour le serveur.
    • Cependant, je ne souhaite pas avoir mes utilisateurs ont à faire, et au lieu de cela je souhaite utiliser leurs informations d'identification d'ouverture de session pour produire des jetons d'authentification que je peux ensuite envoyer au serveur. Vous avez besoin de lire comment kerberos et NTLM (protocoles d'authentification réseau) et SSPI (Fenêtre du wrapper autour de NTLM et Kerberos) de travail.
    • "Kerberos - la Conception d'un Système d'Authentification: un Dialogue à Quatre Scènes" - web.mit.edu/kerberos/dialogue.html
    • SSPI - Lire l'Introduction et l'Authentification des sections à partir d'ici: msdn.microsoft.com/en-us/library/ms973911.aspx
    • J'ai vu vos modifications, et vous n'avez toujours pas l'obtenir, ce qui signifie que vous n'avez pas lu les liens que je vous ai donné. Vous êtes encore en train de faire tous les d'authentification, l'identification et la gestion des autorisations côté client. ce n'est pas sécurisé! Downvote.
    • J'ai lu les liens que vous avez ajouté, et beaucoup plus (je souhaite faire quelque chose de similaire), Mais avez-vous lu que certains le document que j'ai lié? My users are part of a domain, and so I want to be able to use the logon credentials they created when they logged in. Envoyer cette identification de connexion (oui, WindowsIdentity) pour le serveur et exécuter des vérifications de sécurité côté serveur (impersonnation), Soit vous faites confiance à votre contrôleur de domaine à la question de l'ouverture de session des jetons et des informations d'identification associées (ou les allégations), soit vous n'avez pas (et puis aurez besoin d'un SSPI-complient méthode d'authentification qui nécessitent un mot de passe)
    • Ok, alors comment voulez-vous transmettre de manière sûre un WindowsIdentity pour le serveur? Votre code ne montre pas que l', et la seule façon sûre de le faire est en utilisant SSPI, à ma connaissance.
    • Je n'ai pas eu le temps de finir mes tests, mais je crois qu'il y a un moyen de valider le jeton en le soumettant à l'émetteur, ce qui pourrait être la preuve que vous avez tellement envie. Dernière chose, si vous voulez vraiment tout prouver (Kerberos style), votre serveur doit prouver son identité aussi.
    • Droit, mais ce que vous venez de décrire est exactement ce que SSPI n'. Sauf que SSPI peut faire NTLM, Kerberos, ou tout autre Fournisseur de Services de Sécurité installé sur la machine et répond aux exigences imposées par les indicateurs spécifiés dans de l'appelant contexte indicateurs d'attribut.
    • Laissez-nous continuer cette discussion dans le chat.
    • SSPI ne fait rien, SSPI décrit : c'est une interface de fournisseur de services partagés comme Kerberos, NTLM. Vous dites que vous voulez compter sur les informations d'identification des utilisateurs, WIF est fait pour ça. Je ne suis pas un expert (je suis arrivé sur ce post par une recherche Google), mais de l'OMI (et j'ai fait un peu de lecture depuis), la mise en œuvre de SSPI ne ressemble pas une bonne chose pour moi.

    InformationsquelleAutor xum59