Abstract
This paper presents the first white-box implementation of the Identity-Based Signature (IBS) scheme found in the IEEE P1363 standard. By decomposing the user's private key into a series of obfuscated lookup tables, the authors ensure that even an adversary with full access to the software's internal state cannot easily extract the secret key. This approach is particularly suited for high-risk environments such as mobile Digital Rights Management (DRM) and untrusted Internet of Things (IoT) devices.
Introduction: The White-Box Challenge
In traditional "black-box" cryptography, the security model assumes that an adversary only has access to the inputs and outputs of a cryptographic algorithm. However, in modern mobile and IoT ecosystems, software often operates in "white-box" environments. In these scenarios, an attacker or malicious software may have full control over the execution environment, allowing them to inspect memory, trace execution, and modify code to steal cryptographic keys.
While white-box implementations have been developed for symmetric ciphers like AES, public-key cryptography—specifically Identity-Based Signatures (IBS)—has lacked a robust solution. IBS is highly advantageous because it allows a user's identity (such as an email address) to serve as their public key, significantly simplifying key management. The primary challenge addressed here is protecting the user's private key when the signing process occurs on an insecure device.
Methodology: Lookup Table Decomposition
The authors adapt the IEEE P1363 standard IBS scheme into a white-box format using a technique centered on lookup table decomposition. The process involves three main stages:
- WhiteBoxKeyGen: Instead of providing a raw private key ($K_{ID}$), a Trusted Key Generation Center (KGC) generates a set of white-box "keys." These are four sets of lookup tables ($u_i, X_i, v_i, Y_i$) that embed the private key alongside various random blinding factors ($x_i, y_i$).
- Table-Based Signing: The standard signing algorithm is modified to utilize these tables. Mathematical operations required for the signature are performed by looking up values and combining them. At no point during execution is the raw private key $K_{ID}$ present in the device's memory.
- Security Foundations: The implementation maintains "weak white-box security," meaning that for an attacker to extract the private key from these tables, they would need to solve the Discrete Logarithm (DL) problem, which is computationally infeasible.
Key Insights
- KGC Offloading: A critical design choice is shifting the computational burden of table generation to the KGC. While generating the tables is relatively slow, it is a one-time setup cost handled by a server, not the end-user device.
- Implementation-Level Protection: By basing the work on the IEEE P1363 standard, the authors ensure compatibility with existing public-key infrastructure goals while adding a necessary layer of implementation-level security.
- Key Extraction Prevention: The primary goal is preventing the extraction of the underlying secret key. While this does not inherently prevent "code lifting" (copying the entire obfuscated binary), it secures the most sensitive cryptographic asset.
Performance Results
The evaluation was conducted using the MIRACL Cryptographic SDK on BN (Barreto-Naehrig) curves to achieve AES-128 equivalent security. The results demonstrate that the white-box implementation remains practical for real-world use:
- Signing Efficiency: Signing a message takes approximately 11.22 ms, compared to 8.04 ms in a standard black-box implementation.
- Verification Overhead: Verification takes roughly 32.78 ms, a manageable increase from the original 24.16 ms.
- Setup Cost: The
WhiteBoxKeyGenalgorithm takes approximately 4.36 seconds. As this is a one-time server-side operation, it does not impact the daily user experience.
Limitations and Future Directions
Despite its strengths, the current implementation provides "weak" white-box security, meaning it does not yet address "code lifting" or "space hardness" to prevent an attacker from simply copying the entire obfuscated binary to another device. Furthermore, while performance was validated on a PC (Intel Xeon E3-1230 v5), future research should focus on testing these implementations on actual mobile and IoT hardware to measure the impact of lower-power processors on table lookup speeds. Finally, deploying such a system would require non-standard delivery of keys (as tables), necessitating updates to current identity-based deployment models.
Summary updated