public void EqualMatchesEntireSubstring()
{
var segment = new StringSegment("abcdefghij", 2, 6);
segment.Equals("cdefgh", StringComparison.Ordinal).ShouldBe(true);
segment.Equals("cdefg", StringComparison.Ordinal).ShouldBe(false);
segment.Equals("cdefghi", StringComparison.Ordinal).ShouldBe(false);
segment.Equals("cDefgh", StringComparison.Ordinal).ShouldBe(false);
segment.Equals("cDefgh", StringComparison.OrdinalIgnoreCase).ShouldBe(true);
}
/// <summary>
/// Gets a value indicating whether the string has the specified property.
/// </summary>
/// <param name="prop">The name of the property to evaluate.</param>
/// <returns><c>true</c> if the string has the specified property; otherwise, <c>false</c>.</returns>
public Boolean HasPropertyRef(ref StringSegment prop)
{
foreach (var kvp in properties)
{
if (prop.Equals(kvp.Key))
{
return true;
}
}
return false;
}
/// <summary>
/// Compares against another <see cref="EntityTagHeaderValue"/> to see if they match under the RFC specifications (https://tools.ietf.org/html/rfc7232#section-2.3.2).
/// </summary>
/// <param name="other">The other <see cref="EntityTagHeaderValue"/> to compare against.</param>
/// <param name="useStrongComparison"><c>true</c> to use a strong comparison, <c>false</c> to use a weak comparison</param>
/// <returns>
/// <c>true</c> if the <see cref="EntityTagHeaderValue"/> match for the given comparison type,
/// <c>false</c> if the other value is null or the comparison failed.
/// </returns>
public bool Compare(EntityTagHeaderValue?other, bool useStrongComparison)
{
if (other == null)
{
return(false);
}
if (useStrongComparison)
{
return(!IsWeak && !other.IsWeak && StringSegment.Equals(Tag, other.Tag, StringComparison.Ordinal));
}
else
{
return(StringSegment.Equals(Tag, other.Tag, StringComparison.Ordinal));
}
}
// Header contains a comma-separated collection of key / value pairs. Get all values for the "v1" key.
private IEnumerable <StringSegment> GetSignatures(string header)
{
var pairs = new TrimmingTokenizer(header, CommaSeparator);
foreach (var pair in pairs)
{
var keyValuePair = new TrimmingTokenizer(pair, EqualSeparator, maxCount: 2);
var enumerator = keyValuePair.GetEnumerator();
enumerator.MoveNext();
if (StringSegment.Equals(enumerator.Current, StripeConstants.SignatureKey, StringComparison.Ordinal))
{
enumerator.MoveNext();
yield return(enumerator.Current);
}
}
}
public override void OnActionExecuting(ActionExecutingContext context)
{
EnsureArg.IsNotNull(context, nameof(context));
IList <MediaTypeHeaderValue> acceptHeaders = context.HttpContext.Request.GetTypedHeaders().Accept;
bool acceptable = false;
// Validate the accept headers has one of the specified accepted media types.
if (acceptHeaders != null && acceptHeaders.Count > 0)
{
foreach (MediaTypeHeaderValue acceptHeader in acceptHeaders)
{
if (_allowMultiple && StringSegment.Equals(acceptHeader.MediaType, KnownContentTypes.MultipartRelated, StringComparison.InvariantCultureIgnoreCase))
{
NameValueHeaderValue typeParameterValue = acceptHeader.Parameters.FirstOrDefault(
parameter => StringSegment.Equals(parameter.Name, TypeParameter, StringComparison.InvariantCultureIgnoreCase));
if (typeParameterValue != null &&
MediaTypeHeaderValue.TryParse(HeaderUtilities.RemoveQuotes(typeParameterValue.Value), out MediaTypeHeaderValue parsedValue) &&
_mediaTypes.Contains(parsedValue))
{
acceptable = true;
break;
}
}
if (_allowSingle)
{
string[] split = acceptHeader.ToString().Split(';');
List <string> stringHeaders = _mediaTypes.Select(x => x.ToString()).ToList();
if (split.Any(x => stringHeaders.Contains(x, StringComparer.InvariantCultureIgnoreCase)))
{
acceptable = true;
break;
}
}
}
}
if (!acceptable)
{
context.Result = new StatusCodeResult(NotAcceptableResponseCode);
}
base.OnActionExecuting(context);
}
private static CultureInfo GetCultureInfo(StringSegment name, IList <CultureInfo> supportedCultures)
{
// Allow only known culture names as this API is called with input from users (HTTP requests) and
// creating CultureInfo objects is expensive and we don't want it to throw either.
if (name == null || supportedCultures == null)
{
return(null);
}
var culture = supportedCultures.FirstOrDefault(
supportedCulture => StringSegment.Equals(supportedCulture.Name, name, StringComparison.OrdinalIgnoreCase));
if (culture == null)
{
return(null);
}
return(CultureInfo.ReadOnly(culture));
}
// Header contains a comma-separated collection of key / value pairs. Get the value for the "t" key.
private StringSegment GetTimestamp(string header)
{
var pairs = new TrimmingTokenizer(header, CommaSeparator);
foreach (var pair in pairs)
{
var keyValuePair = new TrimmingTokenizer(pair, EqualSeparator, maxCount: 2);
var enumerator = keyValuePair.GetEnumerator();
enumerator.MoveNext();
if (StringSegment.Equals(enumerator.Current, StripeConstants.TimestampKey, StringComparison.Ordinal))
{
enumerator.MoveNext();
return(enumerator.Current);
}
}
return(StringSegment.Empty);
}
/// <inheritdoc />
public virtual ICompressionProvider GetCompressionProvider(HttpContext context)
{
IList <StringWithQualityHeaderValue> unsorted;
// e.g. Accept-Encoding: gzip, deflate, sdch
var accept = context.Request.Headers[HeaderNames.AcceptEncoding];
if (!StringValues.IsNullOrEmpty(accept) &&
StringWithQualityHeaderValue.TryParseList(accept, out unsorted) &&
unsorted != null && unsorted.Count > 0)
{
// TODO PERF: clients don't usually include quality values so this sort will not have any effect. Fast-path?
var sorted = unsorted
.Where(s => s.Quality.GetValueOrDefault(1) > 0)
.OrderByDescending(s => s.Quality.GetValueOrDefault(1));
foreach (var encoding in sorted)
{
// There will rarely be more than three providers, and there's only one by default
foreach (var provider in _providers)
{
if (StringSegment.Equals(provider.EncodingName, encoding.Value, StringComparison.OrdinalIgnoreCase))
{
return(provider);
}
}
// Uncommon but valid options
if (StringSegment.Equals("*", encoding.Value, StringComparison.Ordinal))
{
// Any
return(_providers[0]);
}
if (StringSegment.Equals("identity", encoding.Value, StringComparison.OrdinalIgnoreCase))
{
// No compression
return(null);
}
}
}
return(null);
}
public override bool Equals(object obj)
{
var other = obj as SetCookieHeaderValue;
if (other == null)
{
return(false);
}
return(StringSegment.Equals(_name, other._name, StringComparison.OrdinalIgnoreCase) &&
StringSegment.Equals(_value, other._value, StringComparison.OrdinalIgnoreCase) &&
Expires.Equals(other.Expires) &&
MaxAge.Equals(other.MaxAge) &&
StringSegment.Equals(Domain, other.Domain, StringComparison.OrdinalIgnoreCase) &&
StringSegment.Equals(Path, other.Path, StringComparison.OrdinalIgnoreCase) &&
Secure == other.Secure &&
SameSite == other.SameSite &&
HttpOnly == other.HttpOnly);
}
private static Encoding?GetEncodingFromCharset(StringSegment charset)
{
if (charset.Equals("utf-8", StringComparison.OrdinalIgnoreCase))
{
// This is an optimization for utf-8 that prevents the Substring caused by
// charset.Value
return(Encoding.UTF8);
}
try
{
// charset.Value might be an invalid encoding name as in charset=invalid.
return(charset.HasValue ? Encoding.GetEncoding(charset.Value) : null);
}
catch (Exception ex)
{
throw new InvalidOperationException($"Unable to read the request as JSON because the request content type charset '{charset}' is not a known encoding.", ex);
}
}
public RavenConfiguration CreateDatabaseConfiguration(StringSegment databaseName, bool ignoreDisabledDatabase = false)
{
if (databaseName.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(databaseName), "Database name cannot be empty");
}
if (databaseName.Equals("<system>")) // This is here to guard against old ravendb tests
{
throw new ArgumentNullException(nameof(databaseName), "Database name cannot be <system>. Using of <system> database indicates outdated code that was targeted RavenDB 3.5.");
}
var document = GetDatabaseDocument(databaseName, ignoreDisabledDatabase);
if (document == null)
{
return(null);
}
return(CreateConfiguration(databaseName, document, RavenConfiguration.GetKey(x => x.Core.DataDirectory)));
}
/// <summary>
/// Compares two <see cref="StringWithQualityHeaderValue"/> based on their quality value
/// (a.k.a their "q-value").
/// Values with identical q-values are considered equal (i.e the result is 0) with the exception of wild-card
/// values (i.e. a value of "*") which are considered less than non-wild-card values. This allows to sort
/// a sequence of <see cref="StringWithQualityHeaderValue"/> following their q-values ending up with any
/// wild-cards at the end.
/// </summary>
/// <param name="stringWithQuality1">The first value to compare.</param>
/// <param name="stringWithQuality2">The second value to compare</param>
/// <returns>The result of the comparison.</returns>
public int Compare(
StringWithQualityHeaderValue stringWithQuality1,
StringWithQualityHeaderValue stringWithQuality2)
{
if (stringWithQuality1 == null)
{
throw new ArgumentNullException(nameof(stringWithQuality1));
}
if (stringWithQuality2 == null)
{
throw new ArgumentNullException(nameof(stringWithQuality2));
}
var quality1 = stringWithQuality1.Quality ?? HeaderQuality.Match;
var quality2 = stringWithQuality2.Quality ?? HeaderQuality.Match;
var qualityDifference = quality1 - quality2;
if (qualityDifference < 0)
{
return(-1);
}
else if (qualityDifference > 0)
{
return(1);
}
if (!StringSegment.Equals(stringWithQuality1.Value, stringWithQuality2.Value, StringComparison.OrdinalIgnoreCase))
{
if (StringSegment.Equals(stringWithQuality1.Value, "*", StringComparison.Ordinal))
{
return(-1);
}
else if (StringSegment.Equals(stringWithQuality2.Value, "*", StringComparison.Ordinal))
{
return(1);
}
}
return(0);
}
public static void UseErrorLocalization(this IApplicationBuilder app)
{
var supportedCultures = new[] { "en-US", "zh-CN" };
var localizationOptions = new RequestLocalizationOptions().SetDefaultCulture(supportedCultures[0])
.AddSupportedCultures(supportedCultures)
.AddSupportedUICultures(supportedCultures);
// Use official request localization
app.UseRequestLocalization(localizationOptions);
// Custom language process
app.Use(async(context, next) =>
{
context.Request.Query.TryGetValue("lang", out StringValues queryLanguages);
context.Request.Headers.TryGetValue("language", out StringValues languages);
string language = null;
if (queryLanguages.Count > 0)
{
language = queryLanguages.Last();
}
else if (languages.Count > 0)
{
language = languages.Last();
}
if (!string.IsNullOrEmpty(language))
{
var culture = localizationOptions.SupportedCultures.FirstOrDefault(
supportedCulture => StringSegment.Equals(supportedCulture.Name, language, StringComparison.OrdinalIgnoreCase));
if (culture != null)
{
CultureInfo.CurrentCulture = culture;
CultureInfo.CurrentUICulture = culture;
}
}
await next.Invoke();
});
}
public override ICompressionProvider GetCompressionProvider(HttpContext context)
{
// e.g. Accept-Encoding: gzip, deflate, sdch
var accept = context.Request.Headers[HeaderNames.AcceptEncoding];
if (!StringValues.IsNullOrEmpty(accept) &&
StringWithQualityHeaderValue.TryParseList(accept, out var unsorted) &&
unsorted != null && unsorted.Count > 0)
{
foreach (var provider in _providers)
{
if (unsorted.Any(
x => StringSegment.Equals(provider.EncodingName, x.Value, StringComparison.Ordinal)))
{
return(provider);
}
}
}
return(base.GetCompressionProvider(context));
}
private static Encoding?GetEncodingFromCharset(StringSegment charset)
{
if (charset.Equals("utf-8", StringComparison.OrdinalIgnoreCase))
{
// This is an optimization for utf-8 that prevents the Substring caused by
// charset.Value
return(Encoding.UTF8);
}
try
{
// charset.Value might be an invalid encoding name as in charset=invalid.
// For that reason, we catch the exception thrown by Encoding.GetEncoding
// and return null instead.
return(charset.HasValue ? Encoding.GetEncoding(charset.Value) : null);
}
catch (Exception)
{
return(null);
}
}
public static bool SatisfiesTagName(StringSegment tagNameWithoutPrefix, TagMatchingRuleDescriptor rule)
{
if (StringSegment.IsNullOrEmpty(tagNameWithoutPrefix))
{
return(false);
}
if (tagNameWithoutPrefix[0] == ElementOptOutCharacter)
{
// TagHelpers can never satisfy tag names that are prefixed with the opt-out character.
return(false);
}
if (rule.TagName != ElementCatchAllName &&
rule.TagName != null &&
!tagNameWithoutPrefix.Equals(rule.TagName, rule.CaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase))
{
return(false);
}
return(true);
}
public RavenConfiguration CreateDatabaseConfiguration(StringSegment databaseName, bool ignoreDisabledDatabase = false, bool ignoreBeenDeleted = false, bool ignoreNotRelevant = false)
{
if (databaseName.Trim().Length == 0)
{
throw new ArgumentNullException(nameof(databaseName), "Database name cannot be empty");
}
if (databaseName.Equals("<system>")) // This is here to guard against old ravendb tests
{
throw new ArgumentNullException(nameof(databaseName),
"Database name cannot be <system>. Using of <system> database indicates outdated code that was targeted RavenDB 3.5.");
}
Debug.Assert(_serverStore.Disposed == false);
using (_serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
{
context.OpenReadTransaction();
var doc = _serverStore.Cluster.Read(context, "db/" + databaseName.Value.ToLowerInvariant());
if (doc == null)
{
return(null);
}
var databaseRecord = JsonDeserializationCluster.DatabaseRecord(doc);
if (databaseRecord.Encrypted)
{
if (_serverStore.Server.WebUrl?.StartsWith("https:", StringComparison.OrdinalIgnoreCase) == false)
{
throw new DatabaseDisabledException(
$"The database {databaseName.Value} is encrypted, and must be accessed only via HTTPS, but the web url used is {_serverStore.Server.WebUrl}");
}
}
return(CreateDatabaseConfiguration(databaseName, ignoreDisabledDatabase, ignoreBeenDeleted, ignoreNotRelevant, databaseRecord));
}
}
private void NegotiateEncoding(HttpContext context)
{
var accept = context.Request.Headers.AcceptEncoding;
if (StringValues.IsNullOrEmpty(accept))
{
return;
}
if (!StringWithQualityHeaderValue.TryParseList(accept, out var encodings) || encodings.Count == 0)
{
return;
}
var selectedEncoding = StringSegment.Empty;
var selectedEncodingQuality = .0;
foreach (var encoding in encodings)
{
var encodingName = encoding.Value;
var quality = encoding.Quality.GetValueOrDefault(1);
if (quality >= double.Epsilon && quality >= selectedEncodingQuality)
{
if (quality == selectedEncodingQuality)
{
selectedEncoding = PickPreferredEncoding(context, selectedEncoding, encoding);
}
else if (_encodingExtensionMap.TryGetValue(encodingName, out var encodingExtension) && ResourceExists(context, encodingExtension))
{
selectedEncoding = encodingName;
selectedEncodingQuality = quality;
}
if (StringSegment.Equals("*", encodingName, StringComparison.Ordinal))
{
// If we *, pick the first preferrent encoding for which a resource exists.
selectedEncoding = PickPreferredEncoding(context, default, encoding);
/// <summary>
/// Initializes a new instance of the <see cref="EntityTagHeaderValue"/>.
/// </summary>
/// <param name="tag">A <see cref="StringSegment"/> that contains an <see cref="EntityTagHeaderValue"/>.</param>
/// <param name="isWeak">A value that indicates if this entity-tag header is a weak validator.</param>
public EntityTagHeaderValue(StringSegment tag, bool isWeak)
{
if (StringSegment.IsNullOrEmpty(tag))
{
throw new ArgumentException("An empty string is not allowed.", nameof(tag));
}
if (!isWeak && StringSegment.Equals(tag, "*", StringComparison.Ordinal))
{
// * is valid, but W/* isn't.
_tag = tag;
}
else if ((HttpRuleParser.GetQuotedStringLength(tag, 0, out var length) != HttpParseResult.Parsed) ||
(length != tag.Length))
{
// Note that we don't allow 'W/' prefixes for weak ETags in the 'tag' parameter. If the user wants to
// add a weak ETag, they can set 'isWeak' to true.
throw new FormatException("Invalid ETag name");
}
_tag = tag;
_isWeak = isWeak;
}
public void ComparisonsTest(string a, string b)
{
Assert.AreEqual(a == b, a.AsSegment() == b.AsSegment());
foreach (StringComparison comparison in Enum <StringComparison> .GetValues())
{
Assert.AreEqual(String.Equals(a, b, comparison), StringSegment.Equals(a, b, comparison));
Assert.AreEqual(Math.Sign(String.Compare(a, b, comparison)), Math.Sign(StringSegment.Compare(a, b, comparison)));
}
Assert.AreEqual(StringComparer.Ordinal.Equals(a, b), StringSegmentComparer.Ordinal.Equals(a, b));
Assert.AreEqual(StringComparer.Ordinal.Equals(a, b), StringSegmentComparer.Ordinal.Equals((object)a, b));
Assert.AreEqual(StringComparer.Ordinal.Equals(a, b), StringSegmentComparer.Ordinal.Equals((object)a, (StringSegment)b));
Assert.AreEqual(Math.Sign(StringComparer.Ordinal.Compare(a, b)), Math.Sign(StringSegmentComparer.Ordinal.Compare(a, b)));
Assert.AreEqual(Math.Sign(StringComparer.Ordinal.Compare(a, b)), Math.Sign(StringSegmentComparer.Ordinal.Compare((object)a, b)));
Assert.AreEqual(Math.Sign(StringComparer.Ordinal.Compare(a, b)), Math.Sign(StringSegmentComparer.Ordinal.Compare((object)a, (StringSegment)b)));
Assert.AreEqual(StringComparer.OrdinalIgnoreCase.Equals(a, b), StringSegmentComparer.OrdinalIgnoreCase.Equals(a, b));
Assert.AreEqual(Math.Sign(StringComparer.OrdinalIgnoreCase.Compare(a, b)), Math.Sign(StringSegmentComparer.OrdinalIgnoreCase.Compare(a, b)));
Assert.AreEqual(StringComparer.CurrentCulture.Equals(a, b), StringSegmentComparer.CurrentCulture.Equals(a, b));
Assert.AreEqual(Math.Sign(StringComparer.CurrentCulture.Compare(a, b)), Math.Sign(StringSegmentComparer.CurrentCulture.Compare(a, b)));
Assert.AreEqual(StringComparer.CurrentCultureIgnoreCase.Equals(a, b), StringSegmentComparer.CurrentCultureIgnoreCase.Equals(a, b));
Assert.AreEqual(Math.Sign(StringComparer.CurrentCultureIgnoreCase.Compare(a, b)), Math.Sign(StringSegmentComparer.CurrentCultureIgnoreCase.Compare(a, b)));
}
private bool MatchesParameters(MediaTypeHeaderValue set)
{
if (set._parameters != null && set._parameters.Count != 0)
{
// Make sure all parameters in the potential superset are included locally. Fine to have additional
// parameters locally; they make this one more specific.
foreach (var parameter in set._parameters)
{
if (parameter.Name.Equals(WildcardString, StringComparison.OrdinalIgnoreCase))
{
// A parameter named "*" has no effect on media type matching, as it is only used as an indication
// that the entire media type string should be treated as a wildcard.
continue;
}
if (parameter.Name.Equals(QualityString, StringComparison.OrdinalIgnoreCase))
{
// "q" and later parameters are not involved in media type matching. Quoting the RFC: The first
// "q" parameter (if any) separates the media-range parameter(s) from the accept-params.
break;
}
var localParameter = NameValueHeaderValue.Find(_parameters, parameter.Name);
if (localParameter == null)
{
// Not found.
return(false);
}
if (!StringSegment.Equals(parameter.Value, localParameter.Value, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
}
}
return(true);
}
public bool IsAcceptable(AcceptHeader acceptHeader, out string transferSyntax)
{
EnsureArg.IsNotNull(acceptHeader, nameof(acceptHeader));
transferSyntax = null;
// Check if payload type match
if ((PayloadType & acceptHeader.PayloadType) == PayloadTypes.None)
{
return(false);
}
if (!StringSegment.Equals(acceptHeader.MediaType, MediaType, StringComparison.InvariantCultureIgnoreCase))
{
return(false);
}
if (StringSegment.IsNullOrEmpty(acceptHeader.TransferSyntax))
{
if (IsTransferSyntaxMandatory)
{
return(false);
}
// when transfer syntax is missed from accept header, use default one
transferSyntax = TransferSyntaxWhenMissing;
return(true);
}
if (AcceptableTransferSyntaxes.Contains(acceptHeader.TransferSyntax.Value))
{
transferSyntax = acceptHeader.TransferSyntax.Value;
return(true);
}
return(false);
}
public void EqualsString(string content, string content2, bool expected)
{
var segment = new StringSegment(content);
Assert.Equal(expected, segment.Equals(content2));
}
/// <summary>
/// Gets a value indicating whether the string variant has the specified property.
/// </summary>
/// <param name="prop">The name of the property to evaluate.</param>
/// <returns><see langword="true"/> if the string variant has the specified property; otherwise, <see langword="false"/>.</returns>
public Boolean HasPropertyRef(ref StringSegment prop)
{
foreach (var property in properties)
{
if (prop.Equals(property))
return true;
}
return parent.HasPropertyRef(ref prop);
}
/// <summary>
/// Gets the specified string variant.
/// </summary>
/// <param name="group">The name of the variant group of the variant to retrieve.</param>
/// <returns>The specified string variant.</returns>
public LocalizedStringVariant GetVariant(ref StringSegment group)
{
foreach (var kvp in variants)
{
if (group.Equals(kvp.Key))
{
return kvp.Value;
}
}
return null;
}
public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
if (!this.IsRequestApplicable(context.RouteData) && HttpMethods.IsPost(context.HttpContext.Request.Method))
{
await next();
return;
}
IActionResult ErrorResult = base.EnsureSecureConnection(this.ReceiverName, context.HttpContext.Request);
if (ErrorResult != null)
{
context.Result = ErrorResult;
return;
}
string Header = base.GetRequestHeader(context.HttpContext.Request, BitbucketConstants.SignatureHeaderName, out ErrorResult);
if (ErrorResult != null)
{
context.Result = ErrorResult;
return;
}
TrimmingTokenizer Values = new TrimmingTokenizer(Header, SEPARATORS);
TrimmingTokenizer.Enumerator Enumerator = Values.GetEnumerator();
Enumerator.MoveNext();
StringSegment HeaderKey = Enumerator.Current;
if (Values.Count != 2 || !StringSegment.Equals(HeaderKey, BitbucketConstants.SignatureHeaderKey, StringComparison.OrdinalIgnoreCase))
{
string ErrorMessage = string.Format(CultureInfo.CurrentCulture, Resources.SignatureFilter_BadHeaderValue,
BitbucketConstants.SignatureHeaderName, BitbucketConstants.SignatureHeaderKey, "<value>");
base.Logger.LogError(1, ErrorMessage);
context.Result = new BadRequestObjectResult(ErrorMessage);
return;
}
Enumerator.MoveNext();
string HeaderValue = Enumerator.Current.Value;
byte[] ExpectedHash = base.FromHex(HeaderValue, BitbucketConstants.SignatureHeaderName);
if (ExpectedHash == null)
{
context.Result = base.CreateBadHexEncodingResult(BitbucketConstants.SignatureHeaderName);
return;
}
byte[] Secret = this.GetSecret(this.ReceiverName, context.RouteData);
if (Secret == null)
{
context.Result = new NotFoundResult();
return;
}
byte[] ActualHash = await base.ComputeRequestBodySha256HashAsync(context.HttpContext.Request, Secret);
if (!BitbucketVerifySignatureFilter.SecretEqual(ExpectedHash, ActualHash))
{
context.Result = base.CreateBadSignatureResult(BitbucketConstants.SignatureHeaderName);
return;
}
await next();
}
private IActionResult ValidateHeader(string header)
{
var hasTimestamp = false;
var hasSignature = false;
var pairs = new TrimmingTokenizer(header, CommaSeparator);
foreach (var pair in pairs)
{
var keyValuePair = new TrimmingTokenizer(pair, EqualSeparator, maxCount: 2);
if (keyValuePair.Count != 2)
{
// Header is not formatted correctly.
Logger.LogWarning(
0,
$"The '{StripeConstants.SignatureHeaderName}' header value is invalid. '{{InvalidPair}}' " +
"should be a 'key=value' pair.",
pair);
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.SignatureFilter_InvalidHeaderFormat,
StripeConstants.SignatureHeaderName);
return(new BadRequestObjectResult(message));
}
var enumerator = keyValuePair.GetEnumerator();
enumerator.MoveNext();
var key = enumerator.Current;
if (StringSegment.Equals(key, StripeConstants.SignatureKey, StringComparison.Ordinal))
{
enumerator.MoveNext();
hasSignature = !StringSegment.IsNullOrEmpty(enumerator.Current);
}
else if (StringSegment.Equals(key, StripeConstants.TimestampKey, StringComparison.Ordinal))
{
enumerator.MoveNext();
hasTimestamp = !StringSegment.IsNullOrEmpty(enumerator.Current);
}
}
if (!hasSignature)
{
Logger.LogWarning(
1,
$"The '{StripeConstants.SignatureHeaderName}' header value is invalid. Does not contain a " +
$"timestamp ('{StripeConstants.SignatureKey}') value.");
}
if (!hasTimestamp)
{
Logger.LogWarning(
2,
$"The '{StripeConstants.SignatureHeaderName}' header value is invalid. Does not contain a " +
$"signature ('{StripeConstants.TimestampKey}') value.");
}
if (!hasSignature || !hasTimestamp)
{
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.SignatureFilter_HeaderMissingValue,
StripeConstants.SignatureHeaderName,
StripeConstants.TimestampKey,
StripeConstants.SignatureKey);
return(new BadRequestObjectResult(message));
}
// Success
return(null);
}
public void EqualsString(string content, string content2, bool expected)
{
var segment = new StringSegment(content);
Assert.Equal(expected, segment.Equals(content2));
}
public void TestEquals(string content)
{
var segment = new StringSegment(content);
Assert.True(segment.Equals(segment));
}
public void StringSegment_EqualsString_Invalid()
{
// Arrange
var segment = new StringSegment();
// Act
var result = segment.Equals(string.Empty, StringComparison.Ordinal);
// Assert
Assert.False(result);
}
/// <summary>
/// Check against another <see cref="EntityTagHeaderValue"/> for equality.
/// This equality check should not be used to determine if two values match under the RFC specifications (https://tools.ietf.org/html/rfc7232#section-2.3.2).
/// </summary>
/// <param name="obj">The other value to check against for equality.</param>
/// <returns>
/// <c>true</c> if the strength and tag of the two values match,
/// <c>false</c> if the other value is null, is not an <see cref="EntityTagHeaderValue"/>, or if there is a mismatch of strength or tag between the two values.
/// </returns>
public override bool Equals(object?obj)
{
// Since the tag is a quoted-string we treat it case-sensitive.
return(obj is EntityTagHeaderValue other && _isWeak == other._isWeak && StringSegment.Equals(_tag, other._tag, StringComparison.Ordinal));
}
/// <inheritdoc />
public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
var request = context.HttpContext.Request;
if (HttpMethods.IsPost(request.Method))
{
// 1. Confirm a secure connection.
var errorResult = EnsureSecureConnection(ReceiverName, context.HttpContext.Request);
if (errorResult != null)
{
context.Result = errorResult;
return;
}
// 2. Get the expected hash from the signature header.
var header = GetRequestHeader(request, ZoomConstants.SignatureHeaderName, out errorResult);
if (errorResult != null)
{
context.Result = errorResult;
return;
}
var values = new TrimmingTokenizer(header, PairSeparators);
var enumerator = values.GetEnumerator();
enumerator.MoveNext();
var headerKey = enumerator.Current;
if (values.Count != 2 ||
!StringSegment.Equals(
headerKey,
ZoomConstants.SignatureHeaderKey,
StringComparison.OrdinalIgnoreCase))
{
Logger.LogWarning(
0,
$"Invalid '{ZoomConstants.SignatureHeaderName}' header value. Expecting a value of " +
$"'{ZoomConstants.SignatureHeaderKey}=<value>'.");
var message = string.Format(
CultureInfo.CurrentCulture,
Resources.SignatureFilter_BadHeaderValue,
ZoomConstants.SignatureHeaderName,
ZoomConstants.SignatureHeaderKey,
"<value>");
errorResult = new BadRequestObjectResult(message);
context.Result = errorResult;
return;
}
enumerator.MoveNext();
var headerValue = enumerator.Current.Value;
var expectedHash = FromHex(headerValue, ZoomConstants.SignatureHeaderName);
if (expectedHash == null)
{
context.Result = CreateBadHexEncodingResult(ZoomConstants.SignatureHeaderKey);
return;
}
// 3. Get the configured secret key.
var secretKey = GetSecretKey(ReceiverName, context.RouteData, ZoomConstants.SecretKeyMinLength);
if (secretKey == null)
{
context.Result = new NotFoundResult();
return;
}
var secret = Encoding.UTF8.GetBytes(secretKey);
// 4. Get the actual hash of the request body.
var actualHash = await ComputeRequestBodySha1HashAsync(request, secret);
// 5. Verify that the actual hash matches the expected hash.
if (!SecretEqual(expectedHash, actualHash))
{
// Log about the issue and short-circuit remainder of the pipeline.
errorResult = CreateBadSignatureResult(ZoomConstants.SignatureHeaderName);
context.Result = errorResult;
return;
}
}
await next();
}
/// <summary>
/// Matches a source string to a target variant according to the specified culture and rule.
/// </summary>
private static String MatchVariantInternal(String culture, LocalizedString source, LocalizedStringVariant target, StringSegment rule)
{
Dictionary<String, LocalizationMatchEvaluator> registry;
if (!registeredMatchEvaluators.TryGetValue(culture, out registry))
return null;
foreach (var kvp in registry)
{
if (rule.Equals(kvp.Key))
{
return (kvp.Value == null) ? null : kvp.Value(source, target);
}
}
return null;
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
output.TagName = null;
if (String.IsNullOrWhiteSpace(Include) && String.IsNullOrWhiteSpace(Exclude))
{
return;
}
string currentProtocol = ViewContext.HttpContext.Request.Protocol;
if (Exclude != null)
{
StringTokenizer excludeTokenizer = new StringTokenizer(Exclude, PROTOCOLS_SEPARATOR);
foreach (StringSegment excludeToken in excludeTokenizer)
{
StringSegment excludedProtocol = excludeToken.Trim();
if (excludedProtocol.HasValue && excludedProtocol.Length > 0)
{
if (excludedProtocol.Equals(currentProtocol, StringComparison.OrdinalIgnoreCase))
{
output.SuppressOutput();
return;
}
}
}
}
bool hasIncludeProtocols = false;
if (Include != null)
{
StringTokenizer includeTokenizer = new StringTokenizer(Include, PROTOCOLS_SEPARATOR);
foreach (StringSegment includedToken in includeTokenizer)
{
StringSegment includedProtocol = includedToken.Trim();
if (includedProtocol.HasValue && includedProtocol.Length > 0)
{
hasIncludeProtocols = true;
if (includedProtocol.Equals(currentProtocol, StringComparison.OrdinalIgnoreCase))
{
return;
}
}
}
}
if (hasIncludeProtocols)
{
output.SuppressOutput();
}
}
public bool Equals(HeaderSegment other)
{
return(_formatting.Equals(other._formatting) && _data.Equals(other._data));
}
// name=value; expires=Sun, 06 Nov 1994 08:49:37 GMT; max-age=86400; domain=domain1; path=path1; secure; samesite={Strict|Lax}; httponly
private static int GetSetCookieLength(StringSegment input, int startIndex, out SetCookieHeaderValue parsedValue)
{
Contract.Requires(startIndex >= 0);
var offset = startIndex;
parsedValue = null;
if (StringSegment.IsNullOrEmpty(input) || (offset >= input.Length))
{
return(0);
}
var result = new SetCookieHeaderValue();
// The caller should have already consumed any leading whitespace, commas, etc..
// Name=value;
// Name
var itemLength = HttpRuleParser.GetTokenLength(input, offset);
if (itemLength == 0)
{
return(0);
}
result._name = input.Subsegment(offset, itemLength);
offset += itemLength;
// = (no spaces)
if (!ReadEqualsSign(input, ref offset))
{
return(0);
}
// value or "quoted value"
// The value may be empty
result._value = CookieHeaderValue.GetCookieValue(input, ref offset);
// *(';' SP cookie-av)
while (offset < input.Length)
{
if (input[offset] == ',')
{
// Divider between headers
break;
}
if (input[offset] != ';')
{
// Expecting a ';' between parameters
return(0);
}
offset++;
offset += HttpRuleParser.GetWhitespaceLength(input, offset);
// cookie-av = expires-av / max-age-av / domain-av / path-av / secure-av / samesite-av / httponly-av / extension-av
itemLength = HttpRuleParser.GetTokenLength(input, offset);
if (itemLength == 0)
{
// Trailing ';' or leading into garbage. Let the next parser fail.
break;
}
var token = input.Subsegment(offset, itemLength);
offset += itemLength;
// expires-av = "Expires=" sane-cookie-date
if (StringSegment.Equals(token, ExpiresToken, StringComparison.OrdinalIgnoreCase))
{
// = (no spaces)
if (!ReadEqualsSign(input, ref offset))
{
return(0);
}
var dateString = ReadToSemicolonOrEnd(input, ref offset);
DateTimeOffset expirationDate;
if (!HttpRuleParser.TryStringToDate(dateString, out expirationDate))
{
// Invalid expiration date, abort
return(0);
}
result.Expires = expirationDate;
}
// max-age-av = "Max-Age=" non-zero-digit *DIGIT
else if (StringSegment.Equals(token, MaxAgeToken, StringComparison.OrdinalIgnoreCase))
{
// = (no spaces)
if (!ReadEqualsSign(input, ref offset))
{
return(0);
}
itemLength = HttpRuleParser.GetNumberLength(input, offset, allowDecimal: false);
if (itemLength == 0)
{
return(0);
}
var numberString = input.Subsegment(offset, itemLength);
long maxAge;
if (!HeaderUtilities.TryParseNonNegativeInt64(numberString, out maxAge))
{
// Invalid expiration date, abort
return(0);
}
result.MaxAge = TimeSpan.FromSeconds(maxAge);
offset += itemLength;
}
// domain-av = "Domain=" domain-value
// domain-value = <subdomain> ; defined in [RFC1034], Section 3.5, as enhanced by [RFC1123], Section 2.1
else if (StringSegment.Equals(token, DomainToken, StringComparison.OrdinalIgnoreCase))
{
// = (no spaces)
if (!ReadEqualsSign(input, ref offset))
{
return(0);
}
// We don't do any detailed validation on the domain.
result.Domain = ReadToSemicolonOrEnd(input, ref offset);
}
// path-av = "Path=" path-value
// path-value = <any CHAR except CTLs or ";">
else if (StringSegment.Equals(token, PathToken, StringComparison.OrdinalIgnoreCase))
{
// = (no spaces)
if (!ReadEqualsSign(input, ref offset))
{
return(0);
}
// We don't do any detailed validation on the path.
result.Path = ReadToSemicolonOrEnd(input, ref offset);
}
// secure-av = "Secure"
else if (StringSegment.Equals(token, SecureToken, StringComparison.OrdinalIgnoreCase))
{
result.Secure = true;
}
// samesite-av = "SameSite" / "SameSite=" samesite-value
// samesite-value = "Strict" / "Lax"
else if (StringSegment.Equals(token, SameSiteToken, StringComparison.OrdinalIgnoreCase))
{
if (!ReadEqualsSign(input, ref offset))
{
result.SameSite = SameSiteMode.Strict;
}
else
{
var enforcementMode = ReadToSemicolonOrEnd(input, ref offset);
if (StringSegment.Equals(enforcementMode, SameSiteLaxToken, StringComparison.OrdinalIgnoreCase))
{
result.SameSite = SameSiteMode.Lax;
}
else
{
result.SameSite = SameSiteMode.Strict;
}
}
}
// httponly-av = "HttpOnly"
else if (StringSegment.Equals(token, HttpOnlyToken, StringComparison.OrdinalIgnoreCase))
{
result.HttpOnly = true;
}
// extension-av = <any CHAR except CTLs or ";">
else
{
// TODO: skip it? Store it in a list?
}
}
parsedValue = result;
return(offset - startIndex);
}
/// <inheritdoc />
public virtual ICompressionProvider?GetCompressionProvider(HttpContext context)
{
// e.g. Accept-Encoding: gzip, deflate, sdch
var accept = context.Request.Headers.AcceptEncoding;
// Note this is already checked in CheckRequestAcceptsCompression which _should_ prevent any of these other methods from being called.
if (StringValues.IsNullOrEmpty(accept))
{
Debug.Assert(false, "Duplicate check failed.");
_logger.NoAcceptEncoding();
return(null);
}
if (!StringWithQualityHeaderValue.TryParseList(accept, out var encodings) || encodings.Count == 0)
{
_logger.NoAcceptEncoding();
return(null);
}
var candidates = new HashSet <ProviderCandidate>();
foreach (var encoding in encodings)
{
var encodingName = encoding.Value;
var quality = encoding.Quality.GetValueOrDefault(1);
if (quality < double.Epsilon)
{
continue;
}
for (int i = 0; i < _providers.Length; i++)
{
var provider = _providers[i];
if (StringSegment.Equals(provider.EncodingName, encodingName, StringComparison.OrdinalIgnoreCase))
{
candidates.Add(new ProviderCandidate(provider.EncodingName, quality, i, provider));
}
}
// Uncommon but valid options
if (StringSegment.Equals("*", encodingName, StringComparison.Ordinal))
{
for (int i = 0; i < _providers.Length; i++)
{
var provider = _providers[i];
// Any provider is a candidate.
candidates.Add(new ProviderCandidate(provider.EncodingName, quality, i, provider));
}
break;
}
if (StringSegment.Equals("identity", encodingName, StringComparison.OrdinalIgnoreCase))
{
// We add 'identity' to the list of "candidates" with a very low priority and no provider.
// This will allow it to be ordered based on its quality (and priority) later in the method.
candidates.Add(new ProviderCandidate(encodingName.Value, quality, priority: int.MaxValue, provider: null));
}
}
ICompressionProvider?selectedProvider = null;
if (candidates.Count <= 1)
{
selectedProvider = candidates.FirstOrDefault().Provider;
}
else
{
selectedProvider = candidates
.OrderByDescending(x => x.Quality)
.ThenBy(x => x.Priority)
.First().Provider;
}
if (selectedProvider == null)
{
// "identity" would match as a candidate but not have a provider implementation
_logger.NoCompressionProvider();
return(null);
}
_logger.CompressingWith(selectedProvider.EncodingName);
return(selectedProvider);
}
public void TestEquals(string content)
{
var segment = new StringSegment(content);
Assert.True(segment.Equals(segment));
}
public void StringSegment_Equals_String_Valid(StringSegment candidate, StringComparison comparison, bool expectedResult)
{
// Arrange
var segment = new StringSegment("Hello, World!", 1, 4);
// Act
var result = segment.Equals(candidate, comparison);
// Assert
Assert.Equal(expectedResult, result);
}
public void StringSegment_EqualsStringSegment_Invalid()
{
// Arrange
var segment = new StringSegment();
var candidate = new StringSegment("Hello, World!", 3, 2);
// Act
var result = segment.Equals(candidate, StringComparison.Ordinal);
// Assert
Assert.False(result);
}