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

Question

使用Eneter可以在DuplexTypedMessagesFactory中设置自定义串行器，它可以用于加密客户端和服务器之间的通信。在我的应用程序中，我有单个服务器和多个客户端，但很显然，每个通道应该使用自己的密钥（或相关的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_初始化，直到连接被建立后，使例如服务器公钥在认证/配对过程中被提取）。然而，对于服务器端来说，相同的串行器对象需要为多个通信通道服务，但每个对象都需要一个不同的对象。

有没有办法解决这个问题，还是我只需要将加密推送到更高级别（发送和接收简单的对象，其内容在传递到框架之前会被加密，从框架中获取后会被解密）？

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