public class SecurityApiController {
	...
	public async Task<Result> UpdateUser([FromBody] SecurityRequest request) {
	    var requestBody = RsaHelper.Decrypt(privateKey, request.Content);
            var user = JsonHelper.Deserialize<UserDto>(requestBody);
	    await UpdateUserAsync(user);
	    return new Result(RsaHelper.Encrypt(publicKey, new{ Success=true}));
	}
}

public class SecurityController {
	...
	public async Task<object> EntryPoint([FromBody] SecurityRequest request) {
	    var requestBody = RsaHelper.Decrypt(privateKey, request.Content);
	    var user = JsonHelper.Deserialize<UserDto>(requestBody);
	    var obj = await DispathRouter(requestBody.Router, user);
            return new Result(RsaHelper.Encrypt(publicKey, obj));
	}
	
	public async Task<object> DispathRouter(Router router, object body) {
	    ...
	    Type objectCon = typeof(BaseController);
            MethodInfo methInfo = objectCon.GetMethod(router.Name);
            var resp = (Task<object>)methInfo.Invoke(null, body);
            return await resp;
	}
}

// 文件 UserController.cs
public partial class BaseController {
	...
}
// 文件 AccountController.cs 
public partial class BaseController {

}
// ...

// .NET Core 版本
public class SecuriryTransportMiddleware {
    private readonly RequestDelegate _next;

    public RequestCultureMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
    	// request handle
        var encryptedBody = context.Request.Body;
        var encryptedContent = new StreamReader(encryptedBody).ReadToEnd();
        var decryptedBody = RsaHelper.Decrypt(privateKey, encryptedContent);
        var originBody = JsonHelper.Deserialize<object>(decryptedBody);
        
        var json = JsonHelper.Serialize(dataSource);
        var requestContent = new StringContent(json, Encoding.UTF8, "application/json");
        stream = await requestContent.ReadAsStreamAsync();
        context.Request.Body = stream;
        
        await _next(context);
        // response handle
        var originContent = new StreamReader(context.Response.Body).ReadToEnd();
        var encryptedBody = RsaHelper.Encrypt(privateKey, originContent);
        var responseContent = new StringContent(json, Encoding.UTF8, "application/json");
        context.Response.Body = await responseContent.ReadAsStreamAsync();
        // 或者直接
        // await context.Response.WriteAsync(encryptedBody);
    }
}

public class SecurityTransportHttpModule : IHttpModule {
	...
	public void Init(HttpApplication context) {
	    ...
	    context.BeginRequest += ContextBeginRequest;
	    context.PostRequestHandlerExecute += ContextPostRequestHandlerExecute;
	}
	
	private void ContextBeginRequest(object sender, EventArgs e) {
	    HttpContext context = ((HttpApplication)sender).Context;
	    var encryptedBody = context.Request.Body;
	    ...
	    context.Request.Body = stream;
	}
	
	private void ContextPostRequestHandlerExecute(object sender, EventArgs e)
        {
            HttpContext context = ((HttpApplication)sender).Context;
            ...
            context.Response.Write(encryptedBody)
        }
}

if(context.Request.Path.Contains("upload")) {
	return;
}

public class SecurityTransportModelBinder : IModelBinder {
    ...
    public async Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
        {
            throw new ArgumentNullException(nameof(bindingContext));
        }

        try
        {
            var request = bindingContext.HttpContext.Request;
            var model = await JsonSerializer.DeserializeAsync<SafeDataWrapper>(request.Body, new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            });
            var decryptContent = RsaHelper.Decrypt(model.Info, privateKey);
            var activateModel = JsonSerializer.Deserialize(decryptContent, bindingContext.ModelMetadata.ModelType, new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            });
            //重新包裝
            if (activateModel == null)
            {
                bindingContext.Result = ModelBindingResult.Failed();
            }
            else
            {
                bindingContext.Result = ModelBindingResult.Success(activateModel);
            }
        }
        catch (Exception exception)
        {
            bindingContext.ModelState.TryAddModelError(
                bindingContext.ModelName,
                exception,
                bindingContext.ModelMetadata);
        }

        _logger.DoneAttemptingToBindModel(bindingContext);
        //return Task.CompletedTask;
    }
}

public class SecurityTransportModelBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        if (context.Metadata.IsComplexType && typeof(IApiEncrypt).IsAssignableFrom(context.Metadata.ModelType))
        {
            var loggerFactory = context.Services.GetRequiredService<ILoggerFactory>();
            var configuration = context.Services.GetRequiredService<IConfiguration>();
            return new SecurityTransportModelBinder(loggerFactory, configuration);
        }

        return null;
    }
}

services.AddControllers(options => {
	...
	options.ModelBinderProviders.Insert(0, new SecurityTransportModelBinderProvider());
})

[HttpPost("security")]
public async Task<ResultDto> DemoDecrypt([ModelBinder(typeof(SecurityTransportModelBinder))] OriginBusinessRequest request)
{
    //激活結(jié)果
	...
    return await Task.FromResult(WriteSafeData(data, publicKey));
}

public class UserUpdateRequest: IApiEncrypt {
	public int UserId { get; set; }
	public string Phone { get; set; }
	public string Address { get; set; }
	...
}