react-native-dpop 0.1.0

package/Dpop.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "Dpop"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/Cirilord/react-native-dpop.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Pedro Cirilo
+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.

package/README.md

@@ -0,0 +1,105 @@
+# react-native-dpop
+
+React Native library for DPoP proof generation and key management.
+
+## Features
+
+- Generate DPoP proofs (`dpop+jwt`) signed with ES256.
+- Manage key pairs in the device keystore (create, rotate, delete).
+- Export public key in `JWK`, `DER`, or `RAW` format.
+- Calculate JWK thumbprint (`SHA-256`, base64url).
+- Verify if a proof is bound to a given key alias.
+- Retrieve non-sensitive key metadata (hardware-backed, StrongBox info, etc.).
+
+## Platform Support
+
+- Android: supported.
+- iOS: planned.
+
+Current implementation throws on non-Android platforms.
+
+## Installation
+
+```sh
+npm install react-native-dpop
+```
+
+## Quick Start
+
+```ts
+import { DPoP } from 'react-native-dpop';
+
+const dpop = await DPoP.generateProof({
+  htu: 'https://api.example.com/token',
+  htm: 'POST',
+  accessToken: 'ACCESS_TOKEN',
+  nonce: 'server-nonce',
+});
+
+const proof = dpop.proof;
+const thumbprint = await dpop.calculateThumbprint();
+const publicJwk = await dpop.getPublicKey('JWK');
+```
+
+## API
+
+### Types
+
+- `GenerateProofInput`
+- `DPoPProofContext`
+- `DPoPKeyInfo`
+- `PublicJwk`
+- `PublicKeyFormat = 'JWK' | 'DER' | 'RAW'`
+
+### `DPoP` static methods
+
+- `DPoP.generateProof(input): Promise<DPoP>`
+- `DPoP.assertHardwareBacked(alias?): Promise<void>`
+- `DPoP.deleteKeyPair(alias?): Promise<void>`
+- `DPoP.getKeyInfo(alias?): Promise<DPoPKeyInfo>`
+- `DPoP.hasKeyPair(alias?): Promise<boolean>`
+- `DPoP.rotateKeyPair(alias?): Promise<void>`
+
+### `DPoP` instance fields
+
+- `proof: string`
+- `proofContext: DPoPProofContext`
+- `alias?: string`
+
+### `DPoP` instance methods
+
+- `calculateThumbprint(): Promise<string>`
+- `getPublicKey(format): Promise<PublicJwk | string>`
+- `signWithDpopPrivateKey(payload): Promise<string>`
+- `isBoundToAlias(alias?): Promise<boolean>`
+
+## Error Codes
+
+Native errors are rejected with codes such as:
+
+- `ERR_DPOP_GENERATE_PROOF`
+- `ERR_DPOP_PUBLIC_KEY`
+- `ERR_DPOP_SIGN_WITH_PRIVATE_KEY`
+- `ERR_DPOP_HAS_KEY_PAIR`
+- `ERR_DPOP_GET_KEY_INFO`
+- `ERR_DPOP_ROTATE_KEY_PAIR`
+- `ERR_DPOP_DELETE_KEY_PAIR`
+- `ERR_DPOP_ASSERT_HARDWARE_BACKED`
+- `ERR_DPOP_IS_BOUND_TO_ALIAS`
+
+## Notes
+
+- If no alias is provided, the default alias is `react-native-dpop`.
+- `htm` is normalized to uppercase in proof generation.
+- `ath` is derived from `accessToken` (`SHA-256`, base64url) when provided.
+- `jti` and `iat` are auto-generated when omitted.
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,67 @@
+buildscript {
+  ext.Dpop = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return Dpop[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.dpop"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/dpop/DPoPKeyStore.kt

@@ -0,0 +1,168 @@
+package com.dpop
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyInfo
+import android.security.keystore.KeyProperties
+import android.security.keystore.StrongBoxUnavailableException
+import java.security.KeyFactory
+import java.security.KeyPairGenerator
+import java.security.KeyStore
+import java.security.PrivateKey
+import java.security.ProviderException
+import java.security.interfaces.ECPublicKey
+import java.security.spec.ECGenParameterSpec
+import java.util.Calendar
+import javax.security.auth.x500.X500Principal
+
+internal data class KeyPairReference(
+  val privateKey: PrivateKey,
+  val publicKey: ECPublicKey
+)
+
+internal data class KeyStoreKeyInfo(
+  val alias: String,
+  val algorithm: String,
+  val curve: String,
+  val insideSecureHardware: Boolean,
+  val securityLevel: Int?,
+  val strongBoxAvailable: Boolean,
+  val strongBoxBacked: Boolean
+)
+
+internal class DPoPKeyStore(private val context: Context) {
+  companion object {
+    private const val KEYSTORE_PROVIDER = "AndroidKeyStore"
+    private const val EC_CURVE = "secp256r1"
+  }
+
+  private val keyStore: KeyStore by lazy {
+    KeyStore.getInstance(KEYSTORE_PROVIDER).apply { load(null) }
+  }
+
+  fun deleteKeyPair(alias: String) {
+    if (keyStore.containsAlias(alias)) {
+      keyStore.deleteEntry(alias)
+    }
+  }
+
+  fun generateKeyPair(alias: String): Boolean {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+      throw IllegalStateException("Key pair generation is not supported on API < 23")
+    }
+
+    if (keyStore.containsAlias(alias)) {
+      keyStore.deleteEntry(alias)
+    }
+
+    val generator = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, KEYSTORE_PROVIDER)
+    if (isStrongBoxEnabled()) {
+      try {
+        generator.initialize(buildSpec(alias, useStrongBox = true))
+        generator.generateKeyPair()
+        return true
+      } catch (_: StrongBoxUnavailableException) {
+        // Fallback to hardware-backed keystore when StrongBox is unavailable.
+      } catch (_: ProviderException) {
+        // Some devices expose StrongBox but fail during generation.
+      }
+    }
+
+    generator.initialize(buildSpec(alias, useStrongBox = false))
+    generator.generateKeyPair()
+    return false
+  }
+
+  fun getKeyPair(alias: String): KeyPairReference {
+    val privateKey = keyStore.getKey(alias, null) as? PrivateKey
+      ?: throw IllegalStateException("Private key not found for alias: $alias")
+    val publicKey = keyStore.getCertificate(alias)?.publicKey as? ECPublicKey
+      ?: throw IllegalStateException("Key pair not found for alias: $alias")
+    return KeyPairReference(privateKey = privateKey, publicKey = publicKey)
+  }
+
+  fun hasKeyPair(alias: String): Boolean {
+    val privateKey = keyStore.getKey(alias, null) as? PrivateKey
+    val publicKey = keyStore.getCertificate(alias)?.publicKey as? ECPublicKey
+    return privateKey != null && publicKey != null
+  }
+
+  fun getKeyInfo(alias: String): KeyStoreKeyInfo {
+    val keyPair = getKeyPair(alias)
+    val keyFactory = KeyFactory.getInstance(keyPair.privateKey.algorithm, KEYSTORE_PROVIDER)
+    val keyInfo = keyFactory.getKeySpec(keyPair.privateKey, KeyInfo::class.java)
+
+    return KeyStoreKeyInfo(
+      alias = alias,
+      algorithm = keyPair.privateKey.algorithm,
+      curve = "P-256",
+      insideSecureHardware = keyInfo.isInsideSecureHardware,
+      securityLevel = readSecurityLevel(keyInfo),
+      strongBoxAvailable = isStrongBoxEnabled(),
+      strongBoxBacked = readStrongBoxBacked(keyInfo)
+    )
+  }
+
+  fun isHardwareBacked(alias: String): Boolean {
+    val keyPair = getKeyPair(alias)
+    val keyFactory = KeyFactory.getInstance(keyPair.privateKey.algorithm, KEYSTORE_PROVIDER)
+    val keyInfo = keyFactory.getKeySpec(keyPair.privateKey, KeyInfo::class.java)
+    return keyInfo.isInsideSecureHardware
+  }
+
+  private fun buildSpec(alias: String, useStrongBox: Boolean): KeyGenParameterSpec {
+    val principal = X500Principal("CN=$alias")
+    val start = Calendar.getInstance()
+    val end = Calendar.getInstance().apply { add(Calendar.YEAR, 25) }
+
+    val builder = KeyGenParameterSpec.Builder(alias, KeyProperties.PURPOSE_SIGN)
+      .setAlgorithmParameterSpec(ECGenParameterSpec(EC_CURVE))
+      .setDigests(KeyProperties.DIGEST_SHA256)
+      .setCertificateSubject(principal)
+      .setCertificateNotBefore(start.time)
+      .setCertificateNotAfter(end.time)
+      .setUserAuthenticationRequired(false)
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      builder.setUnlockedDeviceRequired(true)
+      if (useStrongBox) {
+        builder.setIsStrongBoxBacked(true)
+      }
+    }
+
+    return builder.build()
+  }
+
+  private fun isStrongBoxEnabled(): Boolean {
+    return Build.VERSION.SDK_INT >= Build.VERSION_CODES.P &&
+      context.packageManager.hasSystemFeature(PackageManager.FEATURE_STRONGBOX_KEYSTORE)
+  }
+
+  private fun readSecurityLevel(keyInfo: KeyInfo): Int? {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+      return null
+    }
+
+    return try {
+      val method = KeyInfo::class.java.getMethod("getSecurityLevel")
+      method.invoke(keyInfo) as? Int
+    } catch (_: Exception) {
+      null
+    }
+  }
+
+  private fun readStrongBoxBacked(keyInfo: KeyInfo): Boolean {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
+      return false
+    }
+
+    return try {
+      val method = KeyInfo::class.java.getMethod("isStrongBoxBacked")
+      method.invoke(keyInfo) as? Boolean ?: false
+    } catch (_: Exception) {
+      false
+    }
+  }
+}

package/android/src/main/java/com/dpop/DPoPUtils.kt

@@ -0,0 +1,208 @@
+package com.dpop
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import java.math.BigInteger
+import java.security.MessageDigest
+import java.security.interfaces.ECPublicKey
+import java.util.Base64
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal object DPoPUtils {
+  internal fun base64UrlEncode(input: ByteArray): String {
+    return Base64.getUrlEncoder().withoutPadding().encodeToString(input)
+  }
+
+  internal fun calculateThumbprint(kty: String, crv: String, x: String, y: String): String {
+    val canonicalJwk = """{"crv":"$crv","kty":"$kty","x":"$x","y":"$y"}"""
+    val hash = MessageDigest.getInstance("SHA-256").digest(canonicalJwk.toByteArray(Charsets.UTF_8))
+    return base64UrlEncode(hash)
+  }
+
+  internal fun derToJose(derSignature: ByteArray, partLength: Int = 32): ByteArray {
+    if (derSignature.isEmpty() || derSignature[0].toInt() != 0x30) {
+      throw IllegalArgumentException("Invalid DER signature format")
+    }
+
+    var index = 1
+    val sequenceLength = readDerLength(derSignature, index)
+    index += sequenceLength.second
+
+    if (sequenceLength.first <= 0 || index + sequenceLength.first > derSignature.size) {
+      throw IllegalArgumentException("Invalid DER sequence length")
+    }
+
+    if (derSignature[index].toInt() != 0x02) {
+      throw IllegalArgumentException("Invalid DER integer marker for R")
+    }
+    index += 1
+    val rLength = readDerLength(derSignature, index)
+    index += rLength.second
+    val rBytes = derSignature.copyOfRange(index, index + rLength.first)
+    index += rLength.first
+
+    if (derSignature[index].toInt() != 0x02) {
+      throw IllegalArgumentException("Invalid DER integer marker for S")
+    }
+    index += 1
+    val sLength = readDerLength(derSignature, index)
+    index += sLength.second
+    val sBytes = derSignature.copyOfRange(index, index + sLength.first)
+
+    val r = toUnsignedFixedLength(BigInteger(1, rBytes), partLength)
+    val s = toUnsignedFixedLength(BigInteger(1, sBytes), partLength)
+    return r + s
+  }
+
+  internal fun getPublicCoordinates(publicKey: ECPublicKey): Pair<String, String> {
+    val x = base64UrlEncode(toUnsignedFixedLength(publicKey.w.affineX, 32))
+    val y = base64UrlEncode(toUnsignedFixedLength(publicKey.w.affineY, 32))
+    return Pair(x, y)
+  }
+
+  internal fun hashAccessToken(accessToken: String): String {
+    val hash = MessageDigest.getInstance("SHA-256").digest(accessToken.toByteArray(Charsets.UTF_8))
+    return base64UrlEncode(hash)
+  }
+
+  internal fun isProofBoundToPublicKey(proof: String, publicKey: ECPublicKey): Boolean {
+    val segments = proof.split(".")
+    if (segments.size != 3) {
+      throw IllegalArgumentException("Invalid DPoP proof format")
+    }
+
+    val headerBytes = Base64.getUrlDecoder().decode(padBase64Url(segments[0]))
+    val header = JSONObject(String(headerBytes, Charsets.UTF_8))
+    val jwk = header.optJSONObject("jwk")
+      ?: throw IllegalArgumentException("DPoP proof header does not contain jwk")
+
+    val coordinates = getPublicCoordinates(publicKey)
+    return (
+      jwk.optString("kty") == "EC" &&
+        jwk.optString("crv") == "P-256" &&
+        jwk.optString("x") == coordinates.first &&
+        jwk.optString("y") == coordinates.second
+      )
+  }
+
+  internal fun readableMapToWritableMap(map: ReadableMap): WritableMap {
+    val result = Arguments.createMap()
+    val iterator = map.keySetIterator()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      when (map.getType(key)) {
+        ReadableType.Array -> result.putArray(key, readableArrayToWritableArray(map.getArray(key)!!))
+        ReadableType.Boolean -> result.putBoolean(key, map.getBoolean(key))
+        ReadableType.Map -> result.putMap(key, readableMapToWritableMap(map.getMap(key)!!))
+        ReadableType.Null -> result.putNull(key)
+        ReadableType.Number -> result.putDouble(key, map.getDouble(key))
+        ReadableType.String -> result.putString(key, map.getString(key))
+      }
+    }
+    return result
+  }
+
+  internal fun toJsonObject(map: ReadableMap): JSONObject {
+    val result = JSONObject()
+    val iterator = map.keySetIterator()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      when (map.getType(key)) {
+        ReadableType.Array -> result.put(key, toJsonArray(map.getArray(key)!!))
+        ReadableType.Boolean -> result.put(key, map.getBoolean(key))
+        ReadableType.Map -> result.put(key, toJsonObject(map.getMap(key)!!))
+        ReadableType.Null -> result.put(key, JSONObject.NULL)
+        ReadableType.Number -> result.put(key, map.getDouble(key))
+        ReadableType.String -> result.put(key, map.getString(key))
+      }
+    }
+    return result
+  }
+
+  internal fun toRawPublicKey(publicKey: ECPublicKey): ByteArray {
+    val x = toUnsignedFixedLength(publicKey.w.affineX, 32)
+    val y = toUnsignedFixedLength(publicKey.w.affineY, 32)
+    return byteArrayOf(0x04) + x + y
+  }
+
+  private fun readableArrayToWritableArray(array: ReadableArray): WritableArray {
+    val result = Arguments.createArray()
+    for (index in 0 until array.size()) {
+      when (array.getType(index)) {
+        ReadableType.Array -> result.pushArray(readableArrayToWritableArray(array.getArray(index)!!))
+        ReadableType.Boolean -> result.pushBoolean(array.getBoolean(index))
+        ReadableType.Map -> result.pushMap(readableMapToWritableMap(array.getMap(index)!!))
+        ReadableType.Null -> result.pushNull()
+        ReadableType.Number -> result.pushDouble(array.getDouble(index))
+        ReadableType.String -> result.pushString(array.getString(index))
+      }
+    }
+    return result
+  }
+
+  private fun toJsonArray(array: ReadableArray): JSONArray {
+    val result = JSONArray()
+    for (index in 0 until array.size()) {
+      when (array.getType(index)) {
+        ReadableType.Array -> result.put(toJsonArray(array.getArray(index)!!))
+        ReadableType.Boolean -> result.put(array.getBoolean(index))
+        ReadableType.Map -> result.put(toJsonObject(array.getMap(index)!!))
+        ReadableType.Null -> result.put(JSONObject.NULL)
+        ReadableType.Number -> result.put(array.getDouble(index))
+        ReadableType.String -> result.put(array.getString(index))
+      }
+    }
+    return result
+  }
+
+  private fun padBase64Url(input: String): String {
+    val remainder = input.length % 4
+    return if (remainder == 0) {
+      input
+    } else {
+      input + "=".repeat(4 - remainder)
+    }
+  }
+
+  private fun readDerLength(input: ByteArray, startIndex: Int): Pair<Int, Int> {
+    val first = input[startIndex].toInt() and 0xFF
+    if ((first and 0x80) == 0) {
+      return Pair(first, 1)
+    }
+
+    val lengthBytesCount = first and 0x7F
+    if (lengthBytesCount == 0 || lengthBytesCount > 4) {
+      throw IllegalArgumentException("Invalid DER length")
+    }
+
+    var length = 0
+    for (i in 0 until lengthBytesCount) {
+      length = (length shl 8) or (input[startIndex + 1 + i].toInt() and 0xFF)
+    }
+    return Pair(length, 1 + lengthBytesCount)
+  }
+
+  private fun toUnsignedFixedLength(value: BigInteger, length: Int): ByteArray {
+    val signed = value.toByteArray()
+    if (signed.size == length) {
+      return signed
+    }
+
+    if (signed.size == length + 1 && signed[0].toInt() == 0) {
+      return signed.copyOfRange(1, signed.size)
+    }
+
+    if (signed.size < length) {
+      val output = ByteArray(length)
+      System.arraycopy(signed, 0, output, length - signed.size, signed.size)
+      return output
+    }
+
+    throw IllegalArgumentException("Coordinate is larger than expected length")
+  }
+}