Merge pull request #451 from immutable/feat/redact-tokens-logs

nattb8 · web-flow · commit d7d52b96e5d7 · 2025-04-04T13:24:36.000+13:00
[DX-3655] feat: redact tokens from logs
diff --git a/sample/Assets/Scripts/Other/LaunchBrowserScript.cs b/sample/Assets/Scripts/Other/LaunchBrowserScript.cs
@@ -9,13 +9,13 @@ public class LaunchBrowserScript : MonoBehaviour
 {
     [SerializeField] private WebBrowserUIFull webBrowser;
     [SerializeField] private Button openDevToolsButton;
-    
+
     private WebBrowserClient? webBrowserClient;
 
     public void Start()
     {
         webBrowser.browserClient.OnLoadFinish += OnLoadFinish;
-        
+
         void OnLoadFinish(string url)
         {
             webBrowser.browserClient.OnLoadFinish -= OnLoadFinish;
diff --git a/sample/Assets/Scripts/Passport/SelectAuthMethodScript.cs b/sample/Assets/Scripts/Passport/SelectAuthMethodScript.cs
@@ -90,6 +90,9 @@ private async void InitialisePassport(string? redirectUri = null, string? logout
             // Set the log level for the SDK
             Passport.LogLevel = LogLevel.Info;
 
+            // Don't redact token values from logs
+            Passport.RedactTokensInLogs = false;
+
             // Initialise Passport
             string environment = Immutable.Passport.Model.Environment.SANDBOX;
             string clientId = "mp6rxfMDwwZDogcdgNrAaHnG0qMlXuMK";
diff --git a/src/Packages/Passport/Editor/PassportPostprocess.cs b/src/Packages/Passport/Editor/PassportPostprocess.cs
@@ -184,6 +184,6 @@ private void CopyFilesTo(string destinationPath)
             }
         }
     }
-}
-
+}
+
 #endif
diff --git a/src/Packages/Passport/Runtime/Scripts/Private/Core/Logging/PassportLogger.cs b/src/Packages/Passport/Runtime/Scripts/Private/Core/Logging/PassportLogger.cs
@@ -1,4 +1,4 @@
-using UnityEngine;
+using System;
 
 namespace Immutable.Passport.Core.Logging
 {
@@ -8,13 +8,24 @@ public static class PassportLogger
 
         public static LogLevel CurrentLogLevel { get; set; } = LogLevel.Info;
 
-        public static void Log(LogLevel level, string message)
+        /// <summary>
+        /// A function that defines how sensitive data should be redacted.
+        /// If null, no redaction is applied.
+        /// </summary>
+        public static Func<string, string>? RedactionHandler { get; set; }
+
+        private static void Log(LogLevel level, string message)
         {
             if (level < CurrentLogLevel)
             {
                 return; // Don't log messages below the current log level
             }
 
+            if (RedactionHandler != null)
+            {
+                message = RedactionHandler(message);
+            }
+
             switch (level)
             {
                 case LogLevel.Debug:
@@ -30,7 +41,7 @@ public static void Log(LogLevel level, string message)
                     UnityEngine.Debug.LogError($"{TAG} {message}");
                     break;
                 default:
-                    break;
+                    throw new ArgumentOutOfRangeException(nameof(level), level, null);
             }
         }
 
diff --git a/src/Packages/Passport/Runtime/Scripts/Private/PassportFunction.cs b/src/Packages/Passport/Runtime/Scripts/Private/PassportFunction.cs
@@ -6,7 +6,6 @@ public static class PassportFunction
         public const string INIT_DEVICE_FLOW = "initDeviceFlow";
         public const string RELOGIN = "relogin";
         public const string RECONNECT = "reconnect";
-        public const string CONNECT = "connect";
         public const string LOGIN_PKCE = "loginPKCE";
         public const string CONNECT_PKCE = "connectPKCE";
         public const string GET_PKCE_AUTH_URL = "getPKCEAuthUrl";
diff --git a/src/Packages/Passport/Runtime/Scripts/Public/Passport.cs b/src/Packages/Passport/Runtime/Scripts/Public/Passport.cs
@@ -1,10 +1,12 @@
 using System.Collections.Generic;
 using System;
+using System.Text.RegularExpressions;
 #if UNITY_STANDALONE_WIN || (UNITY_ANDROID && UNITY_EDITOR_WIN) || (UNITY_IPHONE && UNITY_EDITOR_WIN)
 #if !IMMUTABLE_CUSTOM_BROWSER
 using VoltstroStudios.UnityWebBrowser;
 using VoltstroStudios.UnityWebBrowser.Core;
 using VoltstroStudios.UnityWebBrowser.Shared;
+using VoltstroStudios.UnityWebBrowser.Logging;
 #endif
 #elif (UNITY_ANDROID && !UNITY_EDITOR_WIN) || (UNITY_IPHONE && !UNITY_EDITOR_WIN) || UNITY_STANDALONE_OSX || UNITY_WEBGL
 using Immutable.Browser.Gree;
@@ -48,13 +50,19 @@ public class Passport
         public event OnAuthEventDelegate OnAuthEvent;
 
         /// <summary>
-        /// The log level for the SDK.
+        /// Gets or sets the log level for the SDK.
         /// </summary>
         /// <remarks>
-        /// The log level determines which messages are recorded based on their severity. The default value is <see cref="LogLevel.Info"/>.
+        /// The log level determines which messages are recorded based on their severity.  
+        /// <para>
+        /// The default value is <see cref="LogLevel.Info"/>.
+        /// </para>
         /// <para>
         /// See <see cref="Immutable.Passport.Core.Logging.LogLevel"/> for valid log levels and their meanings.
         /// </para>
+        /// <example>
+        /// <code>Passport.LogLevel = LogLevel.Debug;</code>
+        /// </example>
         /// </remarks>
         public static LogLevel LogLevel
         {
@@ -72,6 +80,35 @@ public static LogLevel LogLevel
 
         private static LogLevel _logLevel = LogLevel.Info;
 
+        /// <summary>
+        /// Determines whether sensitive token values should be redacted from SDK logs.
+        /// </summary>
+        /// <remarks>
+        /// When set to <c>true</c>, access tokens and ID tokens will be replaced with <code>[REDACTED]</code> in log messages to enhance security.
+        /// This setting is useful for preventing sensitive data from appearing in logs, especially when debugging or sharing logs with others.
+        /// <para>
+        /// The default value is <c>false</c>, meaning tokens will be logged in full at appropriate log levels.
+        /// </para>
+        /// <example>
+        /// <code>Passport.RedactTokensInLogs = true;</code>
+        /// </example>
+        /// </remarks>
+        public static bool RedactTokensInLogs
+        {
+            get => _redactTokensInLogs;
+            set
+            {
+                _redactTokensInLogs = value;
+                PassportLogger.RedactionHandler = value ? RedactTokenValues : null;
+
+#if !IMMUTABLE_CUSTOM_BROWSER && (UNITY_STANDALONE_WIN || (UNITY_ANDROID && UNITY_EDITOR_WIN) || (UNITY_IPHONE && UNITY_EDITOR_WIN))
+                SetWindowsRedactionHandler();
+#endif
+            }
+        }
+
+        private static bool _redactTokensInLogs;
+
         private Passport()
         {
             // Handle clean-up tasks when the application is quitting
@@ -191,7 +228,7 @@ private async UniTask Initialise(
                         " 'windowsWebBrowserClient' must not be null.");
 #else
                     webBrowserClient = gameObject.AddComponent<UwbWebView>();
-                    await ((UwbWebView)webBrowserClient).Init(engineStartupTimeoutMs);
+                    await ((UwbWebView)webBrowserClient).Init(engineStartupTimeoutMs, _redactTokensInLogs, RedactTokenValues);
                     readySignalReceived = true;
 #endif
                 }
@@ -558,8 +595,43 @@ private static void SetDefaultWindowsBrowserLogLevel()
                 };
             }
         }
+
+        private static void SetWindowsRedactionHandler()
+        {
+            if (Instance?.webBrowserClient is WebBrowserClient browserClient)
+            {
+                browserClient.Logger = new DefaultUnityWebBrowserLogger(redactionHandler: _redactTokensInLogs ? RedactTokenValues : null);
+            }
+        }
 #endif
 
+        /// <summary>
+        /// Redacts access and ID token data from a log message if found.
+        /// </summary>
+        private static string RedactTokenValues(string message)
+        {
+            try
+            {
+                var match = Regex.Match(message, @"({.*})");
+                if (match.Success)
+                {
+                    var jsonPart = match.Groups[1].Value;
+                    var response = JsonUtility.FromJson<StringResponse>(jsonPart);
+                    if (response?.responseFor is PassportFunction.GET_ACCESS_TOKEN or PassportFunction.GET_ID_TOKEN && !string.IsNullOrEmpty(response.result))
+                    {
+                        response.result = "[REDACTED]";
+                        return message.Replace(jsonPart, JsonUtility.ToJson(response));
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                // ignored
+            }
+
+            return message;
+        }
+
         private PassportImpl GetPassportImpl()
         {
             if (passportImpl != null)
diff --git a/src/Packages/Passport/Runtime/ThirdParty/UnityWebBrowser/dev.voltstro.unitywebbrowser@2.2.5/Runtime/Logging/DefaultUnityWebBrowserLogger.cs b/src/Packages/Passport/Runtime/ThirdParty/UnityWebBrowser/dev.voltstro.unitywebbrowser@2.2.5/Runtime/Logging/DefaultUnityWebBrowserLogger.cs
@@ -5,6 +5,7 @@
 // 
 // This project is under the MIT license. See the LICENSE.md file for more details.
 
+using System;
 using UnityEngine;
 
 namespace VoltstroStudios.UnityWebBrowser.Logging
@@ -17,25 +18,42 @@ public sealed class DefaultUnityWebBrowserLogger : IWebBrowserLogger
         private const string LoggingTag = "[UWB]";
 
         private readonly ILogger logger;
-
-        public DefaultUnityWebBrowserLogger()
+        
+        /// <summary>
+        /// A function that defines how sensitive data should be redacted.
+        /// If null, no redaction is applied.
+        /// </summary>
+        public Func<string, string>? redactionHandler;
+
+        public DefaultUnityWebBrowserLogger(Func<string, string>? redactionHandler = null)
         {
             logger = UnityEngine.Debug.unityLogger;
+            this.redactionHandler = redactionHandler;
         }
 
         public void Debug(object message)
         {
-            logger.Log(LogType.Log, LoggingTag, message);
+            logger.Log(LogType.Log, LoggingTag, redactIfRequired(message));
         }
 
         public void Warn(object message)
         {
-            logger.LogWarning(LoggingTag, message);
+            logger.LogWarning(LoggingTag, redactIfRequired(message));
         }
 
         public void Error(object message)
         {
-            logger.LogError(LoggingTag, message);
+            logger.LogError(LoggingTag, redactIfRequired(message));
+        }
+
+        private object redactIfRequired(object message)
+        {
+            if (redactionHandler != null && message is string)
+            {
+                return redactionHandler((string)message);
+            }
+
+            return message;
         }
     }
 }
diff --git a/src/Packages/Passport/Runtime/ThirdParty/UnityWebBrowser/dev.voltstro.unitywebbrowser@2.2.5/Runtime/UwbWebView.cs b/src/Packages/Passport/Runtime/ThirdParty/UnityWebBrowser/dev.voltstro.unitywebbrowser@2.2.5/Runtime/UwbWebView.cs
@@ -1,5 +1,6 @@
 #if !IMMUTABLE_CUSTOM_BROWSER && (UNITY_STANDALONE_WIN || (UNITY_ANDROID && UNITY_EDITOR_WIN) || (UNITY_IPHONE && UNITY_EDITOR_WIN))
 
+using System;
 using System.IO;
 using System.Linq;
 using System.Net;
@@ -15,6 +16,7 @@
 using VoltstroStudios.UnityWebBrowser.Core.Engines;
 using VoltstroStudios.UnityWebBrowser.Core.Js;
 using VoltstroStudios.UnityWebBrowser.Helper;
+using VoltstroStudios.UnityWebBrowser.Logging;
 using VoltstroStudios.UnityWebBrowser.Shared;
 using VoltstroStudios.UnityWebBrowser.Shared.Core;
 
@@ -28,7 +30,7 @@ public class UwbWebView : MonoBehaviour, IWebBrowserClient
 
         private WebBrowserClient? webBrowserClient;
 
-        public async UniTask Init(int engineStartupTimeoutMs)
+        public async UniTask Init(int engineStartupTimeoutMs, bool redactTokensInLogs, Func<string, string> redactionHandler)
         {
             GameObject persistentObject = new GameObject("UWB");
             WebBrowserNoUi browser = persistentObject.AddComponent<WebBrowserNoUi>();
@@ -49,6 +51,9 @@ public async UniTask Init(int engineStartupTimeoutMs)
                 _ => LogSeverity.Info
             };
 
+            // Logger
+            webBrowserClient.Logger = new DefaultUnityWebBrowserLogger(redactionHandler: redactTokensInLogs ? redactionHandler : null);
+
             // Js
             webBrowserClient.jsMethodManager = new JsMethodManager { jsMethodsEnable = true };
             webBrowserClient.RegisterJsMethod<string>("callback",

Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,13 @@ public class LaunchBrowserScript : MonoBehaviour`
`9`	`9`	`{`
`10`	`10`	`[SerializeField] private WebBrowserUIFull webBrowser;`
`11`	`11`	`[SerializeField] private Button openDevToolsButton;`
`12`		`-`
	`12`	`+`
`13`	`13`	`private WebBrowserClient? webBrowserClient;`
`14`	`14`
`15`	`15`	`public void Start()`
`16`	`16`	`{`
`17`	`17`	`webBrowser.browserClient.OnLoadFinish += OnLoadFinish;`
`18`		`-`
	`18`	`+`
`19`	`19`	`void OnLoadFinish(string url)`
`20`	`20`	`{`
`21`	`21`	`webBrowser.browserClient.OnLoadFinish -= OnLoadFinish;`
Original file line number	Diff line number	Diff line change
`@@ -184,6 +184,6 @@ private void CopyFilesTo(string destinationPath)`
`184`	`184`	`}`
`185`	`185`	`}`
`186`	`186`	`}`
`187`		`-}`
`188`		`-`
	`187`	`+}`
	`188`	`+`
`189`	`189`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using UnityEngine;`
	`1`	`+using System;`
`2`	`2`
`3`	`3`	`namespace Immutable.Passport.Core.Logging`
`4`	`4`	`{`
`@@ -8,13 +8,24 @@ public static class PassportLogger`
`8`	`8`
`9`	`9`	`public static LogLevel CurrentLogLevel { get; set; } = LogLevel.Info;`
`10`	`10`
`11`		`- public static void Log(LogLevel level, string message)`
	`11`	`+ /// <summary>`
	`12`	`+ /// A function that defines how sensitive data should be redacted.`
	`13`	`+ /// If null, no redaction is applied.`
	`14`	`+ /// </summary>`
	`15`	`+ public static Func<string, string>? RedactionHandler { get; set; }`
	`16`	`+`
	`17`	`+ private static void Log(LogLevel level, string message)`
`12`	`18`	`{`
`13`	`19`	`if (level < CurrentLogLevel)`
`14`	`20`	`{`
`15`	`21`	`return; // Don't log messages below the current log level`
`16`	`22`	`}`
`17`	`23`
	`24`	`+ if (RedactionHandler != null)`
	`25`	`+ {`
	`26`	`+ message = RedactionHandler(message);`
	`27`	`+ }`
	`28`	`+`
`18`	`29`	`switch (level)`
`19`	`30`	`{`
`20`	`31`	`case LogLevel.Debug:`
`@@ -30,7 +41,7 @@ public static void Log(LogLevel level, string message)`
`30`	`41`	`UnityEngine.Debug.LogError($"{TAG} {message}");`
`31`	`42`	`break;`
`32`	`43`	`default:`
`33`		`- break;`
	`44`	`+ throw new ArgumentOutOfRangeException(nameof(level), level, null);`
`34`	`45`	`}`
`35`	`46`	`}`
`36`	`47`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`//`
`6`	`6`	`// This project is under the MIT license. See the LICENSE.md file for more details.`
`7`	`7`
	`8`	`+using System;`
`8`	`9`	`using UnityEngine;`
`9`	`10`
`10`	`11`	`namespace VoltstroStudios.UnityWebBrowser.Logging`
`@@ -17,25 +18,42 @@ public sealed class DefaultUnityWebBrowserLogger : IWebBrowserLogger`
`17`	`18`	`private const string LoggingTag = "[UWB]";`
`18`	`19`
`19`	`20`	`private readonly ILogger logger;`
`20`		`-`
`21`		`- public DefaultUnityWebBrowserLogger()`
	`21`	`+`
	`22`	`+ /// <summary>`
	`23`	`+ /// A function that defines how sensitive data should be redacted.`
	`24`	`+ /// If null, no redaction is applied.`
	`25`	`+ /// </summary>`
	`26`	`+ public Func<string, string>? redactionHandler;`
	`27`	`+`
	`28`	`+ public DefaultUnityWebBrowserLogger(Func<string, string>? redactionHandler = null)`
`22`	`29`	`{`
`23`	`30`	`logger = UnityEngine.Debug.unityLogger;`
	`31`	`+ this.redactionHandler = redactionHandler;`
`24`	`32`	`}`
`25`	`33`
`26`	`34`	`public void Debug(object message)`
`27`	`35`	`{`
`28`		`- logger.Log(LogType.Log, LoggingTag, message);`
	`36`	`+ logger.Log(LogType.Log, LoggingTag, redactIfRequired(message));`
`29`	`37`	`}`
`30`	`38`
`31`	`39`	`public void Warn(object message)`
`32`	`40`	`{`
`33`		`- logger.LogWarning(LoggingTag, message);`
	`41`	`+ logger.LogWarning(LoggingTag, redactIfRequired(message));`
`34`	`42`	`}`
`35`	`43`
`36`	`44`	`public void Error(object message)`
`37`	`45`	`{`
`38`		`- logger.LogError(LoggingTag, message);`
	`46`	`+ logger.LogError(LoggingTag, redactIfRequired(message));`
	`47`	`+ }`
	`48`	`+`
	`49`	`+ private object redactIfRequired(object message)`
	`50`	`+ {`
	`51`	`+ if (redactionHandler != null && message is string)`
	`52`	`+ {`
	`53`	`+ return redactionHandler((string)message);`
	`54`	`+ }`
	`55`	`+`
	`56`	`+ return message;`
`39`	`57`	`}`
`40`	`58`	`}`
`41`	`59`	`}`