private static void RunTask(FullTest ft, string address, int sslPort, ReportAggregator aggregator, SSLTestArgs args)
{
try {
Report rp = Run(ft, address, sslPort, args, @"raw_results\", "_" + address + "_" + sslPort);
Report.UpdateReportAggregator(aggregator, rp);
aggregator.IncrementScanCounter();
Console.WriteLine("Done testing {0}:{1}\n", address, sslPort);
} catch (Exception e) {
Console.WriteLine("Failed to test {0}:{1} due to {2}", address, sslPort, e.Message);
}
}
private static void InspectCerts(ReportAggregator aggregator, Report report, string serverUnderTest)
{
foreach (var x509Chain in report.chains.Values)
{
int n = x509Chain.Elements.Length;
for (int i = 0; i < n; i++)
{
X509Cert xc = x509Chain.ElementsRev[0];
if (xc != null && xc.ValidTo.CompareTo(DateTime.Now) < 0)
{
aggregator.AddOverduedCertificate(serverUnderTest, xc.ValidTo);
return;
}
}
}
}
private static bool StartInstances(XmlDocument xmlDoc, out TaskCreator taskCreator, out TaskDistributor taskDistributor,
out ReportAggregator reportAggregator, out IncentiveEngine incentiveEngine, out Repository repository,
out TransactionNode transactionNode)
{
taskCreator = null;
taskDistributor = null;
reportAggregator = null;
incentiveEngine = null;
repository = null;
transactionNode = null;
int port;
string serverMgrURL;
string repositoryURL = null;
string transactionNodeURL = null;
XmlNode xmlNode;
try
{
xmlNode = xmlDoc.GetElementsByTagName(Global.SERVER_MANAGER_NAME)[0];
if (xmlNode != null)
{
serverMgrURL = $"tcp://{xmlNode.Attributes["hostName"].Value}:{xmlNode.Attributes["port"].Value}/{Global.SERVER_MANAGER_NAME}";
}
else
{
Console.WriteLine("Server Manager Parameters are not defined in the XML!");
return(false);
}
Console.WriteLine("[SERVER MANAGER] - Node Started");
Console.WriteLine("----------------------------" + Environment.NewLine);
/*********REPOSITORY**************/
xmlNode = xmlDoc.GetElementsByTagName(Global.REPOSITORY_NAME)[0];
if (xmlNode != null)
{
repositoryURL = $"tcp://{xmlNode.Attributes["hostName"].Value}:{xmlNode.Attributes["port"].Value}/{Global.REPOSITORY_NAME}";
int.TryParse(xmlNode.Attributes["port"].Value, out port);
repository = new Repository(xmlNode.Attributes["hostName"].Value, port, Global.REPOSITORY_NAME);
}
/**************TRANSACTION NODE********/
xmlNode = xmlDoc.GetElementsByTagName(Global.TRANSACTION_NODE_NAME)[0];
if (xmlNode != null)
{
int.TryParse(xmlNode.Attributes["port"].Value, out port);
transactionNode = new TransactionNode(xmlNode.Attributes["hostName"].Value, port, Global.TRANSACTION_NODE_NAME);
transactionNodeURL = $"tcp://{xmlNode.Attributes["hostName"].Value}:{xmlNode.Attributes["port"].Value}/{Global.TRANSACTION_NODE_NAME}";
}
/**************TASK CREATOR********/
xmlNode = xmlDoc.GetElementsByTagName(Global.TASK_CREATOR_NAME)[0];
if (xmlNode != null)
{
int.TryParse(xmlNode.Attributes["port"].Value, out port);
taskCreator = new TaskCreator(xmlNode.Attributes["hostName"].Value, port, Global.TASK_CREATOR_NAME);
}
/***********TASK DISTRIBUTOR********/
xmlNode = xmlDoc.GetElementsByTagName(Global.TASK_DISTRIBUTOR_NAME)[0];
if (xmlNode != null)
{
int.TryParse(xmlNode.Attributes["port"].Value, out port);
taskDistributor = new TaskDistributor(xmlNode.Attributes["hostName"].Value, port, Global.TASK_DISTRIBUTOR_NAME);
}
/*********REPORT AGGREGATOR**********/
xmlNode = xmlDoc.GetElementsByTagName(Global.REPORT_AGGREGATOR_NAME)[0];
if (xmlNode != null)
{
int.TryParse(xmlNode.Attributes["port"].Value, out port);
reportAggregator = new ReportAggregator(xmlNode.Attributes["hostName"].Value, port, Global.REPORT_AGGREGATOR_NAME);
}
/***********INCENTIVE ENGINE********/
xmlNode = xmlDoc.GetElementsByTagName(Global.INCENTIVE_ENGINE_NAME)[0];
if (xmlNode != null)
{
int.TryParse(xmlNode.Attributes["port"].Value, out port);
incentiveEngine = new IncentiveEngine(xmlNode.Attributes["hostName"].Value, port, Global.INCENTIVE_ENGINE_NAME,
repositoryURL, transactionNodeURL);
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(false);
}
}
// private static SSLTestArgs _testArgs = new SSLTestArgs(new List<string>());
static void Process(string[] args)
{
FullTest ft = new FullTest();
SSLTestArgs _testArgs = new SSLTestArgs(new List <string>());
for (int i = 0; i < args.Length; i++)
{
string a = args[i];
switch (a.ToLowerInvariant())
{
case "-h":
case "-help":
case "--help":
Usage();
break;
case "-v":
case "--verbose":
ft.Verbose = true;
break;
case "-sni":
case "--sni":
if (++i >= args.Length)
{
Usage();
}
ft.ExplicitSNI = args[i];
break;
case "-all":
case "--all-suites":
ft.AllSuites = true;
break;
case "-min":
case "--min-version":
if (++i >= args.Length)
{
Usage();
}
ft.MinVersion = ParseVersion(args[i]);
if (ft.MinVersion < M.SSLv20 ||
ft.MinVersion > M.TLSv12)
{
Usage();
}
break;
case "-max":
case "--max-version":
if (++i >= args.Length)
{
Usage();
}
ft.MaxVersion = ParseVersion(args[i]);
if (ft.MaxVersion < M.SSLv20 ||
ft.MaxVersion > M.TLSv12)
{
Usage();
}
break;
case "-certs":
case "--with-certificates":
_testArgs.WithCerts = true;
break;
case "-prox":
case "--proxy":
if (++i >= args.Length)
{
Usage();
}
_testArgs.ProxString = args[i];
break;
case "-proxssl":
case "--proxy-ssl":
ft.ProxSSL = true;
break;
case "-ec":
case "--with-ec-ext":
ft.AddECExt = true;
break;
case "-text":
case "--text-output":
if (++i >= args.Length)
{
Usage();
}
_testArgs.TextOut = args[i];
break;
case "-json":
case "--json-output":
if (++i >= args.Length)
{
Usage();
}
_testArgs.JsonOut = args[i];
break;
case "-ar":
case "--address-range":
_testArgs.MultiAddr = true;
break;
case "-ap":
case "--all-ports":
_testArgs.IterateOverAllSslPorts = true;
break;
default:
if (a.Length > 0 && a[0] == '-')
{
Usage();
}
_testArgs.R.Add(a);
break;
}
}
args = _testArgs.R.ToArray();
if (args.Length == 0 || args.Length > 2)
{
Usage();
}
string serverName = args[0];
int port = -1;
if (args.Length == 2)
{
try
{
port = Int32.Parse(args[1]);
}
catch (Exception)
{
Usage();
}
}
ReportAggregator aggregator = new ReportAggregator();
aggregator.SetSubnet(serverName);
if (!_testArgs.MultiAddr)
{
Report.UpdateReportAggregator(aggregator, Run(ft, serverName, port, _testArgs));
}
else
{
IpRange range = new IpRange(serverName);
IpRangeEnumerator enumerator = new IpRangeEnumerator();
SslPortEnumerator portEnumerator = new SslPortEnumerator();
Console.WriteLine("Starting test...");
Directory.CreateDirectory("raw_results");
foreach (var address in enumerator.GetIPRange(range))
{
RunTask(ft, address, 443, aggregator, _testArgs);
}
ZipFile.CreateFromDirectory("raw_results", "raw_results_" + serverName.Replace("/", "_") + ".zip");
Directory.Delete("raw_results", true);
}
aggregator.SaveCsv();
aggregator.SaveCerts();
}
public LiquidityReportService(ReportAggregator aggregator, DatabaseContextFactory contextFactory)
{
_aggregator = aggregator;
_contextFactory = contextFactory;
}
public static void UpdateReportAggregator(ReportAggregator aggregator, Report report)
{
String serverUnderTest = $"{report.ConnName}:{report.ConnPort}";
if (report.SSLv2Chain != null)
{
aggregator.AddSsl2Cert(serverUnderTest, report.SSLv2Chain);
X509Cert xc = report.SSLv2Chain.ElementsRev[0];
if (xc != null && xc.ValidTo.CompareTo(DateTime.Now) < 0)
{
aggregator.AddOverduedCertificate(serverUnderTest, xc.ValidTo);
}
}
if (report.ssl2Suites != null && report.ssl2Suites.Length > 0)
{
aggregator.AddSuportedSslVersion(M.VersionString(M.SSLv20));
foreach (int s in report.ssl2Suites)
{
aggregator.AddSupportedCipherSuite(CipherSuite.ToNameV2(s));
}
}
aggregator.AddSsl3Certs(serverUnderTest, report.chains.Values);
InspectCerts(aggregator, report, serverUnderTest);
foreach (int v in report.suites.Keys)
{
aggregator.AddSuportedSslVersion(M.VersionString(v));
SupportedCipherSuites scs = report.suites[v];
if (scs.PrefClient)
{
aggregator.AddCipherSuiteSelectionMode("uses client preferences");
}
else if (scs.PrefServer)
{
aggregator.AddCipherSuiteSelectionMode("enforce server preferences");
}
else
{
aggregator.AddCipherSuiteSelectionMode("complex");
}
foreach (int s in scs.Suites)
{
CipherSuite cs;
string strength;
string fsf;
string anon;
string kt;
if (CipherSuite.ALL.TryGetValue(s, out cs))
{
strength = cs.Strength.ToString();
fsf = cs.HasForwardSecrecy ? "f" : "-";
anon = cs.IsAnonymous ? "A" : "-";
kt = cs.ServerKeyType;
}
else
{
strength = "?";
fsf = "?";
anon = "?";
kt = "?";
}
aggregator.AddSupportedCipherSuite($"{strength}{fsf}{anon} (key: {kt,4}) {CipherSuite.ToName(s)}");
}
}
foreach (var warning in report.Warnings)
{
aggregator.AddWarning(warning.Value);
}
}
