public void HttpReadLine_Breaked()
{
var l7Conversation = this.ReassembleSingleL7Conversation <TcpConversationTracker>(TestPcapFile.HttpTest0);
var stream = new PduDataStream(l7Conversation, PduDataProviderType.Breaked);
var pduStreamReader = new PduStreamReader(stream, Encoding.ASCII);
Assert.False(pduStreamReader.EndOfStream);
Assert.Equal("GET / HTTP/1.1", pduStreamReader.ReadLine());
Assert.Equal("Host: icanhazip.com", pduStreamReader.ReadLine());
Assert.Equal("User-Agent: curl/7.54.0", pduStreamReader.ReadLine());
Assert.Equal("Accept: */*", pduStreamReader.ReadLine());
Assert.Equal("", pduStreamReader.ReadLine());
Assert.True(pduStreamReader.EndOfStream);
Assert.True(pduStreamReader.NewMessage());
Assert.False(pduStreamReader.EndOfStream);
var s = pduStreamReader.ReadToEnd();
Assert.Equal(597, s.Length);
Assert.StartsWith("HTTP/1.1 200 OK", s);
Assert.EndsWith("147.229.14.29\n", s);
Assert.True(pduStreamReader.EndOfStream);
}
private Byte[] ReadChunk(PduStreamReader reader)
{
var chunkSizeLine = reader.ReadLine()?.Trim();
if (chunkSizeLine == null)
{
return(null);
}
var chunkSize = Convert.ToInt32(chunkSizeLine, 16);
if (chunkSize == 0)
{
return(null);
}
var chunkBuffer = new Byte[chunkSize];
var readTotal = 0;
do
{
var read = reader.Read(chunkBuffer, readTotal, chunkSize - readTotal);
if (read == 0)
{
return(null);
}
readTotal += read;
} while(readTotal < chunkSize);
if (reader.ReadLine() == null)
{
return(null);
}
return(chunkBuffer);
}
protected override IPduReader CreatePduReader()
{
var pduDataStream = new PduDataStream(this.CurrentL7Conversation, PduDataProviderType.Breaked);
var pduStreamReader = new PduStreamReader(pduDataStream);
return(pduStreamReader);
}
private void ParseTransferChunked(PduStreamReader reader)
{
var chunks = new List <Byte[]>();
while (true)
{
var chunk = ReadChunk(reader);
if (chunk == null)
{
break;
}
chunks.Add(chunk);
}
var totalContentSize = chunks.Select(chunk => chunk.Length).Sum();
this.Payload = new Byte[totalContentSize];
var writtenBytes = 0;
foreach (var chunk in chunks)
{
chunk.CopyTo(this.Payload, writtenBytes);
writtenBytes += chunk.Length;
}
}
public HttpHeaderResponse(PduStreamReader reader, String headerLine)
{
var headerLineComponents = headerLine.Split(' ');
this.Version = headerLineComponents[0];
this.StatusCode = Convert.ToInt16(headerLineComponents[1]);
this.StatusMessage = String.Join(" ", headerLineComponents.Skip(2));
this.ParseHeaderValues(reader);
}
public HttpHeaderRequest(PduStreamReader reader, String headerLine, HttpRequestMethod method)
{
this.Method = method;
var headerLineComponents = headerLine.Split(' ');
this.RequestUri = headerLineComponents[1];
this.Version = headerLineComponents[2];
this.ParseHeaderValues(reader);
}
public HttpMessage(PduStreamReader reader) : base(reader)
{
try
{
this.Parse(reader);
}
catch (HttpParsingException e)
{
this.ParsingError = e;
}
}
private void ParseTransferHttp1(PduStreamReader reader)
{
var payloadBuffer = new List <Byte>();
var buffer = new Byte[4096];
while ((reader.Read(buffer, 0, buffer.Length)) > 0)
{
payloadBuffer.AddRange(buffer);
}
this.Payload = payloadBuffer.ToArray();
}
private void Parse(PduStreamReader reader)
{
if (!this.ParseHeader(reader))
{
return;
}
if (this.IsProbeRequest())
{
return;
}
this.ParseContent(reader);
}
private Boolean ParseHeader(PduStreamReader reader)
{
var headerLine = reader.ReadLine();
if (headerLine == null)
{
this.ParsingError = new HttpParsingException("Nothing to read");
return(false);
}
if (Enum.TryParse(headerLine.Split(' ').FirstOrDefault(), true, out HttpRequestMethod httpRequestMethod))
{
// HTTP Request
this.Header = new HttpHeaderRequest(reader, headerLine, httpRequestMethod);
}
else if (headerLine.StartsWith("HTTP"))
{
// HTTP Response
this.Header = new HttpHeaderResponse(reader, headerLine);
}
else
{
this.ParsingError = new HttpParsingException("Not a HTTP message");
return(false);
}
switch (this.Header)
{
case HttpHeaderRequest _:
this.Type = HttpMessageType.Request;
break;
case HttpHeaderResponse _:
this.Type = HttpMessageType.Response;
break;
default:
this.Type = HttpMessageType.None;
break;
}
return(true);
}
private Boolean ParseContent(PduStreamReader reader)
{
TransferEncoding transferEncoding;
if (this.Header.HttpVersion.Equals("HTTP/1.0"))
{
transferEncoding = TransferEncoding.Http1Transfer;
}
else
{
var transferEncodingStr = this.Header.GetLastHeaderFieldValue("Transfer-Encoding", "identity");
if (!Enum.TryParse(transferEncodingStr, true, out transferEncoding))
{
this.ParsingError = new HttpParsingException($"Unknown TransferEncoding: {transferEncodingStr}");
return(false);
}
}
var contentEncodingStr = this.Header.GetLastHeaderFieldValue("Content-Encoding", "identity");
if (!Enum.TryParse(contentEncodingStr, true, out ContentEncoding contentEncoding))
{
this.ParsingError = new HttpParsingException($"Unknown ContentEncoding: {contentEncodingStr}");
return(false);
}
Int32?contentLength = null;
var contentLengthStr = this.Header.GetLastHeaderFieldValue("Content-Length");
if (contentLengthStr != null)
{
if (!Int32.TryParse(contentLengthStr, out var contentLengthVal))
{
this.ParsingError = new HttpParsingException($"Failed to parse ContentLength: {contentLengthStr}");
return(false);
}
contentLength = contentLengthVal;
}
this.Content = new HttpContent(reader, transferEncoding, contentLength, contentEncoding);
return(true);
}
private void ParseTransfer(PduStreamReader reader, TransferEncoding transferEncoding, Int32?contentLength)
{
switch (transferEncoding)
{
case TransferEncoding.Identity:
this.ParseTransferIdentity(reader, contentLength ?? 0);
break;
case TransferEncoding.Chunked:
this.ParseTransferChunked(reader);
break;
case TransferEncoding.Http1Transfer:
this.ParseTransferHttp1(reader);
break;
default:
throw new HttpParsingException($"Unsupported TransferEncoding: {transferEncoding}");
}
}
protected void ParseHeaderValues(PduStreamReader reader)
{
String line;
while ((line = reader.ReadLine()) != null && line != "")
{
var fieldNameIndex = line.IndexOf(':');
var fieldName = line.Substring(0, fieldNameIndex).ToLower();
var fieldValue = line.Substring(fieldNameIndex + 1, line.Length - fieldName.Length - 1).Trim().ToLower();
if (this.Fields.ContainsKey(fieldName))
{
this.Fields[fieldName].Add(fieldValue);
}
else
{
this.Fields[fieldName] = new List <String> {
fieldValue
};
}
}
}
private void ParseTransferIdentity(PduStreamReader reader, Int32 contentLength)
{
this.Payload = new Byte[contentLength];
if (contentLength == 0)
{
return;
}
var readTotal = 0;
Int32 read;
do
{
read = reader.Read(this.Payload, readTotal, contentLength - readTotal);
readTotal += read;
} while (readTotal < contentLength && read != 0);
if (contentLength != readTotal)
{
this.PayloadIncomplete = true;
}
}
public HttpContent(PduStreamReader reader, TransferEncoding transferEncoding, Int32?contentLength, ContentEncoding contentEncoding)
{
this.ParseTransfer(reader, transferEncoding, contentLength);
this.DecodeContent(contentEncoding);
}
public void AddContentToProbingRequest(PduStreamReader reader)
{
this.ParseContent(reader);
}
