Eneter加密单个服务器和多个客户端之间的通信，每个客户端使用不同的密钥

Question

Eneter可以在DuplexTypedMessagesFactory中设置自定义序列化程序，用于加密客户端和服务器之间的通信。

DuplexTypedMessagesFactory sender_factory = new DuplexTypedMessagesFactory();
sender_factory.setSerializer(new EncryptingSerializer(client_private_key, server_public_key));
sender_ = sender_factory.createDuplexTypedMessageSender(MyResponse.class, MyRequest.class);

在我的应用程序中，我有一台服务器和多个客户端，但显然每个通道都应该使用自己的密钥（或相关的RSA密钥对）单独加密。不幸的是，序列化程序接口没有公开消息来源通道的任何标识符：

public class EncryptingSerializer implements ISerializer {
    private RsaSerializer rsa_serializer_;
    public EncryptingSerializer(RSAPrivateKey priv, RSAPublicKey pub) {
        rsa_serializer_ = new RsaSerializer(pub, priv);
    }
    @Override
    public <T> Object serialize(T t, Class<T> aClass) throws Exception {
        return rsa_serializer_.serialize(t, aClass);
    }
    @Override
    public <T> T deserialize(Object o, Class<T> aClass) throws Exception {
        return rsa_serializer_.deserialize(o, aClass);
    }
}

所以上面的代码对客户端来说是可以的（似乎我甚至可以延迟rsa_serializer_的初始化，直到建立连接之后，所以例如，在身份验证/配对过程中提取服务器公钥）。然而，对于服务器端，相同的序列化程序对象需要服务于多个通信通道，但每个通道都需要不同的rsa_serializer_对象。

有没有办法解决这个问题，或者我只需要将加密提升到更高的级别（发送和接收简单的BlobRequest/BlobResponse对象，其内容在传递到框架之前会被加密，从框架获得后会解密）？

Answer 1

我最终在DuplexStringMessageReceiver之上重新实现了DuplexTypedMessageReceiver，并根据外部需求获取和存储适当的序列化程序：

class EncryptingTypedMessageReceiver<TResponse, TRequest> : IDuplexTypedMessageReceiver<TResponse, TRequest> {
  public event EventHandler<TypedRequestReceivedEventArgs<TRequest>> MessageReceived;
  public event EventHandler<ResponseReceiverEventArgs> ResponseReceiverConnected;
  public event EventHandler<ResponseReceiverEventArgs> ResponseReceiverDisconnected;
  private IDuplexStringMessageReceiver string_receiver_;
  private Func<string, ISerializer> serializer_factory_;
  private Dictionary<string, ISerializer> serializers_by_receiver_id_ = new Dictionary<string, ISerializer>();
  public EncryptingTypedMessageReceiver(IDuplexStringMessageReceiver receiver, Func<string, ISerializer> serializer_factory) {
    serializer_factory_ = serializer_factory;
    string_receiver_ = receiver;
    string_receiver_.RequestReceived += OnRequestReceived;
    string_receiver_.ResponseReceiverConnected += OnResponseReceiverConnected;
    string_receiver_.ResponseReceiverDisconnected += OnResponseReceiverDisconnected;
  }
  private void OnRequestReceived(object sender, StringRequestReceivedEventArgs e) {
    TRequest typedRequest = serializers_by_receiver_id_[e.ResponseReceiverId].Deserialize<TRequest>(e.RequestMessage);
    var typedE = new TypedRequestReceivedEventArgs<TRequest>(e.ResponseReceiverId, e.SenderAddress, typedRequest);
    if (MessageReceived != null) {
      MessageReceived(sender, typedE);
    }
  }
  public void SendResponseMessage(string responseReceiverId, TResponse responseMessage) {
    string stringMessage = (string)serializers_by_receiver_id_[responseReceiverId].Serialize(responseMessage);
    string_receiver_.SendResponseMessage(responseReceiverId, stringMessage);
  }
  private void OnResponseReceiverConnected(object sender, ResponseReceiverEventArgs e) {
    if (ResponseReceiverConnected != null)
      ResponseReceiverConnected(sender, e);
    serializers_by_receiver_id_.Add(e.ResponseReceiverId, serializer_factory_(e.ResponseReceiverId));
  }
  private void OnResponseReceiverDisconnected(object sender, ResponseReceiverEventArgs e) {
    if (ResponseReceiverDisconnected != null)
      ResponseReceiverDisconnected(sender, e);
    serializers_by_receiver_id_.Remove(e.ResponseReceiverId);
  }
  public IDuplexInputChannel AttachedDuplexInputChannel {
    get {
      return string_receiver_.AttachedDuplexInputChannel;
    }
  }
  public bool IsDuplexInputChannelAttached {
    get {
      return string_receiver_.IsDuplexInputChannelAttached;
    }
  }
  public void AttachDuplexInputChannel(IDuplexInputChannel duplexInputChannel) {
    string_receiver_.AttachDuplexInputChannel(duplexInputChannel);
  }
  public void DetachDuplexInputChannel() {
    string_receiver_.DetachDuplexInputChannel();
  }
}