Mam aplikację internetową (hostowaną w IIS), która komunikuje się z usługą systemu Windows. Usługa systemu Windows korzysta z interfejsu API sieci Web ASP.Net MVC (samodzielnie hostowana), więc można ją komunikować za pośrednictwem protokołu HTTP przy użyciu formatu JSON. Aplikacja internetowa jest skonfigurowana do podszywania się, a idea polega na tym, że użytkownik, który wysyła żądanie do aplikacji internetowej, powinien być użytkownikiem, którego aplikacja internetowa używa do wysłania żądania do usługi. Struktura wygląda następująco:

_{(Użytkownik wyróżniony na czerwono to użytkownik, o którym mowa w poniższych przykładach).}

Aplikacja internetowa wysyła żądania do usługi Windows za pomocą HttpClient:

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

Powoduje to wysłanie żądania do usługi systemu Windows, ale nie przekazuje poprawnie poświadczeń (usługa zgłasza użytkownika jako IIS APPPOOL\ASP.NET 4.0). Nie tego chcę .

Jeśli zmienię powyższy kod, aby WebClientzamiast tego używał a, poświadczenia użytkownika są przekazywane poprawnie:

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

Za pomocą powyższego kodu usługa zgłasza użytkownika jako użytkownika, który zgłosił żądanie do aplikacji internetowej.

Co robię źle z HttpClientimplementacją, która powoduje, że nie przekazuje ona poprawnie poświadczeń (lub czy jest to błąd z HttpClient)?

_{Powodem, dla którego chcę użyć HttpClientjest to, że ma async API, które działa dobrze z Tasks, podczas gdy WebClientasyc API musi być obsługiwane ze zdarzeniami.}

Ja też miałem ten sam problem. Opracowałem rozwiązanie synchroniczne dzięki badaniom wykonanym przez @tpeczek w następującym artykule SO: Nie można uwierzytelnić się w usłudze ASP.NET Web Api z HttpClient

Moje rozwiązanie wykorzystuje znak WebClient, który, jak poprawnie zauważyłeś, przekazuje poświadczenia bez problemu. Przyczyną HttpClientnie jest to, że zabezpieczenia systemu Windows wyłączają możliwość tworzenia nowych wątków na podszywanym koncie (zobacz artykuł SO powyżej). HttpClientTworzy nowe wątki za pośrednictwem fabryki zadań, powodując błąd. WebClientz drugiej strony działa synchronicznie w tym samym wątku, pomijając w ten sposób regułę i przekazując jej poświadczenia.

Chociaż kod działa, wadą jest to, że nie będzie działać asynchronicznie.

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();
}

Uwaga: wymaga pakietu NuGet: Newtonsoft.Json, który jest tym samym, z którego korzysta interfejs WebAPI serializatora JSON.

Możesz skonfigurować HttpClientautomatyczne przekazywanie poświadczeń w następujący sposób:

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

To, co próbujesz zrobić, to zmusić NTLM do przekazania tożsamości na następny serwer, czego nie może zrobić - może wykonać tylko personifikację, która zapewnia tylko dostęp do zasobów lokalnych. Nie pozwoli ci przekroczyć granicy maszyny. Uwierzytelnianie Kerberos obsługuje delegowanie (to, czego potrzebujesz) przy użyciu biletów, a bilet można przekazać dalej, gdy wszystkie serwery i aplikacje w łańcuchu są poprawnie skonfigurowane, a protokół Kerberos jest poprawnie skonfigurowany w domenie. Krótko mówiąc, musisz przejść z używania NTLM na Kerberos.

Więcej informacji na temat dostępnych opcji uwierzytelniania systemu Windows i sposobu ich działania można znaleźć pod adresem : http://msdn.microsoft.com/en-us/library/ff647076.aspx

OK, dziękuję wszystkim współautorom powyżej. Używam .NET 4.6 i mieliśmy ten sam problem. Spędziłem czas na debugowaniu System.Net.Http, a konkretnie na HttpClientHandler, i znalazłem:

    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);
    }

Więc po ocenie, że ExecutionContext.IsFlowSuppressed()mógł być winowajcą, opakowałem nasz kod personifikacji w następujący sposób:

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

Kod wewnątrz SafeCaptureIdenity(nie mój błąd w pisowni), chwyta WindowsIdentity.Current()naszą podrobioną tożsamość. Jest to zauważane, ponieważ teraz tłumimy przepływ. Ze względu na użycie / dispose jest to resetowane po wywołaniu.

Teraz wydaje się, że to działa dla nas, uff!

W .NET Core udało mi się uzyskać System.Net.Http.HttpClientz, UseDefaultCredentials = trueaby przekazać poświadczenia systemu Windows uwierzytelnionego użytkownika do usługi zaplecza przy użyciu 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);
    });
}

U mnie zadziałało po skonfigurowaniu użytkownika z dostępem do Internetu w usłudze Windows.

W moim kodzie:

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

Ok, więc wziąłem kod Joshouna i uczyniłem go ogólnym. Nie jestem pewien, czy powinienem implementować wzorzec singleton w klasie SynchronousPost. Może ktoś lepiej poinformowany może pomóc.

Realizacja

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

Klasa ogólna tutaj. Możesz przekazać dowolny typ

 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; }
    }

Moje klasy Api wyglądają tak, jeśli jesteś ciekawy

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();
    }
}

Używam ninject i wzorca repo z jednostką pracy. W każdym razie powyższa klasa ogólna naprawdę pomaga.