public string BuildStringToAppend(HeaderName header)
{
if (header == HeaderName.Empty)
{
throw new ValidationException("An empty header name was specified.");
}
switch (header)
{
case string str when str == HeaderName.PredefinedHeaderNames.RequestTarget:
return(_requestTargetHeaderAppender.BuildStringToAppend(header));
case string str when str == HeaderName.PredefinedHeaderNames.Created:
return(_createdHeaderAppender.BuildStringToAppend(header));
case string str when str == HeaderName.PredefinedHeaderNames.Expires:
return(_expiresHeaderAppender.BuildStringToAppend(header));
case string str when str == HeaderName.PredefinedHeaderNames.Date:
return(_dateHeaderAppender.BuildStringToAppend(header));
default:
return(_defaultHeaderAppender.BuildStringToAppend(header));
}
}
public bool ParseEnd(AsfParser parser, bool ignoreReadOverflow)
{
if (!ignoreReadOverflow && parser.ReadOverflow)
{
Valid = false;
return(false);
}
if (!HeaderName.IsFlagSet(ObjectFlags.ContainerObject))
{
// Objects extending beyond the end of the file are considered invalid
if (RelativeEndOffset > (ulong)parser.Length)
{
Valid = false;
return(false);
}
// Record unparsed bytes statistic
ulong endOffset = Math.Min(RelativeEndOffset, (ulong)parser.Length);
if ((ulong)parser.Position < endOffset)
{
UnparsedBytes = endOffset - (ulong)parser.Position;
parser.GetHexDump(Attribute.AdditionalData, (int)UnparsedBytes);
}
}
if (!ignoreReadOverflow && (!Valid || (ulong)parser.Position > RelativeEndOffset))
{
return(false);
}
return(base.ParseEnd(parser));
}
public override bool Parse(QtParser parser)
{
if (!base.Parse(parser))
{
return(false);
}
if (HeaderName.IsFlagSet(AtomFlags.SizeAndType))
{
Size = parser.GetUInt(Attribute.Size);
uint type = parser.GetFourCC(Attribute.Type);
if (Size == 1)
{
// 64-bit size atom
Size = (long)parser.GetULong(Attribute.Size);
}
}
if (HeaderName.IsFlagSet(AtomFlags.VersionAndFlags))
{
parser.GetByte(Attribute.Version);
ParseFlags(parser);
}
return(Valid);
}
public override bool IsSuitableParent(Mpeg4Header parent)
{
// Header is allowed in its suitable parent (correct files)
if (HeaderName.GetSuitableParents().Contains(parent.HeaderName))
{
return(true);
}
// Header ends up in the root if no suitable parent was found (partial files)
if (!parent.IsRoot)
{
return(false);
}
// Atoms of partial files are allowed in the root if empty
if (!parent.HasChildren())
{
return(true);
}
// Root should not already contain top-level atoms (FileType, MediaData or Movie)
// Otherwise, the top-level parent of this header should have been in the root as well
foreach (Mpeg4Header header in parent.Children)
{
if (header.HeaderName.IsTopLevel())
{
return(false);
}
}
return(true);
}
/// <summary>
/// Parse the AVIHeader.
/// </summary>
public override bool Parse(AviParser parser)
{
if (!base.Parse(parser))
{
return(false);
}
if (HeaderName.IsFlagSet(ChunkFlags.SizeAndType))
{
// Parse the type and size of the header.
parser.GetFourCC(Attribute.Type);
Size = (uint)parser.GetInt(Attribute.Size);
// 3GPP only
//if (_size == 1)
//{
// // 64-bit size chunk
// parser.GetULong(Attribute.Size);
//}
}
// 3GPP only
//if (HeaderName.IsFlagSet(ChunkFlags.VersionAndFlags))
//{
// parser.GetByte(Attribute.Version);
// ParseFlags(parser);
//}
return(this.Valid);
}
public string BuildStringToAppend(HeaderName header)
{
var path = _request.RequestUri;
return("\n" + new Header(
HeaderName.PredefinedHeaderNames.RequestTarget,
$"{_request.Method.Method.ToLowerInvariant()} {path}"));
}
private static HeaderName[] AppendHeaderName(HeaderName[] headerNames, HeaderName toAppend)
{
var result = new HeaderName[headerNames.Length + 1];
headerNames.CopyTo(result, 0);
result[headerNames.Length] = toAppend;
return(result);
}
public string BuildStringToAppend(HeaderName header)
{
var isPresent = _request.Headers.TryGetValues(header, out var headerValues);
return(isPresent
? "\n" + new Header(header, headerValues.Select(SanitizeHeaderValue).ToArray())
: string.Empty);
}
public string BuildStringToAppend(HeaderName header)
{
if (!_timeOfComposing.HasValue)
{
return(string.Empty);
}
var createdValue = _timeOfComposing.Value.ToUnixTimeSeconds();
return("\n" + new Header(HeaderName.PredefinedHeaderNames.Created, createdValue.ToString()));
}
public string BuildStringToAppend(HeaderName header)
{
var path = _request.RequestUri.OriginalString == "*"
? _request.RequestUri.OriginalString
: _requestTargetEscaper.Escape(_request.RequestUri, _requestTargetEscaping);
return("\n" + new Header(
HeaderName.PredefinedHeaderNames.RequestTarget,
$"{_request.Method.Method.ToLowerInvariant()} {path}"));
}
public string this[HeaderName header]
{
get
{
string value;
_headers.TryGetValue(header, out value);
return value;
}
set { _headers[header] = value; }
}
public bool ChangePad(HeaderName variable, int padSize)
{
if (Pads.ContainsKey(variable))
{
Pads.Remove(variable);
Pads.Add(variable, padSize);
return(true);
}
return(false);
}
public string BuildStringToAppend(HeaderName header)
{
var isPresent = _request.Headers.TryGetValues(header, out var headerValues);
if (!isPresent)
{
throw new HttpMessageSigningException($"Header '{header}' was required to create the signature, but does not exist on the request message to sign.");
}
return("\n" + new Header(header, headerValues.Select(SanitizeHeaderValue).ToArray()));
}
public string BuildStringToAppend(HeaderName header)
{
if (AlgorithmNamesThatDoNotAllowExpiresHeader.Contains(_signatureAlgorithmName, StringComparer.OrdinalIgnoreCase))
{
throw new HttpMessageSigningException($"It is not allowed to include the {HeaderName.PredefinedHeaderNames.Expires} header in the signature, when the signature algorithm is '{_signatureAlgorithmName}'.");
}
var expiresValue = _timeOfComposing.Add(_expires).ToUnixTimeSeconds();
return("\n" + new Header(HeaderName.PredefinedHeaderNames.Expires, expiresValue.ToString()));
}
public string BuildStringToAppend(HeaderName header)
{
if (AlgorithmNamesThatDoNotAllowCreatedHeader.Contains(_signatureAlgorithmName, StringComparer.OrdinalIgnoreCase))
{
throw new HttpMessageSigningException($"It is not allowed to include the {HeaderName.PredefinedHeaderNames.Created} header in the signature, when the signature algorithm is '{_signatureAlgorithmName}'.");
}
// ReSharper disable once PossiblyImpureMethodCallOnReadonlyVariable
var createdValue = _timeOfComposing.ToUnixTimeSeconds();
return("\n" + new Header(HeaderName.PredefinedHeaderNames.Created, createdValue.ToString()));
}
public override bool Parse(Mpeg4Parser parser)
{
if (!base.Parse(parser))
{
return(false);
}
if (HeaderName.IsFlagSet(HeaderFlags.StartCode))
{
StartCode = parser.GetStartCode(Attribute.StartCode, this is VopWithShortHeader);
}
return(this.Valid);
}
public string BuildStringToAppend(HeaderName header)
{
if (!_expires.HasValue)
{
return(string.Empty);
}
if (!_timeOfComposing.HasValue)
{
return(string.Empty);
}
var expiresValue = _timeOfComposing.Value.Add(_expires.Value).ToUnixTimeSeconds();
return("\n" + new Header(HeaderName.PredefinedHeaderNames.Expires, expiresValue.ToString()));
}
public string BuildStringToAppend(HeaderName header)
{
var dateValues = _request.Headers[HeaderName.PredefinedHeaderNames.Date];
if (dateValues == StringValues.Empty)
{
return(string.Empty);
}
if (!DateTimeOffset.TryParseExact(dateValues.First(), "R", CultureInfo.InvariantCulture, DateTimeStyles.None, out var dateValue))
{
return(string.Empty);
}
return("\n" + new Header(HeaderName.PredefinedHeaderNames.Date, dateValue.ToString("R")));
}
public override bool IsSuitableParent(AsfObject parent)
{
if (!parent.IsRoot)
{
// Should fit in parent object
if (Offset < parent.Offset || RelativeEndOffset > parent.RelativeEndOffset)
{
return(false);
}
}
// First object should not be unknown
if (IsUnknown && parent.IsRoot && !parent.HasChildren())
{
return(false);
}
// ASF object should have no duplicates in its parent if DuplicatesAllowed is false
if (!HeaderName.IsFlagSet(ObjectFlags.DuplicatesAllowed) && parent.HasChild(HeaderName))
{
// ASF object of partial files may end up in the root
// Therefore, duplicates are allowed, except for top-level atoms
if (!parent.IsRoot || HeaderName.IsTopLevel())
{
return(false);
}
}
// Header object is always the first object
if (HeaderName == AsfObjectName.HeaderObject && parent.HasChildren())
{
return(false);
}
// Object is allowed in its suitable parent (correct files)
if (HeaderName.GetSuitableParents().Contains(parent.HeaderName))
{
return(true);
}
// Object ends up in the root if no suitable parent was found (partial files)
if (!parent.IsRoot)
{
return(false);
}
return(true);
}
private void AddHeaderClick(object sender, EventArgs e)
{
_configuration.Columns.Add(new DataStoreColumn
{
Alignment = AlignmentLeft.Checked ? ColumnAlignment.Left : ColumnAlignment.Right,
Length = (int)HeaderLength.Value,
Name = HeaderName.Text,
PaddingCharacter = PadCharacter.Text.Length > 0 ? PadCharacter.Text.First() : ' ',
Source = string.Empty
});
HeaderName.Clear();
HeaderLength.Value = 0;
PadCharacter.Text = string.Empty;
ApplyConfiguration();
}
private static T DeserializeLineToObjectOfType <T>(List <string> headers, string line, char separator) where T : new()
{
string[] lineSplit = line.Split(separator);
Dictionary <string, string> columnsNames = new Dictionary <string, string>();
T newObj;
for (int i = 0; i < lineSplit.Length; i++)
{
columnsNames.Add(headers[i], lineSplit[i]);
}
try
{
PropertyInfo[] properties = typeof(T).GetProperties();
newObj = new T();
foreach (string header in headers)
{
for (int i = 0; i < properties.Length; i++)
{
HeaderName headerNameAttribute = null;
string propertyName = properties[i].Name;
headerNameAttribute = properties[i].GetCustomAttribute <HeaderName>();
if (headerNameAttribute != null)
{
propertyName = headerNameAttribute.Name;
}
if (propertyName.Equals(header))
{
SetValueInProperty(columnsNames, properties[i], headerNameAttribute, header, newObj);
break;
}
}
}
}
catch (Exception e)
{
throw e;
}
return(newObj);
}
/// <summary>
/// Returns a sanitized version of the specified <paramref name="headers"/>
/// </summary>
/// <param name="headers">The headers to sanitize</param>
/// <returns>Returns the specified <paramref name="headers"/> with sensitive information
/// removed</returns>
public static IMessageHeaders Sanitize(this IMessageHeaders headers)
{
if (headers == null)
{
throw new ArgumentNullException(nameof(headers));
}
var authorizationHeader = HttpRequestHeader.Authorization.ToString("G");
var platibusSecurityTokenHeader = HeaderName.SecurityToken;
var sensitiveHeaderNames = new HeaderName[]
{
authorizationHeader,
platibusSecurityTokenHeader
};
var sanitizedHeaders = headers
.Where(h => !sensitiveHeaderNames.Contains(h.Key));
return(new MessageHeaders(sanitizedHeaders));
}
/// <summary>Parse the ASF object</summary>
public override bool Parse(AsfParser parser)
{
if (!base.Parse(parser))
{
return(false);
}
if (HeaderName.IsFlagSet(ObjectFlags.SizeAndType))
{
// Parse the type and size of the object.
parser.GetGuid(Attribute.Type);
Size = (ulong)parser.GetLong(Attribute.Size);
}
if (!HeaderName.IsFlagSet(ObjectFlags.Container) && Size > MaxUnparsedBytes)
{
return(false);
}
return(Valid);
}
public override bool ParseEnd(QtParser parser)
{
if (parser.ReadOverflow)
{
Valid = false;
return(false);
}
if (!HeaderName.IsFlagSet(AtomFlags.Container))
{
// Atoms extending beyond the end of the file are considered invalid
if (RelativeEndOffset > parser.Length)
{
Valid = false;
if (HeaderName == AtomName.MediaData)
{
// 'mdat' block may be truncated in the initial scan!
parser.Position = parser.Length;
return(base.ParseEnd(parser));
}
return(false);
}
// Record unparsed bytes statistic
long endOffset = Math.Min(RelativeEndOffset, parser.Length);
if (parser.Position < endOffset)
{
_unparsedBytes = endOffset - parser.Position;
parser.GetHexDump(Attribute.AdditionalData, (int)_unparsedBytes);
}
}
if (!Valid || (parser.Position > RelativeEndOffset))
{
return(false);
}
return(base.ParseEnd(parser));
}
public override Response GetResponse(ParameterInfo paramInfo, HttpApplication httpApp)
{
var response = base.GetResponse(paramInfo, httpApp);
response.Headers = HeaderName.PairWithValue(HeaderValue).AsArray();
if (paramInfo.ParameterType.IsSubClassOfGeneric(typeof(CreatedBodyResponse <>)))
{
response.Example = Parameter.GetTypeName(paramInfo.ParameterType.GenericTypeArguments.First(), httpApp);
return(response);
}
if (paramInfo.ParameterType.IsSubClassOfGeneric(typeof(CreatedBodyResponse <>)))
{
response.Example = Parameter.GetTypeName(paramInfo.ParameterType.GenericTypeArguments.First(), httpApp);
return(response);
}
if (paramInfo.ParameterType.IsSubClassOfGeneric(typeof(MultipartAsyncResponse <>)))
{
var typeName = Parameter.GetTypeName(paramInfo.ParameterType.GenericTypeArguments.First(), httpApp);
response.Example = $"{typeName}[]";
return(response);
}
return(response);
}
public override bool ParseEnd(AviParser parser)
{
if (parser.ReadOverflow)
{
this.Valid = false;
return(false);
}
if (!HeaderName.IsFlagSet(ChunkFlags.ContainerChunk))
{
// Chunks extending beyond the end of the file are considered invalid
if (RelativeEndOffset > (ulong)parser.Length)
{
this.Valid = false;
return(false);
}
// Record unparsed bytes statistic
ulong endOffset = Math.Min(RelativeEndOffset, (ulong)parser.Length);
if ((ulong)parser.Position < endOffset)
{
UnparsedBytes = endOffset - (ulong)parser.Position;
if (!HeaderName.IsFlagSet(ChunkFlags.Container) && (UnparsedBytes > MaxUnparsedBytes))
{
return(false);
}
parser.GetHexDump(Attribute.AdditionalData, (int)UnparsedBytes);
}
}
if (!this.Valid || (ulong)parser.Position > RelativeEndOffset)
{
return(false);
}
return(base.ParseEnd(parser));
}
/// <summary>
/// 数据包头信息转换Byte数组
/// </summary>
/// <param name="dataAllSize">数据包总长度</param>
/// <param name="dataBytes">数据包数据信息</param>
public void Operation(int dataAllSize, byte[] dataBytes)
{
_dataPackage = new byte[dataAllSize];
var size = BitConverter.GetBytes(dataAllSize);
var version = BitConverter.GetBytes(Version);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(size);
}
_dataPackage[0] = size[0];
_dataPackage[1] = size[1];
_dataPackage[2] = size[2];
_dataPackage[3] = size[3];
var chars = HeaderName.ToCharArray();
for (int i = 0; i < chars.Length; i++)
{
_dataPackage[4 + i] = Convert.ToByte(chars[i]);
}
_dataPackage[8] = version[0];
_dataPackage[9] = Convert.ToByte(0);
dataBytes.CopyTo(_dataPackage, HeaderLength);
}
public void Add(HeaderName headerName, string value)
{
this[headerName] = value;
}
public void SetUri(HeaderName headerName, Uri uri)
{
this[headerName] = uri == null ? null : uri.AbsoluteUri;
}
bool IsA404(Request Req, Response Res)
{
Response NotFoundResponse = null;
lock (NotFoundSignatures)
{
if (NotFoundSignatures.ContainsKey(Req.SSL.ToString() + Req.Host + Req.UrlDir + Req.File))
{
NotFoundResponse = NotFoundSignatures[Req.SSL.ToString() + Req.Host + Req.UrlDir + Req.File];
}
}
if (NotFoundResponse == null)
{
Request NotFoundGetter = Req.GetClone();
NotFoundGetter.Method = "GET";
NotFoundGetter.Body.RemoveAll();
if (Req.File.Length > 0)
{
NotFoundGetter.Url = NotFoundGetter.UrlDir + "should_not_xist_" + Tools.GetRandomString(10, 15) + "." + Req.File;
}
else
{
NotFoundGetter.Url = NotFoundGetter.UrlDir + "should_not_xist_" + Tools.GetRandomString(10, 15);
}
NotFoundResponse = NotFoundGetter.Send();
if (Stopped)
{
return(true);
}
NotFoundResponse.BodyString = "";
List <string> HeaderNames = NotFoundResponse.Headers.GetNames();
foreach (string HeaderName in HeaderNames)
{
if (!HeaderName.Equals("Location"))
{
NotFoundResponse.Headers.Remove(HeaderName);
}
}
NotFoundResponse.Flags.Add("Url", NotFoundGetter.Url);
lock (NotFoundSignatures)
{
if (!NotFoundSignatures.ContainsKey(Req.SSL.ToString() + Req.Host + Req.UrlDir + Req.File))
{
NotFoundSignatures.Add(Req.SSL.ToString() + Req.Host + Req.UrlDir + Req.File, NotFoundResponse);
}
}
}
if (Res.Code == 200 && NotFoundResponse.Code != 200)
{
return(false);
}
if (Res.Code == 404)
{
return(true);
}
if (Res.Code > 400)
{
if (NotFoundResponse.Code == Res.Code)
{
return(true);
}
else
{
return(false);
}
}
string NotFoundGetterUrl = NotFoundResponse.Flags["Url"].ToString();
if (Res.Code == 301 || Res.Code == 302 || Res.Code == 303 || Res.Code == 307)
{
string RedirectedUrl = Res.Headers.Get("Location");
if (NotFoundResponse.Code == 301 || NotFoundResponse.Code == 302 || NotFoundResponse.Code == 303 || NotFoundResponse.Code == 307)
{
string NotFoundRedirectedUrl = NotFoundResponse.Headers.Get("Location");
if (RedirectedUrl.ToLower().Equals(NotFoundRedirectedUrl.ToLower()))
{
return(true);
}
else if (Regex.IsMatch(RedirectedUrl, @".*not\Wfound.*", RegexOptions.IgnoreCase))
{
return(true);
}
else if (NotFoundRedirectedUrl.Replace(NotFoundGetterUrl, "").Equals(RedirectedUrl.Replace(Req.Url, "")))
{
return(true);
}
else
{
Request RedirectedLocationReq;
if (RedirectedUrl.StartsWith("http://") || RedirectedUrl.StartsWith("https://"))
{
RedirectedLocationReq = new Request(RedirectedUrl);
}
else if (RedirectedUrl.StartsWith("/"))
{
RedirectedLocationReq = Req.GetClone();
RedirectedLocationReq.Url = RedirectedUrl;
}
else
{
return(true);
}
Request NotFoundRedirectedLocationReq;
if (NotFoundRedirectedUrl.StartsWith("http://") || NotFoundRedirectedUrl.StartsWith("https://"))
{
NotFoundRedirectedLocationReq = new Request(NotFoundRedirectedUrl);
}
else if (NotFoundRedirectedUrl.StartsWith("/"))
{
NotFoundRedirectedLocationReq = Req.GetClone();
NotFoundRedirectedLocationReq.Url = NotFoundRedirectedUrl;
}
else
{
return(false);
}
if (RedirectedLocationReq.Url.Equals(NotFoundRedirectedLocationReq.Url))
{
return(true);
}
}
}
else
{
return(false);
}
}
return(false);
}
/// <summary>
/// Add header to the JWT.
/// </summary>
/// <param name="name">Well-known header name</param>
/// <param name="value">The value you want give to the header</param>
/// <returns>Current builder instance</returns>
public JwtBuilder AddHeader(HeaderName name, object value)
{
_jwt.Header.Add(name.GetHeaderName(), value);
return(this);
}
public BuildStringToAppend()
{
_headerName = new HeaderName("Dalion-test");
}
/// <summary> /// Gets the string representation of a well-known header name enum /// </summary> public static string GetHeaderName(this HeaderName value) => GetDescription(value);
public void SetInt(HeaderName headerName, int intValue)
{
this[headerName] = intValue.ToString("d");
}
public DateTime? GetDateTime(HeaderName headerName)
{
var value = this[headerName];
if (!string.IsNullOrWhiteSpace(value))
{
return DateTime.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal);
}
return null;
}
public Uri GetUri(HeaderName headerName)
{
var value = this[headerName];
if (!string.IsNullOrWhiteSpace(value))
{
return new Uri(value, UriKind.Absolute);
}
return null;
}
public void SetDateTime(HeaderName headerName, DateTime? dateTime)
{
this[HeaderName.Sent] = dateTime == null
? null
: dateTime.Value.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture);
}
public int GetInt(HeaderName headerName)
{
int intValue;
var value = this[headerName];
if (!string.IsNullOrWhiteSpace(value) && int.TryParse(value, out intValue))
{
return intValue;
}
return 0;
}
