UA-.NETStandard/tests/Opc.Ua.Server.Tests/Identity/KeyCredentialBridgeAuthenticatorTests.cs

/* ========================================================================
 * Copyright (c) 2005-2026 The OPC Foundation, Inc. All rights reserved.
 *
 * OPC Foundation MIT License 1.00
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * The complete license agreement can be found here:
 * http://opcfoundation.org/License/MIT/1.00/
 * ======================================================================*/

#pragma warning disable OPCUA_EXPERIMENTAL_KC_BRIDGE

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using NUnit.Framework;
using Opc.Ua.Identity;
using Opc.Ua.Tests;

namespace Opc.Ua.Server.Tests.Identity
{
    [TestFixture]
    [Category("Identity")]
    [Category("KeyCredential")]
    public class KeyCredentialBridgeAuthenticatorTests
    {
        private const string CredentialId = "credential-1";
        private static readonly byte[] s_secret = [11, 22, 33, 44, 55, 66];
        private static readonly string[] s_groups = ["engineering"];
        private static readonly string[] s_roles = ["operator"];
        private static readonly string[] s_scopes = ["ua.session"];

        [Test]
        public async Task AuthenticateAsyncValidProofAcceptedAndClaimsReturned()
        {
            using InMemoryKeyCredentialStore store = await CreateStoreAsync(DateTime.UtcNow.AddMinutes(10))
                .ConfigureAwait(false);
            var authenticator = new KeyCredentialBridgeAuthenticator(store);

            AuthenticationResult result = await authenticator.AuthenticateAsync(
                    CreateContext(CreateTokenData(CredentialId, s_secret)))
                .ConfigureAwait(false);

            Assert.That(result.Outcome, Is.EqualTo(AuthenticationOutcome.Accepted));
            var claims = result.Identity as IIdentityClaims;
            Assert.That(claims, Is.Not.Null);
            Assert.That(claims.Subject, Is.EqualTo("subject-1"));
            Assert.That(claims.Groups, Does.Contain("engineering"));
            Assert.That(claims.Roles, Does.Contain("operator"));
            Assert.That(claims.Claims["email"], Is.EqualTo("operator@example.test"));
        }

        [Test]
        public async Task AuthenticateAsyncBadProofRejected()
        {
            using InMemoryKeyCredentialStore store = await CreateStoreAsync(DateTime.UtcNow.AddMinutes(10))
                .ConfigureAwait(false);
            var authenticator = new KeyCredentialBridgeAuthenticator(store);

            byte[] tokenData = Encoding.UTF8.GetBytes(
                "{\"credentialId\":\"credential-1\",\"nonce\":\"nonce\",\"issuedAt\":" +
                DateTimeOffset.UtcNow.ToUnixTimeSeconds() +
                ",\"proof\":\"bad\"}");
            AuthenticationResult result = await authenticator.AuthenticateAsync(CreateContext(tokenData))
                .ConfigureAwait(false);

            Assert.That(result.Outcome, Is.EqualTo(AuthenticationOutcome.Rejected));
            Assert.That(result.Error!.Code, Is.EqualTo((uint)StatusCodes.BadIdentityTokenRejected));
        }

        [Test]
        public async Task RejectsTokenWithMalformedBase64UrlProof()
        {
            using InMemoryKeyCredentialStore store = await CreateStoreAsync(DateTime.UtcNow.AddMinutes(10))
                .ConfigureAwait(false);
            var authenticator = new KeyCredentialBridgeAuthenticator(store);

            byte[] tokenData = Encoding.UTF8.GetBytes(
                "{\"credentialId\":\"credential-1\",\"nonce\":\"nonce\",\"issuedAt\":" +
                DateTimeOffset.UtcNow.ToUnixTimeSeconds() +
                ",\"proof\":\"not-base64!@#\"}");
            AuthenticationResult result = await authenticator.AuthenticateAsync(CreateContext(tokenData))
                .ConfigureAwait(false);

            Assert.That(result.Outcome, Is.EqualTo(AuthenticationOutcome.Rejected));
            Assert.That(result.Error!.Code, Is.EqualTo((uint)StatusCodes.BadIdentityTokenInvalid));
        }

        [Test]
        public async Task AuthenticateAsyncExpiredCredentialRejected()
        {
            using InMemoryKeyCredentialStore store = await CreateStoreAsync(DateTime.UtcNow.AddMinutes(-1))
                .ConfigureAwait(false);
            var authenticator = new KeyCredentialBridgeAuthenticator(store);

            AuthenticationResult result = await authenticator.AuthenticateAsync(
                    CreateContext(CreateTokenData(CredentialId, s_secret)))
                .ConfigureAwait(false);

            Assert.That(result.Outcome, Is.EqualTo(AuthenticationOutcome.Rejected));
            Assert.That(result.Error!.Code, Is.EqualTo((uint)StatusCodes.BadIdentityTokenRejected));
        }

        [Test]
        public async Task AuthenticateAsyncUnknownCredentialRejected()
        {
            using var store = new InMemoryKeyCredentialStore();
            var authenticator = new KeyCredentialBridgeAuthenticator(store);

            AuthenticationResult result = await authenticator.AuthenticateAsync(
                    CreateContext(CreateTokenData(CredentialId, s_secret)))
                .ConfigureAwait(false);

            Assert.That(result.Outcome, Is.EqualTo(AuthenticationOutcome.Rejected));
            Assert.That(result.Error!.Code, Is.EqualTo((uint)StatusCodes.BadIdentityTokenRejected));
        }

        [Test]
        public async Task AuthenticateAsyncRejectsReplayOfVersionedProof()
        {
            using InMemoryKeyCredentialStore store = await CreateStoreAsync(DateTime.UtcNow.AddMinutes(10))
                .ConfigureAwait(false);
            var authenticator = new KeyCredentialBridgeAuthenticator(store);
            byte[] token = CreateTokenData(CredentialId, s_secret, "urn:test:server");

            AuthenticationResult first = await authenticator.AuthenticateAsync(
                CreateContext(token, "urn:test:server")).ConfigureAwait(false);
            AuthenticationResult replay = await authenticator.AuthenticateAsync(
                CreateContext(token, "urn:test:server")).ConfigureAwait(false);

            Assert.That(first.Outcome, Is.EqualTo(AuthenticationOutcome.Accepted));
            Assert.That(replay.Outcome, Is.EqualTo(AuthenticationOutcome.Rejected));
            Assert.That(replay.Error!.Code, Is.EqualTo((uint)StatusCodes.BadIdentityTokenRejected));
        }

        [Test]
        public async Task AuthenticateAsyncRejectsProofForDifferentAudience()
        {
            using InMemoryKeyCredentialStore store = await CreateStoreAsync(DateTime.UtcNow.AddMinutes(10))
                .ConfigureAwait(false);
            var authenticator = new KeyCredentialBridgeAuthenticator(store);

            AuthenticationResult result = await authenticator.AuthenticateAsync(
                CreateContext(
                    CreateTokenData(CredentialId, s_secret, "urn:test:other-server"),
                    "urn:test:server"))
                .ConfigureAwait(false);

            Assert.That(result.Outcome, Is.EqualTo(AuthenticationOutcome.Rejected));
            Assert.That(result.Error!.Code, Is.EqualTo((uint)StatusCodes.BadIdentityTokenRejected));
        }

        [Test]
        public void CreateTokenDataRequiresAnAudienceInsteadOfIssuingAnUnusableToken()
        {
            Assert.That(
                () => KeyCredentialBridgeAuthenticator.CreateTokenData(
                    CredentialId,
                    s_secret,
                    "nonce-" + Guid.NewGuid().ToString("N"),
                    DateTime.UtcNow,
                    null!),
                Throws.TypeOf<ArgumentNullException>());
        }

        [Test]
        public void ConstructorAndMetadataExposeConfiguredIssuedTokenProfile()
        {
            using var store = new InMemoryKeyCredentialStore();
            var options = new KeyCredentialBridgeOptions
            {
                ProfileUri = "urn:test:profile"
            };

            var authenticator = new KeyCredentialBridgeAuthenticator(store, options);

            Assert.Multiple(() =>
            {
                Assert.That(authenticator.TokenType, Is.EqualTo(UserTokenType.IssuedToken));
                Assert.That(authenticator.IssuedTokenProfileUri, Is.EqualTo("urn:test:profile"));
                Assert.Throws<ArgumentNullException>(() => new KeyCredentialBridgeAuthenticator(null!));
            });
        }

        [Test]
        public void CreateProofValidatesSecretAndReturnsBase64UrlProof()
        {
            long issuedAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            string proof = KeyCredentialBridgeAuthenticator.CreateProof(
                s_secret,
                CredentialId,
                "nonce",
                issuedAt,
                "urn:test:server");

            Assert.Multiple(() =>
            {
                Assert.That(proof, Is.Not.Empty);
                Assert.That(proof, Does.Not.Contain("+"));
                Assert.That(proof, Does.Not.Contain("/"));
                Assert.That(
                    KeyCredentialBridgeAuthenticator.CreateProof(
                        s_secret, CredentialId, "nonce", issuedAt, "urn:test:other"),
                    Is.Not.EqualTo(proof));
                Assert.Throws<ArgumentNullException>(() =>
                    KeyCredentialBridgeAuthenticator.CreateProof(
                        null!, CredentialId, "nonce", 1, "urn:test:server"));
            });
        }

        [Test]
        public void ExperimentalAttributeIsPresent()
        {
            // The [Experimental] attribute is only emitted when Opc.Ua.Server is
            // compiled for .NET 8 or later (the attribute type does not exist in
            // the .NET Framework BCL). This test assembly is
            // always compiled for net8.0, so a compile-time #if would reflect the
            // TEST target framework, not the STACK's. Probe the actual compiled
            // target framework of the Opc.Ua.Server assembly under test instead.
            string frameworkName = (typeof(KeyCredentialBridgeAuthenticator).Assembly
                .GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkName)!;

            // frameworkName looks like ".NETCoreApp,Version=v8.0",
            // ".NETStandard,Version=v2.1" or ".NETFramework,Version=v4.8".
            bool stackIsNet8OrGreater = false;
            if (frameworkName != null &&
                frameworkName.StartsWith(".NETCoreApp", StringComparison.Ordinal))
            {
                string[] parts = frameworkName.Split('=');
                string versionText = parts.Length > 1
                    ? parts[^1].TrimStart('v', 'V')
                    : string.Empty;
                stackIsNet8OrGreater =
                    Version.TryParse(versionText, out Version? version) && version.Major >= 8;
            }

            if (!stackIsNet8OrGreater)
            {
                Assert.Ignore(
                    "ExperimentalAttribute is only emitted when Opc.Ua.Server is compiled for " +
                    ".NET 8 or later.");
            }

            object attribute = typeof(KeyCredentialBridgeAuthenticator)
                .GetCustomAttributes(false)
                .SingleOrDefault(a => a.GetType().FullName ==
                    "System.Diagnostics.CodeAnalysis.ExperimentalAttribute")!;
            Assert.That(attribute, Is.Not.Null);
        }

        private static async Task<InMemoryKeyCredentialStore> CreateStoreAsync(DateTime expiration)
        {
            var store = new InMemoryKeyCredentialStore();
            var claims = new Dictionary<string, object?>
            {
                ["iss"] = "urn:test:issuer",
                ["sub"] = "subject-1",
                ["email"] = "operator@example.test",
                ["groups"] = s_groups,
                ["roles"] = s_roles
            };
            await store.UpdateAsync(
                    CredentialId,
                    new Server.KeyCredential(s_secret, expiration, claims, s_scopes),
                    CancellationToken.None)
                .ConfigureAwait(false);
            return store;
        }

        private static AuthenticationContext CreateContext(
            byte[] tokenData,
            string audience = "urn:test:server")
        {
            return new AuthenticationContext(
                new IssuedIdentityTokenHandler(KeyCredentialBridgeOptions.DefaultProfileUri, tokenData),
                new UserTokenPolicy
                {
                    TokenType = UserTokenType.IssuedToken,
                    PolicyId = "keycredential",
                    IssuedTokenType = KeyCredentialBridgeOptions.DefaultProfileUri
                },
                new EndpointDescription
                {
                    SecurityMode = MessageSecurityMode.SignAndEncrypt,
                    Server = new ApplicationDescription { ApplicationUri = audience }
                },
                ServiceMessageContext.CreateEmpty(NUnitTelemetryContext.Create()));
        }

        private static byte[] CreateTokenData(string credentialId, byte[] secret)
        {
            return KeyCredentialBridgeAuthenticator.CreateTokenData(
                credentialId,
                secret,
                "nonce-" + Guid.NewGuid().ToString("N"),
                DateTime.UtcNow,
                "urn:test:server");
        }

        private static byte[] CreateTokenData(
            string credentialId,
            byte[] secret,
            string audience)
        {
            return KeyCredentialBridgeAuthenticator.CreateTokenData(
                credentialId,
                secret,
                "nonce-" + Guid.NewGuid().ToString("N"),
                DateTime.UtcNow,
                audience);
        }
    }
}

#pragma warning restore OPCUA_EXPERIMENTAL_KC_BRIDGE