feat: route all applet protocol operations through libcanokey

.github/workflows/deploy.yml

@@ -49,20 +49,6 @@ jobs:
         cargo install wasm-pack --version "$WASM_PACK_VERSION" --locked
         flutter_rust_bridge_codegen build-web --release \
           --wasm-pack-rustup-toolchain "$RUST_NIGHTLY"
-    - name: Restore FIDO2 Web backend
-      id: fido2_web_cache
-      uses: actions/cache@v5
-      with:
-        path: web/fido2
-        key: fido2-web-v1-${{ runner.os }}-${{ runner.arch }}-${{ env.RUST_NIGHTLY }}-${{ steps.wasm_pack.outputs.version }}-${{ hashFiles('pubspec.lock') }}
-    - name: Build FIDO2 Web backend
-      if: steps.fido2_web_cache.outputs.cache-hit != 'true'
-      env:
-        RUSTUP_TOOLCHAIN: ${{ env.RUST_NIGHTLY }}
-      run: |
-        dart run fido2:setup --web --output=build/fido2
-        mkdir -p web/fido2
-        cp build/fido2/web/fido2_crypto* web/fido2/
     - run: flutter build web --verbose
     - uses: actions/upload-artifact@v7
       with:

.github/workflows/usbip.yml

@@ -62,7 +62,7 @@ jobs:
           rust-src-dir: rust
           cache-key: usbip-backend
 
-      - name: Build FIDO2 backend
+      - name: Build native backend
         if: steps.backend_cache.outputs.cache-hit != 'true'
         run: |
           cargo build --manifest-path rust/Cargo.toml --release --locked
@@ -78,10 +78,10 @@ jobs:
 
       - run: flutter pub get
 
-      - name: Test FIDO2 backend and client integration
+      - name: Test native backends and client integration
         env:
-          FIDO2_CRYPTO_LIBRARY: ${{ github.workspace }}/build/usbip-backend/librust_lib_canokey_console.so
-        run: flutter test --no-pub test/helper/utils/fido2_backend_test.dart
+          FRB_DART_LOAD_EXTERNAL_LIBRARY_NATIVE_LIB_DIR: ${{ github.workspace }}/build/usbip-backend
+        run: flutter test --no-pub --tags native
 
       - name: Share native backend with firmware jobs
         uses: actions/upload-artifact@v7

.gitignore

@@ -5,7 +5,6 @@ build
 *.iml
 .flutter-plugins*
 dist/
-web/fido2/
 app-store-screenshots/
 android/fastlane/report.xml
 ios/fastlane/report.xml

README.md

@@ -50,12 +50,30 @@ Visit our web application at [CanoKey Console Web](https://console.canokeys.org)
 
 3. Run the application:
    ```bash
-   flutter_rust_bridge_codegen build-web --release # for web only, remove --release for debug Rust build (very slow when decoding qrcode!)
-   dart run fido2:setup --web --output=build/fido2 # for web only
-   mkdir -p web/fido2 && cp build/fido2/web/fido2_crypto* web/fido2/ # for web only
+   flutter_rust_bridge_codegen build-web --release --wasm-pack-rustup-toolchain nightly-2026-09-04 # for web only
    flutter run
    ```
 
+For Chrome development, run `flutter run -d chrome --cross-origin-isolation`
+to enable the headers required for shared WASM memory.
+
+The `wasm-bindgen` crate family is pinned in `rust/Cargo.toml` and the
+`wasm-bindgen-cli` used by `wasm-pack` must match it (currently 0.2.128).
+If `wasm-pack` cannot reuse an installed helper and fails while compiling
+`wasm-bindgen-cli` with WASM linker flags on the host, install the matching
+helper separately, e.g. `cargo +stable install wasm-bindgen-cli --version 0.2.128 --locked`,
+and ensure its `bin` directory is on `PATH` before rebuilding.
+
+After changing Rust code or regenerating Flutter Rust Bridge bindings, rebuild
+the web bundle with the `build-web` command above, then stop and relaunch the
+Flutter app. Hot restart does not recompile Rust. A content-hash mismatch means
+the loaded WASM bundle and generated Dart bindings are out of sync.
+
+If hot restart reports `Identifier 'wasm_bindgen' has already been declared`,
+fully reload the browser page or stop and relaunch the app. The bridge's web
+loader inserts its script again on hot restart, while the previous script's
+global declaration remains in the page.
+
 ## Diagnostic Logs
 
 Open **Settings > View Logs** to inspect this session's local logs without a
@@ -81,24 +99,22 @@ If you change any Rust dependencies (`Cargo.lock`), please run:
 cd rust && cargo bundle-licenses -f json | jq '.third_party_libraries | del(.[].licenses)' > THIRD_PARTY_LICENSES.json
 ```
 
-The fido2 Dart package and native Rust revision are pinned together at 2.0.0.
-Its native C ABI is linked into the existing console Rust library. The
-wasm-bindgen dependency family is pinned to versions compatible with fido2 2.0.0.
-Web uses the separate JS/WASM loader distributed with the Dart package.
+PIV selection, version and algorithm-configuration reads now use a pinned
+libcanokey Rust dependency through Flutter Rust Bridge. See the
+[migration boundary and next steps](docs/libcanokey-migration.md) for the
+implemented scope, session requirements and validation commands.
 
 Before running backend or USB/IP tests locally, build the native backend:
 
 ```bash
 cargo build --manifest-path rust/Cargo.toml --release --locked
-flutter test test/helper/utils/fido2_backend_test.dart
+flutter test --tags native
 ```
 
 ### Web
 
 ```bash
-flutter_rust_bridge_codegen build-web --release
-dart run fido2:setup --web --output=build/fido2
-mkdir -p web/fido2 && cp build/fido2/web/fido2_crypto* web/fido2/
+flutter_rust_bridge_codegen build-web --release --wasm-pack-rustup-toolchain nightly-2026-09-04
 flutter build web
 ```
 

docs/libcanokey-migration.md

@@ -0,0 +1,106 @@
+# libcanokey integration
+
+All card protocol operations in Console go through
+[libcanokey](https://github.com/canokeys/libcanokey) via the Flutter Rust
+Bridge facade in `rust/src/api/protocol.rs`. The pinned revision lives in
+`rust/Cargo.toml`. Dart never constructs APDUs; host-side policy (CSR
+building, UI flows, credential prompting) stays in Console.
+
+## Architecture
+
+- `rust/src/api/protocol.rs` — the FRB facade. `ProtocolProfile` holds probed
+  device evidence; `ProtocolOperation` is an opaque state machine that Dart
+  drives APDU-by-APDU (`start()`/`advance(response)` → `ProtocolStep`).
+  Handles (`CtapPinSession`, `CtapPinToken`, profiles) are opaque and
+  close/dispose locally only.
+- `lib/helper/utils/card_client.dart` — shared client infrastructure:
+  `CardClientBase` (transport/lease guards, `withSession`, cancellation),
+  `ProfileCardClient` (`prepareProfile`, `executePrepared`,
+  `lastStatusWord`), `ProfileBinding` (lease + generation evidence), and
+  `AdminSessionCardClient` (Admin progress and session evidence) in
+  `admin_card.dart`. Per-applet clients (`piv_card.dart`, `oath_card.dart`,
+  `openpgp_card.dart`, `ndef_card.dart`, `pass_card.dart`,
+  `webauthn_card.dart`) hold only domain logic.
+- `lib/helper/utils/smartcard.dart` — the `SmartCard.process` queue; every
+  use case (connect, SELECT, authenticate, commands, cleanup) runs inside it.
+  Connection bootstrap identity commands use upstream `admin::command`
+  builders via `ProtocolOperation.bootstrapIdentity`.
+
+## Contracts that must not be broken
+
+- A physical lease (`CardLease`) owns selection/profile/authentication
+  generations. A closed, failed or replaced lease cannot exchange or publish
+  results. One executor reserves its lease for a whole operation; raw
+  exchanges, other operations and rebinds cannot interleave continuation
+  APDUs.
+- Profiles are immutable evidence, never authentication tokens. Controllers
+  `prepare()` explicitly before dependent reads; an explicit SELECT or a
+  profile-affecting write invalidates the evidence. Failed re-probing never
+  leaves an older profile usable.
+- Mutations are never retried, resumed or rolled back by the host. A
+  cancelled or uncertain write is exposed as unconfirmed, not reported
+  successful.
+- Credentials are explicit per request and enter zeroizing containers; Dart
+  wipes its mutable copies. Admin session evidence (`Access::Existing`
+  reuse) is recorded only by a successful facade `VerifyPin`, is stamped
+  with the lease generations, and is invalidated by cross-applet selection,
+  profile invalidation, uncertain writes, failed Existing requests or lease
+  replacement. UI PIN caches never produce authorization.
+- Capability policy: firmware outside the audited matrix is
+  `CapabilityUnknown` and unsupported operations fail at construction,
+  before any I/O. Console never bypasses capability checks with invented
+  profiles or speculative wire formats.
+- Errors keep kind, phase and status word as separate fields. On CTAP paths
+  `statusWord` carries the raw CTAP status byte (widened), not an ISO SW.
+  Transport errors propagate unchanged.
+
+## Applet notes
+
+- **Admin** — full coverage (config, PIN, NFC, SM2, keymap, applet/factory
+  reset, Pass slots). Requests default to SELECT + per-request PIN and
+  converge to `Access::Existing` while session evidence is valid.
+- **PIV** — full coverage, including PQ seed import, attestation and
+  streaming sign, all with `Access::Existing`. The algorithm-extension read
+  uses the upstream profile-based operation: on 3.0.x firmware it requires
+  management-key authentication (`Access::Management` authenticates and
+  reads in one operation); an unauthenticated read fails with
+  `SecurityStatusNotSatisfied` and the UI falls back to firmware defaults
+  only for that known gate. Certificate/object framing, gzip bounds and
+  continuation are owned upstream.
+- **OATH** — full coverage; password-protected applets pass
+  `accessKey`/`accessChallenge` per operation. Set-default legacy dialects
+  are split by the upstream capability (`OathSetDefaultSlots`).
+- **OpenPGP** — full coverage (data reads, PIN/reset-code/unblock, touch
+  policy/cache, retries, generate, terminate/activate). Optional data
+  objects map only `NotFound` to null.
+- **NDEF** — profile-free read capability/message and crash-safe write.
+  The CC advertises the file ID; read-only and oversized writes fail at the
+  CC preflight (`SecurityStatusNotSatisfied` / `LimitExceeded`).
+- **Pass** — Admin `PassSlots`/`SetPassSlot`. Both are protected; reads take
+  the lease's verified PIN unless session evidence applies. OATH-linked
+  slots are read-only here (configured via OATH); unknown slot types surface
+  as unknown.
+- **WebAuthn/CTAP2** — upstream `ctap2`/`pin`/`credmgmt` client layer
+  (getInfo, ClientPin v1/v2, credential management) with canonical CBOR in
+  Rust. Tokens are ceremony-scoped and never cached; the ephemeral scalar
+  and IV are generated by the facade's CSPRNG. Non-zero CTAP status bytes
+  are data for the UI, not transport errors.
+
+## Verification
+
+```sh
+flutter_rust_bridge_codegen generate   # after facade signature changes
+cargo test --manifest-path rust/Cargo.toml --locked
+cargo build --manifest-path rust/Cargo.toml --release --locked
+cargo check --manifest-path rust/Cargo.toml --target wasm32-unknown-unknown --locked
+flutter test --no-pub
+flutter test --no-pub --tags native   # injected-transport transcripts
+```
+
+The FRB WASM package (`flutter_rust_bridge_codegen build-web --release
+--wasm-pack-rustup-toolchain <nightly>`) and `flutter build web --no-pub`
+must be rebuilt after facade changes; the wasm-bindgen crate family in
+`rust/Cargo.toml` tracks the `wasm-bindgen-cli` version used by wasm-pack.
+The USB/IP firmware matrix runs in CI (`.github/workflows/usbip.yml`) via
+`test/usbip/console_smoke.dart`; physical-card and browser-transport
+coverage is not exercised locally.