protected ITransmissionResponse HandleResponse(HttpResponse httpResponse)
{
Trace span = this.root.Child();
// tracer.newChild(root.context()).name("response").start();
span.Record(Annotations.ServiceName("response"));
span.Record(Annotations.ClientSend());
try
{
HttpResponse response = httpResponse;
span.Record(Annotations.Tag("code", response.StatusCode.ToString()));
// span.tag("code", String.valueOf(response.getStatusLine().getStatusCode()));
if (response.StatusCode != HttpStatusCode.OK)
{
Logger.ErrorFormat(
"AS2 HTTP POST expected HTTP OK, but got : {0} from {1}",
response.StatusCode,
this.transmissionRequest.GetEndpoint().Address);
// Throws exception
this.HandleFailedRequest(response);
}
// handle normal HTTP OK response
Logger.DebugFormat(
"AS2 transmission to {0} returned HTTP OK, verify MDN response",
this.transmissionRequest.GetEndpoint().Address);
string contentTypeHeader = response.Headers["Content-Type"];
if (string.IsNullOrWhiteSpace(contentTypeHeader))
{
throw new HyperwayTransmissionException(
"No Content-Type header in response, probably a server error.");
}
// Read MIME Message
MimeMessage mimeMessage;
using (var m = new MemoryStream())
{
// Add headers to MIME Message
foreach (var headerName in response.Headers.AllKeys)
{
var headerText = $"{headerName}: {response.Headers[headerName]}";
var headerData = Encoding.ASCII.GetBytes(headerText);
m.Write(headerData, 0, headerData.Length);
m.Write(new byte[] { 13, 10 }, 0, 2);
}
m.Write(new byte[] { 13, 10 }, 0, 2);
var messageData = response.Entity.Content;
m.Write(messageData, 0, messageData.Length);
m.Seek(0, SeekOrigin.Begin);
mimeMessage = MimeMessage.Load(m);
mimeMessage.Headers[HeaderId.ContentType] = response.Headers["Content-Type"];
}
SMimeReader sMimeReader = new SMimeReader(mimeMessage);
// Timestamp of reception of MDN
Timestamp t3 = this.timestampProvider.Generate(sMimeReader.GetSignature(), Direction.OUT);
MultipartSigned signedMessage = mimeMessage.Body as MultipartSigned;
using (this.secureMimeContext())
{
Debug.Assert(signedMessage != null, nameof(signedMessage) + " != null");
var signatures = signedMessage.Verify();
var signature = signatures.First();
var mimeCertificate = signature.SignerCertificate as SecureMimeDigitalCertificate;
// Verify if the certificate used by the receiving Access Point in
// the response message does not match its certificate published by the SMP
Debug.Assert(mimeCertificate != null, nameof(mimeCertificate) + " != null");
X509Certificate certificate = mimeCertificate.Certificate;
if (!this.transmissionRequest.GetEndpoint().Certificate.Equals(certificate))
{
throw new HyperwayTransmissionException(
String.Format(
"Certificate in MDN ('{0}') does not match certificate from SMP ('{1}').",
certificate.SubjectDN, // .getSubjectX500Principal().getName(),
this.transmissionRequest.GetEndpoint().Certificate.SubjectDN)); // .getSubjectX500Principal().getName()));
}
Logger.Debug("MDN signature was verified for : " + certificate.SubjectDN);
}
// Verifies the actual MDN
MdnMimeMessageInspector mdnMimeMessageInspector = new MdnMimeMessageInspector(mimeMessage);
String msg = mdnMimeMessageInspector.GetPlainTextPartAsText();
if (!mdnMimeMessageInspector.IsOkOrWarning(new Mic(this.outboundMic)))
{
Logger.ErrorFormat("AS2 transmission failed with some error message '{0}'.", msg);
throw new HyperwayTransmissionException(String.Format("AS2 transmission failed : {0}", msg));
}
// Read structured content
MimeEntity mimeBodyPart = mdnMimeMessageInspector.GetMessageDispositionNotificationPart();
var internetHeaders = mimeBodyPart.Headers;
// InternetHeaders internetHeaders = new InternetHeaders((InputStream)mimeBodyPart.getContent());
// Fetch timestamp if set
DateTime date = t3.GetDate();
if (internetHeaders.Any(x => x.Field == MdnHeader.Date))
{
var dateText = internetHeaders.First(x => x.Field == MdnHeader.Date).Value;
date = As2DateUtil.Rfc822.Parse(dateText);
}
// Return TransmissionResponse
return(new As2TransmissionResponse(
this.transmissionIdentifier,
this.transmissionRequest,
this.outboundMic,
MimeMessageHelper.ToBytes(mimeMessage),
t3,
date));
}
catch (TimestampException e)
{
throw new HyperwayTransmissionException(e.Message, e);
}
catch (Exception e)
{
throw new HyperwayTransmissionException("Unable to parse received content.", e);
}
finally
{
span.Record(Annotations.ClientRecv());
}
}
/// <summary>
/// Receives an AS2 Message in the form of a map of headers together with the payload,
/// which is made available in an input stream
/// <p>If persisting message to the Message Repository fails, we have to return negative MDN.</p>
/// </summary>
/// <param name="httpHeaders">the http headers received</param>
/// <param name="mimeMessage">supplies the MIME message</param>
/// <returns>MDN object to signal if everything is ok or if some error occurred while receiving</returns>
public MimeMessage Receive(IHeaderDictionary httpHeaders, MimeMessage mimeMessage)
{
Logger.Debug("Receiving message ..");
SMimeReader sMimeReader = new SMimeReader(mimeMessage);
// Get timestamp using signature as input
Timestamp t2 = this.timestampProvider.Generate(sMimeReader.GetSignature(), Direction.IN);
// Initiate MDN
MdnBuilder mdnBuilder = MdnBuilder.NewInstance(mimeMessage);
mdnBuilder.AddHeader(MdnHeader.Date, t2.GetDate());
// Extract Message-ID
TransmissionIdentifier transmissionIdentifier =
TransmissionIdentifier.FromHeader(httpHeaders[As2Header.MessageId]);
mdnBuilder.AddHeader(MdnHeader.OriginalMessageId, httpHeaders[As2Header.MessageId]);
// Extract signed digest and digest algorithm
SMimeDigestMethod digestMethod = sMimeReader.GetDigestMethod();
// Extract content headers
byte[] headerBytes = sMimeReader.GetBodyHeader();
Stream bodyStream = sMimeReader.GetBodyInputStream();
byte[] bodyBytes = bodyStream.ToBuffer();
mdnBuilder.AddHeader(MdnHeader.OriginalContentHeader, headerBytes);
// Extract SBDH
Mx.Peppol.Common.Model.Header header;
bodyStream.Seek(0, SeekOrigin.Begin);
using (var sbdReader = SbdReader.NewInstance(bodyStream))
{
header = sbdReader.Header;
// Perform validation of SBDH
this.transmissionVerifier.Verify(header, Direction.IN);
// Extract "fresh" InputStream
using (Stream payloadInputStream = sMimeReader.GetBodyInputStream())
{
// Persist content
this.persisterHandler.Persist(
transmissionIdentifier,
header,
new UnclosableInputStream(payloadInputStream));
}
// Fetch calculated digest
var s = SHA1.Create();
var hash = s.ComputeHash(headerBytes.Concat(bodyBytes).ToArray());
Digest calculatedDigest = Digest.Of(DigestMethod.Sha1, hash);
mdnBuilder.AddHeader(MdnHeader.ReceivedContentMic, new Mic(calculatedDigest));
var check = this.VerifySignature(mimeMessage.Body as MultipartSigned, out var signatures);
if (!check || signatures.Count != 1)
{
throw new NotSupportedException("Firma non valida");
}
var signature = signatures[0];
var certificate = signature.SignerCertificate as SecureMimeDigitalCertificate;
Debug.Assert(certificate != null, nameof(certificate) + " != null");
this.certificateValidator.Validate(Service.Ap, certificate.Certificate);
// Create receipt (MDN)
mdnBuilder.AddHeader(MdnHeader.Disposition, Disposition.Processed);
MimeMessage mdn = this.sMimeMessageFactory.CreateSignedMimeMessage(mdnBuilder.Build(), digestMethod);
mdn.Headers.Add(As2Header.As2Version, As2Header.Version);
mdn.Headers.Add(As2Header.As2From, httpHeaders[As2Header.As2To]);
mdn.Headers.Add(As2Header.As2To, httpHeaders[As2Header.As2From]);
return(mdn);
}
}