private void ConfigureControls(ScanToUsbData data) { usb_TextBox.Text = data.UsbName; quickSet_TextBox.Text = data.QuickSetName; quickSet_RadioButton.Checked = data.UseQuickset; usbName_RadioButton.Checked = !data.UseQuickset; useOcr_CheckBox.Checked = data.UseOcr; pageCount_NumericUpDown.Value = data.ScanOptions.PageCount; lockTimeoutControl.Initialize(data.ScanOptions.LockTimeouts); assetSelectionControl.AutomationPause = data.AutomationPause; assetSelectionControl.UseAdf = data.ScanOptions.UseAdf; // Determine whether the DSS server should be filled in if (!string.IsNullOrEmpty(data.DigitalSendServer)) { digitalSendServer_TextBox.Text = data.DigitalSendServer; usesDigitalSendServer_CheckBox.Checked = true; } else { usesDigitalSendServer_CheckBox.Checked = false; } _scanOptions = data.ScanOptions; if (data.ApplicationAuthentication) { radioButton_ScanToUSB.Checked = true; } else { radioButton_SignInButton.Checked = true; } comboBox_AuthProvider.SelectedValue = data.AuthProvider; }
/// <summary> /// Processes the activity given to the plugin. /// </summary> /// <param name="executionData"></param> public PluginExecutionResult Execute(PluginExecutionData executionData) { PluginExecutionResult result = new PluginExecutionResult(PluginResult.Passed); _activityData = _pluginExecutionData.GetMetadata <JetAdvantageScanActivityData>(); _device = (IDeviceInfo)executionData.Assets.First(); UpdateStatus("Starting JetAdvantage " + "Scan to Cloud Repository"); SetDataLogger(_device); if (CheckJetAdvantageAvailability()) { ScanOptions scanOptions = new ScanOptions() { LockTimeouts = _activityData.LockTimeouts, PageCount = _activityData.PageCount, UseAdf = _activityData.UseAdf, }; _controller = new JetAdvantageScanAutoController(executionData, scanOptions); _controller.ActivityStatusChanged += UpdateStatus; _controller.DeviceSelected += UpdateDevice; UpdateDataLogger(result); return(_controller.RunScanActivity()); } else { result = new PluginExecutionResult(PluginResult.Failed); UpdateDataLogger(result); return(result); } }
Import(string iniFile, FieldsToImport?fields = null) { Core.View.ShowProgressBox(ProgressTasks.ImportFromNDL); try { var(error, fmsToScan) = await ImportInternal(iniFile, fields : fields); if (error != ImportError.None) { Log("Import error: " + error, stackTrace: true); return(false); } await FMScan.ScanAndFind(fmsToScan, ScanOptions.FalseDefault(scanGameType: true, scanCustomResources: true)); } catch (Exception ex) { Log("Exception in NewDarkLoader import", ex); return(false); } finally { Core.View.HideProgressBox(); } return(true); }
/// <summary> /// Executes this plugin's workflow using the specified <see cref="PluginExecutionData" />. /// </summary> /// <param name="executionData">The execution data.</param> /// <returns>A <see cref="PluginExecutionResult" /> indicating the outcome of the execution.</returns> public PluginExecutionResult Execute(PluginExecutionData executionData) { AutoStoreActivityData data = executionData.GetMetadata <AutoStoreActivityData>(); ScanOptions scanOptions = new ScanOptions() { LockTimeouts = data.ScanOptions.LockTimeouts, PageCount = data.ScanOptions.PageCount, FileType = data.ScanOptions.FileType, }; var manager = new AutoStoreScanManager(executionData); UpdateStatus("Starting activity."); manager.ActivityStatusChanged += UpdateStatus; manager.DeviceSelected += UpdateDevice; PluginExecutionResult executionResult = manager.RunScanActivity(); UpdateStatus("Finished activity."); UpdateStatus($"Result = {executionResult.Result}"); return(executionResult); }
private void btnScan_OnClick() { try { switch (currentScanStatus) { case Memory.ScanStatus.CanScan: ScanOptions scanOptions = new ScanOptions() { strScanValue = txtBoxScanValue.Text, strScanSecondValue = txtBoxScanSecondValue.Text, isHexValue = chkBoxIsHexValue.Checked, strSectionNameInclusionFilter = txtBoxSectionsFilterInclude.Text, strSectionNameExclusionFilter = txtBoxSectionsFilterExclude.Text, sectionPageProtectionFilter = (librpc.VM_PROT)Enum.Parse(typeof(librpc.VM_PROT), (String)cmbBoxSectionsFilterProtection.SelectedItem), sectionMaxLengthFilter = Convert.ToInt32(numUpDownSectionMaxLength.Value) }; bgWorkerScanner.RunWorkerAsync(scanOptions); break; case Memory.ScanStatus.DidScan: listViewResults.Items.Clear(); currentScanStatus = Memory.ScanStatus.CanScan; break; case Memory.ScanStatus.Scanning: bgWorkerScanner.CancelAsync(); break; } } catch (Exception ex) { MessageBox.Show(ex.ToString(), "btnScan"); } }
private void Awake() { global::Tweaker.Core.LogManager.Set(new LogManager()); logger = global::Tweaker.Core.LogManager.GetCurrentClassLogger(); logger.Info("Logger initialized"); tweaker = new Tweaker(); Scanner scanner = new Scanner(); ScanOptions scanOptions = new ScanOptions(); scanOptions.Assemblies.ScannableRefs = new Assembly[1] { typeof(TweakerConsoleTestbed).Assembly }; TweakerOptions tweakerOptions = new TweakerOptions(); tweakerOptions.Flags = TweakerOptionFlags.ScanForInvokables | TweakerOptionFlags.ScanForTweakables | TweakerOptionFlags.ScanForWatchables | TweakerOptionFlags.DoNotAutoScan | TweakerOptionFlags.IncludeTests; tweaker.Init(tweakerOptions, scanner); TweakerSerializer serializer = new TweakerSerializer(tweaker.Scanner); tweaker.Scanner.Scan(scanOptions); console = Object.Instantiate(ConsolePrefab); logger.Info("console instatiated: " + console); console.GetComponent <RectTransform>().SetParent(GetComponent <RectTransform>(), worldPositionStays: false); logger.Info("console parented to testbed canvas"); console.Init(tweaker, serializer); }
public string GenerateResult(ScanOptions scanOptions, DiscoveredScanner scanner) { try { string result = ""; foreach (IFileNamingBlock block in Blocks) { result += block.ToString(scanOptions, scanner); } return(result + ConvertImageScannerFormatToString(scanOptions.Format.TargetFormat)); } catch (Exception exc) { ILogService logService = Ioc.Default.GetService <ILogService>(); IAppCenterService appCenterService = Ioc.Default.GetService <IAppCenterService>(); logService.Log.Error(exc, "Generating file name from {pattern} failed", GetSerialized(true)); appCenterService.TrackError(exc); // fallback to rudimentary legacy file naming return("SCN" + DateTime.Now.Hour.ToString("00") + DateTime.Now.Minute.ToString("00") + DateTime.Now.Second.ToString("00"));; } }
static async Task <int> RunScanAndReturnExitCode(ScanOptions opts) { CancellationTokenSource tokenSource = new CancellationTokenSource(); var locoClient = new LocoClient(); locoClient.Log += (sender, args) => { Console.WriteLine(args.Log); }; await locoClient.ConnectAsync(tokenSource.Token); locoClient.ScanResultFound += (sender, args) => { Console.WriteLine($"Locomotive found: {args.RoadNumber}"); }; locoClient.ScanAsync(tokenSource.Token); // Wait until a key is pressed and then exit. await Task.Factory.StartNew(() => { Console.ReadKey(); tokenSource.Cancel(); }); await Task.Delay(100); return(0); }
private void PerformScan() { TweakerOptionFlags flags = Options.Flags; if ((flags & TweakerOptionFlags.ScanInEverything) != 0) { ScanEverything(); return; } if ((flags & TweakerOptionFlags.ScanInNonSystemAssemblies) != 0) { ScanNonSystemAssemblies(); return; } List <Assembly> list = new List <Assembly>(); if ((flags & TweakerOptionFlags.ScanInExecutingAssembly) != 0) { list.Add(Assembly.GetCallingAssembly()); } if ((flags & TweakerOptionFlags.ScanInEntryAssembly) != 0) { list.Add(Assembly.GetEntryAssembly()); } ScanOptions scanOptions = new ScanOptions(); scanOptions.Assemblies.ScannableRefs = list.ToArray(); ScanWithOptions(scanOptions); }
private void ScanNonSystemAssemblies() { ScanOptions scanOptions = new ScanOptions(); scanOptions.Assemblies.NameRegex = "^(?!(System\\.)|System$|mscorlib$|Microsoft\\.|vshost|Unity|Accessibility|Mono\\.).+"; ScanWithOptions(scanOptions); }
public PluginExecutionResult Execute(PluginExecutionData executionData) { ScanToWorkflowData data = executionData.GetMetadata <ScanToWorkflowData>(ConverterProvider.GetMetadataConverters()); ScanOptions scanOptions = new ScanOptions() { LockTimeouts = data.LockTimeouts, PageCount = data.PageCount, UseAdf = data.UseAdf, }; WorkflowScanManager manager; if (string.IsNullOrWhiteSpace(data.DigitalSendServer)) { manager = new WorkflowScanManager(executionData, scanOptions); } else { manager = new WorkflowScanManager(executionData, scanOptions, data.DigitalSendServer); } manager.ActivityStatusChanged += UpdateStatus; manager.DeviceSelected += UpdateDevice; return(manager.RunScanActivity()); }
private void SetValuesOnDeserialized(StreamingContext context) { if (ScanOptions == null) { ScanOptions = new ScanOptions(); } }
private void ConfigureControls(ScanToFolderData data) { folder_TextBox.Text = data.FolderPath; quickSet_TextBox.Text = data.QuickSetName; quickSet_RadioButton.Checked = data.UseQuickset; networkFolder_RadioButton.Checked = !data.UseQuickset; useOcr_CheckBox.Checked = data.UseOcr; applyCredential_Checkbox.Checked = data.ApplyCredentialsOnVerification; pageCount_NumericUpDown.Value = data.ScanOptions.PageCount; OptionalRadioButton.Checked = data.ImagePreviewOptions == 0; GenerateRadioButton.Checked = data.ImagePreviewOptions == 1; RestrictRadioButton.Checked = data.ImagePreviewOptions == 2; lockTimeoutControl.Initialize(data.ScanOptions.LockTimeouts); assetSelectionControl.AutomationPause = data.AutomationPause; assetSelectionControl.UseAdf = data.ScanOptions.UseAdf; // Determine what logging option should be selected if (data.DestinationType == "Folder Multi") { if (data.DestinationCount > 0) { multipleFoldersExact_RadioButton.Checked = true; destinations_NumericUpDown.Value = data.DestinationCount; } else { multipleFoldersAuto_RadioButton.Checked = true; } } else { singleFolder_RadioButton.Checked = true; } // Determine whether the DSS server should be filled in if (!string.IsNullOrEmpty(data.DigitalSendServer)) { digitalSendServer_TextBox.Text = data.DigitalSendServer; usesDigitalSendServer_CheckBox.Checked = true; } else { usesDigitalSendServer_CheckBox.Checked = false; } _scanOptions = data.ScanOptions; if (data.ApplicationAuthentication) { radioButton_ScanToFolder.Checked = true; } else { radioButton_SignInButton.Checked = true; } comboBox_AuthProvider.SelectedValue = data.AuthProvider; }
private void ScanEntryAssembly() { ScanOptions scanOptions = new ScanOptions(); scanOptions.Assemblies.ScannableRefs = new Assembly[1] { Assembly.GetEntryAssembly() }; ScanWithOptions(scanOptions); }
/// <summary> /// Initializes a new instance of the <see cref="ScanToFolderActivityData"/> class. /// </summary> public ScanToUsbData() { UseQuickset = false; UseOcr = false; AutomationPause = TimeSpan.FromSeconds(1); ScanOptions = new ScanOptions(); ApplicationAuthentication = true; AuthProvider = AuthenticationProvider.Auto; }
/// <summary> /// HP JetAdvantage constructor /// </summary> public JetAdvantageScanAutoController(PluginExecutionData executionData, ScanOptions scanOptions) : base(executionData) { var device = (IDeviceInfo)executionData.Assets.First(); _device = new JediWindjammerDevice(device.Address, device.AdminPassword); _data = executionData.GetMetadata <JetAdvantageScanActivityData>(); _engine = new OxpdBrowserEngine(_device.ControlPanel); ScanOptions = scanOptions; }
public Finder(ScanType scanType, FileCompareType fileCompareType, bool includeSubDirectories, string searchPattern = "*") { var scanOptions = new ScanOptions(); scanOptions.FileCompareType = fileCompareType; scanOptions.IncludeSubDirectories = includeSubDirectories; scanOptions.SearchPattern = searchPattern; var scannerFactory = new ScannerFactory(); _scanner = scannerFactory.Create(scanType, scanOptions); }
public MyQScanScanManager(PluginExecutionData pluginExecutionData, ScanOptions scanOptions) : base(pluginExecutionData) { _pluginExecutionData = pluginExecutionData; _activityData = _pluginExecutionData.GetMetadata <MyQScanActivityData>(); if (ScanLog != null) { ScanLog.Ocr = false; } ScanOptions = scanOptions; }
private void ScanPreferences_Button_Click(object sender, EventArgs e) { using (var scanOptionsForm = new ScanOptionsForm(_scanOptions)) { if (scanOptionsForm.ShowDialog() == DialogResult.OK) { _scanOptions = scanOptionsForm.ScanOption; } } }
public async Task <EsclJob> CreateJob(ScanOptions options) { string request = scanRequestGenerator.Generate(options); var response = await esclClient.PostAsync(endpoint, request); string jobUri = response.Location.PathAndQuery; var statusChecker = new JobStatusChecker(esclClient, host, jobUri); return(new EsclJob(statusChecker)); }
/// <summary> /// Initializes a new instance of the <see cref="ScanToJobStorageData"/> class. /// </summary> public ScanToJobStorageData() { JobName = string.Empty; IsPinRequired = false; Pin = string.Empty; AutomationPause = TimeSpan.FromSeconds(1); ScanOptions = new ScanOptions(); ApplicationAuthentication = true; AuthProvider = AuthenticationProvider.Auto; }
public override Status Scan <Serial_Device>(out List <Serial_Device> device_list, ScanOptions scan_opt = ScanOptions.None) { device_list = new List <Serial_Device>(); devices.Clear(); int i = 1; //var allcom = SerialPortStream.GetPortNames(); var desc = SerialPortStream.GetPortDescriptions(); if (desc != null && desc.Length > 0) { foreach (PortDescription com in desc) { string device_name = com.Port.ToUpper().Replace(" ", String.Empty).Trim(); if (!device_name.Contains(DEVICE_PREFIX) || !device_name.Any(c => char.IsDigit(c))) { device_name = DEVICE_PREFIX + i; } while (devices.ContainsKey(device_name)) { device_name += "0"; } Comm.Serial_Device nod = new Comm.Serial_Device ( com.Port, device_name, com.Description, "", Mode.UART_Serial ); nod.FormattedDescription = nod.ToString(); devices.Add(device_name.ToLower(), nod); i++; } try { device_list = devices.Select(pair => pair.Value) .Cast <Serial_Device>() .Select(s => new { key = Int32.Parse(Regex.Match(s.Name, @"\d+").Value), value = s }) .OrderBy(p => p.key) .Select(p => p.value) .ToList(); } catch (Exception) { device_list = devices.Select(pair => pair.Value).Cast <Serial_Device>().ToList(); } } return(Utils.StatusCreate(0)); }
private void FaxOptions_Button_Click(object sender, EventArgs e) { _faxOptions.ScanJobType = "ScanToFax"; using (var scanOptionsForm = new ScanOptionsForm(_faxOptions)) { if (scanOptionsForm.ShowDialog() == DialogResult.OK) { _faxOptions = scanOptionsForm.ScanOption; } } }
/// <summary> /// Initializes a new instance of the FaxActivityData class. /// </summary> public FaxActivityData() { EnableNotification = false; AutomationPause = TimeSpan.FromSeconds(1); FaxType = FaxConfiguration.AnalogFax; FaxOperation = FaxTask.SendFax; FaxNumber = null; FaxReceiveTimeout = new TimeSpan(0, 1, 0); UseSpeedDial = false; ScanOptions = new ScanOptions(); ApplicationAuthentication = true; AuthProvider = AuthenticationProvider.Auto; }
/// <summary> /// Initializes a new instance of the <see cref="ScanToFolderData"/> class. /// </summary> public ScanToFolderData() { UseQuickset = false; UseOcr = false; AutomationPause = TimeSpan.FromSeconds(1); DestinationType = "Folder"; DestinationCount = 1; ImagePreviewOptions = 0; ApplyCredentialsOnVerification = false; ScanOptions = new ScanOptions(); AuthProvider = AuthenticationProvider.Auto; ApplicationAuthentication = true; }
/// <summary> /// Initializes a new instance of the <see cref="ScanToEmailData"/> class. /// </summary> public ScanToEmailData() { UseQuickset = false; QuickSetName = string.Empty; UseOcr = false; AddressSource = string.Empty; AutomationPause = TimeSpan.FromSeconds(1); ImagePreviewOptions = 0; ScanOptions = new ScanOptions(); ApplicationAuthentication = true; AuthProvider = AuthenticationProvider.Auto; }
/// <summary> /// Regenerates the cached data of the add-in registry. /// </summary> /// <param name="monitor"> /// Progress monitor to keep track of the rebuild operation. /// </param> public void Rebuild(IProgressStatus monitor) { var context = new ScanOptions(); context.CleanGeneratedAddinScanDataFiles = true; database.Repair(monitor, currentDomain, context); // A full rebuild may cause the domain to change if (!string.IsNullOrEmpty(startupDirectory)) { currentDomain = database.GetFolderDomain(null, startupDirectory); } }
/// <summary> /// Initializes a new instance of the <see cref="HpcrScanManager"/> class. /// </summary> public HpcrScanManager(PluginExecutionData executionData, ScanOptions scanOptions) : base(executionData) { _pluginExecutionData = executionData; _activityData = _pluginExecutionData.GetMetadata <ScanToHpcrActivityData>(); _documentName = FilePrefix.ToString(); if (ScanLog != null) { ScanLog.Ocr = false; } ScanOptions = scanOptions; }
public static int Main(string [] args) { ProcessProgressStatus monitor = new ProcessProgressStatus(int.Parse(args [0])); try { string registryPath = Console.In.ReadLine(); string startupDir = Console.In.ReadLine(); string addinsDir = Console.In.ReadLine(); string databaseDir = Console.In.ReadLine(); AddinDatabase.RunningSetupProcess = true; AddinRegistry reg = new AddinRegistry(registryPath, startupDir, addinsDir, databaseDir); switch (args [1]) { case "scan": { string folder = args.Length > 2 ? args [2] : null; if (folder.Length == 0) { folder = null; } var context = new ScanOptions(); context.Read(Console.In); reg.ScanFolders(monitor, folder, context); break; } case "pre-scan": { string folder = args.Length > 2 ? args [2] : null; if (folder.Length == 0) { folder = null; } var recursive = bool.Parse(Console.In.ReadLine()); reg.GenerateScanDataFilesInProcess(monitor, folder, recursive); break; } case "get-desc": var outFile = Console.In.ReadLine(); reg.ParseAddin(monitor, args [2], args [3]); break; } } catch (Exception ex) { monitor.ReportError("Unexpected error in setup process", ex); return(1); } return(0); }
public Scanner Create(ScanType scanType, ScanOptions scanOptions) { switch (scanType) { case ScanType.Simple: return new SimpleScanner(scanOptions); case ScanType.Smart: return new SmartScanner(scanOptions); default: return null; } }
private static int ProcessScan(ScanOptions option) { var targetPath = option.Path; if (Directory.Exists(targetPath)) { var searchString = string.Empty; var pathList = new List <string>(); switch (option.FileType) { case FileType.Assemblies: { pathList = ScanAssembly(targetPath, option.Recursive); break; }; case FileType.Nuget: { pathList = ScanNuget(targetPath, option.Recursive); break; }; case FileType.Project: { ConsoleOutput.Message($"Searching {targetPath} for files ending with '.csproj'"); pathList.Add(targetPath); break; }; default: break; } if (pathList.Count <= 0) { ConsoleOutput.ErrorMessage($"No {searchString} files found under {targetPath}"); return(1); } FindDotNetVulnerabilities(pathList, option.Recursive); return(0); } else { ConsoleOutput.ErrorMessage($"'{targetPath}' is not a valid path"); } return(1); }
private void ConfigureControls(ScanToEmailData data) { email_ComboBox.Text = data.EmailAddress; useOcr_CheckBox.Checked = data.UseOcr; pageCount_NumericUpDown.Value = data.ScanOptions.PageCount; assetSelectionControl.AutomationPause = data.AutomationPause; assetSelectionControl.UseAdf = data.ScanOptions.UseAdf; quickSet_TextBox.Text = data.QuickSetName; quickSet_RadioButton.Checked = data.UseQuickset; launchFromApp_RadioButton.Checked = data.LaunchQuicksetFromApp; launchFromHome_RadioButton.Checked = !data.LaunchQuicksetFromApp; OptionalRadioButton.Checked = data.ImagePreviewOptions == 0; GenerateRadioButton.Checked = data.ImagePreviewOptions == 1; RestrictRadioButton.Checked = data.ImagePreviewOptions == 2; email_ComboBox.Items.Clear(); // Populate the list of email addresses foreach (string email in ConfigurationServices.EnvironmentConfiguration.GetOutputMonitorDestinations("OutputEmail")) { email_ComboBox.Items.Add(email); } // Determine whether the DSS server should be filled in if (!string.IsNullOrEmpty(data.DigitalSendServer)) { usesDigitalSendServer_CheckBox.Checked = true; digitalSendServer_TextBox.Text = data.DigitalSendServer; } else { usesDigitalSendServer_CheckBox.Checked = false; } // Check AddressSource addressSource_comboBox.SelectedIndex = string.IsNullOrEmpty(data.AddressSource) ? 0 : addressSource_comboBox.Items.IndexOf(data.AddressSource); _scanOptions = data.ScanOptions; if (data.ApplicationAuthentication) { radioButton_ScanToEmail.Checked = true; } else { radioButton_SignInButton.Checked = true; } comboBox_AuthProvider.SelectedValue = data.AuthProvider; }
/// <summary> /// Asynchronously scans a directory for viruses, recursing into subdirectories. /// </summary> /// <param name="engine">ClamAV engine instance.</param> /// <param name="path">Path to scan.</param> /// <param name="options">Scan options.</param> /// <returns>The task object representing the asynchronous operation. The Result property on the task returns the scan results.</returns> public static async Task<IEnumerable<FileScanResult>> ScanDirectoryAsync(this ClamEngine engine, string path, ScanOptions options) { return await engine.ScanDirectoryAsync(path, options, true, 0); }
public Vtero Scanit(ScanOptions op) { bool SkipVMCS = false; #if TESTING foreach (var sx in op.DisabledScans) { var spec = sx.ToLower(); if (spec.Contains("vmcs")) SkipVMCS = true; if (spec.Contains("obsd")) Version = Version & ~PTType.OpenBSD; if (spec.Contains("nbsd")) Version = Version & ~PTType.NetBSD; if (spec.Contains("fbsd")) Version = Version & ~PTType.FreeBSD; if (spec.Contains("lin")) Version = Version & ~PTType.LinuxS; if (spec.Contains("hv")) Version = Version & ~PTType.HyperV; if (spec.Contains("gen")) Version = Version & ~PTType.GENERIC; if (spec.Contains("win")) Version = Version & ~PTType.Windows; } if((Version & PTType.VALUE) == PTType.VALUE) { bool Parsed = false; do { if(args.Length < 2) { WriteLine($"Specify value"); return; } Parsed = uint.TryParse(args[2],NumberStyles.HexNumber, CultureInfo.CurrentCulture, out valuI); if (!Parsed) { Parsed = ulong.TryParse(args[2], NumberStyles.HexNumber, CultureInfo.CurrentCulture, out valuL); if (Parsed) Is64Scan = true; else { WriteLine($"Unable to parse input {args[2]}"); return; } } else valuL = (ulong)valuI; } while (!Parsed); } #endif string Filename = null; Vtero vtero = null; PTType Version = PTType.Windows; // this instance is temporally used for loading state // i.e. don't set properties or fields here var saveStateFile = $"{Filename}.inVtero.net"; if (File.Exists(saveStateFile)) { if (todo.Key != ConsoleKey.D ) { vtero = vtero.CheckpointRestoreState(saveStateFile); vtero.OverRidePhase = true; } else File.Delete(saveStateFile); } if (vtero.Phase < 2) vtero = new Vtero(Filename); //Mem.InitMem(parsed.FileName, null, vtero.DetectedDesc); ProgressBarz.Bar.Message = "First pass, looking for processes"; ForegroundColor = ConsoleColor.Cyan; #if TESTING Timer = Stopwatch.StartNew(); if ((Version & PTType.VALUE) == PTType.VALUE) { var off = vtero.ScanValue(Is64Scan, valuL, 0); WriteLine(FormatRate(vtero.FileSize, Timer.Elapsed)); using (var dstream = File.OpenRead(vtero.MemFile)) { using (var dbin = new BinaryReader(dstream)) { foreach (var xoff in off) { WriteLine($"Checking Memory Descriptor @{(xoff + 28):X}"); if (xoff > vtero.FileSize) { WriteLine($"offset {xoff:X} > FileSize {vtero.FileSize:X}"); continue; } dstream.Position = xoff + 28; var MemRunDescriptor = new MemoryDescriptor(); MemRunDescriptor.NumberOfRuns = dbin.ReadInt64(); MemRunDescriptor.NumberOfPages = dbin.ReadInt64(); Console.WriteLine($"Runs: {MemRunDescriptor.NumberOfRuns}, Pages: {MemRunDescriptor.NumberOfPages} "); if (MemRunDescriptor.NumberOfRuns < 0 || MemRunDescriptor.NumberOfRuns > 32) { continue; } for (int i = 0; i < MemRunDescriptor.NumberOfRuns; i++) { var basePage = dbin.ReadInt64(); var pageCount = dbin.ReadInt64(); MemRunDescriptor.Run.Add(new MemoryRun() { BasePage = basePage, PageCount = pageCount }); } WriteLine($"MemoryDescriptor {MemRunDescriptor}"); } } } WriteLine("Finished VALUE scan."); return; } if ((Version & PTType.VALUE) == PTType.VALUE) return; #endif // basic perf checking QuickOptions.Timer = Stopwatch.StartNew(); var procCount = vtero.ProcDetectScan(Version); WriteColor(ConsoleColor.Blue, ConsoleColor.Yellow, $"{procCount} candidate process page tables. Time so far: {QuickOptions.Timer.Elapsed}, second pass starting. {QuickOptions.FormatRate(vtero.FileSize, QuickOptions.Timer.Elapsed)}"); //BackgroundColor = ConsoleColor.Black; //ForegroundColor = ConsoleColor.Cyan; if (procCount < 3) { WriteColor(ConsoleColor.Red,"Seems like a fail. Try generic scanning or implement a state scan like LinuxS"); return null; } // second pass // with the page tables we acquired, locate candidate VMCS pages in the format // [31-bit revision id][abort indicator] // the page must also have at least 1 64bit value which is all set (-1) // Root-HOST CR3 will have uniform diff // unless an extent based dump image is input, some .DMP variations // TODO: Add support for extent based inputs // Guest VMCS will contain host CR3 & guest CR3 (hCR3 & gCR3) // sometimes CR3 will be found in multiple page tables, e.g. system process or SMP // if I have more than 1 CR3 from different file_offset, just trim them out for now // future may have a reason to isolate based on original locationAG if (SkipVMCS) return vtero; ProgressBarz.Bar.Message = "Second pass, correlating for VMCS pages"; var VMCSCount = vtero.VMCSScan(); //Timer.Stop(); WriteColor(ConsoleColor.Blue, ConsoleColor.Yellow, $"{VMCSCount} candidate VMCS pages. Time to process: {QuickOptions.Timer.Elapsed}, Data scanned: {vtero.FileSize:N}"); // second time WriteColor(ConsoleColor.Blue, ConsoleColor.Yellow, $"Second pass done. {QuickOptions.FormatRate(vtero.FileSize * 2, QuickOptions.Timer.Elapsed)}"); // each of these depends on a VMCS scan/pass having been done at the moment WriteColor(ConsoleColor.Cyan, ConsoleColor.Black, "grouping and joining all memory"); // After this point were fairly functional vtero.GroupAS(); // sync-save state so restarting is faster if (!File.Exists(saveStateFile)) { Write($"Saving checkpoint... "); saveStateFile = vtero.CheckpointSaveState(); WriteColor(ConsoleColor.White, saveStateFile); } return vtero; }
/// <summary> /// Asynchronously scans a file for viruses. /// </summary> /// <param name="engine">ClamAV engine instance.</param> /// <param name="path">Path to the file to be scanned.</param> /// <param name="options">Scan options.</param> /// <returns>The task object representing the asynchronous operation. The Result property on the task returns a scan result.</returns> public static async Task<FileScanResult> ScanFileAsync(this ClamEngine engine, string path, ScanOptions options) { var virusName = string.Empty; var scanResult = await Task.Factory.StartNew(() => engine.ScanFile(path, options, out virusName)); return new FileScanResult(path, scanResult == ScanResult.Virus, virusName); }
public SimpleScanner(ScanOptions scanOptions) : base(scanOptions) { }
protected Scanner(ScanOptions scanOptions) { var fileComparerFactory = new FileComparerFactory(); _options = scanOptions; _fileComparer = fileComparerFactory.Create(scanOptions.FileCompareType); }
/// <summary> /// Scans a file for viruses. /// </summary> /// <param name="filePath">Path to the file to be scanned.</param> /// <param name="scanOptions">Scan options.</param> /// <param name="virusName">Output variable for the virus name, if detected.</param> /// <returns>File status.</returns> public ScanResult ScanFile(string filePath, ScanOptions scanOptions, out string virusName) { // Validate arguments. if (string.IsNullOrEmpty(filePath)) throw new ArgumentNullException("filePath"); IntPtr virusNamePtr = IntPtr.Zero; ulong scanned = 0; uint options = 0; // Convert ScanOptions parameter. options = (uint)scanOptions; // Perform scan var result = (UnsafeNativeMethods.cl_error_t)UnsafeNativeMethods.cl_scanfile(filePath, ref virusNamePtr, ref scanned, _engine, options); if (result == UnsafeNativeMethods.cl_error_t.CL_CLEAN) { // File is clean. virusName = string.Empty; return ScanResult.Clean; } else if (result == UnsafeNativeMethods.cl_error_t.CL_VIRUS) { // We've detected a virus. virusName = Marshal.PtrToStringAnsi(virusNamePtr); return ScanResult.Virus; } else { // Probably an error condition. throw new ClamException((int)result, ErrorString((int)result)); } }
/// <summary> /// Scan a directory for viruses with custom scan options, recursing into subdirectories. /// </summary> /// <param name="directoryPath">Path to scan.</param> /// <param name="scanOptions">Scan options.</param> /// <param name="fileScannedCallback">Called after a file has been scanned.</param> public void ScanDirectory(string directoryPath, ScanOptions scanOptions, FileScannedCallback fileScannedCallback) { ScanDirectory(directoryPath, ScanOptions.StandardOptions, fileScannedCallback, true, 0); }
/// <summary> /// Scan a directory for viruses, optionally recursing into subdirectories. /// </summary> /// <param name="directoryPath">Path to scan.</param> /// <param name="scanOptions">Scan options.</param> /// <param name="fileScannedCallback">Called after a file has been scanned.</param> /// <param name="recurse">Enter subdirectories.</param> /// <param name="maxDepth">Maximum depth to scan, or zero for unlimited.</param> public void ScanDirectory(string directoryPath, ScanOptions scanOptions, FileScannedCallback fileScannedCallback, bool recurse, int maxDepth) { // Validate arguments. if (string.IsNullOrEmpty(directoryPath)) throw new ArgumentNullException("directoryPath"); if (fileScannedCallback == null) throw new ArgumentNullException("fileScannedCallback"); var pathStack = new Stack<Tuple<string /* path */, int /* depth */>>(); // Push the starting directory onto the stack. pathStack.Push(Tuple.Create(directoryPath, 1)); while (pathStack.Count > 0) { var stackState = pathStack.Pop(); var currentPath = stackState.Item1; var currentDepth = stackState.Item2; var attributes = File.GetAttributes(currentPath); // If we're in a directory, push all files and subdirectories to the stack. if ((attributes & FileAttributes.Directory) == FileAttributes.Directory) { // Check if we're not about to go too deep. if (maxDepth == 0 || currentDepth < maxDepth) { var subFiles = Directory.GetFiles(currentPath); foreach (var file in subFiles) { pathStack.Push(Tuple.Create(file, currentDepth + 1)); } var subDirectories = Directory.GetDirectories(currentPath); foreach (var directory in subDirectories) { pathStack.Push(Tuple.Create(directory, currentDepth + 1)); } } } // If this is a file, scan it. else { var virusName = string.Empty; var scanResult = ScanFile(currentPath, scanOptions, out virusName); fileScannedCallback(currentPath, scanResult, virusName); } } }
/// <summary> /// Asynchronously scans a directory for viruses, optionally recursing into subdirectories. /// </summary> /// <param name="engine">ClamAV engine instance.</param> /// <param name="path">Path to scan.</param> /// <param name="options">Scan options.</param> /// <param name="recurse">Whether to enter subdirectories.</param> /// <param name="maxDepth">Maximum depth to scan, or zero for unlimited.</param> /// <returns>The task object representing the asynchronous operation. The Result property on the task returns the scan results.</returns> public static async Task<IEnumerable<FileScanResult>> ScanDirectoryAsync(this ClamEngine engine, string path, ScanOptions options, bool recurse, int maxDepth) { var scanQueue = new Queue<string>(); var pathStack = new Stack<Tuple<string /* path */, int /* depth */>>(); // Push the starting directory onto the stack. pathStack.Push(Tuple.Create(path, 1)); while (pathStack.Count > 0) { var stackState = pathStack.Pop(); var currentPath = stackState.Item1; var currentDepth = stackState.Item2; var attributes = File.GetAttributes(currentPath); // If we're in a directory, push all files and subdirectories to the stack. if ((attributes & FileAttributes.Directory) == FileAttributes.Directory) { // Check if we're not about to go too deep. if (maxDepth == 0 || currentDepth < maxDepth) { var subFiles = Directory.GetFiles(currentPath); foreach (var file in subFiles) { pathStack.Push(Tuple.Create(file, currentDepth + 1)); } var subDirectories = Directory.GetDirectories(currentPath); foreach (var directory in subDirectories) { pathStack.Push(Tuple.Create(directory, currentDepth + 1)); } } } // If this is a file, enqueue it for scanning. else { scanQueue.Enqueue(currentPath); } } var scanTasks = scanQueue.Select(engine.ScanFileAsync); var scanResults = await Task.WhenAll(scanTasks); return scanResults; }