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

使用，可以在

DuplexTypedMessageFactory

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

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

公共类EncryptingSerializer实现ISerializer{
专用rsa序列化程序rsa\u序列化程序；
公共加密序列化程序（RSAPrivateKey priv，RSAPrivateKey pub）{
rsa_serializer=新的RsaSerializer（pub，priv）；
}
@凌驾
公共对象序列化（T，类aClass）引发异常{
返回rsa_serializer_u.serialize（t，aClass）；
}
@凌驾
公共T反序列化（对象o，类aClass）引发异常{
返回rsa_序列化程序u.deserialize（o，aClass）；
}
}

因此，上面的代码对于客户端来说是可以的（似乎我甚至可以延迟

rsa\u serializer\uu

的初始化，直到建立连接之后，例如，在身份验证/配对过程中获取服务器公钥）。但是，对于服务器端，相同的序列化程序对象需要服务于多个通信通道，但每个通道都需要不同的

rsa\u序列化程序

对象

---

有没有办法解决这个问题，或者我只需要将加密推到更高的级别（发送和接收简单的

BlobRequest

/

blobreresponse

对象，这些对象的内容将在传递到框架之前进行加密，在从框架中获取之后进行解密）？

我最终在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();
  }
}

class EncryptingTypedMessageReceiver:IDuplextTypedMessageReceiver{
已接收公共事件事件处理程序消息；
公共事件事件处理程序ResponseReceiveConnected；
公共事件处理程序ResponseReceiveDisconnected；
专用IDuplexStringMessageReceiver字符串\u receiver\u；
专用Func序列化程序\u工厂\u；
私有字典序列化程序\u by_receiver\u id\uu=new Dictionary（）；
公共加密TypedMessageReceiver（IDuplexStringMessageReceiver，Func序列化程序\工厂）{
序列化程序工厂=序列化程序工厂；
字符串\接收器\接收器；
字符串_receiver_u.RequestReceived+=OnRequestReceived；
字符串_receiver_u.ResponseReceiverConnected+=OnResponseReceiverConnected；
字符串_receiver_.responseReceiveDisconnected+=onResponseReceiveDisconnected；
}
收到请求时的私有void（对象发送方，StringRequestReceivedEventArgs e）{
TRequest typedRequest=序列化程序\u由\u接收方\u id\uu[e.ResponseReceiverId]。反序列化（e.RequestMessage）；
var typedE=new TypedRequestReceivedEventArgs（e.ResponseReceiverId，e.SenderAddress，typedRequest）；
if（MessageReceived！=null）{
MessageReceived（发送方，typedE）；
}
}
public void SendResponseMessage（字符串responseReceiverId、响应响应消息）{
string stringMessage=（字符串）序列化程序\u by_receiver\u id.[responseReceiverId]。序列化（responseMessage）；
字符串\接收器\发送响应消息（responseReceiverId，stringMessage）；
}
ResponseReceiveConnected上的私有void（对象发送方、ResponseReceiveEventArgs e）{
if（ResponseReceiverConnected！=null）
ResponseReceiverConnected（发送方，e）；
serializer_by_receiver_id_.Add（e.ResponseReceiverId，serializer_factory_（e.ResponseReceiverId））；
}
ResponseReceiveDisconnected上的私有void（对象发送方，ResponseReceiveEventArgs e）{
if（ResponseReceiverDisconnected！=null）
ResponseReceiveDisconnected（发送方，e）；
序列化器由接收方id删除（如ResponseReceiverId）；
}
公共IDuplexInputChannel已附加UpleXinPutChannel{
得到{
返回字符串\u receiver\u.attachedUplexinPutChannel；
}
}
公共布尔值是双精度的{
得到{
返回字符串\接收器\已连接；
}
}
public void AttachDuplexInputChannel（IDDupleXinPutChannel duplexInputChannel）{
字符串\接收器\附加双工输入通道（双工输入通道）；
}
public void DetachDuplexInputChannel（）{
字符串_ureceiver_uu.DetachDuplexInputChannel（）；
}
}

我最终在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();
  }
}

class EncryptingTypedMessageReceiver:IDuplextTypedMessageReceiver{
已接收公共事件事件处理程序消息；
公共事件事件处理程序ResponseReceiveConnected；
公共事件处理程序ResponseReceiveDisconnected；
专用IDuplexStringMessageReceiver字符串\u receiver\u；
专用Func序列化程序\u工厂\u；
私有字典序列化程序\u by_receiver\u id\uu=new Dictionary（）；
公共加密TypedMessageReceiver（IDuplexStringMessageReceiver，Func序列化程序\工厂）{
序列化程序工厂=序列化程序工厂；
字符串\接收器\接收器；
字符串_receiver_u.RequestReceived+=OnRequestReceived；
字符串_receiver_u.ResponseReceiverConnected+=OnResponseReceiverConnected；
字符串_receiver_.responseReceiveDisconnected+=onResponseReceiveDisconnected；
}
收到请求时的私有void（对象发送方，StringRequestReceivedEventArgs e）{
TRequest typedRequest=序列化程序\u由\u接收方\u id\uu[e.ResponseReceiverId]。反序列化（e.RequestMessage）；
var typedE=new TypedRequestReceivedEventArgs（e.ResponseReceiverId，e.SenderAddress，typedRequest）；
if（MessageReceived！=null）{
MessageReceived（发送方，typedE）；
}
}
public void SendResponseMessage（字符串responseReceiverId、响应响应消息）{
string stringMessage=（string）序列化程序\u由\u接收方\u id\u[responseReceiverId].Se