ASP.NET Web API Self-Host con Autenticación de Windows

He alojado "Web API" en el servicio de Windows y esto es lo que hice para admitir la autenticación de Windows (básicamente basado en la pregunta anterior, respuestas, algunos artículos relacionados, solo estoy consolidando ya que puede ser útil para otros)

@Servidor HTTP (web api):

Conjunto (referencia: http://msdn.microsoft.com/en-us/library/system.web.http.selfhost.httpselfhostconfiguration.clientcredentialtype(v=vs.118).aspx),

HttpSelfHostConfiguration.ClientCredentialType = System.ServiceModel.HttpClientCredentialType.Windows;

@Cliente:

Y luego, como Allan mencionó (arriba), establezca UseDefaultCredentials en true.

Usando HttpClient:

var handler = new HttpClientHandler();
    handler.UseDefaultCredentials = true;
    _httpClient = new HttpClient(handler);

Usando WebClient (referencia: http://msdn.microsoft.com/en-us/library/system.net.webclient.usedefaultcredentials.aspx )

Establezca usedefaultcrednetials de webclient en 'true'.

Saludos cordiales!

Llego un poco tarde a esto. Sin embargo, si está utilizando Owin para auto host y necesita autorización de Windows. En su clase de inicio puede agregar lo siguiente.

public class Startup
{
    public void Configuration(IAppBuilder app)
    {
        HttpListener listener = (HttpListener)app.Properties["System.Net.HttpListener"];
        listener.AuthenticationSchemes = AuthenticationSchemes.IntegratedWindowsAuthentication;
    }
}

¿Está seguro de que está pasando por la parte de autenticación? Puede usar fiddler para verificar si las solicitudes están pasando realmente o si el servidor siempre responde con 401 No autorizado (ya que está usando autenticación).

También podría intentar implementar su propio AuthorizeAttribute personalizado y poner puntos de interrupción en él para asegurarse de que se golpea (querrá anular el método OnAuthorization y ver si se golpea).

using System.Web.Http;
public class MyAuth : AuthorizeAttribute
{
    public override void OnAuthorization(System.Web.Http.Controllers.HttpActionContext actionContext)
    {
        base.OnAuthorization(actionContext); //put breakpoint here
    }
}

También, asegúrese de que está utilizando el Authorize atributo de System.Web.Http, y no de System.Web.Mvc. Ver aquí ¿por qué.

¿Has intentado poner la [Authorize] atributo en su controlador?

[Authorize]
public class HelloController : ApiController

Aquí hay un enlace a un breve video que explica cómo usar la autorización.

Http://www.asp.net/web-api/videos/getting-started/authorization

En esencia, use el atributo [Authorize] en la clase, capture el error y devuelva una respuesta HTTP 401 y luego haga que el cliente lo detecte y vaya a la página de inicio de sesión

Solo para agregar, si está utilizando la solución de tpeczek y también utilizando HttpClient, es posible que deba hacer esto:

        var handler = new HttpClientHandler();
        handler.UseDefaultCredentials = true;
        _httpClient = new HttpClient(handler);

Similar a la respuesta de tpeczek pero actualizada para reflejar el uso de HTTPS. la respuesta de tpeczek no funciona para HTTPS porque la llamada a base.OnConfigureBinding(httpBinding); con HTTPS sobrescribe los cambios. Además, no puede usar httpBinding.Security.Mode = HttpBindingSecurityMode.TransportCredentialOnly; con HTTPS.

Use una configuración HTTPSELFHOST personalizada:

public class NtlmSelfHostConfiguration : HttpSelfHostConfiguration
{
    public NtlmSelfHostConfiguration(string baseAddress)
        : base(baseAddress)
    { }

    public NtlmSelfHostConfiguration(Uri baseAddress)
        : base(baseAddress)
    { }

    protected override BindingParameterCollection OnConfigureBinding(
        HttpBinding httpBinding)
    {
        if (this.BaseAddress.Scheme == Uri.UriSchemeHttps)
        {
            var ret = base.OnConfigureBinding(httpBinding);
            httpBinding.Security.Transport.ClientCredentialType =
                HttpClientCredentialType.Ntlm;
            return ret;
        }

        httpBinding.Security.Mode = HttpBindingSecurityMode.TransportCredentialOnly;
        httpBinding.Security.Transport.ClientCredentialType = 
            HttpClientCredentialType.Ntlm;
        return base.OnConfigureBinding(httpBinding);
    }
}

Entonces, puedes hacer

var config = new NtlmSelfHostConfiguration("http://myComputerName:8080");

O

var config = new NtlmSelfHostConfiguration("https://myComputerName:8443");

Para obtener una configuración para pasar a new HttpSelfHostServer(config)

Respuesta relacionada para quién lo necesita, sobre autenticación básica con token

Fusionando algo de ayuda, información, respuestas y un sistema de autoauth que hice para una API Web real, finalmente pude usar etiquetas de roles y atributos para esto. Se hace para la etiqueta de autorización en el encabezado.

Invocación del servidor:

 var config = new HttpSelfHostConfiguration("http://localhost:8080");
            config.UserNamePasswordValidator = new PHVValidator();
            config.Routes.MapHttpRoute(
                "API Default", "{controller}/{id}",
                new { id = RouteParameter.Optional });

            using (HttpSelfHostServer server = new HttpSelfHostServer(config))
            {
                server.OpenAsync().Wait();
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new DominusForm());
            }

Auth Method: (hardcoded for ex. solo, elija usuario, pase y roles desde cualquier lugar)

    public class PHVValidator : System.IdentityModel.Selectors.UserNamePasswordValidator
    {
        public override void Validate(string userName, string password)
        {
            if (userName == "admin" && password == "123")
            {
                string[] rolarray = new string[] { "admin" };
               IPrincipal principal = new GenericPrincipal(new GenericIdentity(userName), rolarray);
                Thread.CurrentPrincipal = principal;
            }
        }
    }

Método:

[Authorize(Roles = "admin")]
public HttpResponseMessage Get()
{
     do things
}