public ExhibitorService(IExhibitorRepository exhibitorRepository, IAddressRepository addressRepository,
IExhibitorHorseRepository exhibitorHorseRepository, IHorseRepository horseRepository,
IGroupExhibitorRepository groupExhibitorRepository, IGlobalCodeRepository globalCodeRepository,
IExhibitorClassRepository exhibitorClassRepository, IClassRepository classRepository,
ISponsorExhibitorRepository sponsorExhibitorRepository, ISponsorRepository sponsorRepository,
IScanRepository scanRepository, IExhibitorPaymentDetailRepository exhibitorPaymentDetailRepository,
IApplicationSettingRepository applicationRepository, IEmailSenderRepository emailSenderRepository,
IClassSponsorRepository classSponsorRepository, IMapper mapper, IStallAssignmentRepository stallAssignmentRepository)
{
_exhibitorRepository = exhibitorRepository;
_addressRepository = addressRepository;
_exhibitorHorseRepository = exhibitorHorseRepository;
_horseRepository = horseRepository;
_groupExhibitorRepository = groupExhibitorRepository;
_globalCodeRepository = globalCodeRepository;
_exhibitorClassRepository = exhibitorClassRepository;
_classRepository = classRepository;
_sponsorExhibitorRepository = sponsorExhibitorRepository;
_sponsorRepository = sponsorRepository;
_scanRepository = scanRepository;
_exhibitorPaymentDetailRepository = exhibitorPaymentDetailRepository;
_applicationRepository = applicationRepository;
_emailSenderRepository = emailSenderRepository;
_classSponsorRepository = classSponsorRepository;
_mapper = mapper;
_mainResponse = new MainResponse();
_stallAssignmentRepository = stallAssignmentRepository;
}
public Task <WorkerResult> Run(IObserver observer, string asset, IScanRepository repository, object args)
{
this._observer = observer;
return(this.ExecuteSafely(() =>
{
var http = new RestClient($"http://{Utility.GetIpv4Address()}:{Port}");
return this.Run_Internal(ProxyObserver.Create(observer), http, asset, repository, args);
}));
}
public UnitOfWork(SchoolTripPlannerContext context, IMapper mapper)
{
_context = context;
TeacherRepository = new TeacherRepository(context, mapper);
SchoolTripRepository = new SchoolTripRepository(context, mapper);
ClassRepository = new ClassRepository(context);
ToddlerRepository = new ToddlerRepository(context);
ScanToddlerRepository = new ScanToddlerRepository(context);
ScanRepository = new ScanRepository(context);
}
public PhilatelyController(
IHostingEnvironment hostingEnvironment,
UserManager <ApplicationUser> userManager,
IPhilatelicCollectionRepository collectionRepository,
IScanRepository scanRepository,
IQuoteRepository quoteRepository)
{
this.hostingEnvironment = hostingEnvironment;
this.userManager = userManager;
this.collectionRepository = collectionRepository;
this.scanRepository = scanRepository;
this.quoteRepository = quoteRepository;
}
public async Task <WorkerResult> Run(IObserver observer, string asset, IScanRepository repository, object args)
{
try
{
object result = await Run_Internal(observer, asset, repository, args);
return(new WorkerResult(result));
}
catch (Exception ex)
{
return(new WorkerResult(null, false, ex.Message));
}
}
protected override async Task <object> Run_Internal(IObserver observer, string asset, IScanRepository repository, object args) => await CreateNmap().Run(observer, asset, args);
public override async Task <object> Run_Internal(ProxyObserver observer, RestClient http, string asset, IScanRepository repository, object args)
{
var proxy = new RestClient(http.Host);
List <Result> result = await proxy.GetAsync <List <Result> >("getDollars");
observer?.Notify("Dollars", "got dollar values", null);
return(result);
}
protected override async Task <object> Run_Internal(IObserver observer, string asset, IScanRepository repository,
object args)
{
ReportResponse ret = null;
if (!String.IsNullOrEmpty(asset) && args is IDictionary <string, object> dic)
{
string owaspIp = dic[nameof(owaspIp)]?.ToString();
string owaspPort = dic[nameof(owaspPort)]?.ToString();
if (!String.IsNullOrEmpty(owaspIp) && !String.IsNullOrEmpty(owaspPort))
{
ClientApi api = new ClientApi(owaspIp, Convert.ToInt32(owaspPort), null);
var scanId = ((ApiResponseElement)api.spider.scan(asset, "5", "true", "", "false")).Value;
await Progress(observer, "Spider", () => Convert.ToInt32(((ApiResponseElement)api.spider.status(scanId)).Value));
var response = api.ascan.scan(asset, "", "", "", "", "", "");
await Progress(observer, "Active Scan", () => Convert.ToInt32(((ApiResponseElement)api.ascan.status(scanId)).Value));
byte[] report = api.core.jsonreport();
string json = Encoding.UTF8.GetString(report);
ret = JsonConvert.DeserializeObject <ReportResponse>(json);
}
}
return(ret);
}
protected override async Task <object> Run_Internal(IObserver observer, string asset, IScanRepository repository, object args)
{
if (String.IsNullOrEmpty(asset) || args == null)
{
return(null);
}
string address = args?.ToString();
OpenvasApi api = new OpenvasApi(address);
string taskId = asset;
var r = await api.StartTask(taskId);
if (r?.Status == "202")
{
while (true)
{
await Task.Delay(1000);
GetTasksResponse tasks = await api.GetTasks(new GetTasksRequest { TaskId = taskId });
var first = tasks.Tasks.FirstOrDefault();
if (null != first)
{
if (first.Status == "Running" || first.Status == "Requested")
{
if (first.Progress is JObject jo)
{
observer.Notify("Openvas_" + taskId, "Progress: " + jo["_"], null);
}
else if (first.Progress is string progress)
{
observer.Notify("Openvas_" + taskId, "Progress: " + progress, null);
}
continue;
}
else
{
observer.Notify("Openvas_" + taskId, "Done at : " + DateTime.Now, null);
}
}
else
{
observer.Notify("Openvas_" + taskId, "couldn't get the task info, operation cancelled", null);
}
break;
}
}
GetResultsResponse results = await api.GetResults(new GetResultsRequest { TaskId = taskId });
return(results?.Results);
}
protected override async Task <object> Run_Internal(IObserver observer, string asset, IScanRepository repository, object args)
{
List <TsharkModel> ret = new List <TsharkModel>();
if (!String.IsNullOrEmpty(asset) && args is IDictionary <string, object> dic)
{
string deviceId = asset;
string fileTemplate = dic[nameof(fileTemplate)]?.ToString();
string tsharkPath = dic[nameof(tsharkPath)]?.ToString();//Belki linux' te vermiyoruzdur.
string duration = dic[nameof(duration)]?.ToString();
if (String.IsNullOrEmpty(fileTemplate))
{
fileTemplate = "tshark";
}
if (String.IsNullOrEmpty(tsharkPath) || !int.TryParse(tsharkPath, out int d))
{
duration = "60";
}
EnsureIsListining(fileTemplate, deviceId, tsharkPath, int.Parse(duration));
//
var files = await ReadFiles(fileTemplate, tsharkPath);
foreach (string csv in files)
{
IList <TsharkModel> modelList = TsharkModel.Deserialize(csv);
ret.AddRange(modelList);
observer?.Notify(deviceId, "Network Monitored", modelList);
}
//
}
return(ret);
}
public ScansController(IScanRepository repo, IMapper mapper)
{
this._repo = repo;
this._mapper = mapper;
}
protected abstract Task <object> Run_Internal(IObserver observer, string asset, IScanRepository repository, object args);
protected override async Task <object> Run_Internal(IObserver observer, string asset, IScanRepository repository, object args)
{
IProcessMonitoring monitoring = CreateTerminal();
IEnumerable <ProcessInfo> results = await monitoring.Run(asset, args);
observer.Notify("ProcessMonitoringWorker", "Ok.", null);
return(results);
}
public override async Task <object> Run_Internal(ProxyObserver observer, RestClient http, string asset, IScanRepository repository, object args)
{
if (String.IsNullOrWhiteSpace(asset) || IsLinkFile(asset))
{
return(new List <string>());
}
// asset = CleanURL(asset);
HashSet <string> temp = await http.GetAsync <HashSet <string> >($"getAllLinks?site={asset}");
if (null == temp)
{
return(new List <string>());
}
HashSet <string> temp2 = new HashSet <string>();
foreach (var link in temp)
{
if (!String.IsNullOrEmpty(link))
{
if (_badChars.Contains(link[link.Length - 1]))
{
string fixedLink = link.Remove(link.Length - 1);
temp2.Add(fixedLink);
}
else
{
temp2.Add(link);
}
}
}
IEnumerable <string> links = temp2;
if (null != links && links.Any())
{
var yuri = new Uri(asset);
string host = yuri.Scheme + "://" + yuri.Host;
links = links.Where(link => link.StartsWith(host) && !IsLinkFile(link));//sadece host adıyla başlayanları al.
if (links.Any())
{
IEnumerable <string> previousResults = await repository.GetResults(true, true);
HashSet <string> doNotIncludeThose = new HashSet <string>();
foreach (string result in previousResults)
{
try
{
var list = JsonConvert.DeserializeObject <List <string> >(result);
list.ForEach(i => doNotIncludeThose.Add(i));
}
catch { }
}
links = links.Where(l => !doNotIncludeThose.Contains(l));
_ = repository.AddChildScan(asset, links);//clild' lari ekle asekron olarak.
observer.Notify(nameof(Worker) + "_" + nameof(Run), "The Spider is working now.", links);
}
}
return(links);
}
protected override async Task <object> Run_Internal(IObserver observer, string asset, IScanRepository repository,
object args)
{
GetResultResponse ret = null;
if (!String.IsNullOrEmpty(asset) && args is IDictionary <string, object> dic)
{
string niktoRestApiAddress = dic[nameof(niktoRestApiAddress)]?.ToString();
if (!String.IsNullOrEmpty(niktoRestApiAddress))
{
NiktoApi api = new NiktoApi(niktoRestApiAddress);
var scan = await api.CreateScan(new CreateScanRequest { Asset = asset });
//testden sonra çıkar
await Task.Delay(10000);
var r = await api.StopScan(new StopScanRequest { Id0 = scan.Id0, Id1 = scan.Id1 });
//
while (true)
{
await Task.Delay(1000);
ret = api.GetResult(scan.Id0).Result;
if (null != ret)
{
break;
}
}
}
}
return(ret);
}
public PhilatelicCollectionRepository(IHostingEnvironment hostingEnvironment, IScanRepository scanRepository)
{
this.scanRepository = scanRepository;
this.webRoot = hostingEnvironment.WebRootPath;
}
//template method pattern public abstract Task <object> Run_Internal(ProxyObserver observer, RestClient http, string asset, IScanRepository repository, object args);
public MainViewModel()
{
repository = RepositoryFactory.GetRepository();
}
public override async Task <object> Run_Internal(ProxyObserver observer, RestClient http, string asset, IScanRepository repository, object args)
{
Result result = await http.GetAsync <Result>($"getHtmlSource?site={asset}");
observer?.Notify("WebPageHthm", "got Html Source", null);
return(result?.html);
}
protected override async Task <object> Run_Internal(IObserver observer, string asset, IScanRepository repository, object args)
{
ITerminal terminal = CreateTerminal();
string result = await terminal.Run(asset, args);
observer?.Notify("TerminalWorker", "Ok.", args);
return(result);
}
public override async Task <object> Run_Internal(ProxyObserver observer, RestClient http, string asset, IScanRepository repository, object args)
{
return(await http.GetAsync <HashSet <string> >($"getAllLinks?site={asset}"));
}
public override async Task <object> Run_Internal(ProxyObserver observer, RestClient http, string asset, IScanRepository repository, object args)
{
var img = await http.GetAsync <JsonObject>($"screenshot?site={asset}");
observer?.Notify("WebpageScreenshot", "got screnshot", null);
return(null != img ? img.screenshot?.data : null);
}
protected override async Task <object> Run_Internal(IObserver observer, string asset, IScanRepository repository, object args)
{
ReportResponse ret = null;
if (!String.IsNullOrEmpty(asset) && args is IDictionary <string, object> dic)
{
string arachniRestApiAddress = dic[nameof(arachniRestApiAddress)]?.ToString();
if (!String.IsNullOrEmpty(arachniRestApiAddress))
{
ArachniApi api = new ArachniApi(arachniRestApiAddress);
string id = await api.NewScan(PostRequest.Create(asset));
if (!String.IsNullOrEmpty(id))
{
while (true)
{
await Task.Delay(1000);
SummaryResponse summary = await api.GetSummary(id);
if (null != summary && null != summary.Status)
{
observer?.Notify("Arachni_" + asset, $"Status: {summary.Status}, request: {summary.Statistics?.Http?["request_count"]}, runtime: {summary.Statistics?.Runtime}", null);
if (summary.Status == "done")
{
ret = await api.GetReport(id);
observer?.Notify("Arachni_" + asset, $"{asset} scan has been completed", null);
break;
}
}
else
{
break;
}
}
}
}
}
return(ret);
}
