Adding compiler data to AppInsights

src/BinSkim.Driver/AnalyzeCommand.cs

@@ -43,6 +43,8 @@ protected override BinaryAnalyzerContext CreateContext(AnalyzeOptions options, I
                 ShouldWarnVerbose = false;
             }
 
+            binaryAnalyzerContext.CompilerDataLogger = new CompilerDataLogger(binaryAnalyzerContext, options.RepositoryUri, options.PipelineName);
+
             return binaryAnalyzerContext;
         }
 
@@ -68,6 +70,8 @@ public override int Run(AnalyzeOptions analyzeOptions)
 
             int result = base.Run(analyzeOptions);
 
+            CompilerDataLogger.Flush();
+
             // In BinSkim, no rule is ever applicable to every target type. For example,
             // we have checks that are only relevant to either 32-bit or 64-bit binaries.
             // Because of this, the return code bit for RuleNotApplicableToTarget is not

src/BinSkim.Driver/AnalyzeOptions.cs

@@ -43,5 +43,15 @@ public class AnalyzeOptions : AnalyzeOptionsBase
             HelpText = "Emit verbose output. The resulting comprehensive report is designed to provide appropriate evidence for compliance scenarios.")]
         [Obsolete("Use --level and --kind instead.")]
         public bool Verbose { get; set; }
+
+        [Option(
+            "repository-uri",
+            HelpText = "RepositoryUri is required to rule BA4001 and BA4002.")]
+        public string RepositoryUri { get; set; }
+
+        [Option(
+            "pipeline-name",
+            HelpText = "PipelineName is required to rule BA4001 and BA4002.")]
+        public string PipelineName { get; set; }
     }
 }

src/BinSkim.Rules/DwarfRules/BA4002.ReportDwarfCompilerData.cs

@@ -91,15 +91,7 @@ private void PrintCompilerData(BinaryAnalyzerContext context, string language, I
 
                     processedRecords.Add(currentRecord);
 
-                    Console.Write($"{context.TargetUri.LocalPath},");
-                    Console.Write($"{compiler.Compiler},");
-                    Console.Write($"{compiler.Version},");
-                    Console.Write($"{compiler.Version},");
-                    Console.Write($"{language},");
-                    Console.Write($"{file},");
-                    Console.Write($"{file},");
-                    Console.Write($"{context?.Hashes?.Sha256},");
-                    Console.WriteLine();
+                    context.CompilerDataLogger.Write(compiler.Compiler.ToString(), compiler.Version.ToString(), language, file);
                 }
             }
         }

src/BinSkim.Rules/PERules/BA4001.ReportPECompilerData.cs

@@ -48,14 +48,14 @@ public override void AnalyzePortableExecutableAndPdb(BinaryAnalyzerContext conte
 
             if (PrintHeader)
             {
-                Console.WriteLine("Target,Compiler Name,Compiler BackEnd Version,Compiler FrontEnd Version,Language,Module Name,Module Library,Hash,Error");
+                context.CompilerDataLogger.PrintHeader();
                 PrintHeader = false;
             }
 
             if (pdb == null)
             {
-                Console.Write(context.TargetUri.LocalPath + ",");
-                Console.WriteLine($",,,,,,{context?.Hashes?.Sha256},{target.PdbParseException.Message}");
+                string errorMessage = target.PdbParseException.Message;
+                context.CompilerDataLogger.WriteException(errorMessage);
                 return;
             }
 
@@ -83,7 +83,7 @@ public override void AnalyzePortableExecutableAndPdb(BinaryAnalyzerContext conte
                         omDetails.CompilerFrontEndVersion + "," +
                         omDetails.Language;
 
-                    if (!records.TryGetValue(record, out ObjectModuleDetails value))
+                    if (!records.ContainsKey(record))
                     {
                         records[record] = omDetails;
                     }
@@ -92,18 +92,7 @@ public override void AnalyzePortableExecutableAndPdb(BinaryAnalyzerContext conte
 
             foreach (KeyValuePair<string, ObjectModuleDetails> kv in records)
             {
-                string compilerData = kv.Key;
-                ObjectModuleDetails omDetails = kv.Value;
-
-                string name = omDetails.Name?.Replace(",", "_");
-                string library = omDetails.Library?.Replace(",", ";");
-
-                Console.Write($"{context.TargetUri.LocalPath},");
-                Console.Write($"{compilerData},");
-                Console.Write($"{name},");
-                Console.Write($"{(name == library ? string.Empty : library)},");
-                Console.Write($"{context?.Hashes?.Sha256},");
-                Console.WriteLine();
+                context.CompilerDataLogger.Write(kv.Key, kv.Value);
             }
         }
     }

src/BinSkim.Sdk/BinSkim.Sdk.csproj

@@ -9,6 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.ApplicationInsights" Version="2.17.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="System.Collections.Immutable" Version="5.0.0" />
   </ItemGroup>

src/BinSkim.Sdk/BinaryAnalyzerContext.cs

@@ -55,6 +55,7 @@ public Uri TargetUri
                 this.uri = value;
             }
         }
+
         public bool TracePdbLoads { get; set; }
 
         public string SymbolPath { get; set; }
@@ -77,6 +78,8 @@ public string MimeType
         public bool AnalysisComplete { get; set; }
         public DefaultTraces Traces { get; set; }
 
+        public ICompilerDataLogger CompilerDataLogger { get; set; }
+
         private bool disposed = false;
 
         protected virtual void Dispose(bool disposing)

src/BinSkim.Sdk/BinaryTargetManager.cs

@@ -7,7 +7,7 @@
 
 namespace Microsoft.CodeAnalysis.IL.Sdk
 {
-    internal class BinaryTargetManager
+    internal static class BinaryTargetManager
     {
         // We may want to consider changing this to an extension/plugin model rather than a hardcoded list of supported binary parsers.
         // However, for now this will do.

src/BinSkim.Sdk/CompilerDataLogger.cs

@@ -0,0 +1,172 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Security;
+
+using Microsoft.ApplicationInsights;
+using Microsoft.ApplicationInsights.Extensibility;
+using Microsoft.CodeAnalysis.BinaryParsers.ProgramDatabase;
+using Microsoft.CodeAnalysis.Sarif;
+
+namespace Microsoft.CodeAnalysis.IL.Sdk
+{
+    public class CompilerDataLogger : ICompilerDataLogger
+    {
+        private const string CompilerEventName = "CompilerInformation";
+
+        private readonly bool appInsightsRegistered;
+
+        private readonly string sha256;
+        private readonly string localPath;
+        private readonly string repositoryUri;
+        private readonly string pipelineName;
+
+        private static TelemetryClient s_telemetryClient;
+        private static TelemetryConfiguration s_telemetryConfiguration;
+
+        public CompilerDataLogger(IAnalysisContext analysisContext, string repositoryUri, string pipelineName)
+        {
+            try
+            {
+                string appInsightsKey = Environment.GetEnvironmentVariable("BinskimAppInsightsKey");
+                if (!string.IsNullOrEmpty(appInsightsKey) && Guid.TryParse(appInsightsKey, out _))
+                {
+                    Initialize(appInsightsKey);
+                    appInsightsRegistered = true;
+                }
+            }
+            catch (SecurityException)
+            {
+                // User does not have access to retrieve information from environment variables.
+            }
+
+            this.pipelineName = pipelineName;
+            this.repositoryUri = repositoryUri;
+            this.sha256 = analysisContext?.Hashes?.Sha256;
+            this.localPath = analysisContext?.TargetUri?.LocalPath;
+        }
+
+        public static void Initialize(string instrumentationKey)
+        {
+            s_telemetryConfiguration = new TelemetryConfiguration(instrumentationKey);
+            s_telemetryClient = new TelemetryClient(s_telemetryConfiguration);
+        }
+
+        public static void Flush()
+        {
+            s_telemetryClient?.Flush();
+        }
+
+        public void PrintHeader()
+        {
+            if (!appInsightsRegistered)
+            {
+                Console.WriteLine("RepositoryUri,PipelineName,Target,Compiler Name,Compiler BackEnd Version,Compiler FrontEnd Version,Language,Dialect,Module Name,Module Library,Hash,Error");
+            }
+        }
+
+        public void Write(string compilerData, ObjectModuleDetails omDetails)
+        {
+            string name = omDetails?.Name?.Replace(",", "_");
+            string library = omDetails?.Library?.Replace(",", ";");
+            if (appInsightsRegistered)
+            {
+                string[] compilerDataParts = compilerData.Split(',');
+
+                s_telemetryClient.TrackEvent(CompilerEventName, properties: new Dictionary<string, string>
+                {
+                    { "repositoryUri", repositoryUri ?? string.Empty },
+                    { "pipelineName", pipelineName ?? string.Empty },
+                    { "target", this.localPath },
+                    { "compilerName", compilerDataParts[0] },
+                    { "compilerBackEndVersion", compilerDataParts[1] },
+                    { "compilerFrontEndVersion", compilerDataParts[2] },
+                    { "language", compilerDataParts[3] },
+                    { "dialect", string.Empty },
+                    { "moduleName", name ?? string.Empty },
+                    { "moduleLibrary", (name == library ? string.Empty : library) },
+                    { "hash", this.sha256 ?? string.Empty },
+                    { "error", string.Empty }
+                });
+            }
+            else
+            {
+                Console.Write($"{repositoryUri},");
+                Console.Write($"{pipelineName},");
+                Console.Write($"{this.localPath},");
+                Console.Write($"{compilerData},");
+                Console.Write($",");
+                Console.Write($"{name},");
+                Console.Write($"{(name == library ? string.Empty : library)},");
+                Console.Write($"{this.sha256},");
+                Console.WriteLine();
+            }
+        }
+
+        public void Write(string compilerName, string version, string language, string file)
+        {
+            if (appInsightsRegistered)
+            {
+                s_telemetryClient.TrackEvent(CompilerEventName, properties: new Dictionary<string, string>
+                {
+                    { "repositoryUri", repositoryUri ?? string.Empty },
+                    { "pipelineName", pipelineName ?? string.Empty },
+                    { "target", this.localPath },
+                    { "compilerName", compilerName ?? string.Empty },
+                    { "compilerBackEndVersion", version ?? string.Empty },
+                    { "compilerFrontEndVersion", version ?? string.Empty },
+                    { "language", language ?? string.Empty },
+                    { "dialect", string.Empty },
+                    { "moduleName", file ?? string.Empty },
+                    { "moduleLibrary", string.Empty },
+                    { "hash", this.sha256 ?? string.Empty },
+                    { "error", string.Empty }
+                });
+            }
+            else
+            {
+                Console.Write($"{repositoryUri},");
+                Console.Write($"{pipelineName},");
+                Console.Write($"{this.localPath},");
+                Console.Write($"{compilerName},");
+                Console.Write($"{version},");
+                Console.Write($"{version},");
+                Console.Write($"{language},");
+                Console.Write($",");
+                Console.Write($"{file},");
+                Console.Write(",");
+                Console.Write($"{this.sha256},");
+                Console.WriteLine();
+            }
+        }
+
+        public void WriteException(string errorMessage)
+        {
+            if (appInsightsRegistered)
+            {
+                s_telemetryClient.TrackEvent(CompilerEventName, properties: new Dictionary<string, string>
+                {
+                    { "repositoryUri", repositoryUri ?? string.Empty },
+                    { "pipelineName", pipelineName ?? string.Empty },
+                    { "target", this.localPath },
+                    { "compilerName", string.Empty },
+                    { "compilerBackEndVersion", string.Empty },
+                    { "compilerFrontEndVersion", string.Empty },
+                    { "language", string.Empty },
+                    { "dialect", string.Empty },
+                    { "moduleName", string.Empty },
+                    { "moduleLibrary", string.Empty },
+                    { "hash", this.sha256 ?? string.Empty },
+                    { "error", errorMessage }
+                });
+            }
+            else
+            {
+                Console.Write(this.localPath + ",");
+                Console.WriteLine($",,,,,,,,,{this.sha256},{errorMessage}");
+            }
+        }
+    }
+}

src/BinSkim.Sdk/ICompilerDataLogger.cs

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.CodeAnalysis.BinaryParsers.ProgramDatabase;
+
+namespace Microsoft.CodeAnalysis.IL.Sdk
+{
+    public interface ICompilerDataLogger
+    {
+        void Write(string compilerData, ObjectModuleDetails omDetails);
+        void Write(string compilerName, string version, string language, string file);
+        void WriteException(string errorMessage);
+        void PrintHeader();
+    }
+}

src/BinaryParsers/MachOBinary/MachOBinary.cs

@@ -52,7 +52,7 @@ public static bool CanLoadBinary(Uri uri)
             catch (UnauthorizedAccessException) { return false; }
         }
 
-        public bool IsFatMachO => this.MachOs != null && this.MachOs.Count > 1;
+        public bool IsFatMachO => this.MachOs?.Count > 1;
 
         public IReadOnlyList<SingleMachOBinary> MachOs { get; }
 
@@ -68,7 +68,7 @@ public static bool CanLoadBinary(Uri uri)
         /// <summary>
         /// Unit type of Dwarf used..
         /// </summary>
-        public DwarfUnitType DwarfUnitType { get; set; } = DwarfUnitType.Unknown;
+        public DwarfUnitType DwarfUnitType { get; set; }
 
         /// <summary>
         /// Gets address offset within module when it is loaded.
@@ -115,6 +115,6 @@ public DwarfLanguage GetLanguage()
 
         public ICompiler[] Compilers => throw new NotImplementedException();
 
-        #endregion
+        #endregion IDwarfBinary interface
     }
 }

src/BinaryParsers/MachOBinary/SingleMachOBinary.cs

@@ -25,7 +25,7 @@ public class SingleMachOBinary : BinaryBase, IDwarfBinary
         public SingleMachOBinary(MachO singleMachO, Uri uri) : base(uri)
         {
             this.MachO = singleMachO;
-            LoadCompilationUnits();
+            CompilationUnits = LoadCompilationUnits();
         }
 
         public MachO MachO { get; }
@@ -44,20 +44,7 @@ public SingleMachOBinary(MachO singleMachO, Uri uri) : base(uri)
 
         public IEnumerable<EntryPoint> EntryPoint => this.MachO.GetCommandsOfType<EntryPoint>();
 
-        private List<DwarfCompilationUnit> compilationUnits;
-
-        public List<DwarfCompilationUnit> CompilationUnits
-        {
-            get
-            {
-                if (compilationUnits == null)
-                {
-                    compilationUnits = LoadCompilationUnits();
-                }
-
-                return compilationUnits;
-            }
-        }
+        public List<DwarfCompilationUnit> CompilationUnits { get; }
 
         private List<DwarfLineNumberProgram> lineNumberPrograms;