internal void ParameterizedReceiveProtectedTest(DateTime?utcCreatedDate, bool invalidSignature)
{
TestMessage expectedMessage = GetStandardTestMessage(FieldFill.CompleteBeforeBindings);
var fields = GetStandardTestFields(FieldFill.CompleteBeforeBindings);
fields.Add("Signature", invalidSignature ? "badsig" : MockSigningBindingElement.MessageSignature);
fields.Add("Nonce", "someNonce");
if (utcCreatedDate.HasValue)
{
utcCreatedDate = DateTime.Parse(utcCreatedDate.Value.ToUniversalTime().ToString()); // round off the milliseconds so comparisons work later
fields.Add("created_on", XmlConvert.ToString(utcCreatedDate.Value, XmlDateTimeSerializationMode.Utc));
}
IProtocolMessage requestMessage = this.Channel.ReadFromRequest(CreateHttpRequestInfo("GET", fields));
Assert.IsNotNull(requestMessage);
Assert.IsInstanceOf <TestSignedDirectedMessage>(requestMessage);
TestSignedDirectedMessage actualMessage = (TestSignedDirectedMessage)requestMessage;
Assert.AreEqual(expectedMessage.Age, actualMessage.Age);
Assert.AreEqual(expectedMessage.Name, actualMessage.Name);
Assert.AreEqual(expectedMessage.Location, actualMessage.Location);
if (utcCreatedDate.HasValue)
{
IExpiringProtocolMessage expiringMessage = (IExpiringProtocolMessage)requestMessage;
Assert.AreEqual(utcCreatedDate.Value, expiringMessage.UtcCreationDate);
}
}
/// <summary>
/// Reads the timestamp on a message and throws an exception if the message is too old.
/// </summary>
/// <param name="message">The incoming message.</param>
/// <returns>
/// The protections (if any) that this binding element applied to the message.
/// Null if this binding element did not even apply to this binding element.
/// </returns>
/// <exception cref="ExpiredMessageException">Thrown if the given message has already expired.</exception>
/// <exception cref="ProtocolException">
/// Thrown when the binding element rules indicate that this message is invalid and should
/// NOT be processed.
/// </exception>
public MessageProtections?ProcessIncomingMessage(IProtocolMessage message)
{
IExpiringProtocolMessage expiringMessage = message as IExpiringProtocolMessage;
if (expiringMessage != null)
{
// Yes the UtcCreationDate is supposed to always be in UTC already,
// but just in case a given message failed to guarantee that, we do it here.
DateTime creationDate = expiringMessage.UtcCreationDate.ToUniversalTimeSafe();
DateTime expirationDate = creationDate + MaximumMessageAge;
if (expirationDate < DateTime.UtcNow)
{
throw new ExpiredMessageException(expirationDate, expiringMessage);
}
// Mitigate HMAC attacks (just guessing the signature until they get it) by
// disallowing post-dated messages.
ErrorUtilities.VerifyProtocol(
creationDate <= DateTime.UtcNow + DotNetOpenAuthSection.Messaging.MaximumClockSkew,
MessagingStrings.MessageTimestampInFuture,
creationDate);
return(MessageProtections.Expiration);
}
return(null);
}
/// <summary>
/// Sets the timestamp on an outgoing message.
/// </summary>
/// <param name="message">The outgoing message.</param>
/// <returns>
/// The protections (if any) that this binding element applied to the message.
/// Null if this binding element did not even apply to this binding element.
/// </returns>
public MessageProtections?ProcessOutgoingMessage(IProtocolMessage message)
{
IExpiringProtocolMessage expiringMessage = message as IExpiringProtocolMessage;
if (expiringMessage != null)
{
expiringMessage.UtcCreationDate = DateTime.UtcNow;
return(MessageProtections.Expiration);
}
return(null);
}
/// <summary>
/// Sets the timestamp on an outgoing message.
/// </summary>
/// <param name="message">The outgoing message.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// The protections (if any) that this binding element applied to the message.
/// Null if this binding element did not even apply to this binding element.
/// </returns>
/// <remarks>
/// Implementations that provide message protection must honor the
/// <see cref="MessagePartAttribute.RequiredProtection" /> properties where applicable.
/// </remarks>
public Task <MessageProtections?> ProcessOutgoingMessageAsync(IProtocolMessage message, CancellationToken cancellationToken)
{
IExpiringProtocolMessage expiringMessage = message as IExpiringProtocolMessage;
if (expiringMessage != null)
{
expiringMessage.UtcCreationDate = DateTime.UtcNow;
return(CompletedExpirationTask);
}
return(NullTask);
}
/// <summary>
/// Sets the timestamp on an outgoing message.
/// </summary>
/// <param name="message">The outgoing message.</param>
/// <returns>
/// True if the <paramref name="message"/> applied to this binding element
/// and the operation was successful. False otherwise.
/// </returns>
public bool PrepareMessageForSending(IProtocolMessage message)
{
IExpiringProtocolMessage expiringMessage = message as IExpiringProtocolMessage;
if (expiringMessage != null)
{
expiringMessage.UtcCreationDate = DateTime.UtcNow;
return(true);
}
return(false);
}
/// <summary>
/// Reads the timestamp on a message and throws an exception if the message is too old.
/// </summary>
/// <param name="message">The incoming message.</param>
/// <returns>
/// True if the <paramref name="message"/> applied to this binding element
/// and the operation was successful. False if the operation did not apply to this message.
/// </returns>
/// <exception cref="ExpiredMessageException">Thrown if the given message has already expired.</exception>
/// <exception cref="ProtocolException">
/// Thrown when the binding element rules indicate that this message is invalid and should
/// NOT be processed.
/// </exception>
public bool PrepareMessageForReceiving(IProtocolMessage message)
{
IExpiringProtocolMessage expiringMessage = message as IExpiringProtocolMessage;
if (expiringMessage != null)
{
// Yes the UtcCreationDate is supposed to always be in UTC already,
// but just in case a given message failed to guarantee that, we do it here.
DateTime expirationDate = expiringMessage.UtcCreationDate.ToUniversalTime() + MaximumMessageAge;
if (expirationDate < DateTime.UtcNow)
{
throw new ExpiredMessageException(expirationDate, expiringMessage);
}
return(true);
}
return(false);
}
/// <summary>
/// Reads the timestamp on a message and throws an exception if the message is too old.
/// </summary>
/// <param name="message">The incoming message.</param>
/// <returns>
/// The protections (if any) that this binding element applied to the message.
/// Null if this binding element did not even apply to this binding element.
/// </returns>
/// <exception cref="ExpiredMessageException">Thrown if the given message has already expired.</exception>
/// <exception cref="ProtocolException">
/// Thrown when the binding element rules indicate that this message is invalid and should
/// NOT be processed.
/// </exception>
public MessageProtections?ProcessIncomingMessage(IProtocolMessage message)
{
IExpiringProtocolMessage expiringMessage = message as IExpiringProtocolMessage;
if (expiringMessage != null)
{
// Yes the UtcCreationDate is supposed to always be in UTC already,
// but just in case a given message failed to guarantee that, we do it here.
DateTime expirationDate = expiringMessage.UtcCreationDate.ToUniversalTimeSafe() + MaximumMessageAge;
if (expirationDate < DateTime.UtcNow)
{
throw new ExpiredMessageException(expirationDate, expiringMessage);
}
return(MessageProtections.Expiration);
}
return(null);
}