@qntx/wallet-native 0.0.0-stage → 0.4.0

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

package/cpp/platform/LifecycleAndroid.cpp

@@ -0,0 +1,55 @@
+// Android background-lock lifecycle: the Kotlin AppLifecycle object registers
+// a ProcessLifecycleOwner observer on the main looper; its DefaultLifecycleObserver
+// callbacks reach the dispatcher through the JNI exports below.
+#include "../host/Lifecycle.hpp"
+
+#ifdef __ANDROID__
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <stdexcept>
+
+namespace qntx {
+namespace {
+facebook::jni::global_ref<jclass> g_appLifecycleClass;
+} // namespace
+
+void kernelLifecycleInit(facebook::jni::alias_ref<jclass> clazz) {
+  g_appLifecycleClass = facebook::jni::make_global(clazz);
+}
+
+int64_t sleepInclusiveMonotonicMs() {
+  // CLOCK_BOOTTIME counts suspend; CLOCK_MONOTONIC does not.
+  struct timespec ts;
+  ::clock_gettime(CLOCK_BOOTTIME, &ts);
+  return static_cast<int64_t>(ts.tv_sec) * 1000 + ts.tv_nsec / 1000000;
+}
+
+void installLifecycleObserver() {
+  static std::once_flag once;
+  std::call_once(once, [] {
+    facebook::jni::ThreadScope threadScope;
+    if (!g_appLifecycleClass) {
+      throw std::runtime_error("lifecycle: JNI_OnLoad init did not run");
+    }
+    auto install = g_appLifecycleClass->getStaticMethod<void()>("install");
+    install(g_appLifecycleClass.get());
+  });
+}
+
+} // namespace qntx
+
+// The Kotlin object's DefaultLifecycleObserver dispatches here.
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_qntxwallet_AppLifecycle_onAppBackground(
+    JNIEnv*, jclass) {
+  qntx::KernelLifecycleDispatcher::shared().onBackground();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_qntxwallet_AppLifecycle_onAppForeground(
+    JNIEnv*, jclass) {
+  qntx::KernelLifecycleDispatcher::shared().onForeground();
+}
+
+#endif // __ANDROID__

package/cpp/platform/LifecycleIos.mm

@@ -0,0 +1,36 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+#include <mutex>
+#include <time.h>
+
+#include "../host/Lifecycle.hpp"
+
+namespace qntx {
+
+int64_t sleepInclusiveMonotonicMs() {
+  // CLOCK_MONOTONIC counts sleep (steady_clock/mach_absolute_time does not).
+  const uint64_t ns = clock_gettime_nsec_np(CLOCK_MONOTONIC);
+  return static_cast<int64_t>(ns / 1000000);
+}
+
+void installLifecycleObserver() {
+  static std::once_flag once;
+  std::call_once(once, [] {
+    auto* center = NSNotificationCenter.defaultCenter;
+    [center addObserverForName:UIApplicationDidEnterBackgroundNotification
+                        object:nil
+                         queue:nil
+                    usingBlock:^(NSNotification*) {
+                      KernelLifecycleDispatcher::shared().onBackground();
+                    }];
+    [center addObserverForName:UIApplicationWillEnterForegroundNotification
+                        object:nil
+                         queue:nil
+                    usingBlock:^(NSNotification*) {
+                      KernelLifecycleDispatcher::shared().onForeground();
+                    }];
+  });
+}
+
+} // namespace qntx

package/cpp/platform/PasskeyAndroid.cpp

@@ -0,0 +1,118 @@
+// Android passkey authenticator: the Kotlin Passkey object runs Credential
+// Manager; this file forwards each request JSON through fbjni with a
+// completion token and resolves the parked completion when Kotlin calls back
+// through nativeComplete (on the main thread).
+#include "../host/Passkey.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_passkeyClass;
+
+std::mutex g_mutex;
+int64_t g_nextToken = 1;
+std::unordered_map<int64_t, PasskeyDone> g_pending;
+
+int64_t park(PasskeyDone done) {
+  std::lock_guard<std::mutex> lock(g_mutex);
+  const int64_t token = g_nextToken++;
+  g_pending.emplace(token, std::move(done));
+  return token;
+}
+
+PasskeyDone 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> passkeyClass() {
+  if (!g_passkeyClass) {
+    throw std::runtime_error("passkey: JNI_OnLoad init did not run");
+  }
+  return g_passkeyClass;
+}
+
+// Runs one Kotlin entry point; a JNI failure completes the call as `failed`
+// instead of leaving it parked forever.
+void dispatch(const char* method, const std::string& requestJson, PasskeyDone done) {
+  const int64_t token = park(std::move(done));
+  try {
+    jni::ThreadScope threadScope;
+    auto entry = passkeyClass()->getStaticMethod<void(jlong, jni::alias_ref<jstring>)>(method);
+    entry(passkeyClass(), static_cast<jlong>(token), jni::make_jstring(requestJson));
+  } catch (...) {
+    if (auto parked = take(token)) {
+      parked(PasskeyResult{PasskeyStatus::failed, {}});
+    }
+  }
+}
+
+} // namespace
+
+void kernelPasskeyInit(jni::alias_ref<jclass> clazz) {
+  g_passkeyClass = jni::make_global(clazz);
+}
+
+void passkeyCreate(std::string requestJson, PasskeyDone done) {
+  dispatch("create", requestJson, std::move(done));
+}
+
+void passkeyGet(std::string requestJson, PasskeyDone done) {
+  dispatch("get", requestJson, std::move(done));
+}
+
+void passkeyCancel() {
+  jni::ThreadScope threadScope;
+  auto method = passkeyClass()->getStaticMethod<void()>("cancel");
+  method(passkeyClass());
+}
+
+} // namespace qntx
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_margelo_nitro_qntxwallet_Passkey_nativeComplete(
+    JNIEnv* env, jclass, jlong token, jint status, jstring responseJson) {
+  auto done = qntx::take(static_cast<int64_t>(token));
+  if (!done) {
+    return;
+  }
+  qntx::PasskeyResult result;
+  switch (status) {
+    case static_cast<jint>(qntx::PasskeyStatus::ok):
+    case static_cast<jint>(qntx::PasskeyStatus::cancelled):
+    case static_cast<jint>(qntx::PasskeyStatus::unavailable):
+      result.status = static_cast<qntx::PasskeyStatus>(status);
+      break;
+    default:
+      result.status = qntx::PasskeyStatus::failed;
+  }
+  if (responseJson != nullptr && result.status == qntx::PasskeyStatus::ok) {
+    const char* utf = env->GetStringUTFChars(responseJson, nullptr);
+    if (utf != nullptr) {
+      result.responseJson = utf;
+      env->ReleaseStringUTFChars(responseJson, utf);
+    }
+  }
+  done(std::move(result));
+}
+
+#endif // __ANDROID__

package/cpp/platform/PasskeyIos.mm

@@ -0,0 +1,20 @@
+// iOS passkey authenticator: not available yet. Native passkeys need the
+// app's associated domain (webcredentials), which the current free signing
+// team cannot provision; W6c implements ASAuthorization with PRF once a paid
+// team exists. Until then every ceremony reports `unavailable`, which the
+// kernel surfaces as factor-unavailable (no passkey wallet on this platform).
+#include "../host/Passkey.hpp"
+
+namespace qntx {
+
+void passkeyCreate(std::string, PasskeyDone done) {
+  done(PasskeyResult{PasskeyStatus::unavailable, {}});
+}
+
+void passkeyGet(std::string, PasskeyDone done) {
+  done(PasskeyResult{PasskeyStatus::unavailable, {}});
+}
+
+void passkeyCancel() {}
+
+} // namespace qntx

package/cpp/platform/VaultDirectory.mm

@@ -0,0 +1,58 @@
+// iOS vault directory: Application Support/qntx-wallet/ created with
+// NSFileProtectionComplete and excluded from backup — the vault image must
+// never ride into iCloud or unencrypted backups.
+#include "../host/VaultDirectory.hpp"
+
+#import <Foundation/Foundation.h>
+
+#include <stdexcept>
+
+namespace qntx {
+namespace {
+
+// NSError detail is reduced to its numeric code: failure messages propagate
+// through the kernel's error path and must never carry user-data paths.
+[[noreturn]] void failStep(const char* step, NSError* error) {
+  if (error == nil) {
+    throw std::runtime_error(step);
+  }
+  throw std::runtime_error(
+      std::string(step) + " (Cocoa error " + std::to_string(error.code) + ")");
+}
+
+} // namespace
+
+std::string platformVaultDirectory() {
+  NSFileManager* fileManager = [NSFileManager defaultManager];
+  NSError* error = nil;
+  NSURL* appSupport = [fileManager URLForDirectory:NSApplicationSupportDirectory
+                                          inDomain:NSUserDomainMask
+                                 appropriateForURL:nil
+                                            create:YES
+                                             error:&error];
+  if (appSupport == nil) {
+    failStep("resolve Application Support directory", error);
+  }
+  NSURL* dir = [appSupport URLByAppendingPathComponent:@"qntx-wallet" isDirectory:YES];
+  if (dir == nil) {
+    throw std::runtime_error("resolve vault directory");
+  }
+  error = nil;
+  if (![fileManager createDirectoryAtURL:dir
+             withIntermediateDirectories:YES
+                              attributes:@{NSFileProtectionKey : NSFileProtectionComplete}
+                                   error:&error]) {
+    failStep("create vault directory", error);
+  }
+  error = nil;
+  if (![dir setResourceValue:@YES forKey:NSURLIsExcludedFromBackupKey error:&error]) {
+    failStep("exclude vault directory from backup", error);
+  }
+  const char* path = dir.fileSystemRepresentation;
+  if (path == nullptr) {
+    throw std::runtime_error("resolve vault directory path");
+  }
+  return path;
+}
+
+} // namespace qntx

package/cpp/platform/VaultDirectoryAndroid.cpp

@@ -0,0 +1,35 @@
+// Android vault directory: <noBackupFilesDir>/qntx-wallet, pulled from the
+// Kotlin VaultDirectory.resolve() through fbjni — one supported-API path, no
+// C++-side caching of the path.
+#include "../host/VaultDirectory.hpp"
+
+#ifdef __ANDROID__
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <stdexcept>
+#include <string>
+
+namespace qntx {
+namespace {
+facebook::jni::global_ref<jclass> g_vaultDirectoryClass;
+} // namespace
+
+void kernelVaultDirectoryInit(facebook::jni::alias_ref<jclass> clazz) {
+  g_vaultDirectoryClass = facebook::jni::make_global(clazz);
+}
+
+std::string platformVaultDirectory() {
+  facebook::jni::ThreadScope threadScope;
+  if (!g_vaultDirectoryClass) {
+    throw std::runtime_error("vault directory: JNI_OnLoad init did not run");
+  }
+  auto method = g_vaultDirectoryClass->getStaticMethod<facebook::jni::JString::javaobject()>(
+      "resolve");
+  auto path = method(g_vaultDirectoryClass.get());
+  return path->toStdString();
+}
+
+} // namespace qntx
+
+#endif // __ANDROID__