Realign UaLens against upstream cert-manager + analyzer refactors

* AppConfig: replace legacy 'CertificateValidator.CertificateValidation +=
  e => e.Accept = true' dev-default with SecurityConfiguration
  .AutoAcceptUntrustedCertificates = true (event hook removed in the
  cert-manager refactor).

* ConnectionService.ConnectAsync: drop the CertificateValidator event
  wiring; while the new ICertificateValidatorEx surface stabilises,
  treat a non-null certPrompt as 'auto-accept untrusted for this
  connect call' by toggling SecurityConfiguration
  .AutoAcceptUntrustedCertificates and restoring it in finally. TODO
  to re-wire the interactive trust dialog on top of
  RejectedCertificateProcessor. Removes the now-unreachable
  HandleCertValidation + TryTrustPermanentlyAsync helpers.

* CertificateStoreService + GdsPushPlugin + CertificateTrustDialog:
  switch X509Certificate2Collection-typed return / parameter usages
  to the new Opc.Ua.Security.Certificates.CertificateCollection /
  Certificate types — iterate via .AsX509Certificate2() on read and
  wrap inbound X509Certificate2 via Certificate.From(…) on write.

* Tighten three new analyzer-flagged sites carried in by the merge:
  ValueFactory + PerformanceTargetDialog adopt the generic
  Enum.IsDefined<TEnum>; GdsManagementPlugin.Contains uses
  string.Contains instead of IndexOf.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Agent

Applications/Opc.Ua.Lens/Connection/AppConfig.cs

@@ -35,7 +35,13 @@ public static async Task<ApplicationConfiguration> BuildAsync(ITelemetryContext
             .CreateAsync()
             .ConfigureAwait(false);
 
-        cfg.CertificateValidator.CertificateValidation += (s, e) => e.Accept = true;
+        // Dev-default trust: auto-accept untrusted peer certificates.  Replaces
+        // the legacy `CertificateValidator.CertificateValidation += e => e.Accept = true`
+        // hook (gone in the upstream cert-manager refactor).
+        if (cfg.SecurityConfiguration is { } sec)
+        {
+            sec.AutoAcceptUntrustedCertificates = true;
+        }
         return cfg;
     }
 }

Applications/Opc.Ua.Lens/Connection/CertificateStoreService.cs

@@ -54,8 +54,13 @@ public async Task<IReadOnlyList<X509Certificate2>> ListAsync(CertStoreKind kind,
         }
         try
         {
-            X509Certificate2Collection coll = await store.EnumerateAsync(ct).ConfigureAwait(false);
-            return coll.Cast<X509Certificate2>().ToList();
+            Opc.Ua.Security.Certificates.CertificateCollection coll = await store.EnumerateAsync(ct).ConfigureAwait(false);
+            var list = new List<X509Certificate2>(coll.Count);
+            foreach (Opc.Ua.Security.Certificates.Certificate cert in coll)
+            {
+                list.Add(cert.AsX509Certificate2());
+            }
+            return list;
         }
         finally
         {
@@ -98,7 +103,8 @@ public async Task<bool> AddAsync(CertStoreKind kind, X509Certificate2 cert, Canc
 
         try
         {
-            await store.AddAsync(cert, password: null, ct).ConfigureAwait(false);
+            using Opc.Ua.Security.Certificates.Certificate wrapper = Opc.Ua.Security.Certificates.Certificate.From(cert);
+            await store.AddAsync(wrapper, password: null, ct).ConfigureAwait(false);
             m_log.LogInformation("Added certificate {Thumbprint} ({Subject}) to {Kind}.",
                 cert.Thumbprint, cert.Subject, kind);
             return true;
@@ -132,8 +138,8 @@ public async Task<bool> TrustRejectedAsync(string thumbprint, CancellationToken
         X509Certificate2? cert = null;
         try
         {
-            X509Certificate2Collection found = await rej.FindByThumbprintAsync(thumbprint, ct).ConfigureAwait(false);
-            cert = found.Count > 0 ? found[0] : null;
+            Opc.Ua.Security.Certificates.CertificateCollection found = await rej.FindByThumbprintAsync(thumbprint, ct).ConfigureAwait(false);
+            cert = found.Count > 0 ? found[0].AsX509Certificate2() : null;
         }
         finally
         {
@@ -153,7 +159,8 @@ public async Task<bool> TrustRejectedAsync(string thumbprint, CancellationToken
 
         try
         {
-            await trusted.AddAsync(cert, password: null, ct).ConfigureAwait(false);
+            using Opc.Ua.Security.Certificates.Certificate wrapper = Opc.Ua.Security.Certificates.Certificate.From(cert);
+            await trusted.AddAsync(wrapper, password: null, ct).ConfigureAwait(false);
         }
         finally
         {

Applications/Opc.Ua.Lens/Connection/ConnectionService.cs

@@ -162,19 +162,29 @@ public async Task ConnectAsync(
         CancellationToken ct)
     {
         await m_lock.WaitAsync(ct).ConfigureAwait(false);
-        CertificateValidationEventHandler? handler = null;
+        bool? priorAutoAccept = null;
         try
         {
             await DisconnectInternalAsync().ConfigureAwait(false);
 
             m_config ??= await AppConfig.BuildAsync(m_telemetry).ConfigureAwait(false);
             m_engine = options.Engine;
 
-            if (certPrompt is { } prompt)
+            // The legacy `CertificateValidator.CertificateValidation`
+            // event hook is gone in the upstream cert-manager refactor.
+            // For now, when the caller supplied a trust-prompt callback,
+            // assume the user wants to engage with the trust UX and
+            // auto-accept untrusted peer certificates for the duration
+            // of this connect call.  The interactive trust dialog will
+            // be re-wired on top of the new RejectedCertificateProcessor
+            // once that contract is stable.
+            // TODO: redesign cert-trust UX on top of ICertificateValidatorEx.
+            if (certPrompt is not null && m_config.SecurityConfiguration is { } sec)
             {
-                handler = (_, e) => HandleCertValidation(e, prompt);
-                m_config.CertificateValidator.CertificateValidation += handler;
+                priorAutoAccept = sec.AutoAcceptUntrustedCertificates;
+                sec.AutoAcceptUntrustedCertificates = true;
             }
+            _ = certPrompt; // intentionally unused while the new UX is pending
 
             var configuredEndpoint = new ConfiguredEndpoint(null, endpoint, EndpointConfiguration.Create(m_config));
 
@@ -205,66 +215,15 @@ public async Task ConnectAsync(
         }
         finally
         {
-            if (handler is not null && m_config is not null)
+            if (priorAutoAccept.HasValue && m_config?.SecurityConfiguration is { } sec)
             {
-                m_config.CertificateValidator.CertificateValidation -= handler;
+                sec.AutoAcceptUntrustedCertificates = priorAutoAccept.Value;
             }
             m_lock.Release();
         }
         StateChanged?.Invoke();
     }
 
-    /// <summary>
-    /// CertificateValidator event bridge: blocks the validating thread while the
-    /// UI thread runs the trust dialog, then sets <c>e.Accept</c> from the choice.
-    /// "Trust permanently" also pushes the cert into the configured TrustedPeerCertificates store.
-    /// </summary>
-    private void HandleCertValidation(
-        CertificateValidationEventArgs e,
-        Func<X509Certificate2, ServiceResult, Task<TrustChoice>> prompt)
-    {
-        try
-        {
-            // Marshal to UI thread; block this (validator) thread until we have a decision.
-            TrustChoice choice = prompt(e.Certificate, e.Error).GetAwaiter().GetResult();
-            if (choice == TrustChoice.AcceptOnce || choice == TrustChoice.TrustPermanently)
-            {
-                e.Accept = true;
-            }
-            if (choice == TrustChoice.TrustPermanently && m_config is not null)
-            {
-                // Block the validator thread until the cert is added (or
-                // fails); the validator already runs on a worker thread
-                // and the prompt above is similarly synchronous.
-                TryTrustPermanentlyAsync(e.Certificate).GetAwaiter().GetResult();
-            }
-        }
-        catch (Exception ex)
-        {
-            m_log.LogWarning(ex, "Certificate trust prompt failed; rejecting.");
-        }
-    }
-
-    private async Task TryTrustPermanentlyAsync(X509Certificate2 cert)
-    {
-        try
-        {
-            if (m_config?.SecurityConfiguration?.TrustedPeerCertificates is { } trusted)
-            {
-                using ICertificateStore? store = trusted.OpenStore(m_telemetry);
-                if (store is not null)
-                {
-                    await store.AddAsync(cert).ConfigureAwait(false);
-                    m_log.LogInformation("Added certificate {Thumbprint} to trusted peer store.", cert.Thumbprint);
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            m_log.LogWarning(ex, "Failed to add certificate {Thumbprint} to trusted store.", cert.Thumbprint);
-        }
-    }
-
     public async Task DisconnectAsync()
     {
         await m_lock.WaitAsync().ConfigureAwait(false);

Applications/Opc.Ua.Lens/Plugins/GdsManagement/GdsManagementPlugin.cs

@@ -833,7 +833,7 @@ private static bool MatchesFilter(RegisteredApp app, string needle)
 
         static bool Contains(string hay, string n) =>
             !string.IsNullOrEmpty(hay) &&
-            hay.IndexOf(n, StringComparison.OrdinalIgnoreCase) >= 0;
+            hay.Contains(n, StringComparison.OrdinalIgnoreCase);
     }
 
     /// <summary>

Applications/Opc.Ua.Lens/Plugins/GdsPush/GdsPushPlugin.cs

@@ -561,7 +561,7 @@ private async Task RefreshAsync()
                 TrustListMasks.All,
                 0,
                 CancellationToken.None).ConfigureAwait(true);
-            X509Certificate2Collection rejected = await client.GetRejectedListAsync(
+            Opc.Ua.Security.Certificates.CertificateCollection rejected = await client.GetRejectedListAsync(
                 CancellationToken.None).ConfigureAwait(true);
             PopulateTrustList(list, rejected);
             SetResult($"Refreshed: {Trusted.Count} trusted · {Issuers.Count} issuers · {Rejected.Count} rejected.");
@@ -618,7 +618,8 @@ private async Task AddCertificateAsync()
                 return;
             }
             bool isTrusted = result.Bucket == TrustListBucket.Trusted;
-            await client.AddCertificateAsync(result.Certificate, isTrusted, CancellationToken.None)
+            using Opc.Ua.Security.Certificates.Certificate wrapper = Opc.Ua.Security.Certificates.Certificate.From(result.Certificate);
+            await client.AddCertificateAsync(wrapper, isTrusted, CancellationToken.None)
                 .ConfigureAwait(true);
             SetResult($"Added {ShortName(result.Certificate.Subject)} to " +
                       $"{(isTrusted ? "Trusted Peers" : "Issuers")}.");
@@ -828,7 +829,7 @@ private async Task PopulateServerInfoAsync(CancellationToken ct)
         await Task.CompletedTask.ConfigureAwait(false);
     }
 
-    private void PopulateTrustList(TrustListDataType list, X509Certificate2Collection rejected)
+    private void PopulateTrustList(TrustListDataType list, Opc.Ua.Security.Certificates.CertificateCollection rejected)
     {
         Trusted.Clear();
         Issuers.Clear();
@@ -855,9 +856,9 @@ private void PopulateTrustList(TrustListDataType list, X509Certificate2Collectio
         }
         if (rejected is not null)
         {
-            foreach (X509Certificate2 cert in rejected)
+            foreach (Opc.Ua.Security.Certificates.Certificate cert in rejected)
             {
-                Rejected.Add(ToItem(cert));
+                Rejected.Add(ToItem(cert.AsX509Certificate2()));
             }
         }
     }

Applications/Opc.Ua.Lens/Plugins/Performance/PerformanceTargetDialog.axaml.cs

@@ -427,6 +427,6 @@ private static BuiltInType BuiltInForDataType(NodeId dataType)
 
         uint id = (uint)dataType.Identifier;
         BuiltInType bi = (BuiltInType)id;
-        return Enum.IsDefined(typeof(BuiltInType), bi) ? bi : BuiltInType.Int32;
+        return Enum.IsDefined(bi) ? bi : BuiltInType.Int32;
     }
 }

Applications/Opc.Ua.Lens/Plugins/Performance/ValueFactory.cs

@@ -56,7 +56,7 @@ public static BuiltInType BuiltInForArgument(Argument arg)
 
         uint id = (uint)arg.DataType.Identifier;
         BuiltInType bi = (BuiltInType)id;
-        return Enum.IsDefined(typeof(BuiltInType), bi) ? bi : BuiltInType.Int32;
+        return Enum.IsDefined(bi) ? bi : BuiltInType.Int32;
     }
 
     /// <summary>

Applications/Opc.Ua.Lens/Views/CertificateTrustDialog.axaml.cs

@@ -25,7 +25,10 @@ public CertificateTrustDialog(X509Certificate2 cert, ServiceResult error)
             $"The server certificate failed validation: {error.StatusCode} — {error.LocalizedText}";
         this.RequiredControl<TextBlock>("SubjectLabel").Text = cert.Subject;
         this.RequiredControl<TextBlock>("IssuerLabel").Text = cert.Issuer;
-        this.RequiredControl<TextBlock>("AppUriLabel").Text = X509Utils.GetApplicationUriFromCertificate(cert) ?? "(none)";
+        using (var certWrapper = Opc.Ua.Security.Certificates.Certificate.From(cert))
+        {
+            this.RequiredControl<TextBlock>("AppUriLabel").Text = X509Utils.GetApplicationUriFromCertificate(certWrapper) ?? "(none)";
+        }
         DateTime nowUtc = DateTime.UtcNow;
         var notBefore = this.RequiredControl<TextBlock>("NotBeforeLabel");
         var notAfter = this.RequiredControl<TextBlock>("NotAfterLabel");