Adds support for monitoring specific processes (#230)

Author: waldekmastykarz

msgraph-developer-proxy/ProxyCommandHandler.cs

@@ -13,6 +13,8 @@ public class ProxyCommandHandler : ICommandHandler {
     public Option<int?> Port { get; set; }
     public Option<LogLevel?> LogLevel { get; set; }
     public Option<bool?> Record { get; set; }
+    public Option<IEnumerable<int>?> WatchPids { get; set; }
+    public Option<IEnumerable<string>?> WatchProcessNames { get; set; }
 
     private readonly PluginEvents _pluginEvents;
     private readonly ISet<Regex> _urlsToWatch;
@@ -21,12 +23,16 @@ public class ProxyCommandHandler : ICommandHandler {
     public ProxyCommandHandler(Option<int?> port,
                                Option<LogLevel?> logLevel,
                                Option<bool?> record,
+                               Option<IEnumerable<int>?> watchPids,
+                               Option<IEnumerable<string>?> watchProcessNames,
                                PluginEvents pluginEvents,
                                ISet<Regex> urlsToWatch,
                                ILogger logger) {
         Port = port ?? throw new ArgumentNullException(nameof(port));
         LogLevel = logLevel ?? throw new ArgumentNullException(nameof(logLevel));
         Record = record ?? throw new ArgumentNullException(nameof(record));
+        WatchPids = watchPids ?? throw new ArgumentNullException(nameof(watchPids));
+        WatchProcessNames = watchProcessNames ?? throw new ArgumentNullException(nameof(watchProcessNames));
         _pluginEvents = pluginEvents ?? throw new ArgumentNullException(nameof(pluginEvents));
         _urlsToWatch = urlsToWatch ?? throw new ArgumentNullException(nameof(urlsToWatch));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
@@ -49,6 +55,14 @@ public async Task<int> InvokeAsync(InvocationContext context) {
         if (record is not null) {
             Configuration.Record = record.Value;
         }
+        var watchPids = context.ParseResult.GetValueForOption(WatchPids);
+        if (watchPids is not null) {
+            Configuration.WatchPids = watchPids;
+        }
+        var watchProcessNames = context.ParseResult.GetValueForOption(WatchProcessNames);
+        if (watchProcessNames is not null) {
+            Configuration.WatchProcessNames = watchProcessNames;
+        }
 
         CancellationToken? cancellationToken = (CancellationToken?)context.BindingContext.GetService(typeof(CancellationToken?));
 

msgraph-developer-proxy/ProxyConfiguration.cs

@@ -27,5 +27,7 @@ public class ProxyConfiguration {
     [JsonPropertyName("logLevel")]
     [JsonConverter(typeof(JsonStringEnumConverter))]
     public LogLevel LogLevel { get; set; } = LogLevel.Info;
+    public IEnumerable<int> WatchPids { get; set; } = new List<int>();
+    public IEnumerable<string> WatchProcessNames { get; set; } = new List<string>();
 }
 

msgraph-developer-proxy/ProxyEngine.cs

@@ -245,13 +245,81 @@ private void OnCancellation() {
 
     async Task OnBeforeTunnelConnectRequest(object sender, TunnelConnectSessionEventArgs e) {
         // Ensures that only the targeted Https domains are proxyied
-        if (!IsProxiedHost(e.HttpClient.Request.RequestUri.Host)) {
+        if (!IsProxiedHost(e.HttpClient.Request.RequestUri.Host) ||
+            !IsProxiedProcess(e)) {
             e.DecryptSsl = false;
         }
         await Task.CompletedTask;
     }
 
-    async Task OnRequest(object sender, SessionEventArgs e) {
+  private int GetProcessId(TunnelConnectSessionEventArgs e)
+  {
+    if (RunTime.IsWindows) {
+        return e.HttpClient.ProcessId.Value;
+    }
+
+    var psi = new ProcessStartInfo {
+        FileName = "lsof",
+        Arguments = $"-i :{e.ClientRemoteEndPoint.Port}",
+        UseShellExecute = false,
+        RedirectStandardOutput = true,
+        CreateNoWindow = true
+    };
+    var proc = new Process {
+        StartInfo = psi
+    };
+    proc.Start();
+    var output = proc.StandardOutput.ReadToEnd();
+    proc.WaitForExit();
+
+    var lines = output.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
+    var matchingLine = lines.FirstOrDefault(l => l.Contains($"{e.ClientRemoteEndPoint.Port}->"));
+    if (matchingLine is null) {
+        return -1;
+    }
+    var pidString = Regex.Matches(matchingLine, @"^.*?\s+(\d+)")?.FirstOrDefault()?.Groups[1]?.Value;
+    if (pidString is null) {
+        return -1;
+    }
+
+    var pid = -1;
+    if (int.TryParse(pidString, out pid))
+    {
+        return pid;
+    }
+    else {
+        return -1;
+    }
+  }
+
+  private bool IsProxiedProcess(TunnelConnectSessionEventArgs e) {
+    // If no process names or IDs are specified, we proxy all processes
+    if (!_config.WatchPids.Any() &&
+        !_config.WatchProcessNames.Any()) {
+      return true;
+    }
+
+    var processId = GetProcessId(e);
+    if (processId == -1) {
+      return false;
+    }
+
+    if (_config.WatchPids.Any() &&
+        _config.WatchPids.Contains(processId)) {
+      return true;
+    }
+
+    if (_config.WatchProcessNames.Any()) {
+      var processName = Process.GetProcessById(processId).ProcessName;
+      if (_config.WatchProcessNames .Contains(processName)) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+
+  async Task OnRequest(object sender, SessionEventArgs e) {
         var method = e.HttpClient.Request.Method.ToUpper();
         // The proxy does not intercept or alter OPTIONS requests
         if (method is not "OPTIONS" && IsProxiedHost(e.HttpClient.Request.RequestUri.Host)) {
@@ -276,6 +344,7 @@ private void HandleRequest(SessionEventArgs e) {
 
     private bool IsProxiedHost(string hostName) => _hostsToWatch.Any(h => h.IsMatch(hostName));
 
+
     // Modify response
     async Task OnBeforeResponse(object sender, SessionEventArgs e) {
         // read response headers

msgraph-developer-proxy/ProxyHost.cs

@@ -11,6 +11,8 @@ internal class ProxyHost {
     private Option<int?> _portOption;
     private Option<LogLevel?> _logLevelOption;
     private Option<bool?> _recordOption;
+    private Option<IEnumerable<int>?> _watchPidsOption;
+    private Option<IEnumerable<string>?> _watchProcessNamesOption;
     private static Option<string?>? _configFileOption;
 
     private static bool _configFileResolved = false;
@@ -63,13 +65,23 @@ public ProxyHost() {
         });
 
         _recordOption = new Option<bool?>("--record", "Use this option to record all request logs");
+
+        _watchPidsOption = new Option<IEnumerable<int>?>("--watch-pids", "The IDs of processes to watch for requests");
+        _watchPidsOption.ArgumentHelpName = "pids";
+        _watchPidsOption.AllowMultipleArgumentsPerToken = true;
+
+        _watchProcessNamesOption = new Option<IEnumerable<string>?>("--watch-process-names", "The names of processes to watch for requests");
+        _watchProcessNamesOption.ArgumentHelpName = "processNames";
+        _watchProcessNamesOption.AllowMultipleArgumentsPerToken = true;
     }
 
     public RootCommand GetRootCommand() {
         var command = new RootCommand {
             _portOption,
             _logLevelOption,
             _recordOption,
+            _watchPidsOption,
+            _watchProcessNamesOption,
             // _configFileOption is set during the call to load
             // `ProxyCommandHandler.Configuration`. As such, it's always set here
             _configFileOption!
@@ -79,6 +91,6 @@ public RootCommand GetRootCommand() {
         return command;
     }
 
-    public ProxyCommandHandler GetCommandHandler(PluginEvents pluginEvents, ISet<Regex> urlsToWatch, ILogger logger) => new ProxyCommandHandler(_portOption, _logLevelOption, _recordOption, pluginEvents, urlsToWatch, logger);
+    public ProxyCommandHandler GetCommandHandler(PluginEvents pluginEvents, ISet<Regex> urlsToWatch, ILogger logger) => new ProxyCommandHandler(_portOption, _logLevelOption, _recordOption, _watchPidsOption, _watchProcessNamesOption, pluginEvents, urlsToWatch, logger);
 }