public RequestSequenceViewModel(RequestSequenceEntity entity)
{
id = entity.id;
request_count = entity.request_count;
substitution_count = entity.substitution_count;
run_id = entity.run_id;
next_id = entity.next_id;
prev_id = entity.prev_id;
// Used to enable debug metadata.
ShowMetadata = false;
Requests = new List <RequestViewModel>();
Responses = new List <ResponseViewModel>();
Substitutions = new List <List <SubstitutionViewModel> >();
Labels = new List <RequestSequenceLabelViewModel>();
Metadata = new List <SequenceMetadataViewModel>();
}
private async Task <RequestSequenceViewModel> GetFullSequence(int id)
{
RequestSequenceEntity sequence = await _endpointRepository.GetRequestSequenceById(id);
List <RequestEntity> requests = await _endpointRepository.GetExecutedRequestsBySequence(id);
List <ResponseEntity> responses = await _endpointRepository.GetResponsesBySequence(id);
List <SubstitutionEntity> substitutions = await _endpointRepository.GetSubstitutionsBySequence(id);
List <RequestSequenceLabelEntity> labels = await _endpointRepository.GetRequestSequenceLabelsBySequence(id);
requests.Sort(delegate(RequestEntity left, RequestEntity right)
{
return(left.sequence_position - right.sequence_position ?? 0);
});
responses.Sort(delegate(ResponseEntity left, ResponseEntity right)
{
return(left.sequence_position - right.sequence_position ?? 0);
});
RequestSequenceViewModel sequenceViewModel = new RequestSequenceViewModel(sequence);
foreach (RequestEntity entity in requests)
{
var model = new RequestViewModel(entity);
model.Sequence = sequenceViewModel;
sequenceViewModel.Requests.Add(model);
}
foreach (ResponseEntity entity in responses)
{
var model = new ResponseViewModel(entity);
model.Sequence = sequenceViewModel;
sequenceViewModel.Responses.Add(model);
}
// Add labels
foreach (RequestSequenceLabelEntity label in labels)
{
sequenceViewModel.Labels.Add(new RequestSequenceLabelViewModel(label));
}
// Split substitutions.
List <List <SubstitutionViewModel> > substitutionsGrouped = new List <List <SubstitutionViewModel> >();
for (int i = 0; i < sequence.request_count; ++i)
{
List <SubstitutionViewModel> stage = new List <SubstitutionViewModel>();
foreach (SubstitutionEntity entity in substitutions)
{
if (entity.sequence_position == i)
{
var model = new SubstitutionViewModel(entity);
model.Sequence = sequenceViewModel;
stage.Add(model);
}
}
sequenceViewModel.Substitutions.Add(stage);
}
if (_configuration.GetValue <bool>("ShowDebugMetadata", false))
{
List <SequenceMetadataEntity> metadataEntities = await _endpointRepository.GetSequenceMetadata(id);
foreach (SequenceMetadataEntity entity in metadataEntities)
{
sequenceViewModel.Metadata.Add(new SequenceMetadataViewModel(entity));
}
sequenceViewModel.ShowMetadata = true;
}
return(sequenceViewModel);
}
public async Task AddRequestSequence(RequestSequence sequence, FuzzerRunEntity run)
{
RequestSequenceEntity model = new RequestSequenceEntity();
model.request_count = sequence.StageCount();
model.substitution_count = sequence.SubstitutionCount();
model.run_id = run.id.GetValueOrDefault(0);
using (var connection = GetConnection())
{
connection.Open();
model.id = connection.Query <int>(
@"INSERT INTO sequences
( request_count, substitution_count, run_id ) VALUES
( @request_count, @substitution_count, @run_id )
RETURNING id;", model).First();
foreach (SequenceMetadata meta in sequence.GetDebugMetadata())
{
SequenceMetadataEntity metadata_entity =
new SequenceMetadataEntity {
sequence_id = model.id, content = meta.Content, type = meta.Type
};
connection.Execute(@"INSERT INTO sequence_metadata
( sequence_id, type, content ) VALUES
( @sequence_id, @type, @content );", metadata_entity);
}
}
sequence.Id = model.id;
List <Response>?results = sequence.GetResponses();
if (results != null && results.Count == sequence.StageCount())
{
for (int i = 0; i < sequence.StageCount(); ++i)
{
Request request = sequence.Get(i).Request;
RequestEntity requestModel = RequestEntity.FromRequest(request);
requestModel.sequence_id = model.id;
requestModel.sequence_position = i;
AddExecutedRequest(requestModel);
request.Id = requestModel.id;
Response response = results[i];
ResponseEntity responseModel = ResponseEntity.FromResponse(response);
responseModel.sequence_id = model.id;
responseModel.sequence_position = i;
AddResponse(responseModel);
response.Id = responseModel.id;
foreach (ISubstitution sub in sequence.Get(i).Substitutions)
{
SubstitutionEntity subModel = SubstitutionEntity.FromSubstitution(sub);
subModel.sequence_id = model.id;
subModel.sequence_position = i;
AddSubstitution(subModel);
}
}
if (sequence.GetLastResponse() != null)
{
int statusCode = (int)sequence.GetLastResponse().Status;
RequestSequenceLabelEntity labelEntity = new RequestSequenceLabelEntity();
labelEntity.sequence_id = model.id.Value;
if (statusCode >= 100 && statusCode < 200)
{
labelEntity.name = "Informational";
}
else if (statusCode >= 200 && statusCode < 300)
{
labelEntity.name = "Success";
}
else if (statusCode >= 300 && statusCode < 400)
{
labelEntity.name = "Redirection";
}
else if (statusCode >= 400 && statusCode < 500)
{
labelEntity.name = "Client Error";
}
else if (statusCode >= 500 && statusCode < 600)
{
labelEntity.name = "Server Error";
}
else
{
labelEntity.name = "Unknown Status";
}
await AddRequestSequenceLabel(labelEntity);
}
}
else
{
Console.WriteLine("Warning: Truncated request sequence.");
}
}
