基于Windows认证的桌面应用远程API用户身份识别方案咨询

针对你的场景，以下几种方案可以实现Windows认证的桌面客户端调用AWS ECS中API时的用户识别与组声明验证：

方案一：Kerberos/Negotiate 集成身份验证 #

利用Windows域的Kerberos协议，让客户端直接传递当前登录用户的身份到API，无需额外令牌，适合内部域环境。

客户端实现（C#） #

通过HttpClientHandler启用默认Windows凭据，自动传递身份：

var handler = new HttpClientHandler
{
    UseDefaultCredentials = true
};
using var client = new HttpClient(handler);
var response = await client.GetAsync("https://your-api-endpoint");

API实现（Linux Docker + ASP.NET Core） #

1. 在Linux容器中配置Kerberos：
   • 安装krb5-user包，编辑/etc/krb5.conf绑定到你的AD域，配置KDC和realm信息。
   • 加入AD域（使用kinit和net ads join命令，容器需有域权限）。
2. 在API中启用Negotiate认证：

// Program.cs
builder.Services.AddAuthentication(NegotiateDefaults.AuthenticationScheme)
    .AddNegotiate();

builder.Services.AddAuthorization(options =>
{
    options.FallbackPolicy = options.DefaultPolicy;
});

app.UseAuthentication();
app.UseAuthorization();

3. 验证组声明：
   在API接口中通过User.Claims获取用户所属组，或配置授权策略：

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AllowedApiUsers", policy =>
        policy.RequireClaim("groups", "Your-Permitted-Group-Name"));
});

// 接口上应用策略
[Authorize(Policy = "AllowedApiUsers")]
public IActionResult ProtectedEndpoint()
{
    // 获取当前用户组
    var userGroups = User.Claims.Where(c => c.Type == "groups").Select(c => c.Value);
    return Ok($"Authenticated user: {User.Identity.Name}, Groups: {string.Join(", ", userGroups)}");
}

方案二：AD FS ROPC 令牌流 #

使用AD FS的资源所有者密码凭证（ROPC）流，让客户端直接获取包含用户和组声明的JWT令牌，适合信任的内部桌面应用（注意：ROPC不适合公开应用，需确保客户端安全）。

客户端实现（C#） #

收集当前用户凭据，向AD FS令牌端点请求JWT：

public class TokenResponse
{
    public string AccessToken { get; set; }
    public string TokenType { get; set; }
}

// 获取令牌并调用API
var client = new HttpClient();
var tokenRequest = new HttpRequestMessage(HttpMethod.Post, "https://your-adfs-domain/adfs/oauth2/token");
var formData = new Dictionary<string, string>
{
    ["grant_type"] = "password",
    ["client_id"] = "your-registered-api-client-id",
    ["username"] = $"{Environment.UserDomainName}\\{Environment.UserName}",
    ["password"] = GetUserPasswordSecurely(), // 通过SecureString安全获取密码
    ["scope"] = "openid profile groups your-api-audience"
};
tokenRequest.Content = new FormUrlEncodedContent(formData);

var tokenResponse = await client.SendAsync(tokenRequest);
var token = await tokenResponse.Content.ReadFromJsonAsync<TokenResponse>();

// 携带令牌调用API
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken);
var apiResponse = await client.GetAsync("https://your-api-endpoint");

API实现 #

配置JWT认证，验证令牌并解析组声明：

// Program.cs
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Authority = "https://your-adfs-domain/adfs";
        options.Audience = "your-api-audience";
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true
        };
    });

// 配置组授权策略
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("RequireSpecificGroup", policy =>
        policy.RequireClaim("groups", "Your-Allowed-Group-Guid-Or-Name"));
});

方案三：证书认证（用户/设备证书） #

利用Windows证书存储中的用户/设备证书，客户端通过证书向API证明身份，API将证书映射到AD用户并获取组信息，适合高安全要求的场景。

客户端实现（C#） #

从当前用户证书存储中获取绑定的证书，附加到请求：

var handler = new HttpClientHandler();
using var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly);
// 根据用户名查找证书（需提前在AD中为用户颁发证书）
var certs = store.Certificates.Find(X509FindType.FindBySubjectName, Environment.UserName, validOnly: true);
if (certs.Count > 0)
{
    handler.ClientCertificates.Add(certs[0]);
}
store.Close();

using var client = new HttpClient(handler);
var response = await client.GetAsync("https://your-api-endpoint");

API实现 #

配置证书认证，映射证书到AD用户并获取组声明：

// Program.cs
builder.Services.AddAuthentication(CertificateAuthenticationDefaults.AuthenticationScheme)
    .AddCertificate(options =>
    {
        options.AllowedCertificateTypes = CertificateTypes.All;
        options.Events = new CertificateAuthenticationEvents
        {
            OnCertificateValidated = context =>
            {
                // 从证书主体提取用户名（示例：CN=username）
                var subjectParts = context.ClientCertificate.Subject.Split(',');
                var userName = subjectParts.First(p => p.StartsWith("CN=")).Split('=')[1];
                
                // 调用AD服务查询用户所属组（需API有AD查询权限）
                var userGroups = QueryUserGroupsFromAD(userName);
                
                // 添加组声明到用户身份
                foreach (var group in userGroups)
                {
                    context.Principal.Identities.First().AddClaim(new Claim("groups", group));
                }
                
                context.Success();
                return Task.CompletedTask;
            }
        };
    });

// 授权策略同前
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AllowedGroup", policy =>
        policy.RequireClaim("groups", "Your-Permitted-Group"));
});

内容的提问来源于stack exchange，提问作者Luc Millette