以WCF安全认证方式调用通用权限管理系统获取基础信息资料

using System.ServiceModel;
using System.Collections.Generic;
using System.Runtime.Serialization;
 
namespace PermissionSystem.ServiceContracts
{
    /// <summary>
    /// 用户信息服务契约
    /// </summary>
    [ServiceContract(Name = "IUserService", Namespace = "http://permission-system.com/services/2024")]
    public interface IUserService
    {
        /// <summary>
        /// 根据用户ID获取用户信息
        /// </summary>
        [OperationContract]
        UserInfo GetUserById(string userId);
 
        /// <summary>
        /// 获取所有用户列表
        /// </summary>
        [OperationContract]
        List<UserInfo> GetAllUsers();
 
        /// <summary>
        /// 验证用户凭证（用于安全认证）
        /// </summary>
        [OperationContract]
        bool ValidateUser(string username, string password);
    }
}

[DataContract(Name = "UserInfo", Namespace = "http://permission-system.com/models/2024")]
public class UserInfo
{
    [DataMember]
    public string UserId { get; set; }
 
    [DataMember]
    public string UserName { get; set; }
 
    [DataMember]
    public string RealName { get; set; }
 
    [DataMember]
    public string Email { get; set; }
 
    [DataMember]
    public List<string> Roles { get; set; } // 用户所属角色ID列表
}

<system.serviceModel>
  <services>
    <service name="PermissionSystem.Services.UserService" 
             behaviorConfiguration="SecureBehavior">
      <endpoint address="" 
                binding="wsHttpBinding" 
                bindingConfiguration="SecureBinding"
                contract="PermissionSystem.ServiceContracts.IUserService" />
      <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
    </service>
  </services>
  <bindings>
    <wsHttpBinding>
      <binding name="SecureBinding">
        <security mode="Message"> <!-- 消息安全模式 -->
          <message clientCredentialType="UserName" /> <!-- 客户端凭证类型：用户名/密码 -->
        </security>
      </binding>
    </wsHttpBinding>
  </bindings>
  <behaviors>
    <serviceBehaviors>
      <behavior name="SecureBehavior">
        <serviceMetadata httpGetEnabled="true" />
        <serviceDebug includeExceptionDetailInFaults="false" />
        <serviceCredentials>
          <!-- 用户名/密码验证器（自定义逻辑） -->
          <userNameAuthentication 
              userNamePasswordValidationMode="Custom"
              customUserNamePasswordValidatorType="PermissionSystem.Security.CustomUserValidator, PermissionSystem" />
          <!-- 服务端证书（可选，用于消息加密） -->
          <serviceCertificate 
              findValue="PermissionServiceCert" 
              storeLocation="LocalMachine" 
              storeName="My" 
              x509FindType="FindBySubjectName" />
        </serviceCredentials>
      </behavior>
    </serviceBehaviors>
  </behaviors>
</system.serviceModel>

using System.IdentityModel.Selectors;
using System.IdentityModel.Tokens;
using PermissionSystem.Repositories; // 假设包含用户仓储
 
namespace PermissionSystem.Security
{
    public class CustomUserValidator : UserNamePasswordValidator
    {
        public override void Validate(string userName, string password)
        {
            // 从数据库/缓存验证用户凭证
            var userRepo = new UserRepository();
            bool isValid = userRepo.ValidateUser(userName, password);
            if (!isValid)
            {
                throw new SecurityTokenException("Invalid username or password.");
            }
        }
    }
}

namespace PermissionSystem.Services
{
    public class UserService : IUserService
    {
        private readonly UserRepository _userRepo = new UserRepository();
 
        public UserInfo GetUserById(string userId)
        {
            // 业务逻辑：从数据库获取用户信息
            return _userRepo.GetUserById(userId);
        }
 
        public List<UserInfo> GetAllUsers()
        {
            return _userRepo.GetAllUsers();
        }
 
        public bool ValidateUser(string username, string password)
        {
            // 通常由UserNamePasswordValidator调用，此处可复用逻辑
            return _userRepo.ValidateUser(username, password);
        }
    }
}

<system.serviceModel>
  <client>
    <endpoint name="UserServiceEndpoint"
              address="http://localhost:8080/PermissionService/UserService"
              binding="wsHttpBinding"
              bindingConfiguration="ClientSecureBinding"
              contract="PermissionSystem.ServiceContracts.IUserService" />
  </client>
  <bindings>
    <wsHttpBinding>
      <binding name="ClientSecureBinding">
        <security mode="Message">
          <message clientCredentialType="UserName" />
        </security>
      </binding>
    </wsHttpBinding>
  </bindings>
</system.serviceModel>

using System;
using System.ServiceModel;
using PermissionSystem.ServiceContracts; // 服务契约命名空间
 
namespace BusinessSystem.Client
{
    class Program
    {
        static void Main(string[] args)
        {
            // 方式1：使用ChannelFactory
            var binding = new WSHttpBinding();
            binding.Security.Mode = SecurityMode.Message;
            binding.Security.Message.ClientCredentialType = MessageCredentialType.UserName;
 
            var endpoint = new EndpointAddress("http://localhost:8080/PermissionService/UserService");
 
            using (var factory = new ChannelFactory<IUserService>(binding, endpoint))
            {
                // 设置客户端凭证（用户名/密码）
                factory.Credentials.UserName.UserName = "admin";
                factory.Credentials.UserName.Password = "Admin@123";
 
                // 创建代理
                var client = factory.CreateChannel();
 
                try
                {
                    // 调用服务方法：获取用户信息
                    var user = client.GetUserById("user001");
                    Console.WriteLine($"用户：{user.RealName}（{user.UserName}），角色：{string.Join(",", user.Roles)}");
 
                    // 调用验证方法（可选，通常服务端认证后自动通过）
                    bool isValid = client.ValidateUser("admin", "Admin@123");
                    Console.WriteLine($"验证结果：{isValid}");
                }
                catch (FaultException ex)
                {
                    Console.WriteLine($"服务异常：{ex.Message}");
                }
                catch (CommunicationException ex)
                {
                    Console.WriteLine($"通信异常：{ex.Message}");
                }
                finally
                {
                    ((IClientChannel)client).Close();
                }
            }
        }
    }
}