public static PolicyCollection GetAllPolicies(CxRestContext ctx, CancellationToken token) { return(WebOperation.ExecuteGet <PolicyCollection>( ctx.Json.CreateMnoClient , (response) => { JToken jt = JToken.Load(new JsonTextReader(new StreamReader (response.Content.ReadAsStreamAsync().Result))); return ParsePolicies(ctx, token, jt); } , CxRestContext.MakeUrl(ctx.MnoUrl, POLICY_LIST_URL_SUFFIX) , ctx , token , exceptionErrorLogic: (ex) => { if (ex is System.AggregateException) { foreach (var x in (ex as System.AggregateException).InnerExceptions) { if (x is System.Net.Http.HttpRequestException) { return false; } } } return true; })); }
public static PolicyCollection GetAllPolicies(CxRestContext ctx, CancellationToken token) { try { using (var client = ctx.Json.CreateMnoClient()) using (var policyPayload = client.GetAsync(CxRestContext.MakeUrl(ctx.MnoUrl, POLICY_LIST_URL_SUFFIX), token).Result) { if (!policyPayload.IsSuccessStatusCode) { throw new InvalidOperationException ("Unable to retrieve policies."); } JToken jt = JToken.Load(new JsonTextReader(new StreamReader (policyPayload.Content.ReadAsStreamAsync().Result))); return(ParsePolicies(ctx, token, jt)); } } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
public static ViolatedPolicyCollection GetViolations(CxRestContext ctx, CancellationToken token, int projectId, PolicyCollection policies) { try { using (var client = ctx.Json.CreateMnoClient()) using (var violationsPayload = client.GetAsync(CxRestContext.MakeUrl(ctx.MnoUrl, String.Format(URL_SUFFIX, projectId)), token).Result) { if (!violationsPayload.IsSuccessStatusCode) { throw new InvalidOperationException ($"Unable to retrieve rule violations for project {projectId}."); } using (var sr = new StreamReader (violationsPayload.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return(ParseViolatedRules(policies, projectId, jt)); } } } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
public static GenStatus GetReportGenerationStatus(CxRestContext ctx, CancellationToken token, String reportId) { try { using (var client = ctx.Json.CreateSastClient()) { using (var scanReportStatus = client.GetAsync( CxRestContext.MakeUrl(ctx.Url, String.Format(URL_SUFFIX, reportId)), token).Result) { if (!scanReportStatus.IsSuccessStatusCode) { return(GenStatus.None); } using (var sr = new StreamReader (scanReportStatus.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return(ReadStatus(jt)); } } } } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
public static ScanSummary GetReport(CxRestContext ctx, CancellationToken token, String scanId) { try { String url = CxRestContext.MakeUrl(ctx.Url, URL_SUFFIX, new Dictionary <String, String>() { { "scanId", Convert.ToString(scanId) } }); using (var client = ctx.Json.CreateSastClient()) using (var scanSummary = client.GetAsync(url, token).Result) { if (!scanSummary.IsSuccessStatusCode) { throw new InvalidOperationException(scanSummary.ReasonPhrase); } using (var sr = new StreamReader (scanSummary.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return(ParseScanSummary(jt)); } } } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
public static IEnumerable <int> GetPolicyIdsForProject(CxRestContext ctx, CancellationToken token, int projectId) { try { using (var client = ctx.Json.CreateMnoClient()) using (var policyPayload = client.GetAsync(CxRestContext.MakeUrl(ctx.MnoUrl, String.Format(PROJECT_POLICY_URL_SUFFIX, projectId)), token).Result) { if (!policyPayload.IsSuccessStatusCode) { throw new InvalidOperationException ($"Unable to retrieve policies for project {projectId}."); } JToken jt = JToken.Load(new JsonTextReader(new StreamReader (policyPayload.Content.ReadAsStreamAsync().Result))); LinkedList <int> policyIds = new LinkedList <int>(); using (JTokenReader reader = new JTokenReader(jt)) while (JsonUtils.MoveToNextProperty(reader, "id")) { policyIds.AddLast(Convert.ToInt32(((JProperty)reader.CurrentToken).Value)); } return(policyIds); } } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
public static IEnumerable <Project> GetProjects(CxRestContext ctx, CancellationToken token) { try { using (var client = ctx.Json.CreateSastClient()) using (var projects = client.GetAsync( CxRestContext.MakeUrl(ctx.Url, URL_SUFFIX), token).Result) { if (token.IsCancellationRequested) { return(null); } if (!projects.IsSuccessStatusCode) { throw new InvalidOperationException(projects.ReasonPhrase); } using (var sr = new StreamReader (projects.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return(new ProjectReader(jt, ctx, token)); } } } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
public static String GetGeneratedReportId(CxRestContext ctx, CancellationToken token, String scanId, ReportTypes type) { var dict = new Dictionary <String, String>() { { "reportType", type.ToString() }, { "scanId", scanId } }; return(WebOperation.ExecutePost <String>( ctx.Json.CreateSastClient , (response) => { using (var sr = new StreamReader(response.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return ReadReportId(jt); } } , CxRestContext.MakeUrl(ctx.Url, URL_SUFFIX) , () => new FormUrlEncodedContent(dict) , ctx , token)); }
/// <summary> /// The main logic for invoking a transformation. It does not return until a sweep /// for new scans is performed across all projects. /// </summary> /// <param name="concurrentThreads">The number of concurrent scan transformation threads.</param> /// <param name="previousStatePath">A folder path where files will be created to store any state /// data required to resume operations across program runs.</param> /// <param name="ctx"></param> /// <param name="outFactory">The factory implementation for making IOutput instances /// used for outputting various record types.</param> /// <param name="records">The names of the supported record types that will be used by /// the IOutputFactory to create the correct output implementation instance.</param> /// <param name="token">A cancellation token that can be used to stop processing of data if /// the task needs to be interrupted.</param> public static void DoTransform(int concurrentThreads, String previousStatePath, String instanceId, CxRestContext ctx, IOutputFactory outFactory, RecordNames records, CancellationToken token) { try { Transformer xform = new Transformer(ctx, token, previousStatePath) { ThreadOpts = new ParallelOptions() { CancellationToken = token, MaxDegreeOfParallelism = concurrentThreads }, ProjectInfoOut = outFactory.newInstance(records.ProjectInfo), SastScanSummaryOut = outFactory.newInstance(records.SASTScanSummary), SastScanDetailOut = outFactory.newInstance(records.SASTScanDetail), PolicyViolationDetailOut = outFactory.newInstance(records.PolicyViolations), ScaScanSummaryOut = outFactory.newInstance(records.SCAScanSummary), ScaScanDetailOut = outFactory.newInstance(records.SCAScanDetail), InstanceId = instanceId }; xform.ExecuteSweep(); } catch (Exception ex) { _log.Error("Unhandled exception caught.", ex); } }
public static Stream GetVulnerabilities(CxRestContext ctx, CancellationToken token, String reportId) { return(WebOperation.ExecuteGet <Stream>( ctx.Xml.CreateSastClient , (response) => { var report = response.Content.ReadAsStreamAsync().Result; var mem = new SharedMemoryStream(response.Content.Headers.ContentLength.Value); int readAmount = 0; byte[] buffer = new byte[BUFFER_SIZE]; do { readAmount = report.Read(buffer, 0, BUFFER_SIZE); mem.Write(buffer, 0, readAmount); if (readAmount < BUFFER_SIZE) { mem.Seek(0, SeekOrigin.Begin); } } while (readAmount == BUFFER_SIZE); return mem; } , CxRestContext.MakeUrl(ctx.Url, String.Format(URL_SUFFIX, reportId)) , ctx , token)); }
internal ProjectReader(JToken json, CxRestContext ctx, CancellationToken token) { _json = json; _ctx = ctx; _reader = new JTokenReader(_json); _token = token; }
public static IEnumerable <RuleDescriptor> GetRulesForPolicy(CxRestContext ctx, CancellationToken token, int policyId) { try { using (var client = ctx.Json.CreateMnoClient()) using (var rulePayload = client.GetAsync(CxRestContext.MakeUrl(ctx.MnoUrl, String.Format(URL_SUFFIX, policyId)), token).Result) { if (!rulePayload.IsSuccessStatusCode) { throw new InvalidOperationException ($"Unable to retrieve rules for policy {policyId}."); } using (var sr = new StreamReader (rulePayload.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return(ParseRules(ctx, token, jt)); } } } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
private Transformer(CxRestContext ctx, CancellationToken token, String previousStatePath, IProjectFilter filter) { RestContext = ctx; CancelToken = token; Filter = filter; _state = new CrawlState(previousStatePath); ResolveScans().Wait(); }
public static IEnumerable <Library> GetLibraries(CxRestContext ctx, CancellationToken token, String scanId) { int curPage = 1; List <Library> returnLibs = new List <Library>(); try { Func <int, String> url = (pg) => CxRestContext.MakeUrl(ctx.Url, URL_SUFFIX, new Dictionary <String, String>() { { "scanId", Convert.ToString(scanId) }, { "page", Convert.ToString(pg) }, { "itemsPerPage", PAGE_SIZE } }); while (true) { using (var client = ctx.Json.CreateSastClient()) using (var libraryResponse = client.GetAsync(url(curPage++), token).Result) { if (token.IsCancellationRequested) { return(null); } if (!libraryResponse.IsSuccessStatusCode) { throw new InvalidOperationException(libraryResponse.ReasonPhrase); } using (var sr = new StreamReader (libraryResponse.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); var beforeCount = returnLibs.Count; returnLibs.AddRange(new LibrariesReader(jt)); if (returnLibs.Count == beforeCount) { break; } } } } return(returnLibs); } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
public static bool CalculateViolations(CxRestContext ctx, CancellationToken token, int projectId) { return(WebOperation.ExecutePost <bool>( ctx.Json.CreateMnoClient , (response) => response.StatusCode == HttpStatusCode.Created , CxRestContext.MakeUrl(ctx.MnoUrl, String.Format(URL_SUFFIX, projectId)) , null , ctx , token)); }
static void Main(string[] args) { appLog.Info("Start"); appLog.InfoFormat("CWD: {0}", Directory.GetCurrentDirectory()); var builder = new CxRestContext.CxRestContextBuilder(); builder.WithSASTServiceURL(Config.Connection.URL) .WithOpTimeout(Config.Connection.TimeoutSeconds) .WithSSLValidate(Config.Connection.ValidateCertificates) .WithUsername(Config.Credentials.Username) .WithPassword(Config.Credentials.Password). WithMNOServiceURL(Config.Connection.MNOUrl); using (CancellationTokenSource t = new CancellationTokenSource()) { try { var outFactory = MakeFactory(); CxRestContext ctx = builder.Build(); Transformer.DoTransform(Config.Service.ConcurrentThreads, Config.Service.StateDataStoragePath, Config.Service.InstanceIdentifier, ctx, outFactory, new RecordNames() { SASTScanSummary = Config.Service.SASTScanSummaryRecordName, SASTScanDetail = Config.Service.SASTScanDetailRecordName, SCAScanSummary = Config.Service.SCAScanSummaryRecordName, SCAScanDetail = Config.Service.SCAScanDetailRecordName, ProjectInfo = Config.Service.ProjectInfoRecordName, PolicyViolations = Config.Service.PolicyViolationsRecordName }, t.Token); AuditTrailCrawler.CrawlAuditTrails(outFactory, t.Token); } catch (ProcessFatalException pfe) { appLog.Error("Fatal exception caught, program ending.", pfe); } catch (Exception ex) { appLog.Error("Unhandled exception caught, program ending.", ex); } } appLog.Info("End"); }
private static IEnumerable <RuleDescriptor> ParseRules(CxRestContext ctx, CancellationToken token, JToken rulePayload) { using (var reader = new JTokenReader(rulePayload)) { LinkedList <RuleDescriptor> rules = new LinkedList <RuleDescriptor>(); while (JsonUtils.MoveToNextProperty(reader, "ruleId")) { RuleDescriptor rule = new RuleDescriptor() { RuleId = Convert.ToInt32(((JProperty)reader.CurrentToken).Value) }; if (!JsonUtils.MoveToNextProperty(reader, "name")) { continue; } rule.Name = ((JProperty)reader.CurrentToken).Value.ToString(); if (!JsonUtils.MoveToNextProperty(reader, "description")) { continue; } rule.Description = ((JProperty)reader.CurrentToken).Value.ToString(); if (!JsonUtils.MoveToNextProperty(reader, "scanType")) { continue; } rule.ScanProduct = ((JProperty)reader.CurrentToken).Value.ToString(); if (!JsonUtils.MoveToNextProperty(reader, "ruleType")) { continue; } rule.RuleType = ((JProperty)reader.CurrentToken).Value.ToString(); if (!JsonUtils.MoveToNextProperty(reader, "createdOn")) { continue; } rule.CreatedOn = JsonUtils.UtcEpochTimeToDateTime (Convert.ToInt64(((JProperty)reader.CurrentToken).Value) / 1000); rules.AddLast(rule); } return(rules); } }
public static String GetProjectPoliciesSingleField(CxRestContext ctx, CancellationToken token, int projectId) { return(WebOperation.ExecuteGet <String>( ctx.Json.CreateMnoClient , (response) => { JToken jt = JToken.Load(new JsonTextReader(new StreamReader (response.Content.ReadAsStreamAsync().Result))); return GetFlatPolicyNames(jt); } , CxRestContext.MakeUrl(ctx.MnoUrl, String.Format(PROJECT_POLICY_URL_SUFFIX, projectId)) , ctx , token)); }
public static bool CalculateViolations(CxRestContext ctx, CancellationToken token, int projectId) { try { using (var client = ctx.Json.CreateMnoClient()) using (var calculationResponse = client.PostAsync(CxRestContext.MakeUrl(ctx.MnoUrl, String.Format(URL_SUFFIX, projectId)), null, token).Result) return(calculationResponse.StatusCode == HttpStatusCode.Created); } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
public static T ExecuteGet <T>(Func <CxRestClient.IO.CxRestClient> clientFactory, Func <HttpResponseMessage, T> onSuccess, String url, CxRestContext ctx, CancellationToken token, Func <HttpResponseMessage, Boolean> responseErrorLogic = null, Func <Exception, Boolean> exceptionErrorLogic = null) { return(ExecuteOperation <T>( clientFactory , onSuccess , (client) => { _log.Trace($"Executing GET operation at {url}"); return client.GetAsync(url, token).Result; } , ctx , token , responseErrorLogic , exceptionErrorLogic)); }
public static IEnumerable <Preset> GetPresets(CxRestContext ctx, CancellationToken token) { return(WebOperation.ExecuteGet <PresetReader>( ctx.Json.CreateSastClient , (response) => { using (var sr = new StreamReader(response.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return new PresetReader(jt); } } , CxRestContext.MakeUrl(ctx.Url, URL_SUFFIX) , ctx , token)); }
private static PolicyCollection ParsePolicies(CxRestContext ctx, CancellationToken token, JToken policyPayload) { PolicyCollection result = new PolicyCollection(); using (JTokenReader reader = new JTokenReader(policyPayload)) while (JsonUtils.MoveToNextProperty(reader, "id")) { PolicyDescriptor policy = new PolicyDescriptor() { PolicyId = Convert.ToInt32(((JProperty)reader.CurrentToken).Value) }; if (!JsonUtils.MoveToNextProperty(reader, "name")) { continue; } policy.Name = ((JProperty)reader.CurrentToken).Value.ToString(); if (!JsonUtils.MoveToNextProperty(reader, "description")) { continue; } policy.Description = ((JProperty)reader.CurrentToken).Value.ToString(); if (!JsonUtils.MoveToNextProperty(reader, "isActive")) { continue; } policy.isActive = Convert.ToBoolean(((JProperty)reader.CurrentToken).Value); if (!JsonUtils.MoveToNextProperty(reader, "createdOn")) { continue; } policy.CreatedOn = JsonUtils.UtcEpochTimeToDateTime (Convert.ToInt64(((JProperty)reader.CurrentToken).Value) / 1000); var rules = CxMnoPolicyRules.GetRulesForPolicy(ctx, token, policy.PolicyId); policy.AddRule(rules); result.AddPolicy(policy); } return(result); }
public static IEnumerable <Vulnerability> GetVulnerabilities (CxRestContext ctx, CancellationToken token, String scanId) { int curPage = 1; List <Vulnerability> returnVulns = new List <Vulnerability>(); Func <int, String> url = (pg) => CxRestContext.MakeUrl(ctx.Url, URL_SUFFIX, new Dictionary <String, String>() { { "scanId", Convert.ToString(scanId) }, { "page", Convert.ToString(pg) }, { "itemsPerPage", PAGE_SIZE } }); while (true) { if (token.IsCancellationRequested) { return(null); } var beforeCount = returnVulns.Count; returnVulns.AddRange(WebOperation.ExecuteGet <IEnumerable <Vulnerability> >( ctx.Json.CreateSastClient , (response) => { using (var sr = new StreamReader(response.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return(new VulnerabilityReader(jt)); } } , url(curPage++) , ctx , token)); if (returnVulns.Count == beforeCount) { break; } } return(returnVulns); }
public static IEnumerable <Scan> GetScans(CxRestContext ctx, CancellationToken token, int projectId) { try { String url = CxRestContext.MakeUrl(ctx.Url, URL_SUFFIX, new Dictionary <String, String>() { { "projectId", Convert.ToString(projectId) }, { "itemsPerPage", "5000" } }); using (var client = ctx.Json.CreateSastClient()) using (var scans = client.GetAsync(url, token).Result) { if (token.IsCancellationRequested) { return(null); } // If no OSA license, result is 403. Return an empty set of scans. if (scans.StatusCode == System.Net.HttpStatusCode.Forbidden) { return(new ScansReader()); } if (!scans.IsSuccessStatusCode) { throw new InvalidOperationException(scans.ReasonPhrase); } using (var sr = new StreamReader (scans.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return(new ScansReader(jt, projectId)); } } } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
public static GenStatus GetReportGenerationStatus(CxRestContext ctx, CancellationToken token, String reportId) { return(WebOperation.ExecuteGet <GenStatus>( ctx.Json.CreateSastClient , (response) => { using (var sr = new StreamReader(response.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return ReadStatus(jt); } } , CxRestContext.MakeUrl(ctx.Url, String.Format(URL_SUFFIX, reportId)) , ctx , token)); }
public static ViolatedPolicyCollection GetViolations(CxRestContext ctx, CancellationToken token, int projectId, PolicyCollection policies) { return(WebOperation.ExecuteGet <ViolatedPolicyCollection>( ctx.Json.CreateMnoClient , (response) => { using (var sr = new StreamReader(response.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return ParseViolatedRules(policies, projectId, jt); } } , CxRestContext.MakeUrl(ctx.MnoUrl, String.Format(URL_SUFFIX, projectId)) , ctx , token)); }
public static IEnumerable <RuleDescriptor> GetRulesForPolicy(CxRestContext ctx, CancellationToken token, int policyId) { return(WebOperation.ExecuteGet <IEnumerable <RuleDescriptor> >( ctx.Json.CreateMnoClient , (response) => { using (var sr = new StreamReader(response.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return ParseRules(ctx, token, jt); } } , CxRestContext.MakeUrl(ctx.MnoUrl, String.Format(URL_SUFFIX, policyId)) , ctx , token)); }
public static ScanSettings GetScanSettings(CxRestContext ctx, CancellationToken token, int projectId) { String restUrl = CxRestContext.MakeUrl(ctx.Url, URL_SUFFIX); return(WebOperation.ExecuteGet <ScanSettings>( ctx.Json.CreateSastClient , (response) => { using (var sr = new StreamReader(response.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return new ScanSettings(jt); } } , CxRestContext.MakeUrl(restUrl, Convert.ToString(projectId)) , ctx , token)); }
public static String GetGeneratedReportId(CxRestContext ctx, CancellationToken token, String scanId, ReportTypes type) { try { using (var client = ctx.Json.CreateSastClient()) { var dict = new Dictionary <String, String>() { { "reportType", type.ToString() }, { "scanId", scanId } }; using (var payload = new FormUrlEncodedContent(dict)) { using (var scanReportTicket = client.PostAsync( CxRestContext.MakeUrl(ctx.Url, URL_SUFFIX), payload, token).Result) { if (!scanReportTicket.IsSuccessStatusCode) { throw new InvalidOperationException ($"Scan report generation request for scan {scanId} returned " + $"{scanReportTicket.StatusCode}"); } using (var sr = new StreamReader (scanReportTicket.Content.ReadAsStreamAsync().Result)) using (var jtr = new JsonTextReader(sr)) { JToken jt = JToken.Load(jtr); return(ReadReportId(jt)); } } } } } catch (HttpRequestException hex) { _log.Error("Communication error.", hex); throw hex; } }
public static String GetProjectPoliciesSingleField(CxRestContext ctx, CancellationToken token, int projectId) { using (var client = ctx.Json.CreateMnoClient()) { using (var policyPayload = client.GetAsync(CxRestContext.MakeUrl(ctx.MnoUrl, String.Format(PROJECT_POLICY_URL_SUFFIX, projectId)), token).Result) { if (!policyPayload.IsSuccessStatusCode) { throw new InvalidOperationException ($"Unable to retrieve policies for project {projectId}."); } JToken jt = JToken.Load(new JsonTextReader(new StreamReader (policyPayload.Content.ReadAsStreamAsync().Result))); return(GetFlatPolicyNames(jt)); } } }