.NET API接口数据传输加密怎么实现

发布时间：2022-11-01 09:20:50 作者：iii
来源：亿速云阅读：97

这篇文章主要介绍了.NET API接口数据传输加密怎么实现的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇.NET API接口数据传输加密怎么实现文章都会有所收获，下面我们一起来看看吧。

硬编码方式

最先想到的应该就是硬编码方式，就是哪个接口需要进行传输加密，那么就针对该接口特殊处理：

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

这种方式好处是简单明了，按需编程即可，不会对其它接口造成污染。

一旦这种需求越来越多，我们就会写大量如上的重复性代码；而对于前端而言也是如此，所以当我们需要传输加密乃是最基础的需求时，上面硬编码的方式就显得很不合适了。

这个时候我们可以采用统一入口的方式来实现

统一入口

回顾上面的硬编码方式，其实每个接口处的加解密处理从 SRP 原则上理解，不应该是接口的职责。所以需要把这部分的代码移到一个单独的方法，再加解密之后我们再把该请求调度到具体的接口。

这种方式其实有很多种实现方式，在这里我先说一下我司其中一个 .NET4.5 的项目采取的方式。

其实就是额外提供了一个统一的入口，所有需要传输加密的需求都走这一个接口：如http://api.example.com/security

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

很明显这是通过统一入口地址调用并配合反射来实现这种目的。

这种好处如前面所说，统一了调用入口，这样提高了代码复用率，让加解密不再是业务接口的一部分了。同样，这种利用一些不好的点；比如用了反射性能会大打折扣。并且我们过度的进行统一了。我们看到这种方式只能将所有的接口方法都写到 BaseController。所以我司项目的 Controller 部分，会看到大量如下的写法：

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

}
// ...

这样势必就会导致一个明显的问题，就是“代码爆炸”。这相当于将所有的业务逻辑全部灌输到一个控制器中，刚开始写的时候方便了，但是后期维护以及交接换人的时候阅读代码是非常痛苦的一个过程。因为在不同的 Controller 文件中势必会重复初始化一些模块，而我们在引用方法的时候 IDE 每次都会显示上千个方法，有时候还不得不查看哪些方法名一样或相近的具体意义。

针对上述代码爆炸的方式还有一种优化，就是将控制器的选择开放给应用端，也就是将方法名和控制器名都作为请求参数暴露给前端，但是这样会加大前端的开发心智负担。

综上所述我是非常不建议采用这种方式的。虽说是很古老的.Net4/4.5 的框架，但是我们还是有其它相对更优雅的实现方式。

中间件

其实我们熟悉了 .NETCore 下的 Middleware机制，我们会很容易的在 .NETCore 下实现如标题的这种需求：

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

为了方便描述，以上代码我省略了必要的校验和异常错误处理

这样有什么好处呢？一个最明显的好处就是解耦了加解密与真正业务需求。对真正的业务代码几乎没有侵略性。其实我认为业务开发能做到这里其实就差不多了，还有其它需求都可以基于这个中间件进行拓展开发。

那么在 .NET Framwork 没有中间件怎么办呢？

其实在 .NET Framwork 框架下 IHttpModule 能和中间件一样能做到这点：

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

为什么之前提到这种方案就“差不多”了呢，实际上上面这种方式在某些场景下会显得比较“累赘”。因为无论通过中间件和还是 IHttpModule 都会导致所有请求都会经过它，相当于增加了一个过滤器，如果这时候我要新增一个上传文件接口，那必然也会经过这个处理程序。说的更直接一点，如果碰到那些少数不需要加解密的接口请求那要怎么办呢？

其实上面可以进行拓展处理，比如对特定的请求进行过滤：

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

注意上述代码只是做个 demo 展示，真正还是需要通过如 context.GetRouterData() 获取路由数据进行精准比对。

当类似于这种需求开始变多以后（吐槽：谁知道业务是怎么发展的呢？）原来的中间件的“任务量”开始变得厚重了起来。到时候也会变得难以维护和阅读。

这个时候就是我目前较为满意的解决方案登场了，它就是模型绑定 ModelBinding。

模型绑定

回到需求的开端，不难发现，我们其实要是如何将前端加密后的请求体绑定到我们编写的接口方法中。这里面的过程很复杂，需要解析前端发起的请求，解密之后还要反序列化成目标接口需要的方法参数。而这个过程还要伴随着参数校验，如这个请求是否符合加密格式。而这个过程的一切都是模型绑定要解决的事。我们以 NETCore 版本为例子，讲一下大概的流程；

模型绑定的过程其实就是将请求体的各个字段于具体的 CLR 类型的字段属性进行一一匹配的过程。.NetCore 再程序启动时会默认提供了一些内置的模型绑定器，并开放 IModelBinderProvider 接口允许用户自定义模型绑定器。我们通过查看 MvcCoreMvcOptionsSetup 就清楚看到框架为我们添加 18 个自带的模型绑定器。以及如何调用的方式。

所以接下来我们很容易的可以一葫芦画瓢的照抄下来：

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&lt;SafeDataWrapper&gt;(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;
    }
}

抄了 ModelBinder 还不行，还要抄 ModelBinderProvider：

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

这里我做了一个方便我自己的拓展功能，就是显示打了 IApiEncrypt 接口标签的才会正常进行解析绑定。

剩下的就是在 ConfigureService 中添加进去即可：

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

这样实现过后，我们就能像使用 FromBody 那样就能按需调用即可：

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

如果是默认处理加解密也是可以的，直接在对应的请求实体类打上 IApiEncrypt 标签就会自动执行模型绑定

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

这种方案其实也还是有缺点的，从刚刚的使用来看就知道，模型绑定无法解决返回自动加密处理。所以我们不得不在每个接口处写下如 WriteSafeData(data, publicKey) 这种显式加密的代码。

优化的方式也很简单，其实我们可以通过过滤器可以解决，这也是为什么我要加 IApiEncrypt 的原因，因为有了这个就能确定知道这是一个安全传输的请求，进而进行特殊处理。

注意，这不是 .NET Core 独有的特性，.Net Framework 也有模型绑定器

关于“.NET API接口数据传输加密怎么实现”这篇文章的内容就介绍到这里，感谢各位的阅读！相信大家对“.NET API接口数据传输加密怎么实现”知识都有一定的了解，大家如果还想学习更多知识，欢迎关注亿速云行业资讯频道。

.NET API接口数据传输加密怎么实现

硬编码方式

统一入口

中间件

模型绑定

相关阅读