Ich habe eine Webanwendung (in IIS gehostet), die mit einem Windows-Dienst kommuniziert. Der Windows-Dienst verwendet die ASP.Net MVC-Web-API (selbst gehostet) und kann daher über JSON über http kommuniziert werden. Die Webanwendung ist für den Identitätswechsel konfiguriert. Die Idee besteht darin, dass der Benutzer, der die Anforderung an die Webanwendung stellt, der Benutzer sein sollte, mit dem die Webanwendung die Anforderung an den Dienst sendet. Die Struktur sieht folgendermaßen aus:

_{(Der rot hervorgehobene Benutzer ist der Benutzer, auf den in den folgenden Beispielen verwiesen wird.)}

Die Webanwendung sendet Anforderungen an den Windows-Dienst mit HttpClient:

var httpClient = new HttpClient(new HttpClientHandler() 
                      {
                          UseDefaultCredentials = true
                      });
httpClient.GetStringAsync("http://localhost/some/endpoint/");

Dadurch wird die Anforderung an den Windows-Dienst gesendet, die Anmeldeinformationen werden jedoch nicht korrekt übergeben (der Dienst meldet den Benutzer als IIS APPPOOL\ASP.NET 4.0). Das will ich nicht .

Wenn ich den obigen Code so ändere, dass WebClientstattdessen a verwendet wird, werden die Anmeldeinformationen des Benutzers korrekt übergeben:

WebClient c = new WebClient
                   {
                       UseDefaultCredentials = true
                   };
c.DownloadStringAsync(new Uri("http://localhost/some/endpoint/"));

Mit dem obigen Code meldet der Dienst den Benutzer als den Benutzer, der die Anforderung an die Webanwendung gestellt hat.

Was mache ich falsch mit der HttpClientImplementierung, die dazu führt, dass die Anmeldeinformationen nicht korrekt übergeben werden (oder liegt ein Fehler mit der vor HttpClient)?

_{Der Grund, warum ich das verwenden möchte, HttpClientist, dass es eine asynchrone API hat, die gut mit Tasks funktioniert , während die WebClientasyc-API der mit Ereignissen behandelt werden muss.}

Ich hatte auch das gleiche Problem. Ich habe dank der von @tpeczek im folgenden SO-Artikel durchgeführten Recherche eine synchrone Lösung entwickelt: Authentifizierung beim ASP.NET Web Api-Dienst mit HttpClient nicht möglich

Meine Lösung verwendet eine WebClient, die, wie Sie richtig notiert haben, die Anmeldeinformationen ohne Probleme weitergibt. Der Grund, warum HttpClientdies nicht funktioniert, liegt darin, dass die Windows-Sicherheit die Möglichkeit deaktiviert, neue Threads unter einem imitierten Konto zu erstellen (siehe SO-Artikel oben). HttpClientÜber die Task Factory werden neue Threads erstellt, wodurch der Fehler verursacht wird. WebClientAuf der anderen Seite wird synchron auf demselben Thread ausgeführt, wodurch die Regel umgangen und ihre Anmeldeinformationen weitergeleitet werden.

Obwohl der Code funktioniert, ist der Nachteil, dass er nicht asynchron funktioniert.

var wi = (System.Security.Principal.WindowsIdentity)HttpContext.Current.User.Identity;

var wic = wi.Impersonate();
try
{
    var data = JsonConvert.SerializeObject(new
    {
        Property1 = 1,
        Property2 = "blah"
    });

    using (var client = new WebClient { UseDefaultCredentials = true })
    {
        client.Headers.Add(HttpRequestHeader.ContentType, "application/json; charset=utf-8");
        client.UploadData("http://url/api/controller", "POST", Encoding.UTF8.GetBytes(data));
    }
}
catch (Exception exc)
{
    // handle exception
}
finally
{
    wic.Undo();
}

Hinweis: Erfordert das NuGet-Paket: Newtonsoft.Json, das der gleiche JSON-Serializer ist, den WebAPI verwendet.

Sie können so konfigurieren HttpClient, dass Anmeldeinformationen wie folgt automatisch übergeben werden:

var myClient = new HttpClient(new HttpClientHandler() { UseDefaultCredentials = true });

Sie versuchen, NTLM dazu zu bringen, die Identität an den nächsten Server weiterzuleiten, was nicht möglich ist. Es kann nur einen Identitätswechsel durchführen, bei dem Sie nur auf lokale Ressourcen zugreifen können. Sie können keine Maschinengrenze überschreiten. Die Kerberos-Authentifizierung unterstützt die Delegierung (was Sie benötigen) mithilfe von Tickets. Das Ticket kann weitergeleitet werden, wenn alle Server und Anwendungen in der Kette korrekt konfiguriert sind und Kerberos in der Domäne korrekt eingerichtet ist. Kurz gesagt, Sie müssen von NTLM zu Kerberos wechseln.

Weitere Informationen zu den Windows-Authentifizierungsoptionen und deren Funktionsweise finden Sie unter: http://msdn.microsoft.com/en-us/library/ff647076.aspx

OK, also danke an alle oben genannten Mitwirkenden. Ich verwende .NET 4.6 und wir hatten auch das gleiche Problem. Ich verbrachte Zeit mit dem Debuggen System.Net.Http, insbesondere dem HttpClientHandler, und fand Folgendes:

    if (ExecutionContext.IsFlowSuppressed())
    {
      IWebProxy webProxy = (IWebProxy) null;
      if (this.useProxy)
        webProxy = this.proxy ?? WebRequest.DefaultWebProxy;
      if (this.UseDefaultCredentials || this.Credentials != null || webProxy != null && webProxy.Credentials != null)
        this.SafeCaptureIdenity(state);
    }

Nachdem ExecutionContext.IsFlowSuppressed()ich festgestellt hatte , dass dies möglicherweise der Schuldige war, habe ich unseren Identitätswechselcode wie folgt verpackt:

using (((WindowsIdentity)ExecutionContext.Current.Identity).Impersonate())
using (System.Threading.ExecutionContext.SuppressFlow())
{
    // HttpClient code goes here!
}

Der Code in SafeCaptureIdenity(nicht mein Rechtschreibfehler) greift WindowsIdentity.Current()nach unserer Identität. Dies wird aufgegriffen, weil wir jetzt den Fluss unterdrücken. Aufgrund der Verwendung / Entsorgung wird diese nach dem Aufruf zurückgesetzt.

Es scheint jetzt für uns zu funktionieren, Puh!

In .NET Kern konnte ich eine bekommen System.Net.Http.HttpClientmit UseDefaultCredentials = truedem authentifizierten Benutzer-Windows - Anmeldeinformationen an einen Back - End - Dienst durchlaufen , indem Sie WindowsIdentity.RunImpersonated.

HttpClient client = new HttpClient(new HttpClientHandler { UseDefaultCredentials = true } );
HttpResponseMessage response = null;

if (identity is WindowsIdentity windowsIdentity)
{
    await WindowsIdentity.RunImpersonated(windowsIdentity.AccessToken, async () =>
    {
        var request = new HttpRequestMessage(HttpMethod.Get, url)
        response = await client.SendAsync(request);
    });
}

Es hat bei mir funktioniert, nachdem ich einen Benutzer mit Internetzugang im Windows-Dienst eingerichtet habe.

In meinem Code:

HttpClientHandler handler = new HttpClientHandler();
handler.Proxy = System.Net.WebRequest.DefaultWebProxy;
handler.Proxy.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
.....
HttpClient httpClient = new HttpClient(handler)
.... 

Ok, also habe ich Joshoun-Code genommen und ihn generisch gemacht. Ich bin nicht sicher, ob ich ein Singleton-Muster für die SynchronousPost-Klasse implementieren soll. Vielleicht kann jemand mit mehr Wissen helfen.

Implementierung

FileCategory x = new FileCategory { CategoryName = "Some Bs"};
SynchronousPost<FileCategory>test= new SynchronousPost<FileCategory>();
test.PostEntity(x, "/api/ApiFileCategories"); 

Generische Klasse hier. Sie können jeden Typ übergeben

 public class SynchronousPost<T>where T :class
    {
        public SynchronousPost()
        {
            Client = new WebClient { UseDefaultCredentials = true };
        }

        public void PostEntity(T PostThis,string ApiControllerName)//The ApiController name should be "/api/MyName/"
        {
            //this just determines the root url. 
            Client.BaseAddress = string.Format(
         (
            System.Web.HttpContext.Current.Request.Url.Port != 80) ? "{0}://{1}:{2}" : "{0}://{1}",
            System.Web.HttpContext.Current.Request.Url.Scheme,
            System.Web.HttpContext.Current.Request.Url.Host,
            System.Web.HttpContext.Current.Request.Url.Port
           );
            Client.Headers.Add(HttpRequestHeader.ContentType, "application/json;charset=utf-8");
            Client.UploadData(
                                 ApiControllerName, "Post", 
                                 Encoding.UTF8.GetBytes
                                 (
                                    JsonConvert.SerializeObject(PostThis)
                                 )
                             );  
        }
        private WebClient Client  { get; set; }
    }

Meine Api-Klassen sehen so aus, wenn Sie neugierig sind

public class ApiFileCategoriesController : ApiBaseController
{
    public ApiFileCategoriesController(IMshIntranetUnitOfWork unitOfWork)
    {
        UnitOfWork = unitOfWork;
    }

    public IEnumerable<FileCategory> GetFiles()
    {
        return UnitOfWork.FileCategories.GetAll().OrderBy(x=>x.CategoryName);
    }
    public FileCategory GetFile(int id)
    {
        return UnitOfWork.FileCategories.GetById(id);
    }
    //Post api/ApileFileCategories

    public HttpResponseMessage Post(FileCategory fileCategory)
    {
        UnitOfWork.FileCategories.Add(fileCategory);
        UnitOfWork.Commit(); 
        return new HttpResponseMessage();
    }
}

Ich benutze Ninject und Repo-Muster mit Arbeitseinheit. Wie auch immer, die obige generische Klasse hilft wirklich.