Feature pathmask

Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
 	<PropertyGroup>
-		<Version>1.7.1.0</Version>
-		<Authors>Sander van Vliet, Huibert Jan Nieuwkamer, Scott Toberman</Authors>
+		<Version>1.8.0.0</Version>
+		<Authors>Sander van Vliet, Huibert Jan Nieuwkamer, Scott Toberman, sunnamed434</Authors>
 		<Company>Codenizer BV</Company>
 		<Copyright>2023 Sander van Vliet</Copyright>
 	</PropertyGroup>

README.md

@@ -102,6 +102,7 @@ By default the enricher uses the following masking operators:
 - EmailAddressMaskingOperator
 - IbanMaskingOperator
 - CreditCardMaskingOperator
+- PathMaskingOperator
 
 It's good practice to only configure the masking operators that are applicable for your application. For example:
 

src/Serilog.Enrichers.Sensitive.Demo/Program.cs

@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using System.Threading.Tasks;
 using Serilog.Core;
 
@@ -13,7 +14,8 @@ static async Task Main(string[] args)
 				{
 					new EmailAddressMaskingOperator(),
 					new IbanMaskingOperator(),
-					new CreditCardMaskingOperator(false)
+					new CreditCardMaskingOperator(false),
+					new PathMaskingOperator()
 				})
 				.WriteTo.Console()
 				.CreateLogger();
@@ -43,16 +45,24 @@ static async Task Main(string[] args)
 					Key = 12345, XmlValue = "<MyElement><CreditCard>4111111111111111</CreditCard></MyElement>"
 				};
 				logger.Information("Object dump with embedded credit card: {x}", x);
+
+				// Path to the file is also masked
+				logger.Information("This is path to the file: {0}",
+					@"E:\SuperSecretPath\test.txt");
+
+				// Path to the directory is also masked
+				logger.Information("This is path to the directory: {0}", @"C:\Admin\");
 
 			}
 
 			// But outside the sensitive area nothing is masked
 			logger.Information("Felix can be reached at [email protected]");
 
+			logger.Information("This is your path to the file: {file}", new FileInfo("test.txt").FullName);
 
 			// Now, show that this works for async contexts too
 			logger.Information("Now, show the Async works");
-
+			
 			var t1 = LogAsSensitiveAsync(logger);
 			var t2 = LogAsUnsensitiveAsync(logger);
 

src/Serilog.Enrichers.Sensitive/IPathWrapper.cs

@@ -0,0 +1,8 @@
+namespace Serilog.Enrichers.Sensitive;
+
+public interface IPathWrapper
+{
+    bool IsDirectory(string path);
+    string GetFileName(string path);
+    string GetDirectoryName(string path);
+}

src/Serilog.Enrichers.Sensitive/PathMaskingOperator.cs

@@ -0,0 +1,52 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Text.RegularExpressions;
+
+namespace Serilog.Enrichers.Sensitive;
+
+/// <summary>
+/// Represents a masking operator for path names.
+/// <remarks>Supports path names for Windows, Linux, and macOS.</remarks>
+/// </summary>
+public class PathMaskingOperator : RegexMaskingOperator
+{
+    private readonly IPathWrapper _pathWrapper;
+    private readonly bool _combineMaskWithPath;
+    private const string PathPattern =
+        @"^(?:[a-zA-Z]\:|\\\\[\w-]+\\[\w-]+\$?|[\/][^\/\0]+)+(\\[^\\/:*?""<>|]*)*(\\?)?$";
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PathMaskingOperator"/> class.
+    /// </summary>
+    /// <param name="pathWrapper">The path wrapper.</param>
+    /// <param name="combineMaskWithPath">This means if set to <see langword="true"/> then the mask will combine with the file name or its directory name.</param>
+    public PathMaskingOperator(IPathWrapper pathWrapper, bool combineMaskWithPath = true) : base(PathPattern)
+    {
+        _pathWrapper = pathWrapper;
+        _combineMaskWithPath = combineMaskWithPath;
+    }
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PathMaskingOperator"/> class, with default <see cref="PathWrapper"/>.
+    /// </summary>
+    /// <param name="combineMaskWithPath">This means if set to <see langword="true"/> then the mask will combine with the file name or its directory name.</param>
+    public PathMaskingOperator(bool combineMaskWithPath = true) : this(new PathWrapper(), combineMaskWithPath)
+    {
+    }
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PathMaskingOperator"/> class.
+    /// </summary>
+    public PathMaskingOperator() : this(combineMaskWithPath: true)
+    {
+    }
+    [SuppressMessage("ReSharper", "InvertIf")]
+    protected override string PreprocessMask(string mask, Match match)
+    {
+        if (_combineMaskWithPath)
+        {
+            var value = match.Value;
+            return _pathWrapper.IsDirectory(value)
+                ? mask + _pathWrapper.GetDirectoryName(value)
+                : mask + _pathWrapper.GetFileName(value);
+        }
+        return mask;
+    }
+}

src/Serilog.Enrichers.Sensitive/PathWrapper.cs

@@ -0,0 +1,19 @@
+using System.IO;
+
+namespace Serilog.Enrichers.Sensitive;
+
+public class PathWrapper : IPathWrapper
+{
+    public bool IsDirectory(string path)
+    {
+        return Path.GetExtension(path) == string.Empty;
+    }
+    public string GetFileName(string path)
+    {
+        return Path.GetFileName(path);
+    }
+    public string GetDirectoryName(string path)
+    {
+        return new DirectoryInfo(path).Name;
+    }
+}

src/Serilog.Enrichers.Sensitive/Serilog.Enrichers.Sensitive.csproj

@@ -12,7 +12,7 @@
 		<Title>Serilog enricher to mask sensitive data</Title>
 		<Description>An enricher to be used for masking sensitive (PII) data using Serilog</Description>
 		<Copyright Condition="'$(Copyright)' == ''">2021 Sander van Vliet</Copyright>
-		<Authors Condition="'$(Authors)' == ''">Sander van Vliet, Huibert Jan Nieuwkamer, Scott Toberman</Authors>
+		<Authors Condition="'$(Authors)' == ''">Sander van Vliet, Huibert Jan Nieuwkamer, Scott Toberman, sunnamed434</Authors>
 		<PackageProjectUrl>https://github.com/serilog-contrib/Serilog.Enrichers.Sensitive/README.md</PackageProjectUrl>
 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
 		<RepositoryUrl>https://github.com/serilog-contrib/Serilog.Enrichers.Sensitive/</RepositoryUrl>

test/Serilog.Enrichers.Sensitive.Tests.Benchmark/PathMaskingOperatorBenchmarks.cs

@@ -0,0 +1,37 @@
+using System.Text.RegularExpressions;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Engines;
+
+namespace Serilog.Enrichers.Sensitive.Tests.Benchmark;
+
+[SimpleJob(RunStrategy.Throughput, warmupCount: 1)]
+public class PathMaskingOperatorBenchmarks
+{
+    private const string PathInput = "/home/me";
+    private const string MaskValue = "***MASKED***";
+
+    private readonly Regex PathRegex =
+        new(@"^(?:[a-zA-Z]\:|\\\\[\w-]+\\[\w-]+\$?|[\/][^\/\0]+)+(\\[^\\/:*?""<>|]*)*(\\?)?$");
+
+    private readonly Regex PathCompiledRegex =
+        new(@"^(?:[a-zA-Z]\:|\\\\[\w-]+\\[\w-]+\$?|[\/][^\/\0]+)+(\\[^\\/:*?""<>|]*)*(\\?)?$",
+            RegexOptions.Compiled);
+
+    [Benchmark]
+    public string PathRegexReplace()
+    {
+        string result = null;
+        for (var i = 0; i < 10000; i++)
+            result = PathRegex.Replace(PathInput, MaskValue);
+        return result;
+    }
+
+    [Benchmark]
+    public string PathRegexCompiledReplace()
+    {
+        string result = null;
+        for (var i = 0; i < 10000; i++)
+            result = PathCompiledRegex.Replace(PathInput, MaskValue);
+        return result;
+    }
+}

test/Serilog.Enrichers.Sensitive.Tests.Benchmark/Program.cs

@@ -9,6 +9,7 @@ private static void Main(string[] args)
             BenchmarkRunner.Run<BenchmarkCompiledEmailRegex>();
             BenchmarkRunner.Run<BenchmarkCompiledIbanRegex>();
             BenchmarkRunner.Run<CreditCardMarkingBenchmarks>();
+            BenchmarkRunner.Run<PathMaskingOperatorBenchmarks>();
         }
     }
 }

test/Serilog.Enrichers.Sensitive.Tests.Unit/WhenMaskingPaths.cs

@@ -0,0 +1,39 @@
+using FluentAssertions;
+using Xunit;
+
+namespace Serilog.Enrichers.Sensitive.Tests.Unit;
+
+public class WhenMaskingPaths
+{
+    private const string Mask = @"***\";
+
+    [Theory]
+    [InlineData(@"C:\Users\Admin\Secret\File.dll", @"***\", false)]
+    [InlineData(@"C:\Users\Admin\Secret\File.dll", @"***\File.dll", true)]
+    [InlineData(@"C:\Users\Admin\Secret\Hidden\File.dll", @"***\File.dll", true)]
+    [InlineData(@"C:\Users\Admin\Secret\Hidden", @"***\", false)]
+    [InlineData(@"C:\Users\Admin\Secret\Hidden", @"***\Hidden", true)]
+    [InlineData(@"C:\Users\Admin\Secret", @"***\Secret", true)]
+    [InlineData(@"C:\Users\", @"***\Users", true)]
+    [InlineData(@"/home/i_use_arch_linux_btw", @"***\i_use_arch_linux_btw", true)]
+    [InlineData(@"/home/i_use_arch_linux_btw", @"***\", false)]
+    [InlineData(@"C:\", @"***\C:\", true)]
+    [InlineData(@"C:\", @"***\", false)]
+    [InlineData("File.txt", "File.txt", false)]
+    [InlineData(@"This is not a path", "This is not a path", false)]
+    public void GivenPaths_ReturnsExpectedResult(string path, string result, bool combineMaskWithPath)
+    {
+        TheMaskedResultOf(path, combineMaskWithPath)
+            .Should()
+            .Be(result);
+    }
+
+    private static string TheMaskedResultOf(string input, bool combineMaskWithPath)
+    {
+        var maskingResult = new PathMaskingOperator(combineMaskWithPath)
+            .Mask(input, Mask);
+        return maskingResult.Match
+            ? maskingResult.Result
+            : input;
+    }
+}