fix(opcua): credential lockout counts per credential identity, ignores transient denials (#844, #845)
#844: a success cleared the whole per-client count, so a client holding a valid key could make four guesses at another key id, sign in with its own, and repeat forever. Failures are now charged to the (client, credential identity) pair -- IOpcUaUserAuthenticator.DescribeCredential, key:<keyId> for API keys -- and to the client as a whole. A success clears only its own identity's count; the per-identity threshold locks that identity; a new per-client cap (OpcUa:CredentialLockout:MaxFailedAttemptsPerClient, default 2 x MaxFailedAttempts) that a success never resets bounds spraying across key ids and locks every credential. Slots are bounded on both counts; a waiter whose identity has room is not held behind one whose identity has none. #845: (1) store timeouts, miss-budget refusals, store/authenticator exceptions, an unset pepper and cancellation are reported Transient (OpcUaUserAuthResult.Unavailable) and released uncounted, so a ConfigDb stall can no longer lock every keyed client out; the client still sees the same opaque denial. (2) a full 4096-entry table defers its next prune until the earliest entry could age out instead of rescanning under the lock per failure. (3) ApplicationUri deliberately NOT added to the key: on a None channel it is a free string, so it would let an attacker reset the count per guess -- documented. (4) wire tests: distinct client certificates on a Sign endpoint are locked out separately; the ApplicationConfigPath branch keeps the SDK lockout off (falsified by removing the loaded-branch disable).
This commit is contained in:
@@ -55,7 +55,7 @@ public sealed class FailedCredentialLockoutTests
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_success_clears_the_count()
|
||||
public void A_success_clears_that_identitys_count()
|
||||
{
|
||||
var lockout = new FailedCredentialLockout(new OpcUaCredentialLockoutOptions(), new ManualClock());
|
||||
for (var i = 0; i < 4; i++) lockout.RecordFailure(Client);
|
||||
@@ -186,10 +186,10 @@ public sealed class FailedCredentialLockoutTests
|
||||
await WaitUntilAsync(() => lockout.WaitingCount(Client) == 1);
|
||||
second.IsCompleted.ShouldBeFalse("one failure short of the threshold leaves exactly one slot");
|
||||
|
||||
lockout.Complete(Client, succeeded: true); // a success clears the count and hands the slot on
|
||||
lockout.Complete(Client, succeeded: true); // a success clears the identity's count and hands the slot on
|
||||
(await second).Verdict.ShouldBe(CredentialLockoutVerdict.Proceed);
|
||||
lockout.Complete(Client, succeeded: true);
|
||||
lockout.TrackedCount.ShouldBe(0);
|
||||
lockout.TrackedCount.ShouldBe(1, "#844: the client-wide count survives a success until it ages out");
|
||||
}
|
||||
|
||||
/// <summary>A cancelled waiter is dequeued and leaves nothing behind (no leaked slot, entry prunable).</summary>
|
||||
@@ -242,10 +242,226 @@ public sealed class FailedCredentialLockoutTests
|
||||
|
||||
clock.Advance(TimeSpan.FromSeconds(11));
|
||||
(await lockout.BeginAsync(Client, Ct)).Verdict.ShouldBe(CredentialLockoutVerdict.Proceed);
|
||||
lockout.Complete(Client, succeeded: false).ShouldBeTrue("a new episode");
|
||||
lockout.Complete(Client, succeeded: false).ShouldNotBe(CredentialLockoutScope.None, "a new episode");
|
||||
(await lockout.BeginAsync(Client, Ct)).FirstRefusal.ShouldBeTrue("each lockout episode logs its first refusal once");
|
||||
}
|
||||
|
||||
// ---- lmxopcua#844: per-identity counts + a client-wide cap a success never resets ----
|
||||
|
||||
/// <summary>
|
||||
/// #844 — the laundering attack: four guesses at another key id, then a sign-in with the client's own valid
|
||||
/// key, repeated. The success used to clear the whole per-client count, so this ran forever. Now the success
|
||||
/// clears only the client's own identity: the fifth guess at the victim locks that identity.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void A_success_with_one_key_does_not_launder_guesses_at_another()
|
||||
{
|
||||
var lockout = new FailedCredentialLockout(new OpcUaCredentialLockoutOptions(), new ManualClock());
|
||||
for (var i = 0; i < 4; i++) lockout.RecordFailure(Client, "key:victim").ShouldBeFalse();
|
||||
lockout.RecordSuccess(Client, "key:own");
|
||||
lockout.RecordFailure(Client, "key:victim").ShouldBeTrue("the own-key success did not touch the victim's count");
|
||||
|
||||
lockout.IsLockedOut(Client, "key:victim", out var remaining).ShouldBeTrue();
|
||||
remaining.ShouldBe(TimeSpan.FromMinutes(5));
|
||||
lockout.IsLockedOut(Client, "key:own", out _).ShouldBeFalse(
|
||||
"a per-credential lockout leaves the client's other credentials usable");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// #844 — spraying a few guesses at each of many key ids, with own-key successes in between, still hits the
|
||||
/// client-wide cap (default 2 × MaxFailedAttempts), which a success never resets; then every credential —
|
||||
/// the client's own valid key included — is refused.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task Spraying_many_identities_with_successes_in_between_hits_the_client_wide_cap()
|
||||
{
|
||||
var lockout = new FailedCredentialLockout(new OpcUaCredentialLockoutOptions(), new ManualClock());
|
||||
lockout.ClientThreshold.ShouldBe(10);
|
||||
var locked = false;
|
||||
var failures = 0;
|
||||
for (var target = 0; !locked && target < 10; target++)
|
||||
{
|
||||
for (var guess = 0; guess < 4 && !locked; guess++)
|
||||
{
|
||||
locked = lockout.RecordFailure(Client, $"key:victim{target}");
|
||||
failures++;
|
||||
}
|
||||
|
||||
lockout.RecordSuccess(Client, "key:own");
|
||||
}
|
||||
|
||||
locked.ShouldBeTrue();
|
||||
failures.ShouldBe(10, "the tenth failure across identities locks the client");
|
||||
lockout.IsLockedOut(Client, "key:own", out _).ShouldBeTrue("a client-wide lockout covers the client's own key too");
|
||||
var refused = await lockout.BeginAsync(Client, "key:own", Ct);
|
||||
refused.Verdict.ShouldBe(CredentialLockoutVerdict.LockedOut);
|
||||
refused.Scope.ShouldBe(CredentialLockoutScope.Client);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void An_explicit_per_client_cap_is_honoured()
|
||||
{
|
||||
var lockout = new FailedCredentialLockout(
|
||||
new OpcUaCredentialLockoutOptions { MaxFailedAttempts = 5, MaxFailedAttemptsPerClient = 6 }, new ManualClock());
|
||||
for (var i = 0; i < 5; i++) lockout.RecordFailure(Client, $"key:k{i}").ShouldBeFalse();
|
||||
lockout.RecordFailure(Client, "key:k5").ShouldBeTrue();
|
||||
lockout.IsLockedOut(Client, "key:anything", out _).ShouldBeTrue();
|
||||
}
|
||||
|
||||
/// <summary>The client-wide count also ages out through the failure window — it is not a lifetime count.</summary>
|
||||
[Fact]
|
||||
public void The_client_wide_count_ages_out_through_the_window()
|
||||
{
|
||||
var clock = new ManualClock();
|
||||
var lockout = new FailedCredentialLockout(new OpcUaCredentialLockoutOptions(), clock);
|
||||
for (var i = 0; i < 9; i++) lockout.RecordFailure(Client, $"key:k{i}");
|
||||
clock.Advance(TimeSpan.FromSeconds(61));
|
||||
for (var i = 0; i < 9; i++) lockout.RecordFailure(Client, $"key:j{i}").ShouldBeFalse();
|
||||
lockout.IsLockedOut(Client, "key:own", out _).ShouldBeFalse();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// #844 — a client with a stale (revoked) key and a good one: the stale key locks only itself; the good key's
|
||||
/// activations keep getting slots and are not held behind the stale identity's waiter.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task A_locked_identity_does_not_block_another_identitys_slots()
|
||||
{
|
||||
var lockout = new FailedCredentialLockout(new OpcUaCredentialLockoutOptions { MaxFailedAttempts = 2 }, new ManualClock());
|
||||
lockout.RecordFailure(Client, "key:stale");
|
||||
|
||||
(await lockout.BeginAsync(Client, "key:stale", Ct)).Verdict.ShouldBe(CredentialLockoutVerdict.Proceed);
|
||||
var staleWaiter = lockout.BeginAsync(Client, "key:stale", Ct).AsTask(); // no stale slot left: waits
|
||||
await WaitUntilAsync(() => lockout.WaitingCount(Client) == 1);
|
||||
|
||||
// The good key is not queued behind the stale waiter.
|
||||
(await lockout.BeginAsync(Client, "key:good", Ct)).Verdict.ShouldBe(CredentialLockoutVerdict.Proceed);
|
||||
|
||||
lockout.Complete(Client, "key:stale", succeeded: false).ShouldBe(CredentialLockoutScope.Credential);
|
||||
var refused = await staleWaiter;
|
||||
refused.Verdict.ShouldBe(CredentialLockoutVerdict.LockedOut, "the waiter's identity locked: refused unauthenticated");
|
||||
refused.Scope.ShouldBe(CredentialLockoutScope.Credential);
|
||||
|
||||
lockout.Complete(Client, "key:good", succeeded: true).ShouldBe(CredentialLockoutScope.None);
|
||||
(await lockout.BeginAsync(Client, "key:good", Ct)).Verdict.ShouldBe(CredentialLockoutVerdict.Proceed);
|
||||
lockout.Complete(Client, "key:good", succeeded: true);
|
||||
}
|
||||
|
||||
/// <summary>A parallel burst of guesses at one identity still reaches the authenticator only MaxFailedAttempts times.</summary>
|
||||
[Fact]
|
||||
public async Task A_parallel_burst_at_one_identity_is_capped_at_the_per_credential_threshold()
|
||||
{
|
||||
var lockout = new FailedCredentialLockout(new OpcUaCredentialLockoutOptions { MaxFailedAttempts = 3 }, new ManualClock());
|
||||
var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
||||
var authenticated = 0;
|
||||
var attempts = Enumerable.Range(0, 10).Select(_ => Task.Run(async () =>
|
||||
{
|
||||
var decision = await lockout.BeginAsync(Client, "key:victim", Ct);
|
||||
if (decision.Verdict != CredentialLockoutVerdict.Proceed) return;
|
||||
Interlocked.Increment(ref authenticated);
|
||||
await release.Task;
|
||||
lockout.Complete(Client, "key:victim", succeeded: false);
|
||||
}, Ct)).ToArray();
|
||||
|
||||
await WaitUntilAsync(() => lockout.WaitingCount(Client) == 7);
|
||||
authenticated.ShouldBe(3);
|
||||
release.SetResult();
|
||||
await Task.WhenAll(attempts);
|
||||
authenticated.ShouldBe(3);
|
||||
lockout.IsLockedOut(Client, "key:victim", out _).ShouldBeTrue();
|
||||
}
|
||||
|
||||
/// <summary>Identities beyond the per-client bound share one overflow count — conservative, never laxer.</summary>
|
||||
[Fact]
|
||||
public void Identities_beyond_the_per_client_bound_share_one_overflow_count()
|
||||
{
|
||||
var lockout = new FailedCredentialLockout(
|
||||
new OpcUaCredentialLockoutOptions { MaxFailedAttempts = 2, MaxFailedAttemptsPerClient = 1000 }, new ManualClock());
|
||||
for (var i = 0; i < FailedCredentialLockout.MaxTrackedIdentitiesPerClient - 1; i++)
|
||||
lockout.RecordFailure(Client, $"key:k{i}").ShouldBeFalse();
|
||||
|
||||
lockout.RecordFailure(Client, "key:overflow-a").ShouldBeFalse();
|
||||
lockout.RecordFailure(Client, "key:overflow-b").ShouldBeTrue("both untracked identities share the overflow count");
|
||||
lockout.IsLockedOut(Client, "key:overflow-c", out _).ShouldBeTrue();
|
||||
lockout.IsLockedOut(Client, "key:k0", out _).ShouldBeFalse("tracked identities keep their own counts");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Oversized_identities_are_bounded_but_stay_distinct()
|
||||
{
|
||||
var lockout = new FailedCredentialLockout(new OpcUaCredentialLockoutOptions { MaxFailedAttempts = 1 }, new ManualClock());
|
||||
var a = "key:" + new string('a', 1000) + "1";
|
||||
var b = "key:" + new string('a', 1000) + "2";
|
||||
lockout.RecordFailure(Client, a).ShouldBeTrue();
|
||||
lockout.IsLockedOut(Client, a, out _).ShouldBeTrue();
|
||||
lockout.IsLockedOut(Client, b, out _).ShouldBeFalse();
|
||||
}
|
||||
|
||||
// ---- lmxopcua#845: transient outcomes are uncounted; a full table backs off its prune ----
|
||||
|
||||
/// <summary>
|
||||
/// #845 — a transient denial (store timeout, miss budget, authenticator fault) is released with Abandon and
|
||||
/// never counts: a ConfigDb stall cannot lock the client out.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task Abandoned_attempts_never_count_toward_either_threshold()
|
||||
{
|
||||
var lockout = new FailedCredentialLockout(new OpcUaCredentialLockoutOptions { MaxFailedAttempts = 2 }, new ManualClock());
|
||||
for (var i = 0; i < 20; i++)
|
||||
{
|
||||
(await lockout.BeginAsync(Client, "key:k", Ct)).Verdict.ShouldBe(CredentialLockoutVerdict.Proceed);
|
||||
lockout.Abandon(Client, "key:k");
|
||||
}
|
||||
|
||||
lockout.IsLockedOut(Client, "key:k", out _).ShouldBeFalse();
|
||||
lockout.TrackedCount.ShouldBe(0);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// #845 — at a full table with nothing expired, a new client key's failure used to rescan all 4096 entries
|
||||
/// under the global lock every time. The prune now waits until the earliest entry could have expired.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void A_full_table_does_not_rescan_until_the_earliest_entry_could_expire()
|
||||
{
|
||||
var clock = new ManualClock();
|
||||
var lockout = new FailedCredentialLockout(new OpcUaCredentialLockoutOptions(), clock);
|
||||
for (var i = 0; i < FailedCredentialLockout.MaxTrackedClients; i++)
|
||||
{
|
||||
lockout.RecordFailure($"c{i}");
|
||||
if (i == 0) clock.Advance(TimeSpan.FromSeconds(10)); // c0 is the earliest to age out
|
||||
}
|
||||
|
||||
for (var i = 0; i < 100; i++) lockout.RecordFailure($"new{i}");
|
||||
lockout.PruneScanCount.ShouldBe(1, "one scan found nothing to free; the next 99 did not rescan");
|
||||
lockout.TrackedCount.ShouldBe(FailedCredentialLockout.MaxTrackedClients);
|
||||
|
||||
clock.Advance(TimeSpan.FromSeconds(51)); // c0's 60 s window has now passed; nobody else's has
|
||||
lockout.RecordFailure("late").ShouldBeFalse();
|
||||
lockout.PruneScanCount.ShouldBe(2);
|
||||
lockout.TrackedCount.ShouldBe(FailedCredentialLockout.MaxTrackedClients, "c0 pruned, 'late' took its place");
|
||||
lockout.RecordFailure("later");
|
||||
lockout.PruneScanCount.ShouldBe(3, "the table was full again: one scan…");
|
||||
lockout.RecordFailure("latest");
|
||||
lockout.PruneScanCount.ShouldBe(3, "…and then it backs off again");
|
||||
}
|
||||
|
||||
/// <summary>A release that frees an entry lets a full table prune again immediately.</summary>
|
||||
[Fact]
|
||||
public async Task Freeing_an_entry_resets_the_prune_backoff()
|
||||
{
|
||||
var lockout = new FailedCredentialLockout(new OpcUaCredentialLockoutOptions(), new ManualClock());
|
||||
(await lockout.BeginAsync("holder", Ct)).Verdict.ShouldBe(CredentialLockoutVerdict.Proceed);
|
||||
for (var i = 1; i < FailedCredentialLockout.MaxTrackedClients; i++) lockout.RecordFailure($"c{i}");
|
||||
lockout.RecordFailure("blocked");
|
||||
lockout.PruneScanCount.ShouldBe(1);
|
||||
|
||||
lockout.Complete("holder", succeeded: true); // removes the holder's entry
|
||||
for (var i = 0; i < 4; i++) lockout.RecordFailure("admitted").ShouldBeFalse();
|
||||
lockout.RecordFailure("admitted").ShouldBeTrue("tracked now: its count reached the threshold");
|
||||
}
|
||||
|
||||
|
||||
private static void InterlockedMax(ref int target, int value)
|
||||
{
|
||||
int seen;
|
||||
|
||||
+43
-1
@@ -116,10 +116,43 @@ public sealed class OpcUaApplicationHostImpersonationTests
|
||||
var args = new ImpersonateEventArgs(token, UserNamePolicy, new EndpointDescription());
|
||||
var authenticator = new ThrowingAuthenticator(new InvalidOperationException("LDAP unreachable"));
|
||||
|
||||
OpcUaApplicationHost.HandleImpersonation(authenticator, args, NullLogger<object>.Instance);
|
||||
var transient = OpcUaApplicationHost.HandleImpersonation(authenticator, args, NullLogger<object>.Instance);
|
||||
|
||||
args.Identity.ShouldBeNull();
|
||||
args.IdentityValidationError.Code.ShouldBe(StatusCodes.BadIdentityTokenRejected.Code);
|
||||
transient.ShouldBeTrue("#845: an authenticator fault is not a verdict on the credential");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// #845 — a denial the authenticator marks Transient (store timeout, miss-budget refusal) is reported as such,
|
||||
/// so the lockout does not count it, while the client sees the same opaque rejection as a bad credential.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void HandleImpersonation_reports_a_transient_denial_and_a_definite_one_apart()
|
||||
{
|
||||
OpcUaUserAuthResult[] outcomes = [OpcUaUserAuthResult.Unavailable("Invalid API key."), OpcUaUserAuthResult.Deny("Invalid API key.")];
|
||||
var verdicts = outcomes.Select(outcome =>
|
||||
{
|
||||
var token = new UserNameIdentityTokenHandler(new UserNameIdentityToken { UserName = "apikey" }) { DecryptedPassword = Encoding.UTF8.GetBytes("otua_k1_x") };
|
||||
var args = new ImpersonateEventArgs(token, UserNamePolicy, new EndpointDescription());
|
||||
var transient = OpcUaApplicationHost.HandleImpersonation(new RecordingAuthenticator(outcome), args, NullLogger<object>.Instance);
|
||||
args.IdentityValidationError.Code.ShouldBe(StatusCodes.BadIdentityTokenRejected.Code);
|
||||
args.IdentityValidationError.LocalizedText.Text!.ShouldContain("Invalid API key.");
|
||||
return transient;
|
||||
}).ToArray();
|
||||
|
||||
verdicts.ShouldBe([true, false]);
|
||||
}
|
||||
|
||||
/// <summary>#844 — the default credential identity is the username; a faulting implementation falls back to it.</summary>
|
||||
[Fact]
|
||||
public void DescribeCredential_defaults_to_the_username_and_never_throws()
|
||||
{
|
||||
var handler = new UserNameIdentityTokenHandler(new UserNameIdentityToken { UserName = "alice" }) { DecryptedPassword = Encoding.UTF8.GetBytes("pw") };
|
||||
OpcUaApplicationHost.DescribeCredential(new RecordingAuthenticator(OpcUaUserAuthResult.Deny("x")), handler)
|
||||
.ShouldBe("user:alice");
|
||||
OpcUaApplicationHost.DescribeCredential(new DescribingAuthenticator(), handler).ShouldBe("custom:alice:pw".Length.ToString());
|
||||
OpcUaApplicationHost.DescribeCredential(new DescribingAuthenticator(fail: true), handler).ShouldBe("user:alice");
|
||||
}
|
||||
|
||||
/// <summary>Verifies null username is normalized to empty string before authenticator call.</summary>
|
||||
@@ -167,6 +200,15 @@ public sealed class OpcUaApplicationHostImpersonationTests
|
||||
}
|
||||
}
|
||||
|
||||
private sealed class DescribingAuthenticator(bool fail = false) : IOpcUaUserAuthenticator
|
||||
{
|
||||
public Task<OpcUaUserAuthResult> AuthenticateUserNameAsync(string username, string password, CancellationToken ct) =>
|
||||
Task.FromResult(OpcUaUserAuthResult.Deny("x"));
|
||||
|
||||
public string DescribeCredential(string username, string password) =>
|
||||
fail ? throw new InvalidOperationException("boom") : $"custom:{username}:{password}".Length.ToString();
|
||||
}
|
||||
|
||||
/// <summary>Test authenticator that throws an exception during authentication.</summary>
|
||||
private sealed class ThrowingAuthenticator(Exception ex) : IOpcUaUserAuthenticator
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user