/// <summary>
/// Process a transmitted message to import any signing certificates for subsequent S/MIME encryption.
/// </summary>
/// <param name="o">A ProcessMessageArguments object containing message parameters.</param>
private void ProcessMessage(object o)
{
ProcessMessageArguments arguments = (ProcessMessageArguments)o;
// Export the message to a local directory.
if (!string.IsNullOrEmpty(arguments.ExportDirectory))
{
string messageId = Functions.ReturnBetween(arguments.MessageText.ToLower(), "message-id: <", ">");
if (string.IsNullOrEmpty(messageId))
{
messageId = Guid.NewGuid().ToString();
}
string fileName = ProxyFunctions.GetExportFileName(arguments.ExportDirectory, messageId, arguments.InstanceId, arguments.UserName);
File.WriteAllText(fileName, arguments.MessageText);
}
// Only parse the message if it contains a known S/MIME content type.
string canonicalMessageText = arguments.MessageText.ToLower();
if (canonicalMessageText.IndexOf("application/x-pkcs7-signature") > -1 || canonicalMessageText.IndexOf("application/pkcs7-mime") > -1)
{
try
{
// Parse the message.
MailMessage message = new MailMessage(arguments.MessageText);
// If the message contains a signing certificate that we haven't processed on this session, import it.
if (message.SmimeSigningCertificate != null && !SmimeCertificatesReceived.Contains(message.SmimeSigningCertificate))
{
// Import the certificate to the Local Machine store.
ProxyFunctions.Log(LogWriter, SessionId, arguments.ConnectionId, "Importing certificate with Serial Number {" + message.SmimeSigningCertificate.SerialNumber + "}.", Proxy.LogLevel.Information, LogLevel);
CertHelper.InstallWindowsCertificate(message.SmimeSigningCertificate, StoreLocation.LocalMachine);
// Remember this ceriticate to avoid importing it again this session.
SmimeCertificatesReceived.Add(message.SmimeSigningCertificate);
}
}
catch (Exception ex)
{
if (arguments.DebugMode || System.Diagnostics.Debugger.IsAttached)
{
ProxyFunctions.Log(LogWriter, SessionId, "Exception while processing message: " + ex.ToString(), Proxy.LogLevel.Error, LogLevel);
}
else
{
ProxyFunctions.Log(LogWriter, SessionId, "Exception while processing message: " + ex.Message, Proxy.LogLevel.Error, LogLevel);
}
}
}
}
/// <summary>
/// Relay data read from one connection to another.
/// </summary>
/// <param name="o">A TransmitArguments object containing local and remote server parameters.</param>
private async void RelayData(object o)
{
// Cast the passed-in parameters back to their original objects.
TransmitArguments arguments = (TransmitArguments)o;
Stream clientStream = arguments.ClientStream;
Stream remoteServerStream = arguments.RemoteServerStream;
// A byte array to streamline bit shuffling.
char[] buffer = new char[Constants.SMALLBUFFERSIZE];
// Placeholder variables to track the current message being transmitted.
StringBuilder messageBuilder = new StringBuilder(Constants.SMALLSBSIZE);
// The overall number of bytes transmitted on this connection.
ulong bytesTransmitted = 0;
if (arguments.Credential != null)
{
UserName = arguments.Credential.UserName;
}
bool stillReceiving = true;
try
{
using (StreamReader clientStreamReader = new StreamReader(clientStream))
{
using (StreamWriter remoteServerStreamWriter = new StreamWriter(remoteServerStream))
{
remoteServerStreamWriter.AutoFlush = true;
while (Started && stillReceiving)
{
// Read data from the source and send it to its destination.
string stringRead = await clientStreamReader.ReadLineAsync();
if (stringRead != null)
{
int bytesRead = stringRead.Length;
bytesTransmitted += (ulong)bytesRead;
messageBuilder.AppendLine(stringRead);
// If this data comes from the client, log it. Otherwise, process it.
if (arguments.IsClient)
{
bool messageRelayed = false;
string[] commandParts = stringRead.Substring(0, stringRead.Length).Split(new char[] { ' ' }, 2);
// Optionally replace credentials with those from our settings file.
if (commandParts.Length == 2)
{
if (commandParts[0] == "USER")
{
if (arguments.Credential != null)
{
await remoteServerStreamWriter.WriteLineAsync("USER " + arguments.Credential.UserName);
ProxyFunctions.Log(LogWriter, SessionId, arguments.ConnectionId.ToString(), "C: USER " + arguments.Credential.UserName, Proxy.LogLevel.Raw, LogLevel);
messageRelayed = true;
}
else
{
UserName = commandParts[1];
}
}
else if (arguments.Credential != null && commandParts[0] == "PASS")
{
await remoteServerStreamWriter.WriteLineAsync("PASS" + arguments.Credential.Password);
ProxyFunctions.Log(LogWriter, SessionId, arguments.ConnectionId.ToString(), "C: PASS " + arguments.Credential.Password, Proxy.LogLevel.Raw, LogLevel);
messageRelayed = true;
}
}
if (LogLevel == Proxy.LogLevel.Verbose)
{
ProxyFunctions.Log(LogWriter, SessionId, arguments.ConnectionId.ToString(), "Command {" + commandParts[0] + "} processed.", Proxy.LogLevel.Verbose, LogLevel);
}
if (!messageRelayed)
{
await remoteServerStreamWriter.WriteLineAsync(stringRead);
ProxyFunctions.Log(LogWriter, SessionId, arguments.ConnectionId.ToString(), "C: " + stringRead, Proxy.LogLevel.Raw, LogLevel);
}
}
else
{
await remoteServerStreamWriter.WriteLineAsync(stringRead);
ProxyFunctions.Log(LogWriter, SessionId, arguments.ConnectionId.ToString(), "S: " + stringRead, Proxy.LogLevel.Raw, LogLevel);
// If we see a period between two linebreaks, treat it as the end of a message.
if (stringRead == ".")
{
string message = messageBuilder.ToString();
int endPos = message.IndexOf("\r\n.\r\n");
if (message.Contains("\r\n\r\n"))
{
int lastOkPos = message.LastIndexOf("+OK", endPos);
if (lastOkPos > -1)
{
message = message.Substring(message.IndexOf("\r\n", lastOkPos) + 2);
if (message.IndexOf("application/x-pkcs7-signature") > -1 || message.IndexOf("application/pkcs7-mime") > -1 || !string.IsNullOrEmpty(arguments.ExportDirectory))
{
Thread processThread = new Thread(new ParameterizedThreadStart(ProcessMessage));
processThread.Name = "OpaqueMail POP3 Proxy Signature Processor";
ProcessMessageArguments processMessageArguments = new ProcessMessageArguments();
processMessageArguments.MessageText = message.Substring(0, message.Length - 5);
processMessageArguments.ConnectionId = ConnectionId.ToString();
processMessageArguments.ExportDirectory = arguments.ExportDirectory;
processMessageArguments.InstanceId = arguments.InstanceId;
processMessageArguments.DebugMode = arguments.DebugMode;
processMessageArguments.UserName = UserName;
processThread.Start(processMessageArguments);
}
messageBuilder.Remove(0, endPos + 5);
}
}
messageBuilder.Clear();
}
}
}
else
{
stillReceiving = false;
}
}
}
}
}
catch (IOException)
{
// Ignore either stream being closed.
}
catch (ObjectDisposedException)
{
// Ignore either stream being closed.
}
catch (Exception ex)
{
// Log other exceptions.
if (arguments.DebugMode || System.Diagnostics.Debugger.IsAttached)
{
ProxyFunctions.Log(LogWriter, SessionId, arguments.ConnectionId, "Exception while transmitting data: " + ex.ToString(), Proxy.LogLevel.Error, LogLevel);
}
else
{
ProxyFunctions.Log(LogWriter, SessionId, arguments.ConnectionId, "Exception while transmitting data: " + ex.Message, Proxy.LogLevel.Error, LogLevel);
}
}
finally
{
// If sending to the local client, log the connection being closed.
if (!arguments.IsClient)
{
ProxyFunctions.Log(LogWriter, SessionId, arguments.ConnectionId, "Connection from {" + arguments.IPAddress + "} closed after transmitting {" + bytesTransmitted.ToString("N0") + "} bytes.", Proxy.LogLevel.Information, LogLevel);
}
if (clientStream != null)
{
clientStream.Dispose();
}
if (remoteServerStream != null)
{
remoteServerStream.Dispose();
}
}
}