/// <summary>
/// Processes the encrypted message.
/// </summary>
/// <param name="transactID">Secure transaction identifier.</param>
/// <param name="sinkStack">The sink stack.</param>
/// <param name="requestMsg">Request message.</param>
/// <param name="requestHeaders">Request transport headers.</param>
/// <param name="requestStream">Request stream.</param>
/// <param name="responseMsg">Response message.</param>
/// <param name="responseHeaders">Response transport headers.</param>
/// <param name="responseStream">Response stream.</param>
public ServerProcessing ProcessEncryptedMessage(Guid transactID, IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
// Get the client connection data
ClientConnectionData connectionData;
lock (_connections.SyncRoot)
{
connectionData = (ClientConnectionData)_connections[transactID.ToString()];
}
if (connectionData == null)
{
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_ClientConnectionInfoMissing);
}
// Update the timestamp and indicate that method call is in progress
connectionData.UpdateTimestamp();
connectionData.BeginMethodCall();
try
{
// Decrypt the data stream
Stream decryptedStream = CryptoTools.GetDecryptedStream(requestStream, connectionData.CryptoProvider);
requestStream.Close();
// Pass decrypted message for further processing to the next channel sink
ServerProcessing processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, decryptedStream, out responseMsg, out responseHeaders, out responseStream);
// Update secure transaction state
responseHeaders[CommonHeaderNames.SECURE_TRANSACTION_STATE] = ((int)SecureTransactionStage.SendingEncryptedResult).ToString();
// Encrypt the response stream and close the original response stream now that we're done with it
Stream encryptedStream = CryptoTools.GetEncryptedStream(responseStream, connectionData.CryptoProvider);
responseStream.Close(); //
// Use encrypted data stream as a response stream
responseStream = encryptedStream;
return(processingResult);
}
finally
{
// Method call is finished, so the connection data can be swept
connectionData.EndMethodCall();
connectionData.UpdateTimestamp();
}
}
/// <summary>
/// Decrypts the incoming response stream.
/// </summary>
/// <param name="responseStream">The response stream.</param>
/// <param name="responseHeaders">The response headers.</param>
private Stream DecryptResponse(Stream responseStream, ITransportHeaders responseHeaders)
{
try
{
if (responseHeaders != null && (SecureTransactionStage)Convert.ToInt32((string)responseHeaders[CommonHeaderNames.SECURE_TRANSACTION_STATE]) == SecureTransactionStage.SendingEncryptedResult)
{
// Decrypt the response stream and close it as we won't be using it anymore
Stream decryptedStream = CryptoTools.GetDecryptedStream(responseStream, _provider);
responseStream.Close();
return(decryptedStream);
}
}
catch { }
// Failed to decrypt server's response
return(null);
}
/// <summary>
/// Entschlüsselt die eingehende Nachricht vom Client.
/// </summary>
/// <param name="transactID">Sicherheitstransaktionskennung</param>
/// <param name="sinkStack">Senkenstapel</param>
/// <param name="requestMsg">Anfrage-Nachricht vom Client</param>
/// <param name="requestHeaders">Anfrage-Header vom Cient</param>
/// <param name="requestStream">Anfrage-Datenstrom</param>
/// <param name="responseMsg">Antwort-Nachricht</param>
/// <param name="responseHeaders">Antwort-Header</param>
/// <param name="responseStream">Antwort-Datenstrom</param>
/// <returns>Verarbeitungsstatus</returns>
public ServerProcessing ProcessEncryptedMessage(Guid transactID, IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
// Variable für Client-Verbindungsinformationen
ClientConnectionData connectionData;
lock (_connections.SyncRoot)
{
// Client-Verbindungsdaten über die angegebene Sicherheitstransaktionskennung abrufen
connectionData = (ClientConnectionData)_connections[transactID.ToString()];
}
// Wenn keine Verbindungsdaten zu dieser Sicherheitstransaktionskennung gefunden wurden ...
if (connectionData == null)
{
// Ausnahme werfen
throw new CryptoRemotingException(LanguageResource.CryptoRemotingException_ClientConnectionInfoMissing);
}
// Zeitstempel aktualisieren
connectionData.UpdateTimestamp();
// Datenstrom entschlüsseln
Stream decryptedStream = CryptoTools.GetDecryptedStream(requestStream, connectionData.CryptoProvider);
// Verschlüsselten-Quelldatenstrom schließen
requestStream.Close();
// Entschlüsselte Nachricht zur Weiterverarbeitung an die nächste Kanalsenke weitergeben
ServerProcessing processingResult = _next.ProcessMessage(sinkStack, requestMsg, requestHeaders, decryptedStream, out responseMsg, out responseHeaders, out responseStream);
// Status der Sicherheitstransaktion auf "verschlüsselte Atwortnachricht senden" einstellen
responseHeaders[CommonHeaderNames.SECURE_TRANSACTION_STATE] = ((int)SecureTransactionStage.SendingEncryptedResult).ToString();
// Antwortnachricht verschlüsseln
Stream encryptedStream = CryptoTools.GetEncryptedStream(responseStream, connectionData.CryptoProvider);
// Unverschlüsselten Quell-Datenstrom schließen
responseStream.Close(); // close the plaintext stream now that we're done with it
// Verschlüsselten Datenstrom als Antwort-Datenstrom verwenden
responseStream = encryptedStream;
// Verarbeitungsstatus zurückgeben
return(processingResult);
}
/// <summary>Entschlüsselt den eingehenden Antwort-Datenstrom</summary>
/// <param name="responseStream">Antwort-Datenstrom</param>
/// <param name="responseHeaders">Antwort-Transportheader</param>
/// <returns>Entschlüsselter Datenstrom (oder null, wenn die Verschlüsselung fehlgeschlagen ist)</returns>
private Stream DecryptResponse(Stream responseStream, ITransportHeaders responseHeaders)
{
try
{
// Wenn laut Header verschlüsselte Daten vom Server zurückgesendet wurden ...
if (responseHeaders != null && (SecureTransactionStage)Convert.ToInt32((string)responseHeaders[CommonHeaderNames.SECURE_TRANSACTION_STATE]) == SecureTransactionStage.SendingEncryptedResult)
{
// Antwort-Datenstrom entschlüsseln
Stream decryptedStream = CryptoTools.GetDecryptedStream(responseStream, _provider);
responseStream.Close(); // close the old stream as we won't be using it anymore
// Entschlüsselten Datenstrom zurückgeben
return(decryptedStream);
}
}
catch {}
// Nichts zurückgeben
return(null);
}