@doko/react-native-yubikit 0.0.2

package/src/hooks/use-yubikey.tsx

@@ -0,0 +1,10 @@
+import { useContext } from 'react';
+import { YubiKeyContext, type YubiKeyContextValue } from './yubikey-provider';
+
+export function useYubiKey(): YubiKeyContextValue {
+  const ctx = useContext(YubiKeyContext);
+  if (!ctx) {
+    throw new Error('useYubiKey must be used within a <YubiKeyProvider>');
+  }
+  return ctx;
+}

package/src/hooks/yubikey-provider.tsx

@@ -0,0 +1,146 @@
+import {
+  createContext,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+import type { ReactNode } from 'react';
+import * as Core from '../core';
+import type {
+  NfcConfiguration,
+  UsbConfiguration,
+  YubiKeyDevice,
+  YubiKeyEvent,
+} from '../types';
+
+export interface YubiKeyContextValue {
+  /** Devices currently attached, most-recently-attached first. */
+  devices: YubiKeyDevice[];
+  /** The selected device, or the most recently attached one if none was explicitly selected. */
+  selectedDevice: YubiKeyDevice | null;
+  /** Explicitly select a device by handle, or `null` to fall back to auto-selection. */
+  selectDevice: (handle: string | null) => void;
+  isUsbDiscovering: boolean;
+  isNfcDiscovering: boolean;
+  startUsbDiscovery: (config?: UsbConfiguration) => void;
+  stopUsbDiscovery: () => void;
+  startNfcDiscovery: (config?: NfcConfiguration) => void;
+  stopNfcDiscovery: () => void;
+  /** The most recent native-side error event, if any. */
+  lastError: string | null;
+}
+
+export const YubiKeyContext = createContext<YubiKeyContextValue | null>(null);
+
+export function YubiKeyProvider({ children }: { children: ReactNode }) {
+  const [devices, setDevices] = useState<YubiKeyDevice[]>(() =>
+    Core.getDiscoveredDevices()
+  );
+  const [selectedHandle, setSelectedHandle] = useState<string | null>(null);
+  const [isUsbDiscovering, setIsUsbDiscovering] = useState(false);
+  const [isNfcDiscovering, setIsNfcDiscovering] = useState(false);
+  const [lastError, setLastError] = useState<string | null>(null);
+  const isUsbDiscoveringRef = useRef(isUsbDiscovering);
+  const isNfcDiscoveringRef = useRef(isNfcDiscovering);
+
+  useEffect(() => {
+    isUsbDiscoveringRef.current = isUsbDiscovering;
+  }, [isUsbDiscovering]);
+
+  useEffect(() => {
+    isNfcDiscoveringRef.current = isNfcDiscovering;
+  }, [isNfcDiscovering]);
+
+  useEffect(() => {
+    const subscription = Core.addYubiKeyListener((event: YubiKeyEvent) => {
+      if (event.type === 'attached') {
+        setDevices((prev) => [
+          event.device,
+          ...prev.filter((d) => d.handle !== event.device.handle),
+        ]);
+        return;
+      }
+      if (event.type === 'detached') {
+        setDevices((prev) => prev.filter((d) => d.handle !== event.handle));
+        setSelectedHandle((prev) => (prev === event.handle ? null : prev));
+        return;
+      }
+      setLastError(event.error);
+    });
+
+    return () => subscription.remove();
+  }, []);
+
+  const startUsbDiscovery = useCallback((config?: UsbConfiguration) => {
+    Core.startUsbDiscovery(config);
+    setIsUsbDiscovering(true);
+  }, []);
+
+  const stopUsbDiscovery = useCallback(() => {
+    Core.stopUsbDiscovery();
+    setIsUsbDiscovering(false);
+  }, []);
+
+  const startNfcDiscovery = useCallback((config?: NfcConfiguration) => {
+    Core.startNfcDiscovery(config);
+    setIsNfcDiscovering(true);
+  }, []);
+
+  const stopNfcDiscovery = useCallback(() => {
+    Core.stopNfcDiscovery();
+    setIsNfcDiscovering(false);
+  }, []);
+
+  // Discovery is a global, imperative native API (not tied to this component's
+  // lifetime by the native side), but leaving it running past the provider that
+  // started it would leak a dangling USB/NFC session the app can no longer see.
+  useEffect(() => {
+    return () => {
+      if (isUsbDiscoveringRef.current) Core.stopUsbDiscovery();
+      if (isNfcDiscoveringRef.current) Core.stopNfcDiscovery();
+    };
+  }, []);
+
+  const selectDevice = useCallback((handle: string | null) => {
+    setSelectedHandle(handle);
+  }, []);
+
+  const selectedDevice = useMemo(
+    () =>
+      devices.find((d) => d.handle === selectedHandle) ?? devices[0] ?? null,
+    [devices, selectedHandle]
+  );
+
+  const value = useMemo<YubiKeyContextValue>(
+    () => ({
+      devices,
+      selectedDevice,
+      selectDevice,
+      isUsbDiscovering,
+      isNfcDiscovering,
+      startUsbDiscovery,
+      stopUsbDiscovery,
+      startNfcDiscovery,
+      stopNfcDiscovery,
+      lastError,
+    }),
+    [
+      devices,
+      selectedDevice,
+      selectDevice,
+      isUsbDiscovering,
+      isNfcDiscovering,
+      startUsbDiscovery,
+      stopUsbDiscovery,
+      startNfcDiscovery,
+      stopNfcDiscovery,
+      lastError,
+    ]
+  );
+
+  return (
+    <YubiKeyContext.Provider value={value}>{children}</YubiKeyContext.Provider>
+  );
+}

package/src/index.tsx

@@ -0,0 +1,10 @@
+export * from './types';
+
+export * as Core from './core';
+export * as Management from './management';
+export * as Oath from './oath';
+export * as Piv from './piv';
+export * as OpenPgp from './openpgp';
+export * as YubiOtp from './yubiotp';
+export * as Fido from './fido';
+export * as Support from './support';

package/src/management.ts

@@ -0,0 +1,44 @@
+import NativeYubikitManagement from './specs/NativeYubikitManagement';
+import type { Base64String, DeviceConfig, DeviceInfo, UsbMode } from './types';
+
+export function getDeviceInfo(deviceHandle: string): Promise<DeviceInfo> {
+  return NativeYubikitManagement.getDeviceInfo(
+    deviceHandle
+  ) as Promise<DeviceInfo>;
+}
+
+export function updateDeviceConfig(
+  deviceHandle: string,
+  config: DeviceConfig,
+  reboot: boolean,
+  currentLockCode?: Base64String,
+  newLockCode?: Base64String
+): Promise<void> {
+  return NativeYubikitManagement.updateDeviceConfig(
+    deviceHandle,
+    config,
+    reboot,
+    currentLockCode,
+    newLockCode
+  );
+}
+
+export function setMode(
+  deviceHandle: string,
+  mode: UsbMode,
+  chalrespTimeout: number,
+  autoejectTimeout: number
+): Promise<void> {
+  return NativeYubikitManagement.setMode(
+    deviceHandle,
+    mode,
+    chalrespTimeout,
+    autoejectTimeout
+  );
+}
+
+export function deviceReset(deviceHandle: string): Promise<void> {
+  return NativeYubikitManagement.deviceReset(deviceHandle);
+}
+
+export { NativeYubikitManagement };

package/src/oath.ts

@@ -0,0 +1,134 @@
+import NativeYubikitOath from './specs/NativeYubikitOath';
+import type {
+  Base64String,
+  Code,
+  Credential,
+  CredentialData,
+  OathCodesResult,
+  OathCredentialsResult,
+} from './types';
+
+export function getDeviceId(deviceHandle: string): Promise<string> {
+  return NativeYubikitOath.getDeviceId(deviceHandle);
+}
+
+export function reset(deviceHandle: string): Promise<void> {
+  return NativeYubikitOath.reset(deviceHandle);
+}
+
+export function isAccessKeySet(deviceHandle: string): Promise<boolean> {
+  return NativeYubikitOath.isAccessKeySet(deviceHandle);
+}
+
+export function isLocked(deviceHandle: string): Promise<boolean> {
+  return NativeYubikitOath.isLocked(deviceHandle);
+}
+
+export function unlockWithPassword(
+  deviceHandle: string,
+  password: string
+): Promise<boolean> {
+  return NativeYubikitOath.unlockWithPassword(deviceHandle, password);
+}
+
+export function unlockWithAccessKey(
+  deviceHandle: string,
+  accessKey: Base64String
+): Promise<boolean> {
+  return NativeYubikitOath.unlockWithAccessKey(deviceHandle, accessKey);
+}
+
+export function setPassword(
+  deviceHandle: string,
+  password: string
+): Promise<void> {
+  return NativeYubikitOath.setPassword(deviceHandle, password);
+}
+
+export function setAccessKey(
+  deviceHandle: string,
+  accessKey: Base64String
+): Promise<void> {
+  return NativeYubikitOath.setAccessKey(deviceHandle, accessKey);
+}
+
+export function deleteAccessKey(deviceHandle: string): Promise<void> {
+  return NativeYubikitOath.deleteAccessKey(deviceHandle);
+}
+
+export function getCredentials(
+  deviceHandle: string
+): Promise<OathCredentialsResult> {
+  return NativeYubikitOath.getCredentials(
+    deviceHandle
+  ) as Promise<OathCredentialsResult>;
+}
+
+export function calculateCodes(
+  deviceHandle: string,
+  timestamp?: number
+): Promise<OathCodesResult> {
+  return NativeYubikitOath.calculateCodes(
+    deviceHandle,
+    timestamp
+  ) as Promise<OathCodesResult>;
+}
+
+export function calculateResponse(
+  deviceHandle: string,
+  credentialId: Base64String,
+  challenge: Base64String
+): Promise<Base64String> {
+  return NativeYubikitOath.calculateResponse(
+    deviceHandle,
+    credentialId,
+    challenge
+  );
+}
+
+export function calculateCode(
+  deviceHandle: string,
+  credentialId: Base64String,
+  timestamp?: number
+): Promise<Code> {
+  return NativeYubikitOath.calculateCode(
+    deviceHandle,
+    credentialId,
+    timestamp
+  ) as Promise<Code>;
+}
+
+export function putCredential(
+  deviceHandle: string,
+  credentialData: CredentialData,
+  requireTouch: boolean
+): Promise<Credential> {
+  return NativeYubikitOath.putCredential(
+    deviceHandle,
+    credentialData,
+    requireTouch
+  ) as Promise<Credential>;
+}
+
+export function deleteCredential(
+  deviceHandle: string,
+  credentialId: Base64String
+): Promise<void> {
+  return NativeYubikitOath.deleteCredential(deviceHandle, credentialId);
+}
+
+export function renameCredential(
+  deviceHandle: string,
+  credentialId: Base64String,
+  newAccountName: string,
+  newIssuer?: string
+): Promise<Credential> {
+  return NativeYubikitOath.renameCredential(
+    deviceHandle,
+    credentialId,
+    newAccountName,
+    newIssuer
+  ) as Promise<Credential>;
+}
+
+export { NativeYubikitOath };

package/src/openpgp.ts

@@ -0,0 +1,220 @@
+import NativeYubikitOpenPgp from './specs/NativeYubikitOpenPgp';
+import type {
+  Base64String,
+  OpenPgpAlgorithmAttributes,
+  OpenPgpApplicationRelatedData,
+  OpenPgpCurve,
+  OpenPgpKeyRef,
+  OpenPgpPinPolicy,
+  OpenPgpUif,
+  Version,
+} from './types';
+
+export function getVersion(deviceHandle: string): Promise<Version> {
+  return NativeYubikitOpenPgp.getVersion(deviceHandle) as Promise<Version>;
+}
+
+export function getApplicationRelatedData(
+  deviceHandle: string
+): Promise<OpenPgpApplicationRelatedData> {
+  return NativeYubikitOpenPgp.getApplicationRelatedData(
+    deviceHandle
+  ) as Promise<OpenPgpApplicationRelatedData>;
+}
+
+export function verifyUserPin(
+  deviceHandle: string,
+  pin: string,
+  extended?: boolean
+): Promise<void> {
+  return NativeYubikitOpenPgp.verifyUserPin(deviceHandle, pin, extended);
+}
+
+export function verifyAdminPin(
+  deviceHandle: string,
+  pin: string
+): Promise<void> {
+  return NativeYubikitOpenPgp.verifyAdminPin(deviceHandle, pin);
+}
+
+export function unverifyUserPin(deviceHandle: string): Promise<void> {
+  return NativeYubikitOpenPgp.unverifyUserPin(deviceHandle);
+}
+
+export function unverifyAdminPin(deviceHandle: string): Promise<void> {
+  return NativeYubikitOpenPgp.unverifyAdminPin(deviceHandle);
+}
+
+export function getSignatureCounter(deviceHandle: string): Promise<number> {
+  return NativeYubikitOpenPgp.getSignatureCounter(deviceHandle);
+}
+
+export function getChallenge(
+  deviceHandle: string,
+  length: number
+): Promise<Base64String> {
+  return NativeYubikitOpenPgp.getChallenge(deviceHandle, length);
+}
+
+export function reset(deviceHandle: string): Promise<void> {
+  return NativeYubikitOpenPgp.reset(deviceHandle);
+}
+
+export function setPinAttempts(
+  deviceHandle: string,
+  userAttempts: number,
+  resetAttempts: number,
+  adminAttempts: number
+): Promise<void> {
+  return NativeYubikitOpenPgp.setPinAttempts(
+    deviceHandle,
+    userAttempts,
+    resetAttempts,
+    adminAttempts
+  );
+}
+
+export function changeUserPin(
+  deviceHandle: string,
+  pin: string,
+  newPin: string
+): Promise<void> {
+  return NativeYubikitOpenPgp.changeUserPin(deviceHandle, pin, newPin);
+}
+
+export function changeAdminPin(
+  deviceHandle: string,
+  pin: string,
+  newPin: string
+): Promise<void> {
+  return NativeYubikitOpenPgp.changeAdminPin(deviceHandle, pin, newPin);
+}
+
+export function setSignaturePinPolicy(
+  deviceHandle: string,
+  policy: OpenPgpPinPolicy
+): Promise<void> {
+  return NativeYubikitOpenPgp.setSignaturePinPolicy(deviceHandle, policy);
+}
+
+export function getUif(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef
+): Promise<OpenPgpUif> {
+  return NativeYubikitOpenPgp.getUif(
+    deviceHandle,
+    keyRef
+  ) as Promise<OpenPgpUif>;
+}
+
+export function setUif(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef,
+  uif: OpenPgpUif
+): Promise<void> {
+  return NativeYubikitOpenPgp.setUif(deviceHandle, keyRef, uif);
+}
+
+export function getAlgorithmInformation(
+  deviceHandle: string
+): Promise<
+  Array<{ keyRef: OpenPgpKeyRef; attributes: OpenPgpAlgorithmAttributes[] }>
+> {
+  return NativeYubikitOpenPgp.getAlgorithmInformation(deviceHandle) as Promise<
+    Array<{ keyRef: OpenPgpKeyRef; attributes: OpenPgpAlgorithmAttributes[] }>
+  >;
+}
+
+export function setAlgorithmAttributes(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef,
+  attributes: OpenPgpAlgorithmAttributes
+): Promise<void> {
+  return NativeYubikitOpenPgp.setAlgorithmAttributes(
+    deviceHandle,
+    keyRef,
+    attributes
+  );
+}
+
+export function getCertificate(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef
+): Promise<Base64String> {
+  return NativeYubikitOpenPgp.getCertificate(deviceHandle, keyRef);
+}
+
+export function putCertificate(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef,
+  certificate: Base64String
+): Promise<void> {
+  return NativeYubikitOpenPgp.putCertificate(deviceHandle, keyRef, certificate);
+}
+
+export function deleteCertificate(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef
+): Promise<void> {
+  return NativeYubikitOpenPgp.deleteCertificate(deviceHandle, keyRef);
+}
+
+export function generateRsaKey(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef,
+  keySize: number
+): Promise<Base64String> {
+  return NativeYubikitOpenPgp.generateRsaKey(deviceHandle, keyRef, keySize);
+}
+
+export function generateEcKey(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef,
+  curve: OpenPgpCurve
+): Promise<Base64String> {
+  return NativeYubikitOpenPgp.generateEcKey(deviceHandle, keyRef, curve);
+}
+
+export function getPublicKey(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef
+): Promise<Base64String> {
+  return NativeYubikitOpenPgp.getPublicKey(deviceHandle, keyRef);
+}
+
+export function deleteKey(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef
+): Promise<void> {
+  return NativeYubikitOpenPgp.deleteKey(deviceHandle, keyRef);
+}
+
+export function sign(
+  deviceHandle: string,
+  payload: Base64String
+): Promise<Base64String> {
+  return NativeYubikitOpenPgp.sign(deviceHandle, payload);
+}
+
+export function decrypt(
+  deviceHandle: string,
+  payload: Base64String
+): Promise<Base64String> {
+  return NativeYubikitOpenPgp.decrypt(deviceHandle, payload);
+}
+
+export function authenticate(
+  deviceHandle: string,
+  payload: Base64String
+): Promise<Base64String> {
+  return NativeYubikitOpenPgp.authenticate(deviceHandle, payload);
+}
+
+export function attestKey(
+  deviceHandle: string,
+  keyRef: OpenPgpKeyRef
+): Promise<Base64String> {
+  return NativeYubikitOpenPgp.attestKey(deviceHandle, keyRef);
+}
+
+export { NativeYubikitOpenPgp };