public static List <CompareResult> GetComparisonResults(string compareId, RESULT_TYPE exportType)
{
List <CompareResult> records = new List <CompareResult>();
if (MainConnection != null)
{
using (var cmd = new SQLiteCommand(GET_COMPARISON_RESULTS, MainConnection.Connection, MainConnection.Transaction))
{
cmd.Parameters.AddWithValue("@comparison_id", compareId);
cmd.Parameters.AddWithValue("@result_type", exportType);
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
if (reader["serialized"].ToString() is string serialized)
{
try
{
records.Add(JsonConvert.DeserializeObject <CompareResult>(serialized));
}
catch (Exception e)
{
Log.Debug(e, "Couldn't deserialized into a CompareResult {0}", serialized);
}
}
}
}
}
}
return(records);
}
public static string ResultTypeToTableName(RESULT_TYPE result_type)
{
switch (result_type)
{
case RESULT_TYPE.FILE:
return("file_system");
case RESULT_TYPE.PORT:
return("network_ports");
case RESULT_TYPE.REGISTRY:
return("registry");
case RESULT_TYPE.CERTIFICATE:
return("certificates");
case RESULT_TYPE.SERVICE:
return("win_system_service");
case RESULT_TYPE.USER:
return("user_account");
default:
return("null");
}
}
public static int GetNumResults(RESULT_TYPE ResultType, string runId)
{
try
{
if (MainConnection != null)
{
using (var cmd = new SqliteCommand(SQL_GET_NUM_RESULTS, MainConnection.Connection, MainConnection.Transaction))
{
cmd.Parameters.AddWithValue("@run_id", runId);
cmd.Parameters.AddWithValue("@result_type", ResultType.ToString());
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
return(int.Parse(reader["the_count"].ToString() ?? "-1", CultureInfo.InvariantCulture));
}
}
}
}
}
catch (SqliteException)
{
Log.Error(Strings.Get("Err_Sql"), MethodBase.GetCurrentMethod()?.Name);
}
return(-1);
}
private WriteObject(byte[] SerializedIn, RESULT_TYPE ResultTypeIn, string RunIdIn)
{
_serialized = SerializedIn;
_rowKey = CryptoHelpers.CreateHash(_serialized);
RunId = RunIdIn;
ColObj = JsonUtils.Hydrate(SerializedIn, ResultTypeIn) !;
}
public GGResult(string mainResult, string notice, int itemIndex, RESULT_TYPE result_type, string tag="")
{
this.mainResult = mainResult;
this.notice = notice;
this.itemIndex = itemIndex;
this.type = result_type;
this.tag = tag;
}
/// <summary>
/// Deserialize a Collect object from a RawCollectResult
/// </summary>
/// <param name="res"> The RawCollectResult containing the msgpack serialized object to hydrate. </param>
/// <returns>
/// An appropriately typed collect object based on the collect result passed in, or null if the
/// RESULT_TYPE is unknown.
/// </returns>
public static CollectObject?Hydrate(string serialized, RESULT_TYPE type)
{
if (serialized == null)
{
return(null);
}
switch (type)
{
case RESULT_TYPE.CERTIFICATE:
return(JsonConvert.DeserializeObject <CertificateObject>(serialized, jsonSettings));
case RESULT_TYPE.FILE:
return(JsonConvert.DeserializeObject <FileSystemObject>(serialized, jsonSettings));
case RESULT_TYPE.PORT:
return(JsonConvert.DeserializeObject <OpenPortObject>(serialized, jsonSettings));
case RESULT_TYPE.REGISTRY:
return(JsonConvert.DeserializeObject <RegistryObject>(serialized, jsonSettings));
case RESULT_TYPE.SERVICE:
return(JsonConvert.DeserializeObject <ServiceObject>(serialized, jsonSettings));
case RESULT_TYPE.USER:
return(JsonConvert.DeserializeObject <UserAccountObject>(serialized, jsonSettings));
case RESULT_TYPE.GROUP:
return(JsonConvert.DeserializeObject <GroupAccountObject>(serialized, jsonSettings));
case RESULT_TYPE.FIREWALL:
return(JsonConvert.DeserializeObject <FirewallObject>(serialized, jsonSettings));
case RESULT_TYPE.COM:
return(JsonConvert.DeserializeObject <ComObject>(serialized, jsonSettings));
case RESULT_TYPE.LOG:
return(JsonConvert.DeserializeObject <EventLogObject>(serialized, jsonSettings));
case RESULT_TYPE.TPM:
return(JsonConvert.DeserializeObject <TpmObject>(serialized, jsonSettings));
case RESULT_TYPE.KEY:
return(JsonConvert.DeserializeObject <CryptographicKeyObject>(serialized, jsonSettings));
case RESULT_TYPE.PROCESS:
return(JsonConvert.DeserializeObject <ProcessObject>(serialized, jsonSettings));
case RESULT_TYPE.DRIVER:
return(JsonConvert.DeserializeObject <DriverObject>(serialized, jsonSettings));
case RESULT_TYPE.FILEMONITOR:
return(JsonConvert.DeserializeObject <FileMonitorObject>(serialized, jsonSettings));
default:
return(null);
}
}
private static string?ResultTypeToTargetName(RESULT_TYPE value)
{
switch (value)
{
case RESULT_TYPE.CERTIFICATE:
return(typeof(CertificateObject).Name);
case RESULT_TYPE.COM:
return(typeof(ComObject).Name);
case RESULT_TYPE.DRIVER:
return(typeof(DriverObject).Name);
case RESULT_TYPE.FILE:
return(typeof(FileSystemObject).Name);
case RESULT_TYPE.FILEMONITOR:
return(typeof(FileMonitorObject).Name);
case RESULT_TYPE.FIREWALL:
return(typeof(FirewallObject).Name);
case RESULT_TYPE.GROUP:
return(typeof(GroupAccountObject).Name);
case RESULT_TYPE.KEY:
return(typeof(CryptographicKeyObject).Name);
case RESULT_TYPE.LOG:
return(typeof(EventLogObject).Name);
case RESULT_TYPE.PORT:
return(typeof(OpenPortObject).Name);
case RESULT_TYPE.PROCESS:
return(typeof(ProcessObject).Name);
case RESULT_TYPE.REGISTRY:
return(typeof(RegistryObject).Name);
case RESULT_TYPE.SERVICE:
return(typeof(ServiceObject).Name);
case RESULT_TYPE.TPM:
return(typeof(TpmObject).Name);
case RESULT_TYPE.USER:
return(typeof(UserAccountObject).Name);
case RESULT_TYPE.WIFI:
return(typeof(WifiObject).Name);
default:
return(null);
}
}
public static WriteObject?FromString(string SerializedIn, RESULT_TYPE ResultTypeIn, string RunIdIn)
{
var wo = new WriteObject(SerializedIn, ResultTypeIn, RunIdIn);
if (wo.ColObj == null)
{
return(null);
}
return(wo);
}
/// <summary>
/// The ResultCollection constructor.
/// </summary>
/// <param name="rgResults">Specifies the results.</param>
/// <param name="outputLayerType">Specifies the output layer type.</param>
public ResultCollection(List <Result> rgResults, LayerParameter.LayerType outputLayerType)
{
m_resultType = GetResultType(outputLayerType);
m_rgResultsOriginal = rgResults;
foreach (Result item in rgResults)
{
m_rgResultsSorted.Add(item);
}
m_rgResultsSorted = m_rgResultsSorted.OrderByDescending(p => p.Score).ToList();
}
public static WriteObject?FromString(string SerializedIn, RESULT_TYPE ResultTypeIn, string RunIdIn)
{
var deserialized = JsonUtils.Hydrate(SerializedIn, ResultTypeIn);
if (deserialized is CollectObject)
{
return(new WriteObject(deserialized, RunIdIn));
}
else
{
Log.Debug($"Couldn't hydrate {SerializedIn} Failed to make a WriteObject.");
return(null);
}
}
TestResultEvent createResultEvent()
{
RESULT_TYPE type = RESULT_TYPE.SUCCESS;
Exception error = null;
ExpectedExceptionAttribute attr = Method.GetCustomAttribute <ExpectedExceptionAttribute>();
if (attr != null)
{
type = RESULT_TYPE.FAILED_ASSERTION;
error = new AssertException("Expected " + attr.ExpectedExceptionType
+ " but test method did not raise an exception");
}
return(new TestResultEvent(type, this, error));
}
public static List <CompareResult> GetComparisonResults(string compareId, RESULT_TYPE exportType)
{
List <CompareResult> records = new List <CompareResult>();
using (var cmd = new SQLiteCommand(GET_COMPARISON_RESULTS, Connection, Transaction))
{
cmd.Parameters.AddWithValue("@comparison_id", compareId);
cmd.Parameters.AddWithValue("@result_type", exportType);
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
records.Add(JsonSerializer.Deserialize <CompareResult>(reader["serialized"].ToString()));
}
}
}
return(records);
}
/// <summary>
/// Deserialize a Collect object from a RawCollectResult
/// </summary>
/// <param name="res">The RawCollectResult containing the msgpack serialized object to hydrate.</param>
/// <returns>An appropriately typed collect object based on the collect result passed in, or null if the RESULT_TYPE is unknown.</returns>
public static CollectObject?Hydrate(string bytes, RESULT_TYPE type)
{
if (bytes == null)
{
throw new NullReferenceException();
}
switch (type)
{
case RESULT_TYPE.CERTIFICATE:
return(JsonConvert.DeserializeObject <CertificateObject>(bytes));
case RESULT_TYPE.FILE:
return(JsonConvert.DeserializeObject <FileSystemObject>(bytes));
case RESULT_TYPE.PORT:
return(JsonConvert.DeserializeObject <OpenPortObject>(bytes));
case RESULT_TYPE.REGISTRY:
return(JsonConvert.DeserializeObject <RegistryObject>(bytes));
case RESULT_TYPE.SERVICE:
return(JsonConvert.DeserializeObject <ServiceObject>(bytes));
case RESULT_TYPE.USER:
return(JsonConvert.DeserializeObject <UserAccountObject>(bytes));
case RESULT_TYPE.GROUP:
return(JsonConvert.DeserializeObject <GroupAccountObject>(bytes));
case RESULT_TYPE.FIREWALL:
return(JsonConvert.DeserializeObject <FirewallObject>(bytes));
case RESULT_TYPE.COM:
return(JsonConvert.DeserializeObject <ComObject>(bytes));
case RESULT_TYPE.LOG:
return(JsonConvert.DeserializeObject <EventLogObject>(bytes));
default:
return(null);
}
}
TestResultEvent createResultEvent(Exception ex)
{
RESULT_TYPE type = RESULT_TYPE.SUCCESS;
Exception error = ex;
ExpectedExceptionAttribute attr = Method.GetCustomAttribute <ExpectedExceptionAttribute>();
if (attr != null)
{
Type ExpectedExceptionType = attr.ExpectedExceptionType;
Type ActualExceptionType = ex.GetType();
if (ExpectedExceptionType.IsAssignableFrom(ActualExceptionType))
{
if (attr.Message == null || ex.Message.Contains(attr.Message))
{
type = RESULT_TYPE.SUCCESS;
error = ex;
}
else
{
type = RESULT_TYPE.FAILED_ASSERTION;
error = new AssertException("Expected exception message to contain " +
"[" + attr.Message + "] but actual message was " +
"[" + ex.Message + "]");
}
}
else
{
type = RESULT_TYPE.FAILED_ASSERTION;
error = new AssertException("Expected " + ExpectedExceptionType
+ " but was " + ActualExceptionType);
}
}
else
{
error = ex;
type = ex is AssertException
? RESULT_TYPE.FAILED_ASSERTION: RESULT_TYPE.FAILED_EXECUTION;
}
return(new TestResultEvent(type, this, error));
}
public static int GetNumResults(RESULT_TYPE ResultType, string runId)
{
try
{
using (var cmd = new SqliteCommand(SQL_GET_NUM_RESULTS.Replace("@table_name", Helpers.ResultTypeToTableName(ResultType)), DatabaseManager.Connection, DatabaseManager.Transaction))
{
cmd.Parameters.AddWithValue("@run_id", runId);
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
return(int.Parse(reader["the_count"].ToString()));
}
}
}
}
catch (Exception e)
{
Logger.DebugException(e);
}
return(-1);
}
public abstract List <CompareResult> GetComparisonResults(string baseId, string compareId, string analysesHash, RESULT_TYPE resultType, int offset, int numResults);
void RegScan_MatchItem(cLightning.ROOT_KEY root, string key, string value, string data, RESULT_TYPE id)
{
_iResultsCounter += 1;
}
void RegScan_MatchItem(cLightning.ROOT_KEY root, string key, string value, string data, RESULT_TYPE id)
{
_sMatch = data;
ProblemsCount += 1;
}
public static IEnumerable <CompareResult>?GetComparisonResults(string firstRunId, string secondRunId, RESULT_TYPE resultType, int offset = 0, int numResults = 2147483647)
{
var crs = db?.GetCollection <CompareResult>("CompareResult");
return(crs?.Find(x => x.BaseRunId != null && x.CompareRunId != null && x.BaseRunId.Equals(firstRunId) && x.CompareRunId.Equals(secondRunId) && x.ResultType.Equals(resultType), offset, numResults));
}
public void SetResponse(object response, RESULT_TYPE type)
{
this.Response = response;
this.ErrorMessage = "success";
ErrorCode = (int)type;
}
public void SetErrorResponse(string errorMessage, RESULT_TYPE type)
{
this.ErrorCode = (int)type;
this.ErrorMessage = errorMessage;
this.Response = null;
}
public static int GetNumResults(RESULT_TYPE ResultType, string runId)
{
var wo = db?.GetCollection <WriteObject>("WriteObjects");
return(wo?.Count(Query.And(Query.EQ("RunId", runId), Query.EQ("ColObj.ResultType", (int)ResultType))) ?? 0);
}
public ExecutionResult(int _result)
{
type = RESULT_TYPE.INTEGER;
integerResult = _result;
}
string IdConverter(RESULT_TYPE id)
{
switch (id)
{
case RESULT_TYPE.ControlAppID:
return rm.GetString("SystemScan");
case RESULT_TYPE.ControlClassSubEdit:
return rm.GetString("SystemScan");
case RESULT_TYPE.ControlClassSubExt:
return rm.GetString("SystemScan");
case RESULT_TYPE.ControlClassSubOpen:
return rm.GetString("SystemScan");
case RESULT_TYPE.ControlInterfaceProxy:
return rm.GetString("SystemScan");
case RESULT_TYPE.ControlInterfaceType:
return rm.GetString("SystemScan");
case RESULT_TYPE.ControlProcServer:
return rm.GetString("SystemScan");
case RESULT_TYPE.ControlTypeHelp:
return rm.GetString("SystemScan");
case RESULT_TYPE.ControlTypeLib:
return rm.GetString("SystemScan");
case RESULT_TYPE.ControlTypeWin32:
return rm.GetString("SystemScan");
case RESULT_TYPE.DeepMs:
return rm.GetString("DeepSystemScan");
case RESULT_TYPE.DeepSft:
return rm.GetString("DeepSystemScan");
case RESULT_TYPE.Font:
return rm.GetString("SystemFonts");
case RESULT_TYPE.FullClassName:
return rm.GetString("SystemSoftware");
case RESULT_TYPE.FullClsid:
return rm.GetString("SystemSoftware");
case RESULT_TYPE.FullIcon:
return rm.GetString("SystemSoftware");
case RESULT_TYPE.Help:
return rm.GetString("HelpFiles");
case RESULT_TYPE.HistoryExplorer:
return rm.GetString("HistoryandStartMenu");
case RESULT_TYPE.HistoryLink:
return rm.GetString("HistoryandStartMenu");
case RESULT_TYPE.HistoryMenu:
return rm.GetString("HistoryandStartMenu");
case RESULT_TYPE.HistoryStart:
return rm.GetString("HistoryandStartMenu");
case RESULT_TYPE.Mru:
return rm.GetString("MRULists");
case RESULT_TYPE.Shared:
return rm.GetString("SharedLibraries");
case RESULT_TYPE.Startup:
return rm.GetString("StartupEntries");
case RESULT_TYPE.Uninstall:
return rm.GetString("InstallationStrings");
case RESULT_TYPE.User:
return rm.GetString("UserScan");
case RESULT_TYPE.Vdf:
return rm.GetString("VirtualDevices");
default:
return "";
}
}
//store: root, subkey, value, path, id
//scandata: key root, string key, string value, string path, string img, string name, int scope, int id
void StoreResults(cLightning.ROOT_KEY root, string subkey, string value, string data, RESULT_TYPE id)
{
// ****************************************************
// Trying to check registry key permissions
// ****************************************************
try
{
var permission = new RegistryPermission(RegistryPermissionAccess.Write, root.ToString());
permission.Demand();
}
catch (System.Security.SecurityException ex)
{
return;
}
// ****************************************************
// Trying to check registry key permissions
// ****************************************************
if (_oProcessAsyncBackgroundWorker != null && _oProcessAsyncBackgroundWorker.CancellationPending)
{
return;
}
int i = (int)id;
if (value.Length == 0)
{
value = STR_DEFAULT;
}
Data.Add(new ScanData(root, subkey, value, data, "", IdConverter(id), IdToScope(i), i));
// notify
MatchItem(root, subkey, value, data, id);
}
public ExecutionResult(Boolean _result)
{
type = RESULT_TYPE.BOOLEAN;
booleanResult = _result;
}
//store: root, subkey, value, path, id
//scandata: key root, string key, string value, string path, string img, string name, int scope, int id
private void StoreResults(cLightning.ROOT_KEY root, string subkey, string value, string data, RESULT_TYPE id)
{
int i = (int)id;
if (value.Length == 0)
{
value = STR_DEFAULT;
}
Data.Add(new ScanData(root, subkey, value, data, "", IdConverter(i), IdToScope(i), i));
// notify
MatchItem(root, subkey, value, data, id);
}
public Result(int integerResult)
{
type = RESULT_TYPE.INTEGER;
this.IntegerResult = integerResult;
}
public Result(bool booleanResult)
{
type = RESULT_TYPE.BOOLEAN;
this.BooleanResult = booleanResult;
}
public override List <CompareResult> GetComparisonResults(string baseId, string compareId, RESULT_TYPE exportType)
{
List <CompareResult> records = new List <CompareResult>();
if (MainConnection != null)
{
using (var cmd = new SqliteCommand(GET_COMPARISON_RESULTS, MainConnection.Connection, MainConnection.Transaction))
{
cmd.Parameters.AddWithValue("@first_run_id", baseId);
cmd.Parameters.AddWithValue("@second_run_id", compareId);
cmd.Parameters.AddWithValue("@result_type", exportType);
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
if (reader["serialized"].ToString() is string serialized)
{
records.Add(JsonConvert.DeserializeObject <CompareResult>(serialized));
}
}
}
}
}
return(records);
}
public abstract List <CompareResult> GetComparisonResults(string baseId, string compareId, RESULT_TYPE exportType);
public abstract int GetNumResults(RESULT_TYPE ResultType, string runId);
public TestResultEvent(RESULT_TYPE f, TestMethod m, Exception e)
{
Nature = f;
Method = m;
Error = e;
}
