Authentification Client-serveur-utilisant SSPI?

je travaille sur une application client-serveur et je veux que le client s'authentifie sur le serveur en utilisant les informations d'identification de l'utilisateur, mais je ne veux pas que l'utilisateur ait à taper son nom d'utilisateur et son mot de passe. Je ne veux certainement pas être responsable du traitement sécurisé des mots de passe. J'ai seulement besoin que l'utilisateur me prouve qu'ils sont qui ils disent qu'ils sont, et alors mon serveur peut aller de l'avant et accorder/refuser des commandes comme il le veut.

Mes utilisateurs font partie d'un domaine, et donc je vous voulez être en mesure d'utiliser les identifiants de connexion qu'ils ont créés lorsqu'ils se sont connectés.

Je n'utilise aucune sorte de services web, et je ne le veux pas. Je contrôle à la fois le logiciel client et le logiciel serveur, et les deux sont écrits en pur C# et utilisent de bonnes vieilles sockets pour obtenir le travail fait.

je préférerais le faire avec C#/.Net pur, mais je suis ouvert à l'utilisation de C# et pinvokes dangereux pour win32 API si cela signifie que je vais faire le travail.

j'ai lu un peu sur SSPI dans windows, mais je me sens un peu dans le noir car ce genre de développement d'application est nouveau pour moi.

quelqu'un sait comment faire cela? Est SSPI? Comment utiliser SSPI à partir de C#? Y a-t-il une façon .net-native pour que mon code puisse rester portable?

22
demandé sur antiduh 2013-06-21 21:48:52

4 réponses

mise à Jour:

SSPI est le droit pour cette approche. L'API n'est pas trop difficile à utiliser, mais nécessite un projet de taille décente à intégrer dans C#.

dans le processus de recherche des bits nécessaires pour résoudre cette question, j'ai écrit un projet pour fournir SSPI in .Net. Ci-dessous, je décris les bases de l'interfaçage avec L'API Windows SSPI afin que n'importe qui puisse répliquer mes résultats. Si vous voulez utiliser SSPI dans .Net, je peux vous suggérer d'utiliser le projet que j'ai créé pour résoudre ce problème:

nsspi-A. interface .Net vers L'API SSPI

SSPI vous fournit des tableaux d'octets bruts contenant des tokens d'authentification que vous décidez ensuite comment transmettre - que ce soit sur une socket avec des messages binaires formatés, un canal XML personnalisé, .Net, une certaine forme de 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 le client en toute sécurité, et même effectuer les procédures de traitement de messages de base comme le chiffrement / la signature en utilisant le contexte de sécurité établi avec le client.

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

jetez un coup D'oeil spécifiquement aux fonctions suivantes:

  • Acquirecretentialshandle
    • acquiert une poignée vers une certaine forme de justificatifs d'identité (par exemple, l'ouverture de session de l'utilisateur courant). Utilisé par les serveurs et client.
  • 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 chaque partie initialise leurs justificatifs d'identité en utilisant Acquirecentialshandle. Le le cycle d'authentification commence et progresse comme suit:

  • le client invoque InitializeSecurityContext, ne fournissant pas de tokens d'entrée, qui renvoie des tokens de sortie sous la forme d'un tableau d'octets. ISC retourne "ContinueNeeded" pour indiquer que le cycle d'authentification n'est pas terminé.
  • le client envoie les jetons au serveur par le moyen de son choix.
  • le serveur alimente les tokens reçus en input pour accepter SecurityContext et produit ses propres jetons de sortie. ASC renvoie également "ContinueNeeded" pour indiquer que l'authentification le cycle n'est pas complète.
  • le serveur envoie alors ses tokens de sortie au client.
  • le client fournit les tokens serveurs en tant qu'input à InitializeSecurityContext, qui renvoie de nouveaux tokens de sortie.
  • le client envoie ses nouveaux tokens de sortie au serveur.
  • ...

ce cycle se poursuit jusqu'à ce que le client voie InitializeSecurityContext return ' OK 'et le serveur voit AcceptSecurityContext return'OK'. Chaque fonction peut retourner " OK " et fournir tout de même un jeton de sortie (comme indiqué par un retour non-null), pour indiquer qu'elle doit encore envoyer des données à l'autre côté. C'est ainsi que le client sait que sa moitié est faite mais que celle du serveur est encore incomplète; et vice versa si le serveur termine avant le client. Quel côté remplit en premier (retourne "OK") dépend du paquet de sécurité utilisé sous le capot par SSPI, et tout consommateur SSPI devrait être conscient de cela.

les informations ci-dessus devraient être suffisantes pour permettre à quiconque d'être interfacé avec le système SSPI afin de fournir une "authentification intégrée Windows" dans leur application et de répliquer mes résultats.

ci-dessous est ma réponse précédente car j'ai appris à invoquer L'API SSPI.


j'avais oublié cette question, et par coïncidence je suis revenu à ce problème quelques jours il y a sur un coup de tête. J'ai besoin de résoudre ce problème dans un an ou deux :)

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

Je Base mon travail sur certains SSPI samples à partir de Microsoft que j'ai trouvé.

l'échantillon contient un assemblage géré par C++/CLI qui implémente les parties nécessaires de L'API SSPI (dans le dossier Microsoft\Samples\Security\SSPI\SSPI extrait du REMSSPI.EXE.) Ils ont ensuite deux UIs, a une application client et une application serveur, toutes deux écrites en C# qui utilisent cette API pour effectuer l'authentification SSPI.

L'UIs utilise la fonction remoting de .Net pour tout relier, mais si je comprends bien L'API SSPI, les seules informations que le client et le serveur doivent échanger sont des octets contenant des données de contexte de sécurité, qui peuvent facilement être intégrées dans n'importe quelle infrastructure de communication que vous voulez; dans mon cas, un protocole binaire de ma propre conception.

quelques notes sur le fonctionnement de l'échantillon - ils ont la source de bibliothèque 'SSPI', qui se compile le mieux sous VS 2005, bien que je l'ai fait fonctionner sous 2008; 2010 ou plus nécessiterait quelques retouches car ils utilisent des constructions linguistiques qui ont été dépréciées. Vous pouvez également avoir besoin de modifier les fichiers d'en-tête qui font partie de votre SDK de plate-forme, parce qu'ils font usage de const pointer assignments to unconst variables, et je ne sais pas une meilleure façon de rendre le compilateur heureux (j'ai jamais utilisé C++ / CLI avant).

ils incluent une dll SSPI compilée dans le dossier Microsoft\Samples\Security\SSPI\bin. Pour que les binaires client/serveur fonctionnent, vous devez copier cette dll dans leur répertoire bin, sinon la résolution de l'Assemblée d'échec.

Donc, pour résumer:

  • ici pour télécharger le REMSSPI.échantillon d'exe auto-extraction zip.
  • extraire le REMSSPI.EXE (deux fois..)
  • Microsoft\Samples\Security\SSPI\
    • bin\ - contient la dll compilée Microsoft.Samples.Security.SSPI.dll
    • SSPI\ - contient source à dll
    • Sample\ - contient le code source de L'assurance-chômage
      • bin\ - contient des échantillons d'interface de compilation. Copie de la SSPI.dll fichier ici et exécuter ControlPanel.Client.exe et ControlPanel.Server.exe
19
répondu antiduh 2015-11-04 16:45:49

Nikola est correct; il n'y a pas de façon native .NET pour accomplir ce que vous faites (du moins, pas en utilisant le support de bas niveau .net Sockets). Vous pouvez certainement plonger sous les couvertures pour faire de la magie noire interop, mais si à la fois le client et le serveur sont sous votre contrôle, vous pouvez envisager de remonter un peu la pile et d'utiliser une API de plus haut niveau comme WCF, qui a la prise en charge .net-native pour l'authentification intégrée de Windows.

basé sur votre question et votre environnement décrit, vous seriez en mesure d'utiliser le NetTcpBinding, qui offre de hautes performances ainsi que la plomberie pour le flux d'authentification/identité que vous recherchez (il offre également une façon assez propre de gérer l'autorisation en utilisant la classe ServiceAuthorizationManager). Sans connaître les détails de votre application / service Je ne peux pas fournir un "Comment" pour mettre en œuvre ce que vous cherchez à faire, mais je peux pointez - vous vers le docs qui ont un assez simple exemple.

0
répondu Andy Hopper 2014-06-19 13:30:01

je me suis complètement trompé avec WindowsIdentity (ce qui est bon pour l'autorisation) parce que j'ai oublié que la WCF gère beaucoup de choses avec les fichiers de configuration, la sécurité des terminaux et la sécurité des messages/transports.

avez-vous essayé avec NegotiateStream