public bool Authenticate(NameValueCollection requestHeaders, AddHeaderDelegate d, out HttpStatusCode statusCode) { if (requestHeaders["X-SecondLife-Shard"] != null) { statusCode = HttpStatusCode.Forbidden; return false; } statusCode = HttpStatusCode.OK; return true; }
public bool Authenticate(NameValueCollection requestHeaders, AddHeaderDelegate d, out HttpStatusCode statusCode) { foreach (IServiceAuth auth in m_authentications) { if (!auth.Authenticate(requestHeaders, d, out statusCode)) return false; } statusCode = HttpStatusCode.OK; return true; }
public bool Authenticate(NameValueCollection requestHeaders, AddHeaderDelegate d, out HttpStatusCode statusCode) { // Console.WriteLine("DisallowLlHttpRequest"); if (requestHeaders["X-SecondLife-Shard"] != null) { statusCode = HttpStatusCode.Forbidden; return false; } statusCode = HttpStatusCode.OK; return true; }
public static void ParseParameters (byte[] data, AddHeaderDelegate func, object userData) { int dataLength = data.Length; int offset = 0; int nlen, vlen; string name, value; //TODO: can encoding change? Encoding enc = Encoding.Default; while (offset < dataLength) { nlen = data [offset++]; if (nlen >= 0x80) { nlen = ((0x7F & nlen) * 0x1000000) + ((int)data [offset++]) * 0x10000 + ((int)data [offset++]) * 0x100 + ((int)data [offset++]); } vlen = data [offset++]; if (vlen >= 0x80) { vlen = ((0x7F & vlen) * 0x1000000) + ((int)data [offset++]) * 0x10000 + ((int)data [offset++]) * 0x100 + ((int)data [offset++]); } // Do a sanity check on the size of the data. if (offset + nlen + vlen > dataLength) throw new ArgumentOutOfRangeException ("offset"); name = enc.GetString (data, offset, nlen); offset += nlen; value = enc.GetString (data, offset, vlen); offset += vlen; string header = ReformatHttpHeader (name); bool isHeader = !String.IsNullOrEmpty (header); //return value 'false' means stop further processing if (!func (isHeader? header : name, value, isHeader, userData)) return; } }
public bool Authenticate(NameValueCollection requestHeaders, AddHeaderDelegate d) { //m_log.DebugFormat("[HTTP BASIC AUTH]: Authenticate in {0}", remove_me); if (requestHeaders != null) { string value = requestHeaders.Get("Authorization"); if (value != null) { value = value.Trim(); if (value.StartsWith("Basic ")) { value = value.Replace("Basic ", string.Empty); if (Authenticate(value)) return true; } } } d("WWW-Authenticate", "Basic realm = \"Asset Server\""); return false; }
public bool Authenticate(NameValueCollection requestHeaders, AddHeaderDelegate d) { //m_log.DebugFormat("[HTTP BASIC AUTH]: Authenticate in {0}", remove_me); if (requestHeaders != null) { string value = requestHeaders.Get("Authorization"); if (value != null) { value = value.Trim(); if (value.StartsWith("Basic ")) { value = value.Replace("Basic ", string.Empty); if (Authenticate(value)) { return(true); } } } } d("WWW-Authenticate", "Basic realm = \"Asset Server\""); return(false); }
public bool Authenticate(NameValueCollection requestHeaders, AddHeaderDelegate d, out HttpStatusCode statusCode) { // m_log.DebugFormat("[HTTP BASIC AUTH]: Authenticate in {0}", "BasicHttpAuthentication"); string value = requestHeaders.Get("Authorization"); if (value != null) { value = value.Trim(); if (value.StartsWith("Basic ")) { value = value.Replace("Basic ", string.Empty); if (Authenticate(value)) { statusCode = HttpStatusCode.OK; return true; } } } d("WWW-Authenticate", "Basic realm = \"OpenSim Server\""); statusCode = HttpStatusCode.Unauthorized; return false; }
/// <summary> /// Decode the header block into header fields. /// </summary> /// <param name="input">Input.</param> /// <param name="headerListener">Header listener.</param> public void Decode(BinaryReader input, AddHeaderDelegate addHeaderDelegate) { while(input.BaseStream.Length - input.BaseStream.Position > 0) { switch(this.state) { case State.READ_HEADER_REPRESENTATION: sbyte b = input.ReadSByte(); if (maxDynamicTableSizeChangeRequired && (b & 0xE0) != 0x20) { // Encoder MUST signal maximum dynamic table size change throw new IOException("max dynamic table size change required"); } if (b < 0) { // Indexed Header Field index = b & 0x7F; if (index == 0) { throw new IOException("illegal index value (" + index + ")"); } else if (index == 0x7F) { state = State.READ_INDEXED_HEADER; } else { this.IndexHeader(index, addHeaderDelegate); } } else if ((b & 0x40) == 0x40) { // Literal Header Field with Incremental Indexing indexType = HPackUtil.IndexType.INCREMENTAL; index = b & 0x3F; if (index == 0) { state = State.READ_LITERAL_HEADER_NAME_LENGTH_PREFIX; } else if (index == 0x3F) { state = State.READ_INDEXED_HEADER_NAME; } else { // Index was stored as the prefix this.ReadName(index); state = State.READ_LITERAL_HEADER_VALUE_LENGTH_PREFIX; } } else if ((b & 0x20) == 0x20) { // Dynamic Table Size Update index = b & 0x1F; if (index == 0x1F) { state = State.READ_MAX_DYNAMIC_TABLE_SIZE; } else { this.SetDynamicTableSize(index); state = State.READ_HEADER_REPRESENTATION; } } else { // Literal Header Field without Indexing / never Indexed indexType = ((b & 0x10) == 0x10) ? HPackUtil.IndexType.NEVER : HPackUtil.IndexType.NONE; index = b & 0x0F; if (index == 0) { state = State.READ_LITERAL_HEADER_NAME_LENGTH_PREFIX; } else if (index == 0x0F) { state = State.READ_INDEXED_HEADER_NAME; } else { // Index was stored as the prefix this.ReadName(index); state = State.READ_LITERAL_HEADER_VALUE_LENGTH_PREFIX; } } break; case State.READ_MAX_DYNAMIC_TABLE_SIZE: int maxSize = Decoder.DecodeULE128(input); if (maxSize == -1) { return; } // Check for numerical overflow if (maxSize > int.MaxValue - index) { throw DECOMPRESSION_EXCEPTION; } this.SetDynamicTableSize(index + maxSize); state = State.READ_HEADER_REPRESENTATION; break; case State.READ_INDEXED_HEADER: int headerIndex = Decoder.DecodeULE128(input); if (headerIndex == -1) { return; } // Check for numerical overflow if (headerIndex > int.MaxValue - index) { throw DECOMPRESSION_EXCEPTION; } this.IndexHeader(index + headerIndex, addHeaderDelegate); state = State.READ_HEADER_REPRESENTATION; break; case State.READ_INDEXED_HEADER_NAME: // Header Name matches an entry in the Header Table int nameIndex = Decoder.DecodeULE128(input); if (nameIndex == -1) { return; } // Check for numerical overflow if (nameIndex > int.MaxValue - index) { throw DECOMPRESSION_EXCEPTION; } this.ReadName(index + nameIndex); state = State.READ_LITERAL_HEADER_VALUE_LENGTH_PREFIX; break; case State.READ_LITERAL_HEADER_NAME_LENGTH_PREFIX: b = input.ReadSByte(); huffmanEncoded = (b & 0x80) == 0x80; index = b & 0x7F; if (index == 0x7f) { state = State.READ_LITERAL_HEADER_NAME_LENGTH; } else { nameLength = index; // Disallow empty names -- they cannot be represented in HTTP/1.x if (nameLength == 0) { throw DECOMPRESSION_EXCEPTION; } // Check name length against max header size if (this.ExceedsMaxHeaderSize(nameLength)) { if (indexType == HPackUtil.IndexType.NONE) { // Name is unused so skip bytes name = EMPTY; this.skipLength = nameLength; state = State.SKIP_LITERAL_HEADER_NAME; break; } // Check name length against max dynamic table size if (nameLength + HeaderField.HEADER_ENTRY_OVERHEAD > this.dynamicTable.Capacity) { this.dynamicTable.Clear(); name = EMPTY; this.skipLength = nameLength; state = State.SKIP_LITERAL_HEADER_NAME; break; } } state = State.READ_LITERAL_HEADER_NAME; } break; case State.READ_LITERAL_HEADER_NAME_LENGTH: // Header Name is a Literal String nameLength = Decoder.DecodeULE128(input); if (nameLength == -1) { return; } // Check for numerical overflow if (nameLength > int.MaxValue - index) { throw DECOMPRESSION_EXCEPTION; } nameLength += index; // Check name length against max header size if (this.ExceedsMaxHeaderSize(nameLength)) { if (indexType == HPackUtil.IndexType.NONE) { // Name is unused so skip bytes name = EMPTY; this.skipLength = nameLength; state = State.SKIP_LITERAL_HEADER_NAME; break; } // Check name length against max dynamic table size if (nameLength + HeaderField.HEADER_ENTRY_OVERHEAD > this.dynamicTable.Capacity) { this.dynamicTable.Clear(); name = EMPTY; this.skipLength = nameLength; state = State.SKIP_LITERAL_HEADER_NAME; break; } } state = State.READ_LITERAL_HEADER_NAME; break; case State.READ_LITERAL_HEADER_NAME: // Wait until entire name is readable if (input.BaseStream.Length - input.BaseStream.Position < nameLength) { return; } name = this.ReadStringLiteral(input, nameLength); state = State.READ_LITERAL_HEADER_VALUE_LENGTH_PREFIX; break; case State.SKIP_LITERAL_HEADER_NAME: this.skipLength -= (int)input.BaseStream.Seek(this.skipLength, SeekOrigin.Current); if (this.skipLength < 0) { this.skipLength = 0; } if (this.skipLength == 0) { state = State.READ_LITERAL_HEADER_VALUE_LENGTH_PREFIX; } break; case State.READ_LITERAL_HEADER_VALUE_LENGTH_PREFIX: b = input.ReadSByte(); huffmanEncoded = (b & 0x80) == 0x80; index = b & 0x7F; if (index == 0x7f) { state = State.READ_LITERAL_HEADER_VALUE_LENGTH; } else { this.valueLength = index; // Check new header size against max header size long newHeaderSize1 = (long)nameLength + (long)this.valueLength; if (this.ExceedsMaxHeaderSize(newHeaderSize1)) { // truncation will be reported during endHeaderBlock headerSize = maxHeaderSize + 1; if (indexType == HPackUtil.IndexType.NONE) { // Value is unused so skip bytes state = State.SKIP_LITERAL_HEADER_VALUE; break; } // Check new header size against max dynamic table size if (newHeaderSize1 + HeaderField.HEADER_ENTRY_OVERHEAD > this.dynamicTable.Capacity) { this.dynamicTable.Clear(); state = State.SKIP_LITERAL_HEADER_VALUE; break; } } if (this.valueLength == 0) { this.InsertHeader(addHeaderDelegate, name, EMPTY, indexType); state = State.READ_HEADER_REPRESENTATION; } else { state = State.READ_LITERAL_HEADER_VALUE; } } break; case State.READ_LITERAL_HEADER_VALUE_LENGTH: // Header Value is a Literal String this.valueLength = Decoder.DecodeULE128(input); if (this.valueLength == -1) { return; } // Check for numerical overflow if (this.valueLength > int.MaxValue - index) { throw DECOMPRESSION_EXCEPTION; } this.valueLength += index; // Check new header size against max header size long newHeaderSize2 = (long)nameLength + (long)this.valueLength; if (newHeaderSize2 + headerSize > maxHeaderSize) { // truncation will be reported during endHeaderBlock headerSize = maxHeaderSize + 1; if (indexType == HPackUtil.IndexType.NONE) { // Value is unused so skip bytes state = State.SKIP_LITERAL_HEADER_VALUE; break; } // Check new header size against max dynamic table size if (newHeaderSize2 + HeaderField.HEADER_ENTRY_OVERHEAD > this.dynamicTable.Capacity) { this.dynamicTable.Clear(); state = State.SKIP_LITERAL_HEADER_VALUE; break; } } state = State.READ_LITERAL_HEADER_VALUE; break; case State.READ_LITERAL_HEADER_VALUE: // Wait until entire value is readable if (input.BaseStream.Length - input.BaseStream.Position < this.valueLength) { return; } byte[] value = this.ReadStringLiteral(input, this.valueLength); this.InsertHeader(addHeaderDelegate, name, value, indexType); state = State.READ_HEADER_REPRESENTATION; break; case State.SKIP_LITERAL_HEADER_VALUE: this.valueLength -= (int)input.BaseStream.Seek(this.valueLength, SeekOrigin.Current); if (this.valueLength < 0) { this.valueLength = 0; } if (this.valueLength == 0) { state = State.READ_HEADER_REPRESENTATION; } break; default: throw new Exception("should not reach here"); } } }
private void AddHeader(AddHeaderDelegate addHeaderDelegate, byte[] name, byte[] value, bool sensitive) { if (name.Length == 0) { throw new ArgumentException("name is empty"); } long newSize = headerSize + name.Length + value.Length; if (newSize <= maxHeaderSize) { addHeaderDelegate (name, value, sensitive); headerSize = (int)newSize; } else { // truncation will be reported during endHeaderBlock headerSize = maxHeaderSize + 1; } }
private void InsertHeader(AddHeaderDelegate addHeaderDelegate, byte[] name, byte[] value, HPackUtil.IndexType indexType) { this.AddHeader(addHeaderDelegate, name, value, indexType == HPackUtil.IndexType.NEVER); switch(indexType) { case HPackUtil.IndexType.NONE: case HPackUtil.IndexType.NEVER: break; case HPackUtil.IndexType.INCREMENTAL: this.dynamicTable.Add(new HeaderField(name, value)); break; default: throw new Exception("should not reach here"); } }
private void IndexHeader(int index, AddHeaderDelegate addHeaderDelegate) { if (index <= StaticTable.Length) { HeaderField headerField = StaticTable.GetEntry(index); this.AddHeader(addHeaderDelegate, headerField.Name, headerField.Value, false); } else if (index - StaticTable.Length <= this.dynamicTable.Length()) { HeaderField headerField = this.dynamicTable.GetEntry(index - StaticTable.Length); this.AddHeader(addHeaderDelegate, headerField.Name, headerField.Value, false); } else { throw new IOException("illegal index value (" + index + ")"); } }
static void TryAddToCollection(AddHeaderDelegate addHeader, string headerName, string value) { try { addHeader(headerName, value); } catch (ArgumentException ex) { string encodedValue = null; if (TryEncodeHeaderValueAsUri(headerName, value, out encodedValue)) { //note: if the hosthame of a referer header contains illegal chars, we will still throw from here //because Uri will not fix this up for us, which is ok. The request will get rejected in the error code path. addHeader(headerName, encodedValue); } else { // In self-hosted scenarios, some of the headers like Content-Length cannot be added directly. // It will throw ArgumentException instead. FxTrace.Exception.AsInformation(ex); } } }
public static void CopyHeaders(NameValueCollection headers, AddHeaderDelegate addHeader) { //this nested loop logic was copied from NameValueCollection.Add(NameValueCollection) int count = headers.Count; for (int i = 0; i < count; i++) { string key = headers.GetKey(i); string[] values = headers.GetValues(i); if (values != null) { for (int j = 0; j < values.Length; j++) { TryAddToCollection(addHeader, key, values[j]); } } else { addHeader(key, null); } } }
static void CopyHeaders(HttpHeaders headers, AddHeaderDelegate addHeader) { foreach (KeyValuePair<string, IEnumerable<string>> header in headers) { foreach (string value in header.Value) { TryAddToCollection(addHeader, header.Key, value); } } }
public static void CopyHeaders(HttpResponseMessage response, AddHeaderDelegate addHeader) { HttpChannelUtilities.CopyHeaders(response.Headers, addHeader); if (response.Content != null) { HttpChannelUtilities.CopyHeaders(response.Content.Headers, addHeader); } }