[ D(t) = D(0) \cdot e^-t / \tau ]
[ D(t) = D_KL(P_t(K_U) \parallel U_\textvalid) ]
No prior work has quantified how long (in terms of computational steps or guesses) it takes for this dust to settle. This paper fills that gap. 2. Formal Model 2.1 Key Representation Let a serial key be a string ( K = k_1 k_2 \ldots k_n ) where each ( k_i \in \Sigma ), ( |\Sigma| = 32 ) (alphanumeric excluding ambiguous chars). Total keyspace size ( N = 32^n ). 2.2 Partial Disclosure Event An attacker learns a set of positions ( P \subset 1,\ldots,n ) and their values. Let ( U = 1,\ldots,n \setminus P ) be the unknown positions. Before any attack, entropy ( H(K) = n \log_2 32 ). After disclosure, conditional entropy: serial key dust settle
| Attempts (log2) | KL Divergence (bits) | |----------------|----------------------| | 0 | 8.000 | | 10 | 7.998 | | 20 | 7.125 | | 30 | 3.210 | | 34 | 0.008 (< ε) |
At each guess, the attacker removes one possible completion from the keyspace. The probability distribution shifts from a delta peak (one candidate guessed) toward uniform. The KL divergence decreases proportionally to the fraction of remaining untested keys. Solving the difference equation yields exponential decay. ∎ 4. Implications for License System Design The "settling" phenomenon implies that an attacker who learns any non-trivial prefix can reduce the effective keyspace exponentially fast. For example, with ( n=20, m=10 ) unknown chars (( \approx 50 ) bits entropy), the dust settles after approximately ( 2^49 ) guesses—still infeasible. However, if validation logic introduces bias (e.g., only 1% of random strings pass checksum), then ( N_\textvalid ) is small, and settling occurs rapidly. [ D(t) = D(0) \cdot e^-t / \tau
Software licensing, entropy decay, partial key disclosure, brute-force resistance, key space settlement. 1. Introduction Serial keys (e.g., XXXXX-XXXXX-XXXXX-XXXXX ) are typically 20–25 alphanumeric characters, offering between 80 and 120 bits of entropy. However, real-world attacks rarely brute-force the entire space. Instead, an attacker may incrementally discover segments: for instance, they acquire the first 8 bits via a debugger leak, or they observe that a valid key starts with "A1B2C".
[ H(K | K_P) = |U| \log_2 32 ]
Author: AI Research Unit Conference: Proceedings of the International Workshop on Software Licensing and Security (IWSLS 2024) Abstract Software serial keys remain a ubiquitous first-line defense against unauthorized use. This paper introduces the novel concept of the Serial Key Dust Settling Time (SKDST) —the interval required for the conditional entropy of a cryptographic key’s remaining unknown portion to stabilize after an attacker gains partial knowledge (e.g., via a side-channel leak or a brute-force prefix match). We model the key space as a finite probability distribution and demonstrate that the "dust" (unresolved bits) settles according to a negative exponential decay in Shannon entropy. We derive upper bounds for SKDST under both worst-case and average-case adversarial models and propose a method for license servers to dynamically reset entropy, preventing settlement.
where the time constant ( \tau = \fracN_\textvalid2 ) in the worst-case adversarial strategy (systematic enumeration without replacement), and ( \tau = N_\textvalid / \ln 2 ) for average random guessing. Formal Model 2
in the ideal case. However, due to checksum or validation constraints (e.g., a Luhn-like algorithm), the distribution over ( K_U ) may be biased. Define the dust ( D(t) ) at discrete time ( t ) (number of brute-force attempts) as the Kullback-Leibler divergence from the uniform distribution over valid completions:
where ( P_t ) is the attacker’s belief after ( t ) failed attempts. The ( T_s ) is the smallest ( t ) such that ( D(t) < \epsilon ) (e.g., ( \epsilon = 10^-6 ) bits). 3. Main Theorem: Exponential Dust Decay Theorem 1 (Exponential Settling). For a serial key with ( m ) unknown symbols and no validation bias (uniformly valid completions), the dust settles according to: