@qntx/wallet-native 0.0.0-stage → 0.5.2

package/cpp/host/Lifecycle.cpp

@@ -0,0 +1,77 @@
+#include "Lifecycle.hpp"
+
+
+
+namespace qntx {
+
+KernelLifecycleDispatcher& KernelLifecycleDispatcher::shared() {
+  static KernelLifecycleDispatcher dispatcher;
+  return dispatcher;
+}
+
+void KernelLifecycleDispatcher::registerHost(
+    const std::weak_ptr<LifecycleLockTarget>& host, int seconds) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  entries_.push_back(Entry{host, seconds, std::nullopt});
+}
+
+void KernelLifecycleDispatcher::unregister(const LifecycleLockTarget* host) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  std::erase_if(entries_, [&](const Entry& entry) {
+    const auto target = entry.host.lock();
+    return !target || target.get() == host;
+  });
+}
+
+void KernelLifecycleDispatcher::onBackground() {
+  std::vector<std::shared_ptr<LifecycleLockTarget>> immediate;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    const auto now = clock_();
+    for (auto& entry : entries_) {
+      const auto host = entry.host.lock();
+      if (!host) {
+        continue;
+      }
+      if (entry.seconds == 0) {
+        immediate.push_back(host);
+      } else {
+        entry.backgroundAtMs = now;
+      }
+    }
+  }
+  // Lock outside the registry mutex — the target's own lock may re-enter here
+  // (unregister on exit).
+  for (const auto& host : immediate) {
+    host->lockForBackground();
+  }
+}
+
+void KernelLifecycleDispatcher::onForeground() {
+  std::vector<std::shared_ptr<LifecycleLockTarget>> expired;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    const auto now = clock_();
+    for (auto& entry : entries_) {
+      const auto host = entry.host.lock();
+      if (!host) {
+        continue;
+      }
+      if (entry.backgroundAtMs.has_value() &&
+          backgroundExpired(*entry.backgroundAtMs, now, entry.seconds)) {
+        expired.push_back(host);
+      }
+      entry.backgroundAtMs.reset();
+    }
+  }
+  for (const auto& host : expired) {
+    host->lockForBackground();
+  }
+}
+
+void KernelLifecycleDispatcher::setClock(std::function<int64_t()> clock) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  clock_ = std::move(clock);
+}
+
+} // namespace qntx

package/cpp/host/Lifecycle.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <mutex>
+#include <vector>
+
+namespace qntx {
+
+/**
+ * The background-expiry decision: a host whose lock deadline was
+ * `backgroundAtMs + seconds*1000` on the sleep-inclusive monotonic clock is
+ * expired when nowMs is past it. seconds==0 locks the moment the app
+ * backgrounds — the caller never reaches this function for it.
+ */
+inline bool backgroundExpired(int64_t backgroundAtMs, int64_t nowMs, int seconds) {
+  return nowMs >= backgroundAtMs + static_cast<int64_t>(seconds) * 1000;
+}
+
+/** Milliseconds on the clock that keeps running while the device sleeps —
+ *  Apple CLOCK_MONOTONIC, Android CLOCK_BOOTTIME. */
+int64_t sleepInclusiveMonotonicMs();
+
+/** What the platform's lifecycle hooks lock; HybridKernelHost implements it
+ *  (exit(BACKGROUND)). The interface keeps the dispatcher testable without a
+ *  Nitro runtime. */
+class LifecycleLockTarget {
+ public:
+  virtual ~LifecycleLockTarget() = default;
+  virtual void lockForBackground() = 0;
+};
+
+/**
+ * One process-wide registry of live kernel hosts with their
+ * backgroundLockSeconds. `onBackground` stamps every registered host (or locks
+ * it immediately when its seconds is 0); `onForeground` locks the hosts whose
+ * deadline passed while backgrounded. All calls are main-thread safe and take
+ * weak_ptr so a destroyed host is simply skipped.
+ */
+class KernelLifecycleDispatcher {
+ public:
+  static KernelLifecycleDispatcher& shared();
+
+  void registerHost(const std::weak_ptr<LifecycleLockTarget>& host, int seconds);
+  /** Drop the registration — called on every host exit. */
+  void unregister(const LifecycleLockTarget* host);
+
+  void onBackground();
+  void onForeground();
+
+  /** Test seam: the clock defaults to sleepInclusiveMonotonicMs. */
+  void setClock(std::function<int64_t()> clock);
+
+ private:
+  struct Entry {
+    std::weak_ptr<LifecycleLockTarget> host;
+    int seconds;
+    std::optional<int64_t> backgroundAtMs;
+  };
+  std::mutex mutex_;
+  std::vector<Entry> entries_;
+  std::function<int64_t()> clock_ = sleepInclusiveMonotonicMs;
+};
+
+/** Install the platform's app-lifecycle observer exactly once — NSNotificationCenter
+ *  on Apple, ProcessLifecycleOwner on Android. Called from KernelHost.start. */
+void installLifecycleObserver();
+
+} // namespace qntx

package/cpp/host/Passkey.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <functional>
+#include <string>
+
+namespace qntx {
+
+// The platform passkey authenticator behind `__qntx.passkey` (W6). The kernel
+// builds the WebAuthn request JSON and parses the response JSON itself; the
+// platform only runs the system ceremony. Android: Credential Manager. iOS:
+// not yet available (W6c needs an associated domain) — every call completes
+// `unavailable`. Each function has exactly one strong definition per platform
+// (PasskeyAndroid.cpp, PasskeyIos.mm); host tests link a fake.
+
+// The binding maps each status to the kernel's error code: cancelled →
+// "cancelled", unavailable → "factor-unavailable", failed → "unavailable".
+// The values are part of the Android JNI contract (Passkey.kt).
+enum class PasskeyStatus { ok = 0, cancelled = 1, unavailable = 3, failed = 4 };
+
+struct PasskeyResult {
+  PasskeyStatus status = PasskeyStatus::failed;
+  // The WebAuthn registration or authentication response JSON on success.
+  std::string responseJson;
+};
+
+// Completion callbacks run exactly once, on any thread.
+using PasskeyDone = std::function<void(PasskeyResult)>;
+
+// Registers a discoverable credential from PublicKeyCredentialCreationOptions JSON.
+void passkeyCreate(std::string requestJson, PasskeyDone done);
+
+// Asserts a credential from PublicKeyCredentialRequestOptions JSON.
+void passkeyGet(std::string requestJson, PasskeyDone done);
+
+// Dismisses the system UI of an in-flight ceremony, if any; that call still
+// completes (normally `cancelled`). Called when a kernel runtime tears down.
+void passkeyCancel();
+
+} // namespace qntx

package/cpp/host/VaultDirectory.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+
+namespace qntx {
+
+// The directory the vault image file lives in — resolved once per
+// KernelRuntime::start and passed explicitly to kernelFileRead/kernelFileWrite:
+//   iOS     <Application Support>/qntx-wallet
+//   Android <noBackupFilesDir>/qntx-wallet
+// Defined only by a platform translation unit (platform/VaultDirectory.mm on iOS,
+// platform/VaultDirectoryAndroid.cpp on Android): a host that links neither fails
+// at link time instead of misbehaving at runtime.
+std::string platformVaultDirectory();
+
+} // namespace qntx

package/cpp/platform/KeystoreAndroid.cpp

@@ -0,0 +1,175 @@
+// Android keystore: the Kotlin Keystore object owns the AndroidKeyStore key
+// and the BiometricPrompt; this file forwards each call through fbjni with a
+// completion token and resolves the parked completion when Kotlin calls back
+// through nativeComplete (on the main thread).
+#include "../host/Keystore.hpp"
+
+#ifdef __ANDROID__
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+
+#include <cstdint>
+#include <mutex>
+#include <stdexcept>
+#include <unordered_map>
+#include <utility>
+
+namespace qntx {
+namespace {
+
+namespace jni = facebook::jni;
+
+jni::global_ref<jclass> g_keystoreClass;
+
+std::mutex g_mutex;
+int64_t g_nextToken = 1;
+std::unordered_map<int64_t, KeystoreDone> g_pending;
+
+int64_t park(KeystoreDone done) {
+  std::lock_guard<std::mutex> lock(g_mutex);
+  const int64_t token = g_nextToken++;
+  g_pending.emplace(token, std::move(done));
+  return token;
+}
+
+KeystoreDone take(int64_t token) {
+  std::lock_guard<std::mutex> lock(g_mutex);
+  auto found = g_pending.find(token);
+  if (found == g_pending.end()) {
+    return nullptr;
+  }
+  auto done = std::move(found->second);
+  g_pending.erase(found);
+  return done;
+}
+
+jni::alias_ref<jclass> keystoreClass() {
+  if (!g_keystoreClass) {
+    throw std::runtime_error("keystore: JNI_OnLoad init did not run");
+  }
+  return g_keystoreClass;
+}
+
+jni::local_ref<jni::JArrayByte> byteArray(const uint8_t* data, size_t size) {
+  auto array = jni::JArrayByte::newArray(size);
+  array->setRegion(0, static_cast<jsize>(size), reinterpret_cast<const jbyte*>(data));
+  return array;
+}
+
+// Runs one Kotlin entry point; a JNI failure completes the call as `failed`
+// instead of leaving it parked forever.
+template <typename Call>
+void dispatch(KeystoreDone done, Call&& call) {
+  const int64_t token = park(std::move(done));
+  try {
+    jni::ThreadScope threadScope;
+    call(static_cast<jlong>(token));
+  } catch (...) {
+    if (auto parked = take(token)) {
+      parked(KeystoreResult{KeystoreStatus::failed, {}});
+    }
+  }
+}
+
+} // namespace
+
+void kernelKeystoreInit(jni::alias_ref<jclass> clazz) {
+  g_keystoreClass = jni::make_global(clazz);
+}
+
+void keystoreSeal(
+    const std::string& id,
+    SecretBytes secret,
+    KeystorePrompt prompt,
+    KeystoreDone done) {
+  dispatch(std::move(done), [&](jlong token) {
+    auto method = keystoreClass()->getStaticMethod<void(
+        jlong, jni::alias_ref<jstring>, jni::alias_ref<jni::JArrayByte>, jni::alias_ref<jstring>,
+        jni::alias_ref<jstring>)>("seal");
+    method(
+        keystoreClass(),
+        token,
+        jni::make_jstring(id),
+        byteArray(secret.data(), secret.size()),
+        jni::make_jstring(prompt.title),
+        jni::make_jstring(prompt.description));
+  });
+}
+
+void keystoreOpen(
+    const std::string& id,
+    std::vector<uint8_t> sealed,
+    KeystorePrompt prompt,
+    KeystoreDone done) {
+  dispatch(std::move(done), [&](jlong token) {
+    auto method = keystoreClass()->getStaticMethod<void(
+        jlong, jni::alias_ref<jstring>, jni::alias_ref<jni::JArrayByte>, jni::alias_ref<jstring>,
+        jni::alias_ref<jstring>)>("open");
+    method(
+        keystoreClass(),
+        token,
+        jni::make_jstring(id),
+        byteArray(sealed.data(), sealed.size()),
+        jni::make_jstring(prompt.title),
+        jni::make_jstring(prompt.description));
+  });
+}
+
+void keystoreAuthenticate(KeystorePrompt prompt, KeystoreDone done) {
+  dispatch(std::move(done), [&](jlong token) {
+    auto method = keystoreClass()->getStaticMethod<void(
+        jlong, jni::alias_ref<jstring>, jni::alias_ref<jstring>)>("authenticate");
+    method(
+        keystoreClass(),
+        token,
+        jni::make_jstring(prompt.title),
+        jni::make_jstring(prompt.description));
+  });
+}
+
+void keystoreClear(KeystoreDone done) {
+  dispatch(std::move(done), [&](jlong token) {
+    auto method = keystoreClass()->getStaticMethod<void(jlong)>("clear");
+    method(keystoreClass(), token);
+  });
+}
+
+void keystoreCancel() {
+  jni::ThreadScope threadScope;
+  auto method = keystoreClass()->getStaticMethod<void()>("cancel");
+  method(keystoreClass());
+}
+
+std::string keystoreLocale() {
+  jni::ThreadScope threadScope;
+  auto method = keystoreClass()->getStaticMethod<jni::JString::javaobject()>("locale");
+  return method(keystoreClass())->toStdString();
+}
+
+} // namespace qntx
+
+// Kotlin's Keystore.nativeComplete: resolves the parked call. The byte array
+// is copied into wiping storage; Kotlin wipes its own copy afterwards.
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_qntxwallet_Keystore_nativeComplete(
+    JNIEnv* env, jclass, jlong token, jint status, jbyteArray bytes) {
+  auto done = qntx::take(static_cast<int64_t>(token));
+  if (!done) {
+    return;
+  }
+  qntx::KeystoreResult result;
+  result.status = static_cast<qntx::KeystoreStatus>(status);
+  if (status < 0 || status > static_cast<jint>(qntx::KeystoreStatus::failed)) {
+    result.status = qntx::KeystoreStatus::failed;
+  }
+  if (bytes != nullptr && result.status == qntx::KeystoreStatus::ok) {
+    const jsize size = env->GetArrayLength(bytes);
+    qntx::SecretBytes copy(static_cast<size_t>(size));
+    env->GetByteArrayRegion(bytes, 0, size, reinterpret_cast<jbyte*>(copy.data()));
+    result.bytes = std::move(copy);
+  }
+  done(std::move(result));
+}
+
+#endif // __ANDROID__

package/cpp/platform/KeystoreIos.mm

@@ -0,0 +1,300 @@
+// iOS keystore (W5): one Secure Enclave P-256 key per vault factor, tagged
+// org.qntx.wallet.vault.<factor id>, readable only while a device passcode is
+// set and usable only after a fresh user-presence check. Sealing is ECIES with
+// the public key (no prompt); opening decrypts with the private key behind a
+// new LAContext whose reason is the kernel's prompt text, so every unlock,
+// re-verification and per-operation verification is its own system prompt.
+// The simulator has no Secure Enclave: there the key lives in the software
+// keychain with the same user-presence access control.
+#include "../host/Keystore.hpp"
+
+#import <Foundation/Foundation.h>
+#import <LocalAuthentication/LocalAuthentication.h>
+#import <Security/Security.h>
+#include <TargetConditionals.h>
+
+#include <cstring>
+#include <memory>
+#include <mutex>
+#include <utility>
+
+namespace qntx {
+namespace {
+
+NSString* const kTagPrefix = @"org.qntx.wallet.vault.";
+
+SecKeyAlgorithm algorithm() {
+  return kSecKeyAlgorithmECIESEncryptionCofactorVariableIVX963SHA256AESGCM;
+}
+
+dispatch_queue_t keystoreQueue() {
+  static dispatch_queue_t queue =
+      dispatch_queue_create("org.qntx.wallet.keystore", DISPATCH_QUEUE_SERIAL);
+  return queue;
+}
+
+// The context of the prompt currently on screen, for keystoreCancel.
+std::mutex g_contextMutex;
+LAContext* g_context = nil;
+
+void setCurrentContext(LAContext* context) {
+  std::lock_guard<std::mutex> lock(g_contextMutex);
+  g_context = context;
+}
+
+NSData* tagFor(const std::string& factorId) {
+  NSString* suffix = [NSString stringWithUTF8String:factorId.c_str()];
+  return [[kTagPrefix stringByAppendingString:suffix ?: @""]
+      dataUsingEncoding:NSUTF8StringEncoding];
+}
+
+KeystoreStatus statusOf(NSError* error) {
+  if (error == nil) {
+    return KeystoreStatus::failed;
+  }
+  if ([error.domain isEqualToString:LAErrorDomain]) {
+    switch (error.code) {
+      case LAErrorUserCancel:
+      case LAErrorAppCancel:
+      case LAErrorSystemCancel:
+      case LAErrorUserFallback:
+        return KeystoreStatus::cancelled;
+      case LAErrorPasscodeNotSet:
+        return KeystoreStatus::unavailable;
+      default:
+        return KeystoreStatus::failed;
+    }
+  }
+  if ([error.domain isEqualToString:NSOSStatusErrorDomain]) {
+    switch (error.code) {
+      case errSecUserCanceled:
+        return KeystoreStatus::cancelled;
+      case errSecItemNotFound:
+        return KeystoreStatus::invalidated;
+      default:
+        return KeystoreStatus::failed;
+    }
+  }
+  return KeystoreStatus::failed;
+}
+
+KeystoreStatus statusOf(CFErrorRef error) {
+  return statusOf((__bridge NSError*)error);
+}
+
+void deleteKey(NSData* tag) {
+  SecItemDelete((__bridge CFDictionaryRef) @{
+    (id)kSecClass : (id)kSecClassKey,
+    (id)kSecAttrApplicationTag : tag,
+  });
+}
+
+bool deviceOwnerAuthenticationAvailable() {
+  LAContext* probe = [LAContext new];
+  return [probe canEvaluatePolicy:LAPolicyDeviceOwnerAuthentication error:nil];
+}
+
+KeystoreResult sealNow(const std::string& factorId, const SecretBytes& secret) {
+  if (!deviceOwnerAuthenticationAvailable()) {
+    return {KeystoreStatus::unavailable, {}};
+  }
+  NSData* tag = tagFor(factorId);
+  deleteKey(tag);
+  SecAccessControlCreateFlags flags = kSecAccessControlUserPresence;
+#if !TARGET_OS_SIMULATOR
+  flags |= kSecAccessControlPrivateKeyUsage;
+#endif
+  CFErrorRef error = nullptr;
+  SecAccessControlRef access = SecAccessControlCreateWithFlags(
+      kCFAllocatorDefault, kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly, flags, &error);
+  if (access == nullptr) {
+    if (error != nullptr) {
+      CFRelease(error);
+    }
+    return {KeystoreStatus::unavailable, {}};
+  }
+  NSMutableDictionary* attributes = [@{
+    (id)kSecAttrKeyType : (id)kSecAttrKeyTypeECSECPrimeRandom,
+    (id)kSecAttrKeySizeInBits : @256,
+    (id)kSecPrivateKeyAttrs : @{
+      (id)kSecAttrIsPermanent : @YES,
+      (id)kSecAttrApplicationTag : tag,
+      (id)kSecAttrAccessControl : (__bridge id)access,
+    },
+  } mutableCopy];
+#if !TARGET_OS_SIMULATOR
+  attributes[(id)kSecAttrTokenID] = (id)kSecAttrTokenIDSecureEnclave;
+#endif
+  SecKeyRef privateKey = SecKeyCreateRandomKey((__bridge CFDictionaryRef)attributes, &error);
+  CFRelease(access);
+  if (privateKey == nullptr) {
+    if (error != nullptr) {
+      CFRelease(error);
+    }
+    return {KeystoreStatus::unavailable, {}};
+  }
+  SecKeyRef publicKey = SecKeyCopyPublicKey(privateKey);
+  CFRelease(privateKey);
+  if (publicKey == nullptr) {
+    deleteKey(tag);
+    return {KeystoreStatus::failed, {}};
+  }
+  CFDataRef plain = CFDataCreateWithBytesNoCopy(
+      kCFAllocatorDefault, secret.data(), static_cast<CFIndex>(secret.size()), kCFAllocatorNull);
+  CFDataRef sealed = SecKeyCreateEncryptedData(publicKey, algorithm(), plain, &error);
+  CFRelease(plain);
+  CFRelease(publicKey);
+  if (sealed == nullptr) {
+    if (error != nullptr) {
+      CFRelease(error);
+    }
+    deleteKey(tag);
+    return {KeystoreStatus::failed, {}};
+  }
+  SecretBytes out(CFDataGetBytePtr(sealed), static_cast<size_t>(CFDataGetLength(sealed)));
+  CFRelease(sealed);
+  return {KeystoreStatus::ok, std::move(out)};
+}
+
+KeystoreResult openNow(
+    const std::string& factorId,
+    const std::vector<uint8_t>& sealed,
+    const KeystorePrompt& prompt) {
+  LAContext* context = [LAContext new];
+  context.touchIDAuthenticationAllowableReuseDuration = 0;
+  context.localizedReason = @(prompt.description.c_str());
+  CFTypeRef keyRef = nullptr;
+  const OSStatus found = SecItemCopyMatching(
+      (__bridge CFDictionaryRef) @{
+        (id)kSecClass : (id)kSecClassKey,
+        (id)kSecAttrKeyType : (id)kSecAttrKeyTypeECSECPrimeRandom,
+        (id)kSecAttrApplicationTag : tagFor(factorId),
+        (id)kSecReturnRef : @YES,
+        (id)kSecUseAuthenticationContext : context,
+      },
+      &keyRef);
+  auto privateKey = static_cast<SecKeyRef>(const_cast<void*>(keyRef));
+  if (found == errSecItemNotFound) {
+    return {KeystoreStatus::invalidated, {}};
+  }
+  if (found != errSecSuccess || privateKey == nullptr) {
+    return {KeystoreStatus::failed, {}};
+  }
+  setCurrentContext(context);
+  CFDataRef cipher = CFDataCreate(
+      kCFAllocatorDefault, sealed.data(), static_cast<CFIndex>(sealed.size()));
+  CFErrorRef error = nullptr;
+  // Blocks this queue while the system verification is on screen.
+  CFDataRef plain = SecKeyCreateDecryptedData(privateKey, algorithm(), cipher, &error);
+  setCurrentContext(nil);
+  CFRelease(cipher);
+  CFRelease(privateKey);
+  if (plain == nullptr) {
+    const KeystoreStatus status = statusOf(error);
+    if (error != nullptr) {
+      CFRelease(error);
+    }
+    return {status, {}};
+  }
+  const auto length = static_cast<size_t>(CFDataGetLength(plain));
+  SecretBytes out(CFDataGetBytePtr(plain), length);
+  // The KEK must not outlive this copy: wipe the framework's buffer before
+  // releasing it (it is our sole reference).
+  std::memset(const_cast<UInt8*>(CFDataGetBytePtr(plain)), 0, length);
+  CFRelease(plain);
+  return {KeystoreStatus::ok, std::move(out)};
+}
+
+} // namespace
+
+void keystoreSeal(
+    const std::string& factorId,
+    SecretBytes secret,
+    KeystorePrompt,
+    KeystoreDone done) {
+  // Blocks capture C++ references as references: copy everything the
+  // asynchronous work needs into values first.
+  const std::string alias = factorId;
+  auto input = std::make_shared<SecretBytes>(std::move(secret));
+  auto finish = std::make_shared<KeystoreDone>(std::move(done));
+  dispatch_async(keystoreQueue(), ^{
+    (*finish)(sealNow(alias, *input));
+  });
+}
+
+void keystoreOpen(
+    const std::string& factorId,
+    std::vector<uint8_t> sealed,
+    KeystorePrompt prompt,
+    KeystoreDone done) {
+  const std::string alias = factorId;
+  auto finish = std::make_shared<KeystoreDone>(std::move(done));
+  dispatch_async(keystoreQueue(), ^{
+    (*finish)(openNow(alias, sealed, prompt));
+  });
+}
+
+void keystoreAuthenticate(KeystorePrompt prompt, KeystoreDone done) {
+  auto finish = std::make_shared<KeystoreDone>(std::move(done));
+  dispatch_async(keystoreQueue(), ^{
+    LAContext* context = [LAContext new];
+    context.touchIDAuthenticationAllowableReuseDuration = 0;
+    NSError* unavailable = nil;
+    if (![context canEvaluatePolicy:LAPolicyDeviceOwnerAuthentication error:&unavailable]) {
+      (*finish)(KeystoreResult{KeystoreStatus::unavailable, {}});
+      return;
+    }
+    setCurrentContext(context);
+    // Keep the serial queue busy until the reply: one prompt at a time.
+    dispatch_semaphore_t replied = dispatch_semaphore_create(0);
+    __block KeystoreStatus status = KeystoreStatus::failed;
+    [context evaluatePolicy:LAPolicyDeviceOwnerAuthentication
+            localizedReason:@(prompt.description.c_str())
+                      reply:^(BOOL success, NSError* error) {
+                        status = success ? KeystoreStatus::ok : statusOf(error);
+                        dispatch_semaphore_signal(replied);
+                      }];
+    dispatch_semaphore_wait(replied, DISPATCH_TIME_FOREVER);
+    setCurrentContext(nil);
+    (*finish)(KeystoreResult{status, {}});
+  });
+}
+
+void keystoreClear(KeystoreDone done) {
+  auto finish = std::make_shared<KeystoreDone>(std::move(done));
+  dispatch_async(keystoreQueue(), ^{
+    CFTypeRef found = nullptr;
+    const OSStatus status = SecItemCopyMatching(
+        (__bridge CFDictionaryRef) @{
+          (id)kSecClass : (id)kSecClassKey,
+          (id)kSecMatchLimit : (id)kSecMatchLimitAll,
+          (id)kSecReturnAttributes : @YES,
+        },
+        &found);
+    if (status == errSecSuccess && found != nullptr) {
+      NSArray* items = (__bridge_transfer NSArray*)found;
+      NSData* prefix = [kTagPrefix dataUsingEncoding:NSUTF8StringEncoding];
+      for (NSDictionary* item in items) {
+        NSData* tag = item[(id)kSecAttrApplicationTag];
+        if ([tag isKindOfClass:[NSData class]] && tag.length > prefix.length &&
+            [[tag subdataWithRange:NSMakeRange(0, prefix.length)] isEqualToData:prefix]) {
+          deleteKey(tag);
+        }
+      }
+    }
+    const bool ok = status == errSecSuccess || status == errSecItemNotFound;
+    (*finish)(KeystoreResult{ok ? KeystoreStatus::ok : KeystoreStatus::failed, {}});
+  });
+}
+
+void keystoreCancel() {
+  std::lock_guard<std::mutex> lock(g_contextMutex);
+  [g_context invalidate];
+}
+
+std::string keystoreLocale() {
+  NSString* language = NSLocale.preferredLanguages.firstObject;
+  return language == nil ? "en" : std::string(language.UTF8String);
+}
+
+} // namespace qntx