diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1ceb820..d551347 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -125,6 +125,7 @@ jobs: cd host go test -run='^$' -fuzz=FuzzDecodeHeader -fuzztime=20s ./internal/wire/ go test -run='^$' -fuzz=FuzzDecodeBody -fuzztime=20s ./internal/wire/ + go test -run='^$' -fuzz=FuzzDecoder -fuzztime=20s ./internal/tui/ host-windows: env: diff --git a/README.md b/README.md index f861dfe..f20c84c 100644 --- a/README.md +++ b/README.md @@ -39,6 +39,7 @@ The following features are also included. - Key usage enforcement: the core rejects any operation outside the usage assigned at generation time (ENCRYPT, DECRYPT, SIGN, VERIFY, and so on). - Core hardening: on startup the core disables core dumps, denies `ptrace`, sets `no_new_privs` and `umask 077`, scrubs environment variables, closes unneeded `fd`s, verifies the peer UID, and checks the root key file's permissions, owner, and links. On Linux, `mlockall` prevents memory from being swapped. On Windows (experimental since 1.1.0) the core restricts its own process object with a DACL, verifies the peer's user SID and protects files with owner-only DACLs. - Strict protocol: fixed 16-byte header, length-prefixed fields, 1 MiB body limit, and rejection of trailing bytes. `HELLO` must come first, and any framing violation terminates the session. +- Terminal UI: `kmsctl ui` offers every `kmsctl` command in a full-screen interface on Linux, macOS and Windows, built on the Go standard library only. Fingerprints are always typed by the operator, and decrypted data only goes to new private files. - Air-gapped build: Rust dependencies are vendored in `core/vendor` and built with `--frozen`. Go builds with `GOPROXY=off` and `-mod=vendor` and has no external dependencies. ## Build and run diff --git a/README_KR.md b/README_KR.md index d33b0a1..86f2058 100644 --- a/README_KR.md +++ b/README_KR.md @@ -39,15 +39,16 @@ - 키 용도 강제: 생성 시 지정한 용도(ENCRYPT, DECRYPT, SIGN, VERIFY 등) 외의 연산은 코어 측에서 거부합니다. - 코어 하드닝: 시작 시 코어 덤프 차단, `ptrace` 거부, `no_new_privs`, `umask 077`, 환경 변수 제거, 불필요 `fd` 정리, 피어(peer) UID 검증, 루트 키 파일 권한·소유자·링크 검증을 수행합니다. Linux에서는 `mlockall`로 메모리 스와핑(swap)을 막습니다. Windows(1.1.0부터 experimental)에서는 코어가 자기 프로세스 객체를 DACL로 제한하고, 피어의 사용자 SID를 검증하며, 파일을 소유자 전용 DACL로 보호합니다. - 엄격한 프로토콜: 고정 16바이트 헤더와 길이 접두 필드, 1MiB 본문 상한, 후행 바이트를 거부합니다. `HELLO` 선행을 강제하며 프레이밍(framing) 위반 시 세션을 끊어냅니다. +- 터미널 UI: `kmsctl ui`는 모든 `kmsctl` 명령을 Linux, macOS, Windows에서 전체 화면 인터페이스로 제공하며 Go 표준 라이브러리만으로 만들어졌습니다. 지문은 항상 운영자가 직접 입력하고, 복호화한 데이터는 새 비공개 파일로만 저장합니다. - 폐쇄 빌드: Rust 의존성은 `core/vendor`에 벤더링되고 `--frozen`으로 빌드합니다. Go는 `GOPROXY=off`, `-mod=vendor`로 빌드하며 외부 의존성이 없습니다. ## 빌드 및 실행 -이 내용에 관해서는 [USAGE_KR.md](USAGE_KR.md)를 확인할 수 있습니다. +이 내용에 관해서는 [USAGE.md](USAGE_KR.md)를 확인할 수 있습니다. ## 보안 -취약점 신고 방법과 릴리즈 검증 방법은 [SECURITY_KR.md](SECURITY_KR.md)를 확인하세요. +취약점 신고 방법과 릴리즈 검증 방법은 [SECURITY.md](SECURITY_KR.md)를 확인하세요. ## 라이선스 diff --git a/SECURITY.md b/SECURITY.md index 617ae6b..bdd4136 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -128,6 +128,15 @@ Envelope layer: - The core rejects every operation outside the usage assigned to a key. On every use, the host checks stored metadata and public keys against the values the core recomputes from the blob. - Node start, key generation, encryption, decryption, member changes, sent and received envelopes, inbox decisions, card renewal and witness conflicts are written to the hash-chained audit log, and each entry is signed with the core's audit key. +## Terminal UI + +- `kmsctl ui` calls the same node functions as the commands. It adds no storage format, protocol or network endpoint, and every action is audited as the matching command is. +- Every string drawn on the screen goes through one sanitizer that replaces C0 and C1 control characters, DEL and Unicode format characters, including bidirectional overrides, with `?`. Labels, member ids, inbox senders, audit fields, error text from other nodes and core stderr therefore cannot emit terminal escape sequences. The UI itself writes only cursor, erase, colour and mode sequences; it sets no window title and never touches the clipboard. +- `member add` requires the fingerprint to be typed or pasted from the out-of-band channel. The UI never derives it from the card. +- Decrypted data is written only to a file that is created exclusively and privately, with an owner-only DACL on Windows, and is never drawn. Buffers holding plaintext are cleared after use, which is best effort in Go. +- The node stays open for the session, so the core keeps the root key in memory until `--idle` expires or the UI exits. Core stderr is kept in a bounded in-memory log and never written to disk. +- The terminal mode is restored on exit and on SIGINT, SIGTERM and SIGHUP. With `--offline` the UI offers no action that opens a network connection. + ## Platform differences The host and the wire formats behave the same everywhere, so nodes on different platforms interoperate. What the core can enforce against the local system differs. diff --git a/SECURITY_KR.md b/SECURITY_KR.md index 3df1f05..af526db 100644 --- a/SECURITY_KR.md +++ b/SECURITY_KR.md @@ -128,6 +128,15 @@ HTTP 서비스: - 코어는 키에 지정된 용도를 벗어나는 모든 작업을 거부합니다. 호스트는 사용할 때마다 저장된 메타데이터와 공개키를 코어가 blob에서 다시 계산한 값과 대조합니다. - 노드 기동, 키 생성, 암호화, 복호화, 구성원 변경, 보내고 받은 봉투, inbox 처리, 카드 갱신, 증인 충돌은 해시 체인 감사 로그에 기록되며, 각 항목은 코어의 감사 키로 서명됩니다. +## 터미널 UI + +- `kmsctl ui`는 명령과 같은 노드 함수를 호출합니다. 저장 형식, 프로토콜, 네트워크 엔드포인트를 새로 추가하지 않으며, 모든 동작은 해당 명령과 똑같이 감사 로그에 남습니다. +- 화면에 그리는 모든 문자열은 하나의 정화 단계를 거치며, C0·C1 제어 문자, DEL, 양방향 재정의를 포함한 Unicode 서식 문자는 `?`로 바뀝니다. 따라서 라벨, 구성원 id, 수신함 송신자, 감사 필드, 다른 노드가 보낸 오류 문구, 코어 stderr는 터미널 이스케이프 시퀀스를 내보낼 수 없습니다. UI 자체는 커서, 지우기, 색, 모드 시퀀스만 쓰며 창 제목을 바꾸지 않고 클립보드를 건드리지 않습니다. +- `member add`는 지문을 별도 채널에서 받아 직접 입력하거나 붙여 넣어야 합니다. UI는 카드에서 지문을 끌어오지 않습니다. +- 복호화한 데이터는 배타적이고 비공개로 생성한 파일(Windows는 소유자 전용 DACL)에만 쓰며 화면에 그리지 않습니다. 평문을 담은 버퍼는 사용 후 지우지만, Go에서는 최선의 노력 수준입니다. +- 노드는 세션 동안 열려 있으므로 `--idle` 시간이 지나거나 UI가 끝날 때까지 코어가 루트 키를 메모리에 둡니다. 코어 stderr는 크기가 제한된 메모리 로그에만 두고 디스크에 쓰지 않습니다. +- 터미널 모드는 종료할 때와 SIGINT, SIGTERM, SIGHUP을 받을 때 복원됩니다. `--offline`에서는 네트워크 연결을 여는 동작을 제공하지 않습니다. + ## 플랫폼별 차이 호스트와 와이어 형식은 어디서나 같게 동작하므로 서로 다른 플랫폼의 노드끼리 상호 운용됩니다. 코어가 로컬 시스템에 대해 강제할 수 있는 것은 다릅니다. diff --git a/USAGE.md b/USAGE.md index 35b66da..fd569c6 100644 --- a/USAGE.md +++ b/USAGE.md @@ -53,6 +53,23 @@ $ kmsctl version kmsctl 1.1.0 (go go1.27.4, go_fips=true) ``` +### Go toolchain + +The `Makefile` exports `GOTOOLCHAIN=local` and `GOPROXY=off`, so `make` only uses the `go` on your `PATH` and never downloads anything. When that `go` is older than the version in `host/go.mod`, the build stops with `go: go.mod requires go >= 1.27.4 (running go 1.27.2; GOTOOLCHAIN=local)`. This happens when `go.mod` was raised, for example for a security fix, before your installed Go was updated. + +- The preferred fix is to update Go to the version in `host/go.mod` (`brew upgrade go`, the official installer or your package manager). +- If you cannot update right away, download the toolchain once and pass it on the `make` command line. A variable on the `make` command line overrides the `Makefile`; the same variable set in the environment does not. + +```bash +$ GOTOOLCHAIN=go1.27.4 go version # once: fetched from the module proxy and checked against the Go checksum database +$ make build GOTOOLCHAIN=go1.27.4 +$ make test GOTOOLCHAIN=go1.27.4 +``` + +- The first line needs network access because `make` cannot download with `GOPROXY=off`. After that the toolchain is in the module cache and builds work offline. On an air-gapped host, install a verified Go release of the required version instead. +- Running `go` directly in `host/` without `make` uses the default `GOTOOLCHAIN=auto`, so Go downloads and switches to the required version by itself. Set `GOTOOLCHAIN=local` to forbid that, as CI does. +- `kmsctl version` shows which Go built the binary. + ## Installation Release tarballs are provided for Linux amd64 and arm64 and require glibc 2.38 or later, such as Ubuntu 24.04 or Debian 13. `kmsd` and `kmsctl` are static binaries, and `kms-core` links glibc dynamically. Windows x86_64 and ARM64 are provided as zip archives (`pairier-1.1.0-windows-amd64.zip`, `pairier-1.1.0-windows-arm64.zip`) built in CI; their core is non-FIPS. No macOS binaries are provided, so build from source for development (see [Build](#build)). @@ -258,14 +275,60 @@ Global options may appear before or after the command. `kmsctl --dir X key list` | `encrypt --id KEYID [--in FILE] [--out FILE] [--aad STR]` | Encrypts. Reads stdin when no input is given. | | `decrypt --id KEYID [--in FILE] [--out FILE] [--aad STR]` | Decrypts. | | `audit verify [--anchor SEQ:HASH]... [--anchor-file FILE] [--peer MEMBER --url URL]` | Verifies the audit log chain and every checkpoint signature, and prints the head. Also checks that every given head (`--anchor`, `--anchor-file`, `--peer`) is still in the log. | +| `ui [--offline] [--idle DUR] [--lang LANG]` | Opens the terminal UI described below. | | `version` | Prints the version and the Go FIPS status. | -If the file given with `--out` already exists, the command fails instead of overwriting it, and new files are created with `0600` permissions. Exit codes are as follows. +If the file given with `--out` already exists, the command fails instead of overwriting it, and new files are created with `0600` permissions, on Windows with a DACL that allows only you and SYSTEM. Exit codes are as follows. - Success `0` - Execution failure `1` - Argument error `2` +## Terminal UI + +`kmsctl ui` opens a full-screen terminal interface for everything the commands above do. It calls the same node code, so every action is written to the audit log exactly as the matching command would write it. + +``` +alice$ kmsctl --dir ~/.pairier ui +``` + +```powershell +PS> .\kmsctl.exe --dir "$env:LOCALAPPDATA\pairier\bob" ui +``` + +Without `--dir` or `$KMS_DIR` it asks for the node directory (default `~/.pairier`, on Windows `%LOCALAPPDATA%\pairier`), and when the directory does not exist it offers to initialize a node there. + +| Option | Default | Description | +|---------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------| +| `--offline` | off | Hides every action that contacts another node (push, health, peer audit). Use it on air-gapped hosts. | +| `--idle DUR` | `10m` | Closes the node and stops the core after this long without input. `0` keeps it open. | +| `--lang LANG` | `auto` | UI language, `en` or `ko`. `auto` picks Korean when `LC_ALL`, `LC_MESSAGES` or `LANG` starts with `ko`, or when the Windows display language is Korean. | + +The global options (`--dir`, `--core`, `--timeout`, `--allow-unlocked-memory`) apply as usual. + +| Tab | Keys | Commands | +|-----------|-----------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------| +| 1 Node | `c` export card, `R` renew card | `card`, `card renew` | +| 2 Keys | `Enter` info, `n` new, `s` send to a file, `p` push, `r` receive a file, `e` encrypt a file, `d` decrypt a file | `key list`, `key info`, `key gen`, `key send`, `key push`, `key receive`, `encrypt`, `decrypt` | +| 3 Members | `a` add, `w` export witnessed heads, `h` health | `member list`, `member add`, `member witness`, `peer health` | +| 4 Inbox | `Enter` accept, `x` reject, `i` import an envelope file | `inbox list`, `inbox accept`, `inbox reject`, `key receive` | +| 5 Audit | `v` verify with anchors, an anchor file or a peer | `audit verify` | +| 6 Log | | Session messages and core stderr, kept in memory only | + +On every tab `Tab`, `Shift+Tab` or `1`-`6` switch tabs, the arrow keys or `j`/`k` move, `/` filters the list, `Esc` clears the filter or cancels a running action, `Ctrl+R` refreshes, `?` shows help, and `q` or `Ctrl+C` quits. In a form `Tab` and the arrow keys move between fields, `Space` toggles, `Left`/`Right` choose, and `Enter` moves to the next field and submits on the last one. + +The UI behaves differently from a shell session in a few places. + +- Adding a member asks you to type or paste the fingerprint you received over the other channel. The UI never fills it in from the card file. +- Sending, pushing, accepting and rejecting ask for confirmation and show the member fingerprint. Renewing the card asks you to type the member id. +- Encryption and decryption work on files only, up to 1 MiB. Decrypted data is written to a new file that only you can read (`0600`, on Windows an owner-only DACL) and is never drawn on the screen. Existing files are never overwritten. +- Labels, member ids, error messages from other nodes and core output are drawn with control and bidirectional formatting characters replaced by `?`, so none of them can inject terminal escape sequences. The UI sets no window title and does not use the clipboard. +- The node is opened once per session and the lists refresh every 15 seconds, so envelopes that `kmsd` receives appear without a restart. `kmsd` can keep running on the same directory. +- When `--idle` expires the node is closed, the core process exits and the screen is cleared. `Enter` opens the node again. +- In Korean the screens, forms and dialogs are translated. Messages from the node, the core and other nodes stay in English so that they match the troubleshooting table. Shortcuts also work while the Korean input method is on: the Dubeolsik jamo are read as the Latin keys in the same position, so `ㅂ` acts as `q`. + +It needs an interactive terminal on both standard input and output, at least 64 columns by 18 rows. On Linux and macOS any terminal that understands xterm sequences works, but not `TERM=dumb`. On Windows use Windows Terminal, or PowerShell or cmd in the console of Windows 10 1809 or later. The mintty window of Git Bash is not a console, so start the UI from Windows Terminal or through `winpty`. On Windows the UI is experimental like the rest of the Windows support. + ## Key usage | Usage | Meaning | @@ -349,6 +412,8 @@ PS> $env:KMS_DIR = "$env:LOCALAPPDATA\pairier\bob" PS> .\kmsd.exe --listen 0.0.0.0:7443 ``` +`kmsctl.exe ui` needs Windows Terminal or the console of Windows 10 1809 or later. + ## Running kms-core standalone Normally `kmsctl` and `kmsd` launch the core themselves. To run the core separately under its own user, use socket path mode as follows. @@ -450,3 +515,8 @@ The directory that holds the socket must be owned by the core user or root. A di | `store: insecure directory: ... is not owned by the current user` | On Windows the file or directory was created by another account, or by a tool running elevated, so its owner is Administrators. Take ownership with `icacls PATH /setowner "%USERNAME%" /T` or recreate it with `kmsctl init`. The core reports the root key the same way as `object is not owned by the current user`. | | `store: insecure directory: ... is on a network drive` | Move the node directory to a local volume. | | `transport: --socket: unsupported` | The standalone socket mode is not available on Windows. Let `kmsctl` or `kmsd` start the core. | +| `ui: term: standard input and output must be an interactive terminal` | Input or output is redirected, or the shell has no console, such as Git Bash in mintty. Run it directly in a terminal; on Windows use Windows Terminal, PowerShell or cmd, or `winpty kmsctl ui`. | +| `ui: term: the console does not support virtual terminal sequences` | The Windows console is older than Windows 10 1809. Use Windows Terminal or a newer Windows. | +| `terminal too small` | The window is smaller than 64 columns by 18 rows. Enlarge it; the UI redraws on its own. | +| `go: go.mod requires go >= 1.27.4 (running go 1.27.2; GOTOOLCHAIN=local)` | The installed Go is older than `host/go.mod`. Update Go, or see [Go toolchain](#go-toolchain). | +| `go: download go1.27.4 for ...: toolchain not available` | The toolchain is not in the module cache, and `make` cannot download it with `GOPROXY=off`. Run `GOTOOLCHAIN=go1.27.4 go version` once with network access. | diff --git a/USAGE_KR.md b/USAGE_KR.md index dda521c..56c36a3 100644 --- a/USAGE_KR.md +++ b/USAGE_KR.md @@ -53,11 +53,28 @@ $ kmsctl version kmsctl 1.1.0 (go go1.27.4, go_fips=true) ``` +### Go 툴체인 + +`Makefile`은 `GOTOOLCHAIN=local`과 `GOPROXY=off`를 export하므로 `make`는 `PATH`에 있는 `go`만 쓰고 아무것도 내려받지 않습니다. 그 `go`가 `host/go.mod`의 버전보다 오래되면 빌드가 `go: go.mod requires go >= 1.27.4 (running go 1.27.2; GOTOOLCHAIN=local)`로 멈춥니다. 보안 수정 등으로 `go.mod`의 버전이 올라갔는데 설치된 Go를 아직 업데이트하지 않았을 때 생깁니다. + +- 가장 좋은 방법은 Go를 `host/go.mod`의 버전으로 업데이트하는 것입니다(`brew upgrade go`, 공식 설치 프로그램, 패키지 관리자). +- 바로 업데이트할 수 없으면 툴체인을 한 번 내려받은 뒤 `make` 명령줄에 지정하세요. `make` 명령줄에 준 변수는 `Makefile`의 값을 덮어쓰지만, 같은 변수를 환경 변수로 설정하면 덮어쓰지 못합니다. + +```bash +$ GOTOOLCHAIN=go1.27.4 go version # 한 번만, 모듈 프록시에서 받아 Go 체크섬 데이터베이스로 검증 +$ make build GOTOOLCHAIN=go1.27.4 +$ make test GOTOOLCHAIN=go1.27.4 +``` + +- `GOPROXY=off`인 `make` 안에서는 내려받을 수 없으므로 첫 줄에는 네트워크가 필요합니다. 그 뒤로는 툴체인이 모듈 캐시에 있어 네트워크 없이 빌드됩니다. 폐쇄망 호스트에서는 필요한 버전의 검증된 Go 배포본을 설치하세요. +- `make` 없이 `host/`에서 `go`를 직접 실행하면 기본값 `GOTOOLCHAIN=auto`가 적용되어 Go가 필요한 버전을 스스로 내려받아 전환합니다. CI처럼 이를 막으려면 `GOTOOLCHAIN=local`을 설정하세요. +- 어떤 Go로 빌드했는지는 `kmsctl version`에 나옵니다. + ## 설치 배포 tarball은 Linux amd64와 arm64용으로 제공되며 glibc 2.38 이상이 필요합니다(Ubuntu 24.04, Debian 13 등). `kmsd`와 `kmsctl`은 정적 바이너리이고, `kms-core`는 glibc를 동적 링크합니다. Windows x86_64와 ARM64는 CI에서 빌드한 zip(`pairier-1.1.0-windows-amd64.zip`, `pairier-1.1.0-windows-arm64.zip`)으로 제공되며, 코어는 non-FIPS입니다. macOS 바이너리는 제공하지 않기 때문에 개발용으로는 소스에서 직접 빌드하세요([빌드](#빌드) 참고). -배포 아카이브에는 `kms-core`, `kmsd`, `kmsctl`(Windows에서는 `.exe`), `VERSION`, `sbom.cdx.json`, `LICENSE`, `NOTICE`가 들어 있습니다. 해제 전에 `SHA256SUMS`의 minisign 서명(signature)을 먼저 확인하고, 그다음 체크섬(checksum)을 확인하세요. 공개키는 저장소 루트의 `minisign.pub`이며, 확인 방법은 [SECURITY_KR.md](SECURITY_KR.md)를 참고하세요. +배포 아카이브에는 `kms-core`, `kmsd`, `kmsctl`(Windows에서는 `.exe`), `VERSION`, `sbom.cdx.json`, `LICENSE`, `NOTICE`가 들어 있습니다. 해제 전에 `SHA256SUMS`의 minisign 서명(signature)을 먼저 확인하고, 그다음 체크섬(checksum)을 확인하세요. 공개키는 저장소 루트의 `minisign.pub`이며, 확인 방법은 [SECURITY.md](SECURITY_KR.md)를 참고하세요. ```bash $ minisign -Vm SHA256SUMS -p minisign.pub @@ -258,14 +275,60 @@ send the new card and fingerprint to every member and restart kmsd | `encrypt --id KEYID [--in FILE] [--out FILE] [--aad STR]` | 암호화합니다. 입력이 없으면 stdin을 씁니다. | | `decrypt --id KEYID [--in FILE] [--out FILE] [--aad STR]` | 복호화합니다. | | `audit verify [--anchor SEQ:HASH]... [--anchor-file FILE] [--peer MEMBER --url URL]` | 감사 로그 체인과 모든 체크포인트 서명을 검증하고 head를 출력합니다. 주어진 head(`--anchor`, `--anchor-file`, `--peer`)가 모두 로그에 그대로 있는지도 확인합니다. | +| `ui [--offline] [--idle DUR] [--lang LANG]` | 아래에서 설명하는 터미널 UI를 엽니다. | | `version` | 버전과 Go FIPS 상태를 출력합니다. | -`--out`으로 지정한 파일이 이미 있으면 덮어쓰지 않고 실패하며, 새 파일은 `0600` 권한으로 만들어집니다. 종료 코드는 다음과 같습니다. +`--out`으로 지정한 파일이 이미 있으면 덮어쓰지 않고 실패하며, 새 파일은 `0600` 권한으로, Windows에서는 본인과 SYSTEM만 허용하는 DACL로 만들어집니다. 종료 코드는 다음과 같습니다. - 성공 `0` - 실행 실패 `1` - 인자 오류 `2` +## 터미널 UI + +`kmsctl ui`는 위의 명령이 하는 모든 일을 전체 화면 터미널 인터페이스로 제공합니다. 명령과 같은 노드 코드를 호출하므로, 모든 동작은 해당 명령을 실행했을 때와 똑같이 감사 로그에 기록됩니다. + +``` +alice$ kmsctl --dir ~/.pairier ui +``` + +```powershell +PS> .\kmsctl.exe --dir "$env:LOCALAPPDATA\pairier\bob" ui +``` + +`--dir`이나 `$KMS_DIR`이 없으면 노드 디렉토리를 묻고(기본값 `~/.pairier`, Windows는 `%LOCALAPPDATA%\pairier`), 디렉토리가 없으면 그 자리에 노드를 초기화하는 화면을 띄웁니다. + +| 옵션 | 기본값 | 설명 | +|---------------|--------|-----------------------------------------------------------------------------------------------------------| +| `--offline` | 꺼짐 | 다른 노드에 접속하는 동작(push, health, 상대 노드 감사 검증)을 모두 숨깁니다. 폐쇄망 호스트에서 사용합니다. | +| `--idle DUR` | `10m` | 입력 없이 이 시간이 지나면 노드를 닫고 코어를 종료합니다. `0`이면 닫지 않습니다. | +| `--lang LANG` | `auto` | UI 언어, `en` 또는 `ko`. `auto`는 `LC_ALL`, `LC_MESSAGES`, `LANG`이 `ko`로 시작하거나 Windows 표시 언어가 한국어이면 한국어를 고릅니다. | + +전역 옵션(`--dir`, `--core`, `--timeout`, `--allow-unlocked-memory`)은 그대로 적용됩니다. + +| 탭 | 키 | 대응 명령 | +|-----------|------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------| +| 1 Node | `c` 카드 내보내기, `R` 카드 갱신 | `card`, `card renew` | +| 2 Keys | `Enter` 정보, `n` 생성, `s` 파일로 보내기, `p` push, `r` 파일 받기, `e` 파일 암호화, `d` 파일 복호화 | `key list`, `key info`, `key gen`, `key send`, `key push`, `key receive`, `encrypt`, `decrypt` | +| 3 Members | `a` 추가, `w` 증인 head 내보내기, `h` health | `member list`, `member add`, `member witness`, `peer health` | +| 4 Inbox | `Enter` 수락, `x` 거절, `i` 봉투 파일 가져오기 | `inbox list`, `inbox accept`, `inbox reject`, `key receive` | +| 5 Audit | `v` anchor, anchor 파일, 상대 노드로 검증 | `audit verify` | +| 6 Log | | 세션 메시지와 코어 stderr, 메모리에만 보관 | + +모든 탭에서 `Tab`, `Shift+Tab`이나 `1`-`6`으로 탭을 바꾸고, 화살표나 `j`/`k`로 이동하며, `/`로 목록을 거르고, `Esc`로 필터를 지우거나 실행 중인 동작을 취소하고, `Ctrl+R`로 새로 고치고, `?`로 도움말을 보고, `q`나 `Ctrl+C`로 끝냅니다. 폼에서는 `Tab`과 화살표로 필드를 옮기고, `Space`로 켜고 끄며, `Left`/`Right`로 고르고, `Enter`로 다음 필드로 넘어가며 마지막 필드에서 제출합니다. + +셸에서 명령을 쓸 때와 다른 점은 다음과 같습니다. + +- 구성원을 추가할 때는 다른 채널로 받은 지문을 직접 입력하거나 붙여 넣어야 합니다. UI는 카드 파일에서 지문을 채워 넣지 않습니다. +- 보내기, push, 수락, 거절은 확인을 받고 구성원 지문을 보여 줍니다. 카드 갱신은 구성원 id를 직접 입력해야 진행됩니다. +- 암호화와 복호화는 1 MiB까지의 파일만 다룹니다. 복호화한 데이터는 본인만 읽을 수 있는 새 파일(`0600`, Windows는 소유자 전용 DACL)에만 쓰고 화면에는 그리지 않습니다. 이미 있는 파일은 덮어쓰지 않습니다. +- 라벨, 구성원 id, 다른 노드가 보낸 오류 메시지, 코어 출력은 제어 문자와 양방향 서식 문자를 `?`로 바꿔 그리므로 터미널 이스케이프 시퀀스를 주입할 수 없습니다. UI는 창 제목을 바꾸지 않고 클립보드도 쓰지 않습니다. +- 노드는 세션마다 한 번 열리고 목록은 15초마다 새로 고쳐지므로, `kmsd`가 받은 봉투가 다시 시작하지 않아도 나타납니다. 같은 디렉토리에서 `kmsd`를 계속 실행해도 됩니다. +- `--idle` 시간이 지나면 노드를 닫고 코어 프로세스를 끝내며 화면을 지웁니다. `Enter`를 누르면 다시 엽니다. +- 한국어에서는 화면, 폼, 대화 상자가 번역됩니다. 노드, 코어, 다른 노드가 보낸 메시지는 문제 해결 표와 맞도록 영어로 둡니다. 한글 입력 상태에서도 단축키가 동작합니다. 두벌식 자모를 같은 자리의 영문 키로 읽으므로 `ㅂ`은 `q`로 처리됩니다. + +표준 입력과 출력이 모두 대화형 터미널이어야 하고, 최소 64열 18행이 필요합니다. Linux와 macOS에서는 xterm 시퀀스를 이해하는 터미널이면 되지만 `TERM=dumb`는 안 됩니다. Windows에서는 Windows Terminal을 쓰거나, Windows 10 1809 이상의 콘솔에서 PowerShell이나 cmd를 쓰세요. Git Bash의 mintty 창은 콘솔이 아니므로 Windows Terminal에서 실행하거나 `winpty`를 거쳐 실행해야 합니다. Windows에서 UI는 다른 Windows 지원과 마찬가지로 experimental입니다. + ## 키 용도 | 용도 | 의미 | @@ -349,6 +412,8 @@ PS> $env:KMS_DIR = "$env:LOCALAPPDATA\pairier\bob" PS> .\kmsd.exe --listen 0.0.0.0:7443 ``` +`kmsctl.exe ui`에는 Windows Terminal이나 Windows 10 1809 이상의 콘솔이 필요합니다. + ## kms-core 단독 실행 보통은 `kmsctl`과 `kmsd`가 코어를 직접 띄웁니다. 코어를 별도 사용자로 분리해 운영하려면 다음과 같이 소켓 경로 모드를 사용해야 합니다. @@ -450,3 +515,8 @@ $ kms-core --socket /run/pairier/core.sock --root-key-file /path/root.key --pqc | `store: insecure directory: ... is not owned by the current user` | Windows에서 다른 계정이나 관리자 권한으로 올린 도구가 만든 파일이나 디렉토리라 소유자가 Administrators입니다. `icacls PATH /setowner "%USERNAME%" /T`로 소유권을 가져오거나 `kmsctl init`으로 다시 만들어야 합니다. 루트 키는 코어가 `object is not owned by the current user`로 같은 상황을 보고합니다. | | `store: insecure directory: ... is on a network drive` | 노드 디렉토리를 로컬 볼륨으로 옮겨야 합니다. | | `transport: --socket: unsupported` | Windows에서는 단독 소켓 모드를 쓸 수 없습니다. `kmsctl`이나 `kmsd`가 코어를 기동하게 해야 합니다. | +| `ui: term: standard input and output must be an interactive terminal` | 입력이나 출력이 리디렉션되었거나, Git Bash의 mintty처럼 콘솔이 없는 셸입니다. 터미널에서 직접 실행하고, Windows에서는 Windows Terminal, PowerShell, cmd를 쓰거나 `winpty kmsctl ui`로 실행해야 합니다. | +| `ui: term: the console does not support virtual terminal sequences` | Windows 10 1809보다 오래된 콘솔입니다. Windows Terminal이나 더 새로운 Windows를 써야 합니다. | +| `terminal too small` | 창이 64열 18행보다 작습니다. 창을 키우면 UI가 스스로 다시 그립니다. | +| `go: go.mod requires go >= 1.27.4 (running go 1.27.2; GOTOOLCHAIN=local)` | 설치된 Go가 `host/go.mod`보다 오래되었습니다. Go를 업데이트하거나 [Go 툴체인](#go-툴체인)을 참고하세요. | +| `go: download go1.27.4 for ...: toolchain not available` | 툴체인이 모듈 캐시에 없고, `make`는 `GOPROXY=off`라서 내려받을 수 없습니다. 네트워크가 되는 곳에서 `GOTOOLCHAIN=go1.27.4 go version`을 한 번 실행해야 합니다. | diff --git a/host/cmd/kmsctl/main.go b/host/cmd/kmsctl/main.go index 31646e6..38309c3 100644 --- a/host/cmd/kmsctl/main.go +++ b/host/cmd/kmsctl/main.go @@ -8,15 +8,19 @@ import ( "fmt" "io" "os" + "os/signal" "path/filepath" "runtime" "strings" + "syscall" "time" "github.com/Quant-Off/pairier/host/internal/api" "github.com/Quant-Off/pairier/host/internal/audit" + "github.com/Quant-Off/pairier/host/internal/console" "github.com/Quant-Off/pairier/host/internal/fsx" "github.com/Quant-Off/pairier/host/internal/node" + "github.com/Quant-Off/pairier/host/internal/term" "github.com/Quant-Off/pairier/host/internal/wire" ) @@ -44,37 +48,10 @@ commands: audit verify [--anchor SEQ:HASH]... [--anchor-file FILE] [--peer MEMBER --url https://HOST:PORT] encrypt --id KEYID [--in FILE] [--out FILE] [--aad STRING] decrypt --id KEYID [--in FILE] [--out FILE] [--aad STRING] + ui [--offline] [--idle DURATION] [--lang auto|en|ko] version ` -var usageNames = map[string]uint32{ - "encrypt": wire.UsageEncrypt, - "decrypt": wire.UsageDecrypt, - "sign": wire.UsageSign, - "verify": wire.UsageVerify, - "wrap": wire.UsageWrap, - "unwrap": wire.UsageUnwrap, - "derive": wire.UsageDerive, - "decapsulate": wire.UsageDecapsulate, - "export": wire.UsageExport, -} - -var usageOrder = []string{"encrypt", "decrypt", "sign", "verify", "wrap", "unwrap", "derive", "decapsulate", "export"} - -var algNames = map[uint16]string{ - wire.AlgAES256GCM: "aes-256-gcm", - wire.AlgECDSAP256SHA256: "ecdsa-p256-sha256", - wire.AlgECDSAP384SHA384: "ecdsa-p384-sha384", - wire.AlgEd25519: "ed25519", - wire.AlgDHKEMP256: "dhkem-p256", - wire.AlgMLDSA65: "ml-dsa-65", - wire.AlgMLDSA87: "ml-dsa-87", - wire.AlgMLKEM768: "ml-kem-768", - wire.AlgMLKEM1024: "ml-kem-1024", - wire.AlgHybridP256MLKEM768: "hybrid-p256-ml-kem-768", - wire.AlgMLKEM768P256: "mlkem768-p256", -} - type cli struct { stdin io.Reader stdout io.Writer @@ -197,6 +174,8 @@ func (c *cli) dispatch(args []string) (int, error) { return c.cmdCrypt(ctx, args[1:], true) case "decrypt": return c.cmdCrypt(ctx, args[1:], false) + case "ui": + return c.cmdUI(ctx, args[1:]) } fmt.Fprint(c.stderr, usageText) return 2, fmt.Errorf("unknown command %q", args[0]) @@ -212,25 +191,76 @@ func (c *cli) flags(name string) *flag.FlagSet { return fs } +func (c *cli) coreBinary() string { + if c.core != "" { + return c.core + } + if exe, err := os.Executable(); err == nil { + return filepath.Join(filepath.Dir(exe), "kms-core"+fsx.ExeSuffix) + } + return "" +} + func (c *cli) options() (node.Options, error) { if c.dir == "" { return node.Options{}, errNoDir } - core := c.core - if core == "" { - if exe, err := os.Executable(); err == nil { - core = filepath.Join(filepath.Dir(exe), "kms-core"+fsx.ExeSuffix) - } - } return node.Options{ Dir: c.dir, - CoreBinary: core, + CoreBinary: c.coreBinary(), AllowUnlockedMemory: c.allowUnlocked, Timeout: c.timeout, Stderr: c.stderr, }, nil } +func (c *cli) cmdUI(ctx context.Context, args []string) (int, error) { + fs := c.flags("ui") + offline := fs.Bool("offline", false, "hide actions that contact other nodes (push, health, peer audit)") + idle := fs.Duration("idle", 10*time.Minute, "close the node after this long without input, 0 keeps it open") + langFlag := fs.String("lang", "auto", "ui language: auto, en or ko") + if err := fs.Parse(args); err != nil || fs.NArg() != 0 || *idle < 0 { + return 2, errors.New("ui: usage: ui [--offline] [--idle DURATION] [--lang auto|en|ko]") + } + lang, err := console.Language(*langFlag) + if err != nil { + return 2, fmt.Errorf("ui: %w", err) + } + if runtime.GOOS != "windows" && os.Getenv("TERM") == "dumb" { + return 2, errors.New("ui: TERM=dumb cannot show the terminal ui, use the commands instead") + } + in, inOK := c.stdin.(*os.File) + out, outOK := c.stdout.(*os.File) + if !inOK || !outOK { + return 2, fmt.Errorf("ui: %w", term.ErrNotTerminal) + } + tty, err := term.Open(in, out) + if err != nil { + return 2, fmt.Errorf("ui: %w", err) + } + defer tty.Close() + ctx, stop := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP) + defer stop() + err = console.Run(ctx, tty, console.Options{ + Node: node.Options{ + CoreBinary: c.coreBinary(), + AllowUnlockedMemory: c.allowUnlocked, + Timeout: c.timeout, + }, + Dir: c.dir, + Offline: *offline, + Idle: *idle, + Version: version, + Color: os.Getenv("NO_COLOR") == "", + Paste: runtime.GOOS != "windows", + Lang: lang, + }) + if err != nil { + return 1, err + } + return 0, nil +} + func (c *cli) open(ctx context.Context) (*node.Node, error) { opts, err := c.options() if err != nil { @@ -267,7 +297,7 @@ func (c *cli) cmdInit(ctx context.Context, args []string) (int, error) { return 1, err } fmt.Fprintf(c.stdout, "member\t%s\nidentity\t%s\nkem\t%s\ncore_fips\t%v\ngo_fips\t%v\npqc\t%v\nfingerprint\t%s\n", - card.MemberID, algName(card.IdentityAlg), algName(card.KemAlg), n.FIPS(), fips140.Enabled(), n.PQC(), fp) + card.MemberID, wire.AlgName(card.IdentityAlg), wire.AlgName(card.KemAlg), n.FIPS(), fips140.Enabled(), n.PQC(), fp) return 0, nil } @@ -313,7 +343,7 @@ func (c *cli) cmdCardRenew(ctx context.Context, args []string) (int, error) { if err := c.writeOut(*out, raw); err != nil { return 1, err } - fmt.Fprintf(c.stderr, "member\t%s\nkem\t%s\nfingerprint\t%s\n", card.MemberID, algName(card.KemAlg), fp) + fmt.Fprintf(c.stderr, "member\t%s\nkem\t%s\nfingerprint\t%s\n", card.MemberID, wire.AlgName(card.KemAlg), fp) fmt.Fprintln(c.stderr, "send the new card and fingerprint to every member and restart kmsd") return 0, nil } @@ -368,7 +398,7 @@ func (c *cli) cmdMemberList(ctx context.Context, args []string) (int, error) { if err != nil { return 1, fmt.Errorf("member %s: %w", m.MemberID, err) } - fmt.Fprintf(c.stdout, "%s\t%s\t%s\t%s\n", m.MemberID, algName(card.IdentityAlg), algName(card.KemAlg), m.Fingerprint) + fmt.Fprintf(c.stdout, "%s\t%s\t%s\t%s\n", m.MemberID, wire.AlgName(card.IdentityAlg), wire.AlgName(card.KemAlg), m.Fingerprint) } return 0, nil } @@ -380,7 +410,7 @@ func (c *cli) cmdKeyGen(ctx context.Context, args []string) (int, error) { if err := fs.Parse(args); err != nil || fs.NArg() != 0 { return 2, errors.New("key gen: invalid arguments") } - bits, err := parseUsage(*usage) + bits, err := wire.ParseUsage(*usage) if err != nil { return 2, err } @@ -393,7 +423,7 @@ func (c *cli) cmdKeyGen(ctx context.Context, args []string) (int, error) { if err != nil { return 1, err } - fmt.Fprintf(c.stdout, "%s\t%s\t%s\t%s\n", rec.KeyID, algName(rec.Alg), formatUsage(rec.Usage), rec.Label) + fmt.Fprintf(c.stdout, "%s\t%s\t%s\t%s\n", rec.KeyID, wire.AlgName(rec.Alg), wire.FormatUsage(rec.Usage), rec.Label) return 0, nil } @@ -416,7 +446,7 @@ func (c *cli) cmdKeyList(ctx context.Context, args []string) (int, error) { if k.Origin != nil { origin = "from " + k.Origin.Sender } - fmt.Fprintf(c.stdout, "%s\t%s\t%s\t%s\t%s\n", k.KeyID, algName(k.Alg), formatUsage(k.Usage), k.Label, origin) + fmt.Fprintf(c.stdout, "%s\t%s\t%s\t%s\t%s\n", k.KeyID, wire.AlgName(k.Alg), wire.FormatUsage(k.Usage), k.Label, origin) } return 0, nil } @@ -436,7 +466,7 @@ func (c *cli) cmdKeyInfo(ctx context.Context, args []string) (int, error) { if err != nil { return 1, err } - fmt.Fprintf(c.stdout, "id\t%s\nalg\t%s\nusage\t%s\nlabel\t%s\ncreated\t%s\n", k.KeyID, algName(k.Alg), formatUsage(k.Usage), k.Label, time.Unix(k.CreatedAt, 0).UTC().Format(time.RFC3339)) + fmt.Fprintf(c.stdout, "id\t%s\nalg\t%s\nusage\t%s\nlabel\t%s\ncreated\t%s\n", k.KeyID, wire.AlgName(k.Alg), wire.FormatUsage(k.Usage), k.Label, time.Unix(k.CreatedAt, 0).UTC().Format(time.RFC3339)) if k.Origin != nil { fmt.Fprintf(c.stdout, "origin\t%s\t%s\n", k.Origin.Sender, time.Unix(k.Origin.SentAt, 0).UTC().Format(time.RFC3339)) } @@ -455,7 +485,7 @@ func (c *cli) cmdKeySend(ctx context.Context, args []string) (int, error) { if *id == "" || *to == "" { return 2, errors.New("key send: --id and --to are required") } - bits, err := parseUsage(*usage) + bits, err := wire.ParseUsage(*usage) if err != nil { return 2, err } @@ -471,7 +501,7 @@ func (c *cli) cmdKeySend(ctx context.Context, args []string) (int, error) { if err := c.writeOut(*out, env); err != nil { return 1, err } - fmt.Fprintf(c.stderr, "sent\t%s\tto\t%s\tusage\t%s\n", *id, *to, formatUsage(bits)) + fmt.Fprintf(c.stderr, "sent\t%s\tto\t%s\tusage\t%s\n", *id, *to, wire.FormatUsage(bits)) return 0, nil } @@ -494,7 +524,7 @@ func (c *cli) cmdKeyReceive(ctx context.Context, args []string) (int, error) { if err != nil { return 1, err } - fmt.Fprintf(c.stdout, "%s\t%s\t%s\t%s\tfrom %s\n", rec.KeyID, algName(rec.Alg), formatUsage(rec.Usage), rec.Label, rec.Origin.Sender) + fmt.Fprintf(c.stdout, "%s\t%s\t%s\t%s\tfrom %s\n", rec.KeyID, wire.AlgName(rec.Alg), wire.FormatUsage(rec.Usage), rec.Label, rec.Origin.Sender) return 0, nil } @@ -513,7 +543,7 @@ func (c *cli) cmdKeyPush(ctx context.Context, args []string) (int, error) { if !strings.HasPrefix(*url, "https://") { return 2, errors.New("key push: --url must use https") } - bits, err := parseUsage(*usage) + bits, err := wire.ParseUsage(*usage) if err != nil { return 2, err } @@ -569,7 +599,7 @@ func (c *cli) cmdInboxAccept(ctx context.Context, args []string) (int, error) { if err != nil { return 1, err } - fmt.Fprintf(c.stdout, "%s\t%s\t%s\t%s\tfrom %s\n", rec.KeyID, algName(rec.Alg), formatUsage(rec.Usage), rec.Label, rec.Origin.Sender) + fmt.Fprintf(c.stdout, "%s\t%s\t%s\t%s\tfrom %s\n", rec.KeyID, wire.AlgName(rec.Alg), wire.FormatUsage(rec.Usage), rec.Label, rec.Origin.Sender) return 0, nil } @@ -749,23 +779,10 @@ func (c *cli) cmdCrypt(ctx context.Context, args []string, encrypt bool) (int, e const maxInput = 1 << 20 func (c *cli) readIn(path string) ([]byte, error) { - var r io.Reader = c.stdin if path != "" { - f, err := os.Open(path) - if err != nil { - return nil, err - } - defer f.Close() - r = f + return fsx.ReadFileLimited(path, maxInput) } - b, err := io.ReadAll(io.LimitReader(r, maxInput+1)) - if err != nil { - return nil, err - } - if len(b) > maxInput { - return nil, fmt.Errorf("input exceeds %d bytes", maxInput) - } - return b, nil + return fsx.ReadLimited(c.stdin, maxInput) } func (c *cli) writeOut(path string, data []byte) error { @@ -773,53 +790,5 @@ func (c *cli) writeOut(path string, data []byte) error { _, err := c.stdout.Write(data) return err } - f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600) - if err != nil { - return err - } - if _, err := f.Write(data); err != nil { - _ = f.Close() - return err - } - if err := f.Sync(); err != nil { - _ = f.Close() - return err - } - return f.Close() -} - -func parseUsage(s string) (uint32, error) { - var bits uint32 - for _, part := range strings.Split(s, ",") { - part = strings.TrimSpace(strings.ToLower(part)) - if part == "" { - continue - } - b, ok := usageNames[part] - if !ok { - return 0, fmt.Errorf("unknown usage %q", part) - } - bits |= b - } - if bits == 0 { - return 0, errors.New("usage list is empty") - } - return bits, nil -} - -func formatUsage(bits uint32) string { - var parts []string - for _, name := range usageOrder { - if bits&usageNames[name] != 0 { - parts = append(parts, name) - } - } - return strings.Join(parts, ",") -} - -func algName(alg uint16) string { - if s, ok := algNames[alg]; ok { - return s - } - return fmt.Sprintf("0x%04x", alg) + return fsx.WriteNew(path, data) } diff --git a/host/cmd/kmsctl/main_test.go b/host/cmd/kmsctl/main_test.go index bd2a569..8a96c7e 100644 --- a/host/cmd/kmsctl/main_test.go +++ b/host/cmd/kmsctl/main_test.go @@ -28,19 +28,6 @@ func (b *syncBuffer) String() string { return b.buf.String() } -func TestParseAndFormatUsage(t *testing.T) { - bits, err := parseUsage("Encrypt, decrypt,export") - if err != nil || formatUsage(bits) != "encrypt,decrypt,export" { - t.Fatalf("%v %v", bits, err) - } - if _, err := parseUsage("encrypt,bogus"); err == nil { - t.Fatal("unknown usage accepted") - } - if _, err := parseUsage(""); err == nil { - t.Fatal("empty usage accepted") - } -} - func TestUsageAndVersion(t *testing.T) { var out, errb bytes.Buffer if code := run(nil, nil, &out, &errb); code != 2 { @@ -55,6 +42,30 @@ func TestUsageAndVersion(t *testing.T) { } } +func TestUIRequiresATerminal(t *testing.T) { + var out, errb bytes.Buffer + if code := run([]string{"ui"}, nil, &out, &errb); code != 2 || !strings.Contains(errb.String(), "interactive terminal") { + t.Fatalf("ui without a terminal: %d %q", code, errb.String()) + } + errb.Reset() + if code := run([]string{"ui", "--idle", "-1s"}, nil, &out, &errb); code != 2 { + t.Fatalf("negative idle accepted: %d %q", code, errb.String()) + } + errb.Reset() + if code := run([]string{"ui", "--lang", "fr"}, nil, &out, &errb); code != 2 || !strings.Contains(errb.String(), "unknown language") { + t.Fatalf("unknown language accepted: %d %q", code, errb.String()) + } + f, err := os.Create(filepath.Join(t.TempDir(), "plain")) + if err != nil { + t.Fatal(err) + } + defer f.Close() + errb.Reset() + if code := run([]string{"ui"}, f, f, &errb); code != 2 || !strings.Contains(errb.String(), "interactive terminal") { + t.Fatalf("ui on a regular file: %d %q", code, errb.String()) + } +} + func TestGlobalFlagsAfterCommand(t *testing.T) { t.Setenv("KMS_DIR", "") t.Setenv("KMS_CORE", "") diff --git a/host/internal/console/actions.go b/host/internal/console/actions.go new file mode 100644 index 0000000..1e55985 --- /dev/null +++ b/host/internal/console/actions.go @@ -0,0 +1,853 @@ +package console + +import ( + "context" + "errors" + "fmt" + "net/url" + "os" + "strings" + + "github.com/Quant-Off/pairier/host/internal/api" + "github.com/Quant-Off/pairier/host/internal/audit" + "github.com/Quant-Off/pairier/host/internal/exchange" + "github.com/Quant-Off/pairier/host/internal/fsx" + "github.com/Quant-Off/pairier/host/internal/node" + "github.com/Quant-Off/pairier/host/internal/store" + "github.com/Quant-Off/pairier/host/internal/tui" + "github.com/Quant-Off/pairier/host/internal/wire" +) + +const ( + maxPath = 4096 + maxURL = 2048 + maxAAD = 4096 + symUsage = node.SymmetricUsage +) + +type formModal struct { + f *tui.Form + submit func(a *app, f *tui.Form) error +} + +func (m *formModal) handle(a *app, ev tui.Event) { + switch m.f.Handle(ev) { + case tui.Cancel: + a.modal = nil + case tui.Submit: + a.modal = nil + m.f.Err = "" + if err := m.submit(a, m.f); err != nil { + m.f.Err = err.Error() + a.modal = m + } + } +} + +func (m *formModal) draw(s *tui.Screen) { m.f.Draw(s, plain) } + +type dialogModal struct { + d *tui.Dialog + yes func(a *app) +} + +func (m *dialogModal) handle(a *app, ev tui.Event) { + switch m.d.Handle(ev) { + case tui.Cancel: + a.modal = nil + case tui.Submit: + a.modal = nil + if m.yes != nil { + m.yes(a) + } + } +} + +func (m *dialogModal) draw(s *tui.Screen) { m.d.Draw(s, plain) } + +func (a *app) form(title string, note []string, fields []*tui.Field, submit func(a *app, f *tui.Form) error) { + a.modal = &formModal{f: &tui.Form{Title: title, Note: note, Fields: fields, T: a.texts}, submit: submit} +} + +func (a *app) message(title string, lines []string, isErr bool) { + a.modal = &dialogModal{d: &tui.Dialog{Title: title, Lines: lines, Danger: isErr, T: a.texts}} +} + +func (a *app) notify(title string, lines []string, isErr bool) { + if a.modal == nil { + a.message(title, lines, isErr) + } +} + +func (a *app) confirm(title string, lines []string, typed string, danger bool, yes func(a *app)) { + a.modal = &dialogModal{d: &tui.Dialog{Title: title, Lines: lines, Ask: true, Confirm: typed, Danger: danger, T: a.texts}, yes: yes} +} + +func (a *app) inPath(v string) (string, error) { + p := expandPath(v) + if p == "" { + return "", errors.New(a.t("an input file is required")) + } + fi, err := os.Stat(p) + if err != nil { + return "", err + } + if !fi.Mode().IsRegular() { + return "", errors.New(a.tf("%s is not a regular file", p)) + } + if fi.Size() > maxInput { + return "", errors.New(a.tf("%s exceeds %d bytes", p, maxInput)) + } + return p, nil +} + +func (a *app) outPath(v string) (string, error) { + p := expandPath(v) + if p == "" { + return "", errors.New(a.t("an output file is required")) + } + if _, err := os.Lstat(p); err == nil { + return "", errors.New(a.tf("%s already exists, choose another name", p)) + } else if !errors.Is(err, os.ErrNotExist) { + return "", err + } + return p, nil +} + +func (a *app) checkURL(v string) (string, error) { + v = strings.TrimRight(strings.TrimSpace(v), "/") + if !strings.HasPrefix(v, "https://") { + return "", errors.New(a.t("the url must use https")) + } + u, err := url.Parse(v) + if err != nil || u.Host == "" || u.User != nil || u.RawQuery != "" || u.Fragment != "" { + return "", errors.New(a.t("the url must look like https://HOST:PORT")) + } + return v, nil +} + +func usageField(label string, allowed, defaults uint32) *tui.Field { + var names []string + var checked []bool + for _, u := range wire.Usages { + if allowed&u.Bit != 0 { + names = append(names, u.Name) + checked = append(checked, defaults&u.Bit != 0) + } + } + return tui.FlagsField(label, names, checked) +} + +func (a *app) usageBits(f *tui.Field) (uint32, error) { + sel := f.Selected() + if len(sel) == 0 { + return 0, errors.New(a.t("choose at least one usage")) + } + return wire.ParseUsage(strings.Join(sel, ",")) +} + +func shortID(id string) string { + if len(id) > 8 { + return id[:8] + } + return id +} + +func (a *app) runOpen(title string, open func(ctx context.Context) (*node.Node, error), after func(a *app, info nodeInfo)) { + a.phase = phaseOpening + if !a.spawn(title, false, func(ctx context.Context, res *result) { + n, err := open(ctx) + if err != nil { + res.err = err + return + } + info, err := loadInfo(ctx, n) + if err != nil { + _ = n.Close() + res.err = err + return + } + res.cleanup = func() { _ = n.Close() } + res.apply = func(a *app) { + a.node, a.info, a.phase = n, info, phaseMain + a.data, a.verify = snapshot{}, nil + a.done(a.tf("opened %s as %s", a.dir, info.member)) + a.refresh() + if after != nil { + after(a, info) + } + } + }) { + a.phase = phaseStart + } +} + +func (a *app) openNode(dir string) { + opts := a.nodeOptions(dir) + a.dir = dir + a.runOpen(a.t("open node"), func(ctx context.Context) (*node.Node, error) { return node.Open(ctx, opts) }, nil) +} + +func (a *app) dirForm(dir string) { + a.form(a.t("Open node"), []string{a.t("Enter the node directory. If it does not exist yet you can initialize it next.")}, + []*tui.Field{tui.TextField(a.t("Directory"), dir, maxPath)}, + func(a *app, f *tui.Form) error { + d := expandPath(f.Fields[0].Value()) + if d == "" { + return errors.New(a.t("a directory is required")) + } + if _, err := os.Stat(d); errors.Is(err, os.ErrNotExist) { + a.initForm(d) + return nil + } else if err != nil { + return err + } + a.openNode(d) + return nil + }) +} + +func (a *app) initForm(dir string) { + fields := []*tui.Field{ + tui.TextField(a.t("Directory"), dir, maxPath), + tui.TextField(a.t("Member ID"), "", exchange.MaxMemberID), + tui.ToggleField(a.t("Post-quantum"), false), + } + fields[1].Hint = a.t("lowercase letters, digits, . _ -, the name members know you by") + fields[2].Hint = a.t("ML-DSA identity and ML-KEM exchange, needs a core built with pqc") + note := []string{a.t("Creates the directory for your user only, a root key and the node identity (kmsctl init).")} + a.form(a.t("Initialize node"), note, fields, func(a *app, f *tui.Form) error { + d := expandPath(f.Fields[0].Value()) + id := strings.TrimSpace(f.Fields[1].Value()) + pqc := f.Fields[2].On + if d == "" { + return errors.New(a.t("a directory is required")) + } + if !exchange.ValidMemberID(id) { + return errors.New(a.t("invalid member id")) + } + opts := a.nodeOptions(d) + a.dir = d + a.runOpen(a.t("initialize node"), func(ctx context.Context) (*node.Node, error) { + return node.Init(ctx, opts, id, pqc) + }, func(a *app, info nodeInfo) { + lines := []string{ + a.kv("member", info.member), + a.kv("identity", wire.AlgName(info.identityAlg)), + a.kv("kem", wire.AlgName(info.kemAlg)), + a.kv("core_fips", fmt.Sprintf("%v pqc %v", info.coreFIPS, info.pqc)), + } + lines = append(lines, a.fpLines(info.fingerprint)...) + lines = append(lines, "", a.t("Export your card with c and give the card and this fingerprint to each member over separate channels.")) + a.message(a.t("Node initialized"), lines, false) + }) + return nil + }) +} + +func (a *app) filterForm() { + tab := a.tab + a.form(a.tf("Filter %s", a.t(tabNames[tab])), nil, []*tui.Field{tui.TextField(a.t("Contains"), a.filter[tab], 128)}, func(a *app, f *tui.Form) error { + a.filter[tab] = strings.TrimSpace(f.Fields[0].Value()) + a.lists[tab] = tui.List{} + a.selID[tab] = "" + return nil + }) +} + +func (a *app) nodeKey(ev tui.Event) { + switch { + case ev.IsRune('c'): + a.cardForm(nil, a.info.member+".card", nil) + case ev.IsRune('R'): + a.renewDialog() + } +} + +func (a *app) cardForm(raw []byte, name string, note []string) { + a.form(a.t("Export card"), note, []*tui.Field{tui.TextField(a.t("Output file"), name, maxPath)}, func(a *app, f *tui.Form) error { + out, err := a.outPath(f.Fields[0].Value()) + if err != nil { + return err + } + a.run(a.t("export card"), func(ctx context.Context, n *node.Node) (func(*app), error) { + var card *exchange.Card + var err error + data := raw + if data == nil { + card, data, err = n.Card(ctx) + } else { + card, err = exchange.DecodeCard(data) + } + if err != nil { + return nil, err + } + fp, err := card.Fingerprint() + if err != nil { + return nil, err + } + if err := fsx.WriteNew(out, data); err != nil { + return nil, err + } + return func(a *app) { + a.done(a.tf("card written to %s", out)) + lines := append([]string{a.kv("file", out)}, a.fpLines(fp)...) + lines = append(lines, "", a.t("Send the card file and read the fingerprint to the member over a different channel.")) + a.notify(a.t("Card exported"), lines, false) + }, nil + }) + return nil + }) +} + +func (a *app) renewDialog() { + member := a.info.member + lines := []string{ + a.t("Renewing replaces the node KEM key, moves the TLS key into the core and signs a new card."), + a.t("Every member has to add the new card with its new fingerprint, and kmsd must be restarted."), + } + a.confirm(a.t("Renew card"), lines, member, true, func(a *app) { + a.run(a.t("renew card"), func(ctx context.Context, n *node.Node) (func(*app), error) { + card, raw, err := n.RenewCard(ctx) + if err != nil { + return nil, err + } + fp, _ := card.Fingerprint() + info, err := loadInfo(ctx, n) + if err != nil { + return nil, err + } + return func(a *app) { + a.info = info + a.done(a.tf("card renewed, new fingerprint %s", fp)) + a.cardForm(raw, member+".renewed.card", []string{ + a.tf("New fingerprint %s", fp), + a.t("Send the new card to every member and restart kmsd. Esc skips, c exports the card later."), + }) + a.refresh() + }, nil + }) + }) +} + +func (a *app) keysKey(ev tui.Event) { + switch { + case ev.IsRune('n'): + a.genForm() + return + case ev.IsRune('r'): + a.receiveForm() + return + } + k := a.keyByID(a.selected(tabKeys)) + if k == nil { + return + } + switch { + case ev.Is(tui.KeyEnter): + a.keyInfo(k.KeyID) + case ev.IsRune('s'): + a.sendForm(k, false) + case ev.IsRune('p') && !a.opts.Offline: + a.sendForm(k, true) + case ev.IsRune('e'): + a.cryptForm(k, true) + case ev.IsRune('d'): + a.cryptForm(k, false) + } +} + +func (a *app) genForm() { + fields := []*tui.Field{ + tui.TextField(a.t("Label"), "", wire.MaxLabel), + usageField(a.t("Usage"), symUsage, wire.UsageEncrypt|wire.UsageDecrypt|wire.UsageExport), + } + fields[1].Hint = a.t("export is needed to send the key to members") + a.form(a.t("Generate key"), []string{a.t("Creates an AES-256-GCM key inside the core (key gen).")}, fields, func(a *app, f *tui.Form) error { + label := f.Fields[0].Value() + if !node.ValidLabel(label) { + return node.ErrLabel + } + bits, err := a.usageBits(f.Fields[1]) + if err != nil { + return err + } + a.run(a.t("generate key"), func(ctx context.Context, n *node.Node) (func(*app), error) { + rec, err := n.GenerateKey(ctx, label, bits) + if err != nil { + return nil, err + } + return func(a *app) { + a.selID[tabKeys] = rec.KeyID + a.done(a.tf("generated %s %s", rec.KeyID, rec.Label)) + a.refresh() + }, nil + }) + return nil + }) +} + +func (a *app) keyLines(k *store.KeyRecord) []string { + lines := []string{ + a.kv("id", k.KeyID), + a.kv("alg", wire.AlgName(k.Alg)), + a.kv("usage", wire.FormatUsage(k.Usage)), + a.kv("label", k.Label), + a.kv("created", stamp(k.CreatedAt)), + } + if k.Origin != nil { + lines = append(lines, a.kv("origin", a.tf("%s sent %s", k.Origin.Sender, stamp(k.Origin.SentAt)))) + } + return lines +} + +func (a *app) keyInfo(id string) { + a.run(a.t("key info"), func(ctx context.Context, n *node.Node) (func(*app), error) { + k, err := n.Key(ctx, id) + if err != nil { + return nil, err + } + return func(a *app) { + a.notify(a.t("Key"), append(a.keyLines(k), "", a.t("The stored metadata matches what the core reports for this key.")), false) + }, nil + }) +} + +func (a *app) sendForm(k *store.KeyRecord, push bool) { + members := a.memberIDs() + if len(members) == 0 { + a.message(a.t("No members"), []string{a.t("Add the recipient on the Members tab first.")}, true) + return + } + def := uint32(wire.UsageDecrypt) + if k.Usage&def == 0 { + def = 0 + } + fields := []*tui.Field{tui.ChoiceField(a.t("Recipient"), members, 0), usageField(a.t("Grant"), k.Usage, def)} + fields[0].Hint = a.t("Left/Right picks a registered member") + fields[1].Hint = a.t("only a subset of this key's usage can be granted") + title, job := a.t("Send key to file"), a.t("send key") + note := []string{a.t("Seals the key for one member into an envelope file (key send).")} + if push { + u := a.urls[members[0]] + if u == "" { + u = "https://" + } + fields = append(fields, tui.TextField(a.t("kmsd URL"), u, maxURL)) + title, job = a.t("Push key"), a.t("push key") + note = []string{a.t("Seals the key and delivers it to the member's kmsd over mutual TLS (key push).")} + } else { + fields = append(fields, tui.TextField(a.t("Output file"), shortID(k.KeyID)+".kxp", maxPath)) + } + id, label := k.KeyID, k.Label + a.form(title, note, fields, func(a *app, f *tui.Form) error { + to := f.Fields[0].Value() + bits, err := a.usageBits(f.Fields[1]) + if err != nil { + return err + } + var dest string + if push { + dest, err = a.checkURL(f.Fields[2].Value()) + } else { + dest, err = a.outPath(f.Fields[2].Value()) + } + if err != nil { + return err + } + fp := a.t("unknown") + if m := a.memberRecord(to); m != nil { + fp = m.fingerprint + } + lines := []string{a.kv("key", id+" "+label), a.kv("recipient", to)} + lines = append(lines, a.fpLines(fp)...) + lines = append(lines, a.kv("grant", wire.FormatUsage(bits))) + if push { + lines = append(lines, a.kv("kmsd", dest)) + } else { + lines = append(lines, a.kv("file", dest)) + } + a.confirm(title, append(lines, "", a.t("The recipient can use the key with this usage from now on. Continue?")), "", false, func(a *app) { + a.run(job, func(ctx context.Context, n *node.Node) (func(*app), error) { + env, err := n.Send(ctx, id, to, bits) + if err != nil { + return nil, err + } + if !push { + if err := fsx.WriteNew(dest, env); err != nil { + return nil, err + } + return func(a *app) { + a.done(a.tf("sent %s to %s in %s", id, to, dest)) + a.notify(a.t("Envelope written"), []string{a.kv("file", dest), a.tf("Deliver it to %s, who imports it with r on the Keys tab or key receive.", to)}, false) + a.refresh() + }, nil + } + envID, err := api.NewClient(n, nil).Push(ctx, dest, to, env) + if err != nil { + return nil, err + } + return func(a *app) { + a.urls[to] = dest + a.done(a.tf("pushed %s to %s, envelope %s", id, to, envID)) + a.notify(a.t("Key pushed"), []string{a.kv("envelope", envID), a.tf("%s accepts it from the Inbox tab or with inbox accept.", to)}, false) + a.refresh() + }, nil + }) + }) + return nil + }) +} + +func (a *app) cryptForm(k *store.KeyRecord, encrypt bool) { + title, hint, job := a.t("Decrypt file"), a.t("empty means the input name without .enc, or with .dec"), a.t("decrypt") + note := []string{a.t("The plaintext is written only to a new file that only your user can read. It is never shown.")} + if encrypt { + title, hint, job = a.t("Encrypt file"), a.t("empty means the input name with .enc"), a.t("encrypt") + note = []string{a.t("Encrypts up to 1 MiB with AES-256-GCM inside the core.")} + } + fields := []*tui.Field{ + tui.TextField(a.t("Input file"), "", maxPath), + tui.TextField(a.t("Output file"), "", maxPath), + tui.TextField(a.t("AAD"), "", maxAAD), + } + fields[1].Hint = hint + fields[2].Hint = a.t("associated data, must be the same for encrypt and decrypt") + id := k.KeyID + a.form(a.tf("%s with %s", title, shortID(id)), note, fields, func(a *app, f *tui.Form) error { + in, err := a.inPath(f.Fields[0].Value()) + if err != nil { + return err + } + outName := f.Fields[1].Value() + if strings.TrimSpace(outName) == "" { + switch { + case encrypt: + outName = in + ".enc" + case strings.HasSuffix(in, ".enc"): + outName = strings.TrimSuffix(in, ".enc") + default: + outName = in + ".dec" + } + } + out, err := a.outPath(outName) + if err != nil { + return err + } + aad := []byte(f.Fields[2].Value()) + a.run(job, func(ctx context.Context, n *node.Node) (func(*app), error) { + data, err := fsx.ReadFileLimited(in, maxInput) + if err != nil { + return nil, err + } + var res []byte + if encrypt { + res, err = n.Encrypt(ctx, id, data, aad) + clear(data) + } else { + res, err = n.Decrypt(ctx, id, data, aad) + } + if err != nil { + return nil, err + } + werr := fsx.WriteNew(out, res) + size := len(res) + if !encrypt { + clear(res) + } + if werr != nil { + return nil, werr + } + return func(a *app) { + msg := a.tf("wrote %d bytes to %s", size, out) + a.done(job + ": " + msg) + a.notify(title, []string{msg}, false) + }, nil + }) + return nil + }) +} + +func (a *app) receiveForm() { + fields := []*tui.Field{tui.TextField(a.t("Envelope file"), "", maxPath)} + note := []string{a.t("Imports a key sent to this node after checking the signature, recipient and context (key receive).")} + a.form(a.t("Receive key"), note, fields, func(a *app, f *tui.Form) error { + in, err := a.inPath(f.Fields[0].Value()) + if err != nil { + return err + } + a.run(a.t("receive key"), func(ctx context.Context, n *node.Node) (func(*app), error) { + raw, err := fsx.ReadFileLimited(in, maxInput) + if err != nil { + return nil, err + } + rec, err := n.Receive(ctx, raw) + if err != nil { + return nil, err + } + return func(a *app) { + a.selID[tabKeys] = rec.KeyID + a.done(a.tf("received %s from %s", rec.KeyID, rec.Origin.Sender)) + a.notify(a.t("Key received"), a.keyLines(rec), false) + a.refresh() + }, nil + }) + return nil + }) +} + +func (a *app) membersKey(ev tui.Event) { + if ev.IsRune('a') { + a.addForm() + return + } + m := a.memberRecord(a.selected(tabMembers)) + if m == nil { + return + } + switch { + case ev.IsRune('w'): + a.witnessForm(m.id) + case ev.IsRune('h') && !a.opts.Offline: + a.healthForm(m.id) + } +} + +func (a *app) addForm() { + fields := []*tui.Field{ + tui.TextField(a.t("Card file"), "", maxPath), + tui.TextField(a.t("Fingerprint"), "", 256), + } + fields[1].Hint = a.t("as the member read it to you, never copied from the card file") + note := []string{ + a.t("Registers or updates a member (member add). Type or paste the fingerprint you got"), + a.t("over a separate channel, in person or by phone. It must match the card exactly."), + } + a.form(a.t("Add member"), note, fields, func(a *app, f *tui.Form) error { + in, err := a.inPath(f.Fields[0].Value()) + if err != nil { + return err + } + fp := strings.TrimSpace(f.Fields[1].Value()) + if exchange.NormalizeFingerprint(fp) == "" { + return errors.New(a.t("the fingerprint is required")) + } + a.run(a.t("add member"), func(ctx context.Context, n *node.Node) (func(*app), error) { + raw, err := fsx.ReadFileLimited(in, maxInput) + if err != nil { + return nil, err + } + rec, err := n.AddMember(ctx, raw, fp) + if err != nil { + return nil, err + } + title, msg := a.t("Member added"), a.tf("added member %s", rec.MemberID) + if rec.UpdatedAt != 0 { + title, msg = a.t("Member updated"), a.tf("updated member %s", rec.MemberID) + } + return func(a *app) { + a.selID[tabMembers] = rec.MemberID + a.done(msg) + a.notify(title, append([]string{a.kv("member", rec.MemberID)}, a.fpLines(rec.Fingerprint)...), false) + a.refresh() + }, nil + }) + return nil + }) +} + +func (a *app) witnessForm(member string) { + a.form(a.tf("Export witnessed heads of %s", member), []string{a.t("Writes the audit heads this node saw from the member, one SEQ:HASH per line (member witness).")}, + []*tui.Field{tui.TextField(a.t("Output file"), member+".witness", maxPath)}, + func(a *app, f *tui.Form) error { + out, err := a.outPath(f.Fields[0].Value()) + if err != nil { + return err + } + a.run(a.t("export witnessed heads"), func(ctx context.Context, n *node.Node) (func(*app), error) { + heads, err := n.Witnessed(member) + if err != nil { + return nil, err + } + var b strings.Builder + for _, h := range heads { + b.WriteString(h.String()) + b.WriteByte('\n') + } + if err := fsx.WriteNew(out, []byte(b.String())); err != nil { + return nil, err + } + return func(a *app) { + a.done(a.tf("wrote %d witnessed heads for %s to %s", len(heads), member, out)) + a.notify(a.t("Witnessed heads"), []string{a.tf("%d heads written to %s", len(heads), out), a.t("The member verifies its log with them on the Audit tab or audit verify --anchor-file.")}, false) + }, nil + }) + return nil + }) +} + +func (a *app) healthForm(member string) { + u := a.urls[member] + if u == "" { + u = "https://" + } + a.form(a.tf("Health of %s", member), []string{a.t("Connects to the member's kmsd with mutual TLS pinned to its card (peer health).")}, + []*tui.Field{tui.TextField(a.t("kmsd URL"), u, maxURL)}, + func(a *app, f *tui.Form) error { + dest, err := a.checkURL(f.Fields[0].Value()) + if err != nil { + return err + } + a.run(a.t("peer health"), func(ctx context.Context, n *node.Node) (func(*app), error) { + if err := api.NewClient(n, nil).Health(ctx, dest, member); err != nil { + return nil, err + } + return func(a *app) { + a.urls[member] = dest + a.done(a.tf("health ok %s at %s", member, dest)) + }, nil + }) + return nil + }) +} + +func (a *app) inboxKey(ev tui.Event) { + if ev.IsRune('i') { + a.receiveForm() + return + } + it := a.inboxByID(a.selected(tabInbox)) + if it == nil { + return + } + item := *it + from := item.Sender + fp := a.t("not a registered member, accepting will fail") + if m := a.memberRecord(from); m != nil { + fp = m.fingerprint + } + lines := []string{a.kv("envelope", item.ID), a.kv("from", from)} + lines = append(lines, a.fpLines(fp)...) + lines = append(lines, a.kv("sent", stamp(item.SentAt)), a.kv("received", stamp(item.ReceivedAt))) + switch { + case ev.Is(tui.KeyEnter), ev.IsRune('a'): + a.confirm(a.t("Accept envelope"), append(lines, "", a.t("The key is imported only if the signature, recipient and context verify. Accept?")), "", false, func(a *app) { + a.run(a.t("accept envelope"), func(ctx context.Context, n *node.Node) (func(*app), error) { + rec, err := n.Accept(ctx, item.ID) + if err != nil { + return nil, err + } + return func(a *app) { + a.selID[tabKeys] = rec.KeyID + a.done(a.tf("accepted %s, key %s", item.ID, rec.KeyID)) + a.notify(a.t("Key imported"), a.keyLines(rec), false) + a.refresh() + }, nil + }) + }) + case ev.IsRune('x'): + a.confirm(a.t("Reject envelope"), append(lines, "", a.t("The envelope is deleted. The sender has to send it again. Reject?")), "", true, func(a *app) { + a.run(a.t("reject envelope"), func(ctx context.Context, n *node.Node) (func(*app), error) { + if err := n.Reject(ctx, item.ID); err != nil { + return nil, err + } + return func(a *app) { + a.done(a.tf("rejected %s", item.ID)) + a.refresh() + }, nil + }) + }) + } +} + +func parseAnchors(s string) ([]audit.Anchor, error) { + var out []audit.Anchor + for _, tok := range strings.FieldsFunc(s, func(r rune) bool { return r == ' ' || r == ',' || r == ';' }) { + a, err := audit.ParseAnchor(tok) + if err != nil { + return nil, fmt.Errorf("%s: %w", tok, err) + } + out = append(out, a) + } + return out, nil +} + +func (a *app) verifyForm() { + fields := []*tui.Field{ + tui.TextField(a.t("Anchors"), "", 8192), + tui.TextField(a.t("Anchor file"), "", maxPath), + } + fields[0].Hint = a.t("SEQ:HASH heads recorded out of band, separated by spaces") + fields[1].Hint = a.t("one SEQ:HASH per line, for example a member witness file") + if !a.opts.Offline { + peers := append([]string{a.t("(none)")}, a.memberIDs()...) + fields = append(fields, tui.ChoiceField(a.t("Peer"), peers, 0), tui.TextField(a.t("Peer kmsd URL"), "https://", maxURL)) + fields[2].Hint = a.t("a member whose kmsd returns the heads it witnessed") + } + note := []string{a.t("Replays the hash chain and checkpoint signatures and checks every anchor (audit verify).")} + now := a.opts.now + a.form(a.t("Verify audit log"), note, fields, func(a *app, f *tui.Form) error { + anchors, err := parseAnchors(f.Fields[0].Value()) + if err != nil { + return err + } + var file string + if strings.TrimSpace(f.Fields[1].Value()) != "" { + if file, err = a.inPath(f.Fields[1].Value()); err != nil { + return err + } + } + var peer, dest string + if len(f.Fields) > 2 && f.Fields[2].Index > 0 { + peer = f.Fields[2].Value() + if dest, err = a.checkURL(f.Fields[3].Value()); err != nil { + return err + } + } + a.run(a.t("verify audit log"), func(ctx context.Context, n *node.Node) (func(*app), error) { + if file != "" { + raw, err := fsx.ReadFileLimited(file, maxInput) + if err != nil { + return nil, err + } + more, err := parseAnchors(strings.ReplaceAll(string(raw), "\n", " ")) + if err != nil { + return nil, fmt.Errorf("%s: %w", file, err) + } + anchors = append(anchors, more...) + } + if peer != "" { + fetched, err := api.NewClient(n, nil).Witness(ctx, dest, peer) + if err != nil { + return nil, err + } + anchors = append(anchors, fetched...) + } + count, head, verr := n.VerifyAudit(anchors) + at := now() + return func(a *app) { + if peer != "" { + a.urls[peer] = dest + } + if verr != nil { + a.verify = &verifyResult{err: verr.Error(), at: at} + a.flash(a.t("audit verification failed"), true) + a.logs.add(a.t("audit verification failed") + ": " + verr.Error()) + a.notify(a.t("Audit verification failed"), []string{verr.Error()}, true) + return + } + a.verify = &verifyResult{count: count, head: head, anchors: len(anchors), peer: peer, at: at} + a.done(a.tf("audit verified %d entries, head %s", count, head)) + a.notify(a.t("Audit log verified"), []string{ + a.kv("entries", fmt.Sprint(count)), + a.kv("head", head.String()), + a.kv("anchors", fmt.Sprint(len(anchors))), + "", + a.t("Record the head somewhere the node cannot change to catch a later rollback."), + }, false) + a.refresh() + }, nil + }) + return nil + }) +} diff --git a/host/internal/console/console.go b/host/internal/console/console.go new file mode 100644 index 0000000..2f8e30d --- /dev/null +++ b/host/internal/console/console.go @@ -0,0 +1,597 @@ +package console + +import ( + "context" + "errors" + "fmt" + "io" + "os" + "path/filepath" + "runtime" + "strings" + "time" + + "github.com/Quant-Off/pairier/host/internal/node" + "github.com/Quant-Off/pairier/host/internal/tui" +) + +const ( + minWidth = 64 + minHeight = 18 + jobTimeout = 2 * time.Minute + refreshEvery = 15 * time.Second + maxInput = 1 << 20 + spinner = `|/-\` +) + +type Terminal interface { + io.Writer + Size() (int, int, error) + Events() <-chan tui.Event +} + +type Options struct { + Node node.Options + Dir string + Offline bool + Idle time.Duration + Version string + Color bool + Paste bool + Lang string + + afterDraw func(s *tui.Screen, handled int) + now func() time.Time +} + +type phase uint8 + +const ( + phaseStart phase = iota + phaseOpening + phaseMain + phaseLocked +) + +const ( + tabNode = iota + tabKeys + tabMembers + tabInbox + tabAudit + tabLog + tabCount +) + +var tabNames = [tabCount]string{"Node", "Keys", "Members", "Inbox", "Audit", "Log"} + +type modal interface { + handle(a *app, ev tui.Event) + draw(s *tui.Screen) +} + +type work func(ctx context.Context, n *node.Node) (func(*app), error) + +type job struct { + title string + quiet bool + cancel context.CancelFunc +} + +type pending struct { + title string + body func(ctx context.Context, res *result) +} + +type result struct { + title string + quiet bool + apply func(*app) + cleanup func() + err error + panic any +} + +type app struct { + ctx context.Context + term Terminal + opts Options + screen *tui.Screen + rend *tui.Renderer + logs *logBuffer + node *node.Node + dir string + phase phase + tab int + lists [tabCount]tui.List + selID [tabCount]string + filter [tabCount]string + info nodeInfo + data snapshot + verify *verifyResult + urls map[string]string + modal modal + job *job + next *pending + again bool + results chan result + status string + statusErr bool + lastInput time.Time + refreshed time.Time + frame int + handled int + quit bool + catalog map[string]string + texts *tui.Texts +} + +func Run(ctx context.Context, t Terminal, o Options) (err error) { + if o.now == nil { + o.now = time.Now + } + a := &app{ + ctx: ctx, + term: t, + opts: o, + rend: tui.NewRenderer(t, o.Color), + logs: newLogBuffer(500), + urls: map[string]string{}, + results: make(chan result, 1), + } + w, h, serr := t.Size() + if serr != nil || w <= 0 || h <= 0 { + w, h = 80, 24 + } + a.screen = tui.NewScreen(w, h) + a.rend.Paste = o.Paste + if o.Lang == LangKorean { + a.catalog, a.texts = korean, &koreanTexts + } + if err := a.rend.Begin(); err != nil { + return err + } + defer func() { + a.shutdown() + if eerr := a.rend.End(); err == nil { + err = eerr + } + }() + a.lastInput = o.now() + a.begin() + tick := time.NewTicker(time.Second) + defer tick.Stop() + for !a.quit { + a.draw() + select { + case <-ctx.Done(): + return nil + case ev := <-t.Events(): + a.lastInput = a.opts.now() + a.handle(ev) + a.handled++ + case res := <-a.results: + a.finish(res) + case <-tick.C: + a.tick() + } + } + return nil +} + +func (a *app) shutdown() { + if a.job != nil { + a.job.cancel() + select { + case res := <-a.results: + if res.cleanup != nil { + res.cleanup() + } + case <-time.After(5 * time.Second): + } + a.job = nil + } + a.closeNode() +} + +func (a *app) closeNode() { + if a.node != nil { + if err := a.node.Close(); err != nil { + a.logs.add("close node: " + err.Error()) + } + a.node = nil + } +} + +func (a *app) run(title string, w work) bool { + n := a.node + return a.spawn(title, false, func(ctx context.Context, res *result) { + res.apply, res.err = w(ctx, n) + }) +} + +func (a *app) spawn(title string, quiet bool, body func(ctx context.Context, res *result)) bool { + if a.job != nil { + switch { + case quiet: + a.again = true + return true + case a.job.quiet && a.next == nil: + a.next = &pending{title: title, body: body} + return true + } + a.flash(a.tf("busy with %s", a.job.title), true) + return false + } + ctx, cancel := context.WithTimeout(a.ctx, jobTimeout) + a.job = &job{title: title, quiet: quiet, cancel: cancel} + go func() { + defer cancel() + res := result{title: title, quiet: quiet} + func() { + defer func() { + if r := recover(); r != nil { + res.panic = r + } + }() + body(ctx, &res) + }() + a.results <- res + }() + return true +} + +func (a *app) finish(res result) { + a.job = nil + if res.panic != nil { + panic(res.panic) + } + defer a.afterJob() + if res.err != nil { + if errors.Is(res.err, context.Canceled) { + a.flash(a.tf("%s cancelled", res.title), true) + a.logs.add(a.tf("%s cancelled", res.title)) + if a.phase == phaseOpening { + a.phase = phaseStart + } + return + } + a.logs.add(res.title + ": " + res.err.Error()) + if a.phase == phaseOpening { + a.phase = phaseStart + } + a.flash(a.tf("%s failed: %s", res.title, res.err.Error()), true) + if !res.quiet { + a.notify(a.tf("%s failed", res.title), []string{res.err.Error()}, true) + } + return + } + if res.apply != nil { + res.apply(a) + } +} + +func (a *app) afterJob() { + if a.job != nil { + return + } + if p := a.next; p != nil { + a.next = nil + a.spawn(p.title, false, p.body) + return + } + if a.again { + a.again = false + a.refresh() + } +} + +func (a *app) flash(msg string, isErr bool) { + a.status, a.statusErr = msg, isErr +} + +func (a *app) done(msg string) { + a.flash(msg, false) + a.logs.add(msg) +} + +func (a *app) tick() { + a.frame++ + now := a.opts.now() + if a.phase != phaseMain || a.job != nil { + return + } + if a.opts.Idle > 0 && now.Sub(a.lastInput) >= a.opts.Idle { + a.lock() + return + } + if a.modal == nil && now.Sub(a.refreshed) >= refreshEvery { + a.refresh() + } +} + +func (a *app) lock() { + a.closeNode() + a.data = snapshot{} + a.info = nodeInfo{} + a.verify = nil + a.modal = nil + a.phase = phaseLocked + a.rend.Invalidate() + a.logs.add(a.tf("node closed after %s without input", a.opts.Idle)) + a.flash(a.t("node closed after inactivity"), false) +} + +func (a *app) handle(ev tui.Event) { + if ev.Kind == tui.EventResize { + if ev.Width > 0 && ev.Height > 0 && (ev.Width != a.screen.W || ev.Height != a.screen.H) { + a.screen.Resize(ev.Width, ev.Height) + a.rend.Invalidate() + } + return + } + switch { + case ev.IsCtrl('c'): + a.quit = true + return + case ev.IsCtrl('l'): + a.rend.Invalidate() + return + } + if a.modal != nil { + a.modal.handle(a, ev) + return + } + ev = tui.Shortcut(ev) + if ev.Is(tui.KeyEsc) && a.job != nil { + a.job.cancel() + return + } + switch a.phase { + case phaseStart: + a.handleStart(ev) + case phaseOpening: + if ev.IsRune('q') { + a.quit = true + } + case phaseLocked: + switch { + case ev.Is(tui.KeyEnter): + a.openNode(a.dir) + case ev.IsRune('q'): + a.quit = true + } + case phaseMain: + a.handleMain(ev) + } +} + +func (a *app) handleStart(ev tui.Event) { + switch { + case ev.IsRune('o'): + a.dirForm(a.startDir()) + case ev.IsRune('n'): + a.initForm(a.startDir()) + case ev.IsRune('q'): + a.quit = true + } +} + +func (a *app) startDir() string { + if a.dir != "" { + return a.dir + } + if a.opts.Dir != "" { + return a.opts.Dir + } + return defaultDir() +} + +func defaultDir() string { + if runtime.GOOS == "windows" { + if base := os.Getenv("LOCALAPPDATA"); base != "" { + return filepath.Join(base, "pairier") + } + } + if home, err := os.UserHomeDir(); err == nil { + return filepath.Join(home, ".pairier") + } + return "" +} + +func (a *app) begin() { + dir := a.opts.Dir + if dir == "" { + a.dirForm(defaultDir()) + return + } + dir = expandPath(dir) + if _, err := os.Stat(dir); errors.Is(err, os.ErrNotExist) { + a.initForm(dir) + return + } + a.openNode(dir) +} + +func (a *app) nodeOptions(dir string) node.Options { + o := a.opts.Node + o.Dir = dir + o.Stderr = a.logs + return o +} + +var ( + plain = tui.Style{} + bold = tui.Style{Bold: true} + dim = tui.Style{Dim: true} + reverse = tui.Style{Reverse: true} + selected = tui.Style{Reverse: true, Bold: true} + warn = tui.Style{Fg: tui.Yellow, Bold: true} + bad = tui.Style{Fg: tui.Red, Bold: true} + good = tui.Style{Fg: tui.Green} + heading = tui.Style{Fg: tui.Cyan, Bold: true} +) + +func (a *app) draw() { + s := a.screen + s.Clear() + if s.W < minWidth || s.H < minHeight { + s.Put(0, 0, a.tf("terminal too small (%dx%d), need %dx%d", s.W, s.H, minWidth, minHeight), bad) + s.Put(0, 1, a.t("resize the window or press Ctrl+C to quit"), plain) + _ = a.rend.Draw(s) + a.afterDraw() + return + } + a.drawHeader() + body := tui.Style{} + switch a.phase { + case phaseStart: + a.drawStart() + case phaseOpening: + s.Put(2, 3, a.tf("opening %s ...", a.dir), body) + case phaseLocked: + s.Put(2, 3, a.tf("The node was closed after %s without input.", a.opts.Idle), bold) + s.Put(2, 4, a.t("The core process has exited and its key material is gone from memory."), plain) + s.Put(2, 6, a.t("Enter reopen q quit"), plain) + case phaseMain: + a.drawTabs() + a.drawTab() + } + a.drawFooter() + if a.modal != nil { + a.modal.draw(s) + } + _ = a.rend.Draw(s) + a.afterDraw() +} + +func (a *app) afterDraw() { + if a.opts.afterDraw != nil { + a.opts.afterDraw(a.screen, a.handled) + } +} + +func (a *app) drawHeader() { + s := a.screen + s.Fill(0, 0, s.W, 1, reverse) + left := " pairier" + if a.info.member != "" { + left += " " + a.t("member") + " " + a.info.member + } + if a.dir != "" { + left += " " + a.dir + } + right := "kmsctl " + a.opts.Version + " " + if a.opts.Offline { + right = a.t("[offline]") + " " + right + } + rw := tui.StringWidth(right) + s.Field(0, 0, s.W-rw, left, reverse) + s.Put(s.W-rw, 0, right, reverse) +} + +func (a *app) drawTabs() { + s := a.screen + x := 0 + for i, name := range tabNames { + label := fmt.Sprintf(" %d %s ", i+1, a.t(name)) + if i == tabInbox && len(a.data.inbox) > 0 { + label = fmt.Sprintf(" %d %s (%d) ", i+1, a.t(name), len(a.data.inbox)) + } + st := plain + if i == a.tab { + st = selected + } + x += s.Put(x, 1, label, st) + 1 + } +} + +func (a *app) drawFooter() { + s := a.screen + right := a.t("? help q quit ") + if a.phase != phaseMain { + right = "" + } + left := a.hints() + if a.phase == phaseMain { + if more := a.t(" Tab/1-6 tabs / filter Ctrl+R refresh"); tui.StringWidth(left+more+" "+right) <= s.W { + left += more + } + } + rw := tui.StringWidth(right) + s.Field(0, s.H-2, s.W-rw, left, dim) + s.Put(s.W-rw, s.H-2, right, dim) + switch { + case a.job != nil: + s.Field(0, s.H-1, s.W, fmt.Sprintf(" %c %s", spinner[a.frame%len(spinner)], a.job.title)+a.t(" ... (Esc cancels)"), warn) + case a.status != "": + st := good + if a.statusErr { + st = bad + } + s.Field(0, s.H-1, s.W, " "+a.status, st) + } +} + +func (a *app) hints() string { + switch a.phase { + case phaseStart: + return a.t(" o open a node directory n initialize a new node q quit") + case phaseLocked: + return a.t(" Enter reopen q quit") + case phaseOpening: + return a.t(" Esc cancel q quit") + } + net := !a.opts.Offline + switch a.tab { + case tabNode: + return a.t(" c export card R renew card") + case tabKeys: + h := a.t(" n new s send") + if net { + h += a.t(" p push") + } + return h + a.t(" r receive e/d encrypt/decrypt Enter info") + case tabMembers: + h := a.t(" a add w witness heads") + if net { + h += a.t(" h health") + } + return h + case tabInbox: + return a.t(" Enter accept x reject i import file") + case tabAudit: + return a.t(" v verify") + } + return a.t(" Up/Down scroll") +} + +func (a *app) drawStart() { + s := a.screen + lines := []string{ + a.t("No node is open."), + "", + a.t("o open an existing node directory"), + a.t("n initialize a new node"), + a.t("q quit"), + "", + a.t("Every action runs through the same node code as the kmsctl commands"), + a.t("and is written to the node audit log."), + } + for i, l := range lines { + s.Put(2, 3+i, l, plain) + } +} + +func expandPath(p string) string { + p = strings.TrimSpace(p) + if len(p) >= 2 && (p[0] == '"' && p[len(p)-1] == '"' || p[0] == '\'' && p[len(p)-1] == '\'') { + p = strings.TrimSpace(p[1 : len(p)-1]) + } + if p == "~" || strings.HasPrefix(p, "~/") || strings.HasPrefix(p, `~\`) { + if home, err := os.UserHomeDir(); err == nil { + p = filepath.Join(home, p[1:]) + } + } + return p +} diff --git a/host/internal/console/console_test.go b/host/internal/console/console_test.go new file mode 100644 index 0000000..ba6b678 --- /dev/null +++ b/host/internal/console/console_test.go @@ -0,0 +1,795 @@ +package console + +import ( + "bytes" + "context" + "go/ast" + "go/parser" + "go/token" + "net" + "net/http" + "os" + "path/filepath" + "regexp" + "strconv" + "strings" + "sync" + "testing" + "time" + + "github.com/Quant-Off/pairier/host/internal/api" + "github.com/Quant-Off/pairier/host/internal/exchange" + "github.com/Quant-Off/pairier/host/internal/node" + "github.com/Quant-Off/pairier/host/internal/tui" +) + +type fakeTerm struct { + events chan tui.Event + mu sync.Mutex + out bytes.Buffer + w, h int +} + +func (f *fakeTerm) Write(p []byte) (int, error) { + f.mu.Lock() + defer f.mu.Unlock() + return f.out.Write(p) +} + +func (f *fakeTerm) Size() (int, int, error) { return f.w, f.h, nil } + +func (f *fakeTerm) Events() <-chan tui.Event { return f.events } + +func (f *fakeTerm) output() []byte { + f.mu.Lock() + defer f.mu.Unlock() + return append([]byte(nil), f.out.Bytes()...) +} + +type harness struct { + t *testing.T + term *fakeTerm + mu sync.Mutex + screen string + handled int + sent int + seen []string + frames chan struct{} + done chan error + cancel context.CancelFunc +} + +func coreBin(t *testing.T) string { + t.Helper() + bin := os.Getenv("KMS_CORE_BIN") + if bin == "" { + t.Skip("KMS_CORE_BIN not set") + } + return bin +} + +func launch(t *testing.T, o Options, watch ...string) *harness { + t.Helper() + h := &harness{t: t, term: &fakeTerm{events: make(chan tui.Event), w: 110, h: 32}, frames: make(chan struct{}, 1), done: make(chan error, 1)} + if o.Version == "" { + o.Version = "test" + } + o.afterDraw = func(s *tui.Screen, handled int) { + text := s.Text() + h.mu.Lock() + h.screen = text + h.handled = handled + for _, w := range watch { + if strings.Contains(text, w) { + h.seen = append(h.seen, w) + } + } + h.mu.Unlock() + select { + case h.frames <- struct{}{}: + default: + } + } + ctx, cancel := context.WithCancel(context.Background()) + h.cancel = cancel + go func() { h.done <- Run(ctx, h.term, o) }() + t.Cleanup(h.stop) + return h +} + +func (h *harness) stop() { + h.cancel() + select { + case err := <-h.done: + if err != nil { + h.t.Errorf("run: %v", err) + } + h.done <- nil + case <-time.After(10 * time.Second): + h.t.Error("ui did not stop") + } +} + +func (h *harness) caughtUp() bool { + h.mu.Lock() + defer h.mu.Unlock() + return h.handled >= h.sent +} + +func (h *harness) send(evs ...tui.Event) { + for _, ev := range evs { + select { + case h.term.events <- ev: + case <-time.After(10 * time.Second): + h.t.Fatalf("ui stopped reading input\n%s", h.text()) + } + h.mu.Lock() + h.sent++ + h.mu.Unlock() + deadline := time.Now().Add(10 * time.Second) + for !h.caughtUp() { + if time.Now().After(deadline) { + h.t.Fatalf("no frame after input\n%s", h.text()) + } + select { + case <-h.frames: + case <-time.After(10 * time.Millisecond): + } + } + } +} + +func (h *harness) typ(s string) { + for _, r := range s { + h.send(tui.RuneEvent(r)) + } +} + +func (h *harness) enter() { h.send(tui.KeyEvent(tui.KeyEnter)) } +func (h *harness) clearIn() { h.send(tui.CtrlEvent('u')) } +func (h *harness) replace(s string) { + h.clearIn() + h.typ(s) +} + +func (h *harness) text() string { + h.mu.Lock() + defer h.mu.Unlock() + return h.screen +} + +func (h *harness) wait(want string) string { + h.t.Helper() + deadline := time.Now().Add(30 * time.Second) + for { + s := h.text() + if strings.Contains(s, want) { + return s + } + if time.Now().After(deadline) { + h.t.Fatalf("timed out waiting for %q\n%s", want, s) + } + select { + case <-h.frames: + case <-time.After(50 * time.Millisecond): + } + } +} + +func (h *harness) idle() { + h.t.Helper() + deadline := time.Now().Add(30 * time.Second) + for strings.Contains(h.text(), "(Esc cancels)") { + if time.Now().After(deadline) { + h.t.Fatalf("job did not finish\n%s", h.text()) + } + select { + case <-h.frames: + case <-time.After(50 * time.Millisecond): + } + } +} + +func (h *harness) closeDialog(title string) { + h.t.Helper() + h.wait(title) + h.enter() + h.idle() +} + +func cardFingerprint(t *testing.T, path string) string { + t.Helper() + raw, err := os.ReadFile(path) + if err != nil { + t.Fatal(err) + } + card, err := exchange.DecodeCard(raw) + if err != nil { + t.Fatal(err) + } + fp, err := card.Fingerprint() + if err != nil { + t.Fatal(err) + } + return fp +} + +func nodeOpts(bin string) node.Options { + return node.Options{CoreBinary: bin, AllowUnlockedMemory: true, Timeout: 10 * time.Second} +} + +func initNode(t *testing.T, h *harness, id, card string) { + t.Helper() + h.wait("Initialize node") + h.enter() + h.typ(id) + h.enter() + h.enter() + h.closeDialog("Node initialized") + h.wait("member " + id) + h.send(tui.RuneEvent('c')) + h.wait("Export card") + h.replace(card) + h.enter() + h.closeDialog("Card exported") +} + +func addMember(t *testing.T, h *harness, card, fp string) { + t.Helper() + h.send(tui.RuneEvent('3'), tui.RuneEvent('a')) + h.wait("Add member") + h.typ(card) + h.enter() + h.send(tui.PasteEvent(strings.ToUpper(fp) + "\n")) + h.enter() + h.closeDialog("Member added") +} + +func serve(t *testing.T, n *node.Node) string { + t.Helper() + srv := api.New(n, nil) + cfg, err := srv.TLSConfig() + if err != nil { + t.Fatal(err) + } + ln, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + hs := &http.Server{Handler: srv.Handler(), TLSConfig: cfg, ReadHeaderTimeout: 5 * time.Second} + go func() { _ = hs.ServeTLS(ln, "", "") }() + t.Cleanup(func() { + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + _ = hs.Shutdown(ctx) + }) + return "https://" + ln.Addr().String() +} + +func TestConsoleCoversTheKMS(t *testing.T) { + bin := coreBin(t) + base := t.TempDir() + aliceDir, bobDir := filepath.Join(base, "alice"), filepath.Join(base, "bob") + aliceCard, bobCard := filepath.Join(base, "alice.card"), filepath.Join(base, "bob.card") + secret := "top secret plaintext" + + alice := launch(t, Options{Node: nodeOpts(bin), Dir: aliceDir}, secret) + initNode(t, alice, "alice", aliceCard) + bob := launch(t, Options{Node: nodeOpts(bin), Dir: bobDir}, secret) + initNode(t, bob, "bob", bobCard) + aliceFP, bobFP := cardFingerprint(t, aliceCard), cardFingerprint(t, bobCard) + + alice.send(tui.RuneEvent('3'), tui.RuneEvent('a')) + alice.wait("Add member") + alice.typ(bobCard) + alice.enter() + alice.typ(aliceFP) + alice.enter() + alice.closeDialog("add member failed") + if !strings.Contains(alice.text(), "(empty)") { + t.Fatalf("member added with the wrong fingerprint\n%s", alice.text()) + } + addMember(t, alice, bobCard, bobFP) + addMember(t, bob, aliceCard, aliceFP) + alice.wait("dhkem-p256") + + alice.send(tui.RuneEvent('2'), tui.RuneEvent('n')) + alice.wait("Generate key") + alice.typ("project/db 데이터") + alice.enter() + alice.enter() + alice.wait("project/db 데이터") + alice.idle() + + envFile := filepath.Join(base, "db.kxp") + alice.send(tui.RuneEvent('s')) + alice.wait("Send key to file") + alice.enter() + alice.enter() + alice.replace(envFile) + alice.enter() + alice.wait("fingerprint " + splitFingerprint(bobFP)[0]) + alice.send(tui.RuneEvent('y')) + alice.closeDialog("Envelope written") + + plain := filepath.Join(base, "plain.txt") + if err := os.WriteFile(plain, []byte(secret), 0o600); err != nil { + t.Fatal(err) + } + alice.send(tui.RuneEvent('e')) + alice.wait("Encrypt file") + alice.typ(plain) + alice.enter() + alice.enter() + alice.typ("ctx") + alice.enter() + alice.closeDialog("wrote") + if _, err := os.Stat(plain + ".enc"); err != nil { + t.Fatal(err) + } + + bob.send(tui.RuneEvent('2'), tui.RuneEvent('r')) + bob.wait("Receive key") + bob.typ(envFile) + bob.enter() + bob.closeDialog("Key received") + bob.wait("project/db 데이터") + bob.idle() + out := filepath.Join(base, "plain.out") + bob.send(tui.RuneEvent('d')) + bob.wait("Decrypt file") + bob.typ(plain + ".enc") + bob.enter() + bob.typ(out) + bob.enter() + bob.typ("wrong") + bob.enter() + bob.closeDialog("decrypt failed") + bob.send(tui.RuneEvent('d')) + bob.wait("Decrypt file") + bob.typ(plain + ".enc") + bob.enter() + bob.typ(out) + bob.enter() + bob.typ("ctx") + bob.enter() + bob.closeDialog("wrote") + if got, err := os.ReadFile(out); err != nil || string(got) != secret { + t.Fatalf("decrypted %q %v", got, err) + } + bob.send(tui.RuneEvent('d')) + bob.wait("Decrypt file") + bob.typ(plain + ".enc") + bob.enter() + bob.typ(out) + bob.enter() + bob.enter() + bob.wait("already exists") + bob.send(tui.KeyEvent(tui.KeyEsc)) + + bobNode, err := node.Open(context.Background(), node.Options{Dir: bobDir, CoreBinary: bin, AllowUnlockedMemory: true, Timeout: 10 * time.Second}) + if err != nil { + t.Fatal(err) + } + defer bobNode.Close() + bobURL := serve(t, bobNode) + + alice.send(tui.RuneEvent('3'), tui.RuneEvent('h')) + alice.wait("Health of bob") + alice.replace(bobURL) + alice.enter() + alice.wait("health ok bob") + + for _, label := range []string{"push/one", "push/two"} { + alice.send(tui.RuneEvent('2'), tui.RuneEvent('n')) + alice.wait("Generate key") + alice.typ(label) + alice.enter() + alice.enter() + alice.wait(label) + alice.idle() + alice.send(tui.RuneEvent('p')) + alice.wait("Push key") + alice.enter() + alice.enter() + alice.wait(bobURL) + alice.enter() + alice.wait("kmsd " + bobURL) + alice.send(tui.RuneEvent('y')) + alice.closeDialog("Key pushed") + } + + bob.send(tui.RuneEvent('4'), tui.CtrlEvent('r')) + bob.wait("Inbox (2)") + bob.idle() + bob.send(tui.KeyEvent(tui.KeyEnter)) + bob.wait("Accept envelope") + bob.send(tui.RuneEvent('y')) + bob.closeDialog("Key imported") + bob.wait("Inbox (1)") + bob.send(tui.RuneEvent('x')) + bob.wait("Reject envelope") + bob.send(tui.RuneEvent('y')) + bob.idle() + bob.wait("rejected") + bob.send(tui.RuneEvent('2')) + bob.wait("push/") + if one, two := strings.Contains(bob.text(), "push/one"), strings.Contains(bob.text(), "push/two"); one == two { + t.Fatalf("want exactly one pushed key imported\n%s", bob.text()) + } + + witness := filepath.Join(base, "alice.witness") + bob.send(tui.RuneEvent('3'), tui.RuneEvent('w')) + bob.wait("Export witnessed heads of alice") + bob.replace(witness) + bob.enter() + bob.closeDialog("Witnessed heads") + + alice.send(tui.RuneEvent('5')) + alice.wait("key.send") + alice.idle() + alice.send(tui.RuneEvent('v')) + alice.wait("Verify audit log") + alice.enter() + alice.typ(witness) + alice.enter() + alice.send(tui.KeyEvent(tui.KeyRight)) + alice.enter() + alice.replace(bobURL) + alice.enter() + alice.closeDialog("Audit log verified") + alice.wait("heads witnessed by bob") + + alice.send(tui.RuneEvent('1'), tui.RuneEvent('R')) + alice.wait("Renew card") + alice.typ("alic") + alice.enter() + alice.wait("the text does not match") + alice.typ("e") + alice.enter() + alice.wait("New fingerprint") + renewed := filepath.Join(base, "alice.renewed") + alice.replace(renewed) + alice.enter() + alice.closeDialog("Card exported") + if fp := cardFingerprint(t, renewed); fp == aliceFP || !strings.Contains(alice.text(), splitFingerprint(fp)[0]) { + t.Fatalf("renewed fingerprint %s not shown\n%s", fp, alice.text()) + } + + alice.send(tui.RuneEvent('6')) + alice.wait("renewed") + + for _, h := range []*harness{alice, bob} { + h.mu.Lock() + leaked := len(h.seen) > 0 + h.mu.Unlock() + if leaked { + t.Fatal("plaintext was drawn on the screen") + } + raw := h.term.output() + if bytes.Contains(raw, []byte(secret)) { + t.Fatal("plaintext reached the terminal") + } + if bytes.Contains(raw, []byte("\x1b]")) || bytes.Contains(raw, []byte{0x07}) || bytes.Contains(raw, []byte{0xc2, 0x9b}) { + t.Fatal("terminal control sequence emitted") + } + } +} + +func TestOfflineModeHidesNetworkActions(t *testing.T) { + bin := coreBin(t) + base := t.TempDir() + h := launch(t, Options{Node: nodeOpts(bin), Dir: filepath.Join(base, "carol"), Offline: true}) + initNode(t, h, "carol", filepath.Join(base, "carol.card")) + if !strings.Contains(h.text(), "[offline]") { + t.Fatalf("offline not shown\n%s", h.text()) + } + h.send(tui.RuneEvent('2'), tui.RuneEvent('n')) + h.wait("Generate key") + h.typ("k") + h.enter() + h.enter() + h.idle() + h.wait(" k ") + s := h.text() + if strings.Contains(s, "p push") { + t.Fatalf("push offered offline\n%s", s) + } + h.send(tui.RuneEvent('p')) + time.Sleep(100 * time.Millisecond) + if strings.Contains(h.text(), "Push key") { + t.Fatal("push form opened offline") + } + h.send(tui.RuneEvent('5'), tui.RuneEvent('v')) + h.wait("Verify audit log") + if strings.Contains(h.text(), "Peer kmsd URL") { + t.Fatal("peer audit offered offline") + } + h.enter() + h.enter() + h.closeDialog("Audit log verified") +} + +type clock struct { + mu sync.Mutex + t time.Time +} + +func (c *clock) now() time.Time { + c.mu.Lock() + defer c.mu.Unlock() + return c.t +} + +func (c *clock) add(d time.Duration) { + c.mu.Lock() + defer c.mu.Unlock() + c.t = c.t.Add(d) +} + +func TestIdleClosesTheNode(t *testing.T) { + bin := coreBin(t) + base := t.TempDir() + clk := &clock{t: time.Now()} + h := launch(t, Options{Node: nodeOpts(bin), Dir: filepath.Join(base, "dave"), Idle: time.Minute, now: clk.now}) + h.wait("Initialize node") + h.enter() + h.typ("dave") + h.enter() + h.enter() + h.closeDialog("Node initialized") + time.Sleep(1500 * time.Millisecond) + if strings.Contains(h.text(), "without input") { + t.Fatal("node closed before the idle time passed") + } + clk.add(2 * time.Minute) + h.wait("without input") + if strings.Contains(h.text(), "member dave") { + t.Fatalf("node details still shown after idle close\n%s", h.text()) + } + h.enter() + h.wait("member dave") +} + +func TestStartScreenAndErrors(t *testing.T) { + base := t.TempDir() + h := launch(t, Options{Node: node.Options{CoreBinary: filepath.Join(base, "missing-core")}}) + h.wait("Open node") + h.replace(filepath.Join(base, "new")) + h.enter() + h.wait("Initialize node") + h.enter() + h.typ("Bad ID") + h.enter() + h.enter() + h.wait("invalid member id") + h.send(tui.KeyEvent(tui.KeyEsc)) + h.wait("o open a node directory") + h.send(tui.RuneEvent('n')) + h.wait("Initialize node") + h.enter() + h.typ("erin") + h.enter() + h.enter() + h.closeDialog("initialize node failed") + h.wait("No node is open") + if _, err := os.Stat(filepath.Join(base, "new")); !os.IsNotExist(err) { + t.Fatalf("failed init left a directory behind: %v", err) + } + h.send(tui.ResizeEvent(40, 10)) + h.wait("terminal too small") + h.send(tui.ResizeEvent(100, 30)) + h.wait("No node is open") +} + +func TestHelpersRejectBadInput(t *testing.T) { + a := &app{} + if _, err := a.checkURL("http://host:1"); err == nil { + t.Fatal("http url accepted") + } + if _, err := a.checkURL("https://user@host:1"); err == nil { + t.Fatal("url with credentials accepted") + } + if u, err := a.checkURL(" https://host:7443/ "); err != nil || u != "https://host:7443" { + t.Fatalf("%q %v", u, err) + } + if _, err := parseAnchors("1:zz"); err == nil { + t.Fatal("malformed anchor accepted") + } + if got := expandPath(` "C:\Users\a b\x.card" `); got != `C:\Users\a b\x.card` { + t.Fatalf("%q", got) + } + dir := t.TempDir() + if _, err := a.inPath(dir); err == nil { + t.Fatal("directory accepted as input") + } + if _, err := a.outPath(dir); err == nil { + t.Fatal("existing path accepted as output") + } + var l logBuffer + l.max = 3 + _, _ = l.Write([]byte("a\x1b]0;x\x07b\npartial")) + if got := l.snapshot(); len(got) != 1 || !strings.HasSuffix(got[0], "core: a?]0;x?b") { + t.Fatalf("%q", got) + } +} + +func TestSmallTerminals(t *testing.T) { + bin := coreBin(t) + base := t.TempDir() + h := launch(t, Options{Node: nodeOpts(bin), Dir: filepath.Join(base, "frank")}) + initNode(t, h, "frank", filepath.Join(base, "frank.card")) + for _, size := range [][2]int{{80, 24}, {64, 18}} { + h.send(tui.ResizeEvent(size[0], size[1])) + for tab := '1'; tab <= '6'; tab++ { + h.send(tui.RuneEvent(tab)) + lines := strings.Split(h.text(), "\n") + if len(lines) != size[1] || !strings.Contains(lines[1], "6 Log") || !strings.HasSuffix(lines[size[1]-2], "? help q quit") { + t.Fatalf("%dx%d tab %c\n%s", size[0], size[1], tab, h.text()) + } + } + h.send(tui.RuneEvent('?')) + h.wait("Help") + for i := 0; i < 40; i++ { + h.send(tui.KeyEvent(tui.KeyDown)) + } + h.wait("clipboard") + h.enter() + h.send(tui.RuneEvent('5'), tui.RuneEvent('v')) + s := h.wait("Verify audit log") + for _, label := range []string{"Anchors", "Anchor file", "Peer", "Peer kmsd URL", "Esc cancel"} { + if !strings.Contains(s, label) { + t.Fatalf("%dx%d verify form lost %q\n%s", size[0], size[1], label, s) + } + } + h.send(tui.KeyEvent(tui.KeyEsc), tui.RuneEvent('2'), tui.RuneEvent('n')) + s = h.wait("Generate key") + if !strings.Contains(s, "[x] export") { + t.Fatalf("%dx%d usage flags cut\n%s", size[0], size[1], s) + } + h.send(tui.KeyEvent(tui.KeyEsc)) + } +} + +func TestKoreanCatalogIsComplete(t *testing.T) { + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + if err != nil { + t.Fatal(err) + } + keys := map[string]bool{} + for _, name := range tabNames { + keys[name] = true + } + for _, name := range files { + if strings.HasSuffix(name, "_test.go") { + continue + } + f, err := parser.ParseFile(fset, name, nil, 0) + if err != nil { + t.Fatal(err) + } + ast.Inspect(f, func(n ast.Node) bool { + call, ok := n.(*ast.CallExpr) + if !ok || len(call.Args) == 0 { + return true + } + sel, ok := call.Fun.(*ast.SelectorExpr) + if !ok { + return true + } + switch sel.Sel.Name { + case "t", "tf", "kv", "dkv": + default: + return true + } + lit, ok := call.Args[0].(*ast.BasicLit) + if !ok || lit.Kind != token.STRING { + return true + } + v, err := strconv.Unquote(lit.Value) + if err != nil { + t.Fatal(err) + } + keys[v] = true + return true + }) + } + if len(keys) < 200 { + t.Fatalf("only %d translatable strings found, the scan is broken", len(keys)) + } + verbs := regexp.MustCompile(`%(\[\d+\])?[a-zA-Z]`) + for k := range keys { + ko, ok := korean[k] + if !ok { + t.Errorf("no Korean text for %q", k) + continue + } + if len(verbs.FindAllString(k, -1)) != len(verbs.FindAllString(ko, -1)) { + t.Errorf("format verbs differ: %q -> %q", k, ko) + } + } + for k := range korean { + if !keys[k] { + t.Errorf("unused Korean text for %q", k) + } + } +} + +func TestLanguageSelection(t *testing.T) { + for _, c := range []struct { + choice, all, messages, lang, want string + }{ + {"auto", "ko_KR.UTF-8", "", "en_US.UTF-8", LangKorean}, + {"auto", "", "ko_KR.UTF-8", "", LangKorean}, + {"auto", "", "", "ko_KR.eucKR", LangKorean}, + {"auto", "C", "", "ko_KR.UTF-8", LangEnglish}, + {"auto", "", "", "en_US.UTF-8", LangEnglish}, + {"", "", "", "ko", LangKorean}, + {"en", "ko_KR.UTF-8", "", "", LangEnglish}, + {"ko", "", "", "en_US.UTF-8", LangKorean}, + } { + t.Setenv("LC_ALL", c.all) + t.Setenv("LC_MESSAGES", c.messages) + t.Setenv("LANG", c.lang) + if got, err := Language(c.choice); err != nil || got != c.want { + t.Errorf("%+v: got %q %v", c, got, err) + } + } + if _, err := Language("fr"); err == nil { + t.Fatal("unknown language accepted") + } +} + +func TestKoreanUI(t *testing.T) { + bin := coreBin(t) + base := t.TempDir() + h := launch(t, Options{Node: nodeOpts(bin), Dir: filepath.Join(base, "gina"), Lang: LangKorean}) + h.wait("노드 초기화") + h.enter() + h.typ("gina") + h.enter() + h.enter() + h.wait("노드를 초기화했습니다") + h.enter() + h.wait("1 노드") + for _, size := range [][2]int{{80, 24}, {64, 18}} { + h.send(tui.ResizeEvent(size[0], size[1])) + for tab := '1'; tab <= '6'; tab++ { + h.send(tui.RuneEvent(tab)) + lines := strings.Split(h.text(), "\n") + if !strings.Contains(lines[1], "6 로그") || !strings.HasSuffix(lines[size[1]-2], "? 도움말 q 종료") { + t.Fatalf("%dx%d tab %c\n%s", size[0], size[1], tab, h.text()) + } + } + } + h.send(tui.ResizeEvent(100, 30), tui.RuneEvent('2'), tui.RuneEvent('ㅜ')) + h.wait("키 생성") + if !strings.Contains(h.text(), "[x] export") || !strings.Contains(h.text(), "Esc 취소") { + t.Fatalf("Korean form\n%s", h.text()) + } + h.typ("한글 키") + h.enter() + h.enter() + h.wait("한글 키") + h.idle() + h.send(tui.RuneEvent('?')) + h.wait("도움말") + for i := 0; i < 40; i++ { + h.send(tui.KeyEvent(tui.KeyDown)) + } + h.wait("한글 입력 상태에서도") + h.send(tui.RuneEvent('ㅂ')) + h.wait("1 노드") + select { + case h.term.events <- tui.RuneEvent('ㅂ'): + case <-time.After(5 * time.Second): + t.Fatal("ui stopped reading input") + } + select { + case err := <-h.done: + h.done <- err + case <-time.After(5 * time.Second): + t.Fatalf("q typed with the Korean input method did not quit\n%s", h.text()) + } +} diff --git a/host/internal/console/lang.go b/host/internal/console/lang.go new file mode 100644 index 0000000..ae8a40c --- /dev/null +++ b/host/internal/console/lang.go @@ -0,0 +1,357 @@ +package console + +import ( + "fmt" + "os" + "strings" + + "github.com/Quant-Off/pairier/host/internal/tui" +) + +const ( + LangEnglish = "en" + LangKorean = "ko" + labelWidth = 13 + detailWidth = 10 +) + +func Language(choice string) (string, error) { + switch choice { + case LangEnglish, LangKorean: + return choice, nil + case "", "auto": + default: + return "", fmt.Errorf("unknown language %q, use auto, en or ko", choice) + } + for _, name := range []string{"LC_ALL", "LC_MESSAGES", "LANG"} { + if v := os.Getenv(name); v != "" { + if strings.HasPrefix(strings.ToLower(v), "ko") { + return LangKorean, nil + } + return LangEnglish, nil + } + } + if systemKorean() { + return LangKorean, nil + } + return LangEnglish, nil +} + +func (a *app) t(s string) string { + if v, ok := a.catalog[s]; ok { + return v + } + return s +} + +func (a *app) tf(format string, args ...any) string { + return fmt.Sprintf(a.t(format), args...) +} + +func pad(s string, w int) string { + return s + strings.Repeat(" ", max(w-tui.StringWidth(s), 1)) +} + +func (a *app) kv(label, value string) string { return pad(a.t(label), labelWidth) + value } + +func (a *app) dkv(label, value string) string { return pad(a.t(label), detailWidth) + value } + +func (a *app) fpLines(fp string) []string { + label := pad(a.t("fingerprint"), labelWidth) + indent := strings.Repeat(" ", tui.StringWidth(label)) + var out []string + for i, part := range splitFingerprint(fp) { + if i == 0 { + out = append(out, label+part) + } else { + out = append(out, indent+part) + } + } + return out +} + +var koreanTexts = tui.Texts{ + FormHint: " Tab 이동 Space 선택 Enter 다음 Esc 취소 ", + Close: " Enter/Esc 닫기 ", + Confirm: " y 확인 n/Esc 취소 ", + ConfirmTyped: " Enter 확인 Esc 취소 ", + More: " 위/아래 더 보기 ", + Yes: "[x] 예", + No: "[ ] 아니요", + None: "(없음)", + Mismatch: "입력한 내용이 일치하지 않습니다", + Type: "%s 입력: ", +} + +var korean = map[string]string{ + "Node": "노드", + "Keys": "키", + "Members": "구성원", + "Inbox": "수신함", + "Audit": "감사", + "Log": "로그", + + "busy with %s": "%s 진행 중", + "%s cancelled": "%s 취소됨", + "%s failed: %s": "%s 실패: %s", + "%s failed": "%s 실패", + "node closed after %s without input": "입력 없이 %s이 지나 노드를 닫음", + "node closed after inactivity": "입력이 없어 노드를 닫았습니다", + "terminal too small (%dx%d), need %dx%d": "터미널이 너무 작습니다 (%dx%d), %dx%d 이상 필요", + "resize the window or press Ctrl+C to quit": "창을 키우거나 Ctrl+C로 끝내세요", + "opening %s ...": "%s 여는 중 ...", + "The node was closed after %s without input.": "입력 없이 %s이 지나 노드를 닫았습니다.", + "The core process has exited and its key material is gone from memory.": "코어 프로세스가 끝났고 키 자료는 메모리에서 지워졌습니다.", + "Enter reopen q quit": "Enter 다시 열기 q 종료", + "member": "구성원", + "[offline]": "[오프라인]", + "? help q quit ": "? 도움말 q 종료 ", + " Tab/1-6 tabs / filter Ctrl+R refresh": " Tab/1-6 탭 / 필터 Ctrl+R 새로 고침", + " ... (Esc cancels)": " ... (Esc 취소)", + " o open a node directory n initialize a new node q quit": " o 노드 디렉토리 열기 n 새 노드 초기화 q 종료", + " Enter reopen q quit": " Enter 다시 열기 q 종료", + " Esc cancel q quit": " Esc 취소 q 종료", + " c export card R renew card": " c 카드 내보내기 R 카드 갱신", + " n new s send": " n 생성 s 보내기", + " p push": " p push", + " r receive e/d encrypt/decrypt Enter info": " r 받기 e/d 암호화/복호화 Enter 정보", + " a add w witness heads": " a 추가 w 증인 head", + " h health": " h health", + " Enter accept x reject i import file": " Enter 수락 x 거절 i 파일 가져오기", + " v verify": " v 검증", + " Up/Down scroll": " 위/아래 스크롤", + "No node is open.": "열린 노드가 없습니다.", + "o open an existing node directory": "o 기존 노드 디렉토리 열기", + "n initialize a new node": "n 새 노드 초기화", + "q quit": "q 종료", + "Every action runs through the same node code as the kmsctl commands": "모든 동작은 kmsctl 명령과 같은 노드 코드로 실행되며", + "and is written to the node audit log.": "노드 감사 로그에 기록됩니다.", + + "KEY ID": "키 ID", + "ALG": "알고리즘", + "USAGE": "용도", + "LABEL": "라벨", + "FROM": "출처", + "local": "로컬", + "MEMBER": "구성원", + "IDENTITY": "신원", + "KEM": "KEM", + "FINGERPRINT": "지문", + "error": "오류", + "ENVELOPE": "봉투", + "SENT": "보낸 시각", + "RECEIVED": "받은 시각", + "SEQ": "순번", + "TIME": "시각", + "EVENT": "이벤트", + "FIELDS": "필드", + "SESSION LOG (memory only)": "세션 로그 (메모리에만 보관)", + "(empty)": "(비어 있음)", + "(nothing matches the filter %s, Esc clears it)": "(필터 %s에 맞는 항목이 없습니다, Esc로 지우기)", + "filter: %s": "필터: %s", + "generated on this node": "이 노드에서 생성", + "from %s sent %s": "%s에게서, 보낸 시각 %s", + "id": "id", + "label": "라벨", + "usage": "용도", + "created": "생성", + "origin": "출처", + "fingerprint": "지문", + "witnessed audit heads %d": "증인으로 본 감사 head %d개", + ", latest %s": ", 최근 %s", + "warning the card uses a retired kem, ask the member to run card renew": "경고 카드가 폐기된 KEM을 씁니다. 구성원에게 card renew를 요청하세요", + "from": "보낸 이", + "not a registered member": "등록되지 않은 구성원", + "envelope": "봉투", + "sent": "보낸 시각", + "received": "받은 시각", + "Enter verifies and imports the key, x deletes the envelope": "Enter는 검증 후 키를 가져오고, x는 봉투를 지웁니다", + "Member": "구성원", + "Directory": "디렉토리", + "Fingerprint": "지문", + "Identity": "신원", + " retired, press R to renew the card": " 폐기됨, R로 카드를 갱신하세요", + "held in the core": "코어 안에 보관", + "stored outside the core, press R to renew the card": "코어 밖에 저장됨, R로 카드를 갱신하세요", + "TLS key": "TLS 키", + "Core": "코어", + "Host": "호스트", + "Audit log": "감사 로그", + "Store": "저장소", + "%d keys, %d members, %d pending envelopes": "키 %d개, 구성원 %d명, 대기 봉투 %d개", + "network actions enabled (push, health, peer audit), each needs an https URL": "네트워크 동작 사용(push, health, 상대 노드 감사), 각각 https URL 필요", + "offline, actions that contact other nodes are hidden": "오프라인, 다른 노드에 접속하는 동작은 숨김", + "Mode": "모드", + "Idle close": "유휴 종료", + "Not verified in this session. Press v to verify the chain, anchors and witnessed heads.": "이 세션에서 아직 검증하지 않았습니다. v를 눌러 체인, anchor, 증인 head를 검증하세요.", + "Verification FAILED at %s": "%s 검증 실패", + ", heads witnessed by %s": ", %s의 증인 head 포함", + "Verified %d entries against %d anchors%s at %s": "%[4]s 검증 완료, 항목 %[1]d개, anchor %[2]d개%[3]s", + "head": "head", + "reading the log failed: %s": "로그 읽기 실패: %s", + "seq %d %s %s": "순번 %d %s %s", + "Quit": "종료", + "%s is still running. Quit anyway? The operation is cancelled.": "%s 작업이 아직 진행 중입니다. 그래도 끝낼까요? 작업은 취소됩니다.", + "Tab, Shift+Tab or 1-6 switch tabs. Up/Down or j/k move, PgUp/PgDn and Home/End jump.": "Tab, Shift+Tab, 1-6으로 탭을 바꿉니다. 위/아래나 j/k로 이동하고, PgUp/PgDn과 Home/End로 건너뜁니다.", + "/ filters the list, Esc clears the filter or cancels a running action, Ctrl+R refreshes, Ctrl+L redraws, q or Ctrl+C quits.": "/는 목록을 거르고, Esc는 필터를 지우거나 실행 중인 동작을 취소하며, Ctrl+R은 새로 고침, Ctrl+L은 다시 그리기, q나 Ctrl+C는 종료입니다.", + "Node c export card (card) R renew card (card renew)": "노드 c 카드 내보내기 (card) R 카드 갱신 (card renew)", + "Keys Enter info (key info) n new (key gen) s send to file (key send) r receive file (key receive)": "키 Enter 정보 (key info) n 생성 (key gen) s 파일로 보내기 (key send) r 파일 받기 (key receive)", + " e encrypt file (encrypt) d decrypt file (decrypt) p push to kmsd (key push)": " e 파일 암호화 (encrypt) d 파일 복호화 (decrypt) p kmsd로 push (key push)", + "Members a add card (member add) w export witnessed heads (member witness) h health (peer health)": "구성원 a 카드 추가 (member add) w 증인 head 내보내기 (member witness) h health (peer health)", + "Inbox Enter accept (inbox accept) x reject (inbox reject) i import envelope file (key receive)": "수신함 Enter 수락 (inbox accept) x 거절 (inbox reject) i 봉투 파일 가져오기 (key receive)", + "Audit v verify with anchors, an anchor file or a peer (audit verify)": "감사 v anchor, anchor 파일, 상대 노드로 검증 (audit verify)", + "Fingerprints are never filled in for you, type them from the other channel.": "지문은 대신 채워 주지 않습니다. 다른 채널로 받은 지문을 직접 입력하세요.", + "Decrypted data only goes to new files created for your user. Nothing is copied to the clipboard.": "복호화한 데이터는 본인만 읽을 수 있는 새 파일에만 씁니다. 클립보드에는 아무것도 복사하지 않습니다.", + "Offline mode hides push, health and peer audit.": "오프라인 모드에서는 push, health, 상대 노드 감사를 숨깁니다.", + "Shortcuts also work while the Korean input method is on.": "한글 입력 상태에서도 단축키가 동작합니다.", + "Help": "도움말", + + "an input file is required": "입력 파일이 필요합니다", + "%s is not a regular file": "%s은(는) 일반 파일이 아닙니다", + "%s exceeds %d bytes": "%s이(가) %d바이트를 넘습니다", + "an output file is required": "출력 파일이 필요합니다", + "%s already exists, choose another name": "%s이(가) 이미 있습니다. 다른 이름을 고르세요", + "the url must use https": "URL은 https를 써야 합니다", + "the url must look like https://HOST:PORT": "URL은 https://HOST:PORT 형식이어야 합니다", + "choose at least one usage": "용도를 하나 이상 고르세요", + "opened %s as %s": "%s을(를) %s(으)로 열었습니다", + "open node": "노드 열기", + "Open node": "노드 열기", + "Enter the node directory. If it does not exist yet you can initialize it next.": "노드 디렉토리를 입력하세요. 아직 없으면 이어서 초기화할 수 있습니다.", + "a directory is required": "디렉토리가 필요합니다", + "Member ID": "구성원 ID", + "Post-quantum": "양자 내성", + "lowercase letters, digits, . _ -, the name members know you by": "소문자, 숫자, . _ -, 다른 구성원이 알아보는 이름", + "ML-DSA identity and ML-KEM exchange, needs a core built with pqc": "ML-DSA 신원과 ML-KEM 교환, pqc로 빌드한 코어가 필요합니다", + "Creates the directory for your user only, a root key and the node identity (kmsctl init).": "본인만 쓸 수 있는 디렉토리와 루트 키, 노드 신원을 만듭니다 (kmsctl init).", + "Initialize node": "노드 초기화", + "invalid member id": "잘못된 구성원 id입니다", + "initialize node": "노드 초기화", + "identity": "신원", + "kem": "KEM", + "core_fips": "core_fips", + "Export your card with c and give the card and this fingerprint to each member over separate channels.": "c로 카드를 내보내고, 카드와 이 지문을 각 구성원에게 서로 다른 채널로 전달하세요.", + "Node initialized": "노드를 초기화했습니다", + "Filter %s": "%s 필터", + "Contains": "포함 문자열", + "Export card": "카드 내보내기", + "Output file": "출력 파일", + "export card": "카드 내보내기", + "card written to %s": "카드를 %s에 썼습니다", + "file": "파일", + "Send the card file and read the fingerprint to the member over a different channel.": "카드 파일을 보내고, 지문은 다른 채널로 구성원에게 읽어 주세요.", + "Card exported": "카드를 내보냈습니다", + "Renewing replaces the node KEM key, moves the TLS key into the core and signs a new card.": "갱신하면 노드 KEM 키를 바꾸고, TLS 키를 코어 안으로 옮기고, 새 카드에 서명합니다.", + "Every member has to add the new card with its new fingerprint, and kmsd must be restarted.": "모든 구성원이 새 카드를 새 지문으로 다시 추가해야 하고, kmsd를 다시 시작해야 합니다.", + "Renew card": "카드 갱신", + "renew card": "카드 갱신", + "card renewed, new fingerprint %s": "카드를 갱신했습니다, 새 지문 %s", + "New fingerprint %s": "새 지문 %s", + "Send the new card to every member and restart kmsd. Esc skips, c exports the card later.": "새 카드를 모든 구성원에게 보내고 kmsd를 다시 시작하세요. Esc로 건너뛰면 나중에 c로 내보낼 수 있습니다.", + "Label": "라벨", + "Usage": "용도", + "export is needed to send the key to members": "구성원에게 보내려면 export가 필요합니다", + "Generate key": "키 생성", + "Creates an AES-256-GCM key inside the core (key gen).": "코어 안에서 AES-256-GCM 키를 만듭니다 (key gen).", + "generate key": "키 생성", + "generated %s %s": "생성했습니다 %s %s", + "alg": "알고리즘", + "%s sent %s": "%s 보낸 시각 %s", + "key info": "키 정보", + "Key": "키", + "The stored metadata matches what the core reports for this key.": "저장된 메타데이터가 코어가 이 키에 대해 알려 주는 값과 일치합니다.", + "No members": "구성원 없음", + "Add the recipient on the Members tab first.": "먼저 구성원 탭에서 받는 이를 추가하세요.", + "Recipient": "받는 이", + "Grant": "부여 용도", + "Left/Right picks a registered member": "Left/Right로 등록된 구성원을 고릅니다", + "only a subset of this key's usage can be granted": "이 키 용도의 일부만 부여할 수 있습니다", + "Send key to file": "파일로 키 보내기", + "send key": "키 보내기", + "Seals the key for one member into an envelope file (key send).": "한 구성원만 열 수 있게 키를 봉투 파일로 봉인합니다 (key send).", + "kmsd URL": "kmsd URL", + "Push key": "키 push", + "push key": "키 push", + "Seals the key and delivers it to the member's kmsd over mutual TLS (key push).": "키를 봉인해 상호 TLS로 구성원의 kmsd에 전달합니다 (key push).", + "unknown": "알 수 없음", + "key": "키", + "recipient": "받는 이", + "grant": "부여 용도", + "kmsd": "kmsd", + "The recipient can use the key with this usage from now on. Continue?": "이제부터 받는 이가 이 용도로 키를 쓸 수 있습니다. 계속할까요?", + "sent %s to %s in %s": "%[1]s을(를) %[2]s에게 보냈습니다, 파일 %[3]s", + "Envelope written": "봉투를 썼습니다", + "Deliver it to %s, who imports it with r on the Keys tab or key receive.": "%s에게 전달하세요. 받는 쪽은 키 탭의 r이나 key receive로 가져옵니다.", + "pushed %s to %s, envelope %s": "%[1]s을(를) %[2]s에게 push했습니다, 봉투 %[3]s", + "Key pushed": "키를 push했습니다", + "%s accepts it from the Inbox tab or with inbox accept.": "%s이(가) 수신함 탭이나 inbox accept로 수락합니다.", + "Decrypt file": "파일 복호화", + "empty means the input name without .enc, or with .dec": "비우면 입력 이름에서 .enc를 빼거나 .dec를 붙입니다", + "decrypt": "복호화", + "The plaintext is written only to a new file that only your user can read. It is never shown.": "평문은 본인만 읽을 수 있는 새 파일에만 쓰고 화면에는 보여 주지 않습니다.", + "Encrypt file": "파일 암호화", + "empty means the input name with .enc": "비우면 입력 이름에 .enc를 붙입니다", + "encrypt": "암호화", + "Encrypts up to 1 MiB with AES-256-GCM inside the core.": "코어 안에서 1 MiB까지 AES-256-GCM으로 암호화합니다.", + "Input file": "입력 파일", + "AAD": "AAD", + "associated data, must be the same for encrypt and decrypt": "연관 데이터, 암호화와 복호화에서 같아야 합니다", + "%s with %s": "%s (%s)", + "wrote %d bytes to %s": "%[2]s에 %[1]d바이트를 썼습니다", + "Envelope file": "봉투 파일", + "Imports a key sent to this node after checking the signature, recipient and context (key receive).": "서명, 받는 이, 문맥을 확인한 뒤 이 노드로 보낸 키를 가져옵니다 (key receive).", + "Receive key": "키 받기", + "receive key": "키 받기", + "received %s from %s": "%[2]s에게서 %[1]s을(를) 받았습니다", + "Key received": "키를 받았습니다", + "Card file": "카드 파일", + "as the member read it to you, never copied from the card file": "구성원이 읽어 준 그대로, 카드 파일에서 복사하지 마세요", + "Registers or updates a member (member add). Type or paste the fingerprint you got": "구성원을 등록하거나 갱신합니다 (member add). 직접 만나거나 전화처럼 별도 채널로", + "over a separate channel, in person or by phone. It must match the card exactly.": "받은 지문을 입력하거나 붙여 넣으세요. 카드와 정확히 일치해야 합니다.", + "Add member": "구성원 추가", + "the fingerprint is required": "지문이 필요합니다", + "add member": "구성원 추가", + "Member added": "구성원을 추가했습니다", + "added member %s": "구성원 %s을(를) 추가했습니다", + "Member updated": "구성원을 갱신했습니다", + "updated member %s": "구성원 %s을(를) 갱신했습니다", + "Export witnessed heads of %s": "%s의 증인 head 내보내기", + "Writes the audit heads this node saw from the member, one SEQ:HASH per line (member witness).": "이 노드가 그 구성원에게서 본 감사 head를 한 줄에 하나씩 SEQ:HASH로 씁니다 (member witness).", + "export witnessed heads": "증인 head 내보내기", + "wrote %d witnessed heads for %s to %s": "%[2]s의 증인 head %[1]d개를 %[3]s에 썼습니다", + "Witnessed heads": "증인 head", + "%d heads written to %s": "head %d개를 %s에 썼습니다", + "The member verifies its log with them on the Audit tab or audit verify --anchor-file.": "그 구성원은 감사 탭이나 audit verify --anchor-file로 자기 로그를 검증합니다.", + "Health of %s": "%s health 확인", + "Connects to the member's kmsd with mutual TLS pinned to its card (peer health).": "카드에 고정한 상호 TLS로 구성원의 kmsd에 접속합니다 (peer health).", + "peer health": "peer health", + "health ok %s at %s": "health 정상 %s (%s)", + "not a registered member, accepting will fail": "등록되지 않은 구성원이라 수락에 실패합니다", + "Accept envelope": "봉투 수락", + "The key is imported only if the signature, recipient and context verify. Accept?": "서명, 받는 이, 문맥이 모두 검증될 때만 키를 가져옵니다. 수락할까요?", + "accept envelope": "봉투 수락", + "accepted %s, key %s": "%s을(를) 수락했습니다, 키 %s", + "Key imported": "키를 가져왔습니다", + "Reject envelope": "봉투 거절", + "The envelope is deleted. The sender has to send it again. Reject?": "봉투를 지웁니다. 보낸 이가 다시 보내야 합니다. 거절할까요?", + "reject envelope": "봉투 거절", + "rejected %s": "%s을(를) 거절했습니다", + "Anchors": "anchor", + "Anchor file": "anchor 파일", + "SEQ:HASH heads recorded out of band, separated by spaces": "별도로 기록한 SEQ:HASH head, 공백으로 구분", + "one SEQ:HASH per line, for example a member witness file": "한 줄에 SEQ:HASH 하나, 예를 들어 구성원 증인 파일", + "(none)": "(없음)", + "Peer": "상대 노드", + "Peer kmsd URL": "상대 kmsd URL", + "a member whose kmsd returns the heads it witnessed": "자기가 증인으로 본 head를 돌려주는 kmsd의 구성원", + "Replays the hash chain and checkpoint signatures and checks every anchor (audit verify).": "해시 체인과 체크포인트 서명을 다시 계산하고 모든 anchor를 확인합니다 (audit verify).", + "Verify audit log": "감사 로그 검증", + "verify audit log": "감사 로그 검증", + "audit verification failed": "감사 로그 검증 실패", + "Audit verification failed": "감사 로그 검증 실패", + "audit verified %d entries, head %s": "감사 로그 항목 %d개 검증, head %s", + "Audit log verified": "감사 로그를 검증했습니다", + "entries": "항목", + "anchors": "anchor", + "Record the head somewhere the node cannot change to catch a later rollback.": "나중의 롤백을 잡아내려면 이 head를 노드가 바꿀 수 없는 곳에 기록하세요.", +} diff --git a/host/internal/console/lang_other.go b/host/internal/console/lang_other.go new file mode 100644 index 0000000..2bd1d45 --- /dev/null +++ b/host/internal/console/lang_other.go @@ -0,0 +1,5 @@ +//go:build !windows + +package console + +func systemKorean() bool { return false } diff --git a/host/internal/console/lang_windows.go b/host/internal/console/lang_windows.go new file mode 100644 index 0000000..1cefffd --- /dev/null +++ b/host/internal/console/lang_windows.go @@ -0,0 +1,7 @@ +//go:build windows + +package console + +import "github.com/Quant-Off/pairier/host/internal/winsys" + +func systemKorean() bool { return winsys.UserUILanguage()&0x3ff == 0x12 } diff --git a/host/internal/console/logbuf.go b/host/internal/console/logbuf.go new file mode 100644 index 0000000..59d01c6 --- /dev/null +++ b/host/internal/console/logbuf.go @@ -0,0 +1,60 @@ +package console + +import ( + "bytes" + "strings" + "sync" + "time" + + "github.com/Quant-Off/pairier/host/internal/tui" +) + +const maxPartial = 4096 + +type logBuffer struct { + mu sync.Mutex + lines []string + max int + part []byte +} + +func newLogBuffer(max int) *logBuffer { return &logBuffer{max: max} } + +func (l *logBuffer) Write(p []byte) (int, error) { + l.mu.Lock() + defer l.mu.Unlock() + l.part = append(l.part, p...) + for { + i := bytes.IndexByte(l.part, '\n') + if i < 0 { + break + } + l.push("core: " + string(l.part[:i])) + l.part = l.part[i+1:] + } + if len(l.part) > maxPartial { + l.push("core: " + string(l.part)) + l.part = nil + } + return len(p), nil +} + +func (l *logBuffer) add(s string) { + l.mu.Lock() + defer l.mu.Unlock() + l.push(s) +} + +func (l *logBuffer) push(s string) { + s = tui.Clean(strings.TrimRight(s, "\r")) + l.lines = append(l.lines, time.Now().Format("15:04:05 ")+s) + if len(l.lines) > l.max { + l.lines = append(l.lines[:0], l.lines[len(l.lines)-l.max:]...) + } +} + +func (l *logBuffer) snapshot() []string { + l.mu.Lock() + defer l.mu.Unlock() + return append([]string(nil), l.lines...) +} diff --git a/host/internal/console/views.go b/host/internal/console/views.go new file mode 100644 index 0000000..ba29c11 --- /dev/null +++ b/host/internal/console/views.go @@ -0,0 +1,658 @@ +package console + +import ( + "context" + "errors" + "fmt" + "runtime" + "slices" + "sort" + "strings" + "time" + + "crypto/fips140" + + "github.com/Quant-Off/pairier/host/internal/audit" + "github.com/Quant-Off/pairier/host/internal/exchange" + "github.com/Quant-Off/pairier/host/internal/node" + "github.com/Quant-Off/pairier/host/internal/store" + "github.com/Quant-Off/pairier/host/internal/tui" + "github.com/Quant-Off/pairier/host/internal/wire" +) + +const ( + maxEntries = 1000 + detailLines = 4 + auditTop = 6 +) + +type nodeInfo struct { + member string + fingerprint string + identityAlg uint16 + kemAlg uint16 + retiredKEM bool + legacyTLS bool + coreFIPS bool + pqc bool + engine string + auditPath string +} + +type memberRow struct { + id string + fingerprint string + identityAlg uint16 + kemAlg uint16 + retired bool + heads []audit.Anchor + err string +} + +type snapshot struct { + keys []*store.KeyRecord + members []memberRow + inbox []node.InboxItem + entries []audit.Entry + auditErr string + audited bool +} + +type verifyResult struct { + err string + count uint64 + head audit.Anchor + anchors int + peer string + at time.Time +} + +type column struct { + name string + width int +} + +type row struct { + id string + cols []string + st tui.Style +} + +func loadInfo(ctx context.Context, n *node.Node) (nodeInfo, error) { + card, _, err := n.Card(ctx) + if err != nil { + return nodeInfo{}, err + } + fp, err := card.Fingerprint() + if err != nil { + return nodeInfo{}, err + } + _, terr := n.TLSCertificate() + c := n.Core() + return nodeInfo{ + member: n.MemberID(), + fingerprint: fp, + identityAlg: card.IdentityAlg, + kemAlg: card.KemAlg, + retiredKEM: exchange.IsRetiredKemAlg(card.KemAlg), + legacyTLS: errors.Is(terr, node.ErrLegacyTLS), + coreFIPS: n.FIPS(), + pqc: n.PQC(), + engine: strings.TrimSpace(c.EngineName() + " " + c.EngineVersion()), + auditPath: n.AuditLogPath(), + }, nil +} + +func loadSnapshot(ctx context.Context, n *node.Node, withAudit bool) (snapshot, error) { + var s snapshot + var err error + if s.keys, err = n.Keys(); err != nil { + return s, err + } + recs, err := n.Members() + if err != nil { + return s, err + } + for _, m := range recs { + r := memberRow{id: m.MemberID, fingerprint: m.Fingerprint} + if card, err := n.Member(ctx, m.MemberID); err != nil { + r.err = err.Error() + } else { + r.identityAlg, r.kemAlg = card.IdentityAlg, card.KemAlg + r.retired = exchange.IsRetiredKemAlg(card.KemAlg) + } + if heads, err := n.Witnessed(m.MemberID); err == nil { + r.heads = heads + } + s.members = append(s.members, r) + } + if s.inbox, err = n.Inbox(); err != nil { + return s, err + } + sort.SliceStable(s.inbox, func(i, j int) bool { return s.inbox[i].ReceivedAt < s.inbox[j].ReceivedAt }) + if withAudit { + s.audited = true + entries, err := audit.Read(n.AuditLogPath()) + if err != nil { + s.auditErr = err.Error() + } else { + if len(entries) > maxEntries { + entries = entries[len(entries)-maxEntries:] + } + s.entries = entries + } + } + return s, nil +} + +func (a *app) refresh() { + withAudit := a.tab == tabAudit || a.data.audited + a.refreshed = a.opts.now() + n := a.node + if n == nil { + return + } + a.spawn("refresh", true, func(ctx context.Context, res *result) { + snap, err := loadSnapshot(ctx, n, withAudit) + if err != nil { + res.err = err + return + } + res.apply = func(a *app) { a.data = snap } + }) +} + +func stamp(sec int64) string { + if sec == 0 { + return "-" + } + return time.Unix(sec, 0).UTC().Format(time.RFC3339) +} + +func internalKey(k *store.KeyRecord) bool { + for _, p := range []string{"identity/", "kem/", "audit/", "tls/"} { + if strings.HasPrefix(k.Label, p) && k.Origin == nil { + return true + } + } + return false +} + +func (a *app) memberRecord(id string) *memberRow { + for i := range a.data.members { + if a.data.members[i].id == id { + return &a.data.members[i] + } + } + return nil +} + +func (a *app) memberIDs() []string { + var out []string + for _, m := range a.data.members { + out = append(out, m.id) + } + return out +} + +func (a *app) table(tab int) ([]column, []row) { + var cols []column + var rows []row + switch tab { + case tabKeys: + cols = []column{{a.t("KEY ID"), 16}, {a.t("ALG"), 17}, {a.t("USAGE"), 0}, {a.t("LABEL"), 0}, {a.t("FROM"), 12}} + keys := slices.Clone(a.data.keys) + slices.SortStableFunc(keys, func(x, y *store.KeyRecord) int { + switch ix, iy := internalKey(x), internalKey(y); { + case ix == iy: + return 0 + case iy: + return -1 + } + return 1 + }) + for _, k := range keys { + origin := a.t("local") + if k.Origin != nil { + origin = k.Origin.Sender + } + st := plain + if internalKey(k) { + st = dim + } + rows = append(rows, row{id: k.KeyID, cols: []string{k.KeyID[:min(16, len(k.KeyID))], wire.AlgName(k.Alg), wire.FormatUsage(k.Usage), k.Label, origin}, st: st}) + } + case tabMembers: + cols = []column{{a.t("MEMBER"), 16}, {a.t("IDENTITY"), 17}, {a.t("KEM"), 22}, {a.t("FINGERPRINT"), 0}} + for _, m := range a.data.members { + st := plain + ident, kem := wire.AlgName(m.identityAlg), wire.AlgName(m.kemAlg) + if m.err != "" { + st, ident, kem = bad, a.t("error"), a.t("error") + } else if m.retired { + st = warn + } + rows = append(rows, row{id: m.id, cols: []string{m.id, ident, kem, m.fingerprint}, st: st}) + } + case tabInbox: + cols = []column{{a.t("ENVELOPE"), 16}, {a.t("FROM"), 16}, {a.t("SENT"), 20}, {a.t("RECEIVED"), 0}} + for _, it := range a.data.inbox { + st := plain + if a.memberRecord(it.Sender) == nil { + st = warn + } + rows = append(rows, row{id: it.ID, cols: []string{it.ID[:min(16, len(it.ID))], it.Sender, stamp(it.SentAt), stamp(it.ReceivedAt)}, st: st}) + } + case tabAudit: + cols = []column{{a.t("SEQ"), 7}, {a.t("TIME"), 20}, {a.t("EVENT"), 18}, {a.t("FIELDS"), 0}} + for i := len(a.data.entries) - 1; i >= 0; i-- { + e := a.data.entries[i] + st := plain + if _, failed := e.Fields["error"]; failed || strings.HasSuffix(e.Event, ".conflict") { + st = warn + } + rows = append(rows, row{id: fmt.Sprint(e.Seq), cols: []string{fmt.Sprint(e.Seq), stamp(e.Time), e.Event, fieldText(e.Fields)}, st: st}) + } + case tabLog: + cols = []column{{a.t("SESSION LOG (memory only)"), 0}} + lines := a.logs.snapshot() + for i, l := range lines { + rows = append(rows, row{id: fmt.Sprint(i), cols: []string{l}, st: plain}) + } + } + if f := strings.ToLower(a.filter[tab]); f != "" { + kept := rows[:0] + for _, r := range rows { + if strings.Contains(strings.ToLower(strings.Join(r.cols, " ")), f) { + kept = append(kept, r) + } + } + rows = kept + } + return cols, rows +} + +func fieldText(fields map[string]string) string { + keys := make([]string, 0, len(fields)) + for k := range fields { + keys = append(keys, k) + } + slices.Sort(keys) + parts := make([]string, 0, len(keys)) + for _, k := range keys { + parts = append(parts, k+"="+fields[k]) + } + return strings.Join(parts, " ") +} + +func (a *app) listTop(tab int) int { + if tab == tabAudit { + return auditTop + } + return 2 +} + +func (a *app) listRows(tab int) int { + bottom := a.screen.H - 3 - detailLines - 1 + if tab == tabLog { + bottom = a.screen.H - 3 + } + return max(bottom-a.listTop(tab), 1) +} + +func (a *app) selection(tab int, rows []row) int { + l := &a.lists[tab] + if id := a.selID[tab]; id != "" { + for i, r := range rows { + if r.id == id { + l.Sel = i + break + } + } + } + l.Clamp(len(rows), a.listRows(tab)) + if len(rows) == 0 { + return -1 + } + return l.Sel +} + +func layout(cols []column, total int) []int { + widths := make([]int, len(cols)) + fixed, flex := 0, 0 + for i, c := range cols { + widths[i] = c.width + fixed += c.width + 1 + if c.width == 0 { + flex++ + } + } + if flex > 0 { + each := max((total-fixed)/flex, 6) + for i := range widths { + if widths[i] == 0 { + widths[i] = each + } + } + } + return widths +} + +func (a *app) drawTable(tab int) int { + s := a.screen + cols, rows := a.table(tab) + top := a.listTop(tab) + height := a.listRows(tab) + widths := layout(cols, s.W-1) + x := 1 + for i, c := range cols { + s.Field(x, top, widths[i], c.name, heading) + x += widths[i] + 1 + } + sel := a.selection(tab, rows) + l := a.lists[tab] + for i := 0; i < height && l.Off+i < len(rows); i++ { + r := rows[l.Off+i] + st := r.st + y := top + 1 + i + if l.Off+i == sel { + st = selected + s.Fill(0, y, s.W, 1, selected) + s.Put(0, y, ">", selected) + } + x := 1 + for j := range cols { + s.Field(x, y, widths[j], r.cols[j], st) + x += widths[j] + 1 + } + } + if len(rows) == 0 { + msg := a.t("(empty)") + if a.filter[tab] != "" { + msg = a.tf("(nothing matches the filter %s, Esc clears it)", a.filter[tab]) + } + s.Put(2, top+1, msg, dim) + } else if a.filter[tab] != "" { + s.Field(s.W-30, top, 29, a.tf("filter: %s", a.filter[tab]), warn) + } + return sel +} + +func (a *app) detail(lines ...string) { + s := a.screen + y := s.H - 3 - detailLines + s.Put(0, y, strings.Repeat("-", s.W), dim) + for i, l := range lines { + if i >= detailLines { + break + } + s.Field(1, y+1+i, s.W-2, l, plain) + } +} + +func splitFingerprint(fp string) []string { + groups := strings.Split(fp, "-") + if len(groups) <= 8 { + return []string{fp} + } + half := (len(groups) + 1) / 2 + return []string{strings.Join(groups[:half], "-"), strings.Join(groups[half:], "-")} +} + +func (a *app) drawTab() { + switch a.tab { + case tabNode: + a.drawNode() + case tabKeys: + if sel := a.drawTable(tabKeys); sel >= 0 { + _, rows := a.table(tabKeys) + k := a.keyByID(rows[sel].id) + if k != nil { + origin := a.t("generated on this node") + if k.Origin != nil { + origin = a.tf("from %s sent %s", k.Origin.Sender, stamp(k.Origin.SentAt)) + } + a.detail(a.dkv("id", k.KeyID+" "+wire.AlgName(k.Alg)), a.dkv("label", k.Label), + a.dkv("usage", wire.FormatUsage(k.Usage)+" "+a.t("created")+" "+stamp(k.CreatedAt)), a.dkv("origin", origin)) + } + } + case tabMembers: + if sel := a.drawTable(tabMembers); sel >= 0 { + _, rows := a.table(tabMembers) + if m := a.memberRecord(rows[sel].id); m != nil { + fp := splitFingerprint(m.fingerprint) + prefix := a.dkv("member", m.id+" "+a.t("fingerprint")+" ") + lines := []string{prefix + fp[0]} + if len(fp) > 1 { + lines = append(lines, strings.Repeat(" ", tui.StringWidth(prefix))+fp[1]) + } + heads := a.tf("witnessed audit heads %d", len(m.heads)) + if len(m.heads) > 0 { + heads += a.tf(", latest %s", m.heads[len(m.heads)-1].String()) + } + lines = append(lines, heads) + switch { + case m.err != "": + lines = append(lines, a.dkv("error", m.err)) + case m.retired: + lines = append(lines, a.t("warning the card uses a retired kem, ask the member to run card renew")) + } + a.detail(lines...) + } + } + case tabInbox: + if sel := a.drawTable(tabInbox); sel >= 0 { + _, rows := a.table(tabInbox) + if it := a.inboxByID(rows[sel].id); it != nil { + from := a.dkv("from", it.Sender) + if m := a.memberRecord(it.Sender); m != nil { + from += " " + a.t("fingerprint") + " " + m.fingerprint + } else { + from += " " + a.t("not a registered member") + } + a.detail(a.dkv("envelope", it.ID), from, a.dkv("sent", stamp(it.SentAt)+" "+a.t("received")+" "+stamp(it.ReceivedAt)), + a.t("Enter verifies and imports the key, x deletes the envelope")) + } + } + case tabAudit: + a.drawAudit() + case tabLog: + a.drawTable(tabLog) + } +} + +func (a *app) drawNode() { + s := a.screen + i := a.info + y := 3 + put := func(label, value string, st tui.Style) { + s.Field(2, y, 14, label, bold) + s.Field(16, y, s.W-18, value, st) + y++ + } + put(a.t("Member"), i.member, plain) + put(a.t("Directory"), a.dir, plain) + for n, part := range splitFingerprint(i.fingerprint) { + label := "" + if n == 0 { + label = a.t("Fingerprint") + } + put(label, part, heading) + } + put(a.t("Identity"), wire.AlgName(i.identityAlg), plain) + kem := wire.AlgName(i.kemAlg) + kemStyle := plain + if i.retiredKEM { + kem += a.t(" retired, press R to renew the card") + kemStyle = warn + } + put(a.t("KEM"), kem, kemStyle) + tlsText, tlsStyle := a.t("held in the core"), plain + if i.legacyTLS { + tlsText, tlsStyle = a.t("stored outside the core, press R to renew the card"), warn + } + put(a.t("TLS key"), tlsText, tlsStyle) + put(a.t("Core"), fmt.Sprintf("%s fips=%v pqc=%v", i.engine, i.coreFIPS, i.pqc), plain) + put(a.t("Host"), fmt.Sprintf("kmsctl %s %s go_fips=%v", a.opts.Version, runtime.Version(), fips140.Enabled()), plain) + put(a.t("Audit log"), i.auditPath, plain) + put(a.t("Store"), a.tf("%d keys, %d members, %d pending envelopes", len(a.data.keys), len(a.data.members), len(a.data.inbox)), plain) + net := a.t("network actions enabled (push, health, peer audit), each needs an https URL") + if a.opts.Offline { + net = a.t("offline, actions that contact other nodes are hidden") + } + put(a.t("Mode"), net, plain) + if a.opts.Idle > 0 { + put(a.t("Idle close"), a.opts.Idle.String(), plain) + } +} + +func (a *app) drawAudit() { + s := a.screen + v := a.verify + switch { + case v == nil: + s.Field(1, 3, s.W-2, a.t("Not verified in this session. Press v to verify the chain, anchors and witnessed heads."), plain) + case v.err != "": + s.Field(1, 3, s.W-2, a.tf("Verification FAILED at %s", v.at.UTC().Format(time.RFC3339)), bad) + s.Field(1, 4, s.W-2, v.err, bad) + default: + peer := "" + if v.peer != "" { + peer = a.tf(", heads witnessed by %s", v.peer) + } + s.Field(1, 3, s.W-2, a.tf("Verified %d entries against %d anchors%s at %s", v.count, v.anchors, peer, v.at.UTC().Format(time.RFC3339)), good) + s.Field(1, 4, s.W-2, a.t("head")+" "+v.head.String(), heading) + } + if a.data.auditErr != "" { + s.Field(1, auditTop-1, s.W-2, a.tf("reading the log failed: %s", a.data.auditErr), bad) + } + if sel := a.drawTable(tabAudit); sel >= 0 { + _, rows := a.table(tabAudit) + for _, e := range a.data.entries { + if fmt.Sprint(e.Seq) == rows[sel].id { + lines := []string{a.tf("seq %d %s %s", e.Seq, stamp(e.Time), e.Event)} + lines = append(lines, tui.Wrap(fieldText(e.Fields), s.W-2)...) + a.detail(lines...) + break + } + } + } +} + +func (a *app) keyByID(id string) *store.KeyRecord { + for _, k := range a.data.keys { + if k.KeyID == id { + return k + } + } + return nil +} + +func (a *app) inboxByID(id string) *node.InboxItem { + for i := range a.data.inbox { + if a.data.inbox[i].ID == id { + return &a.data.inbox[i] + } + } + return nil +} + +func (a *app) selected(tab int) string { + _, rows := a.table(tab) + if sel := a.selection(tab, rows); sel >= 0 { + return rows[sel].id + } + return "" +} + +func (a *app) switchTab(tab int) { + a.tab = tab + if tab == tabAudit && !a.data.audited && a.job == nil { + a.refresh() + } +} + +func (a *app) handleMain(ev tui.Event) { + switch { + case ev.IsRune('q'): + a.askQuit() + return + case ev.IsRune('?'): + a.help() + return + case ev.Is(tui.KeyTab): + a.switchTab((a.tab + 1) % tabCount) + return + case ev.Is(tui.KeyBacktab): + a.switchTab((a.tab + tabCount - 1) % tabCount) + return + case ev.Kind == tui.EventKey && ev.Key == tui.KeyRune && ev.Rune >= '1' && ev.Rune < '1'+tabCount: + a.switchTab(int(ev.Rune - '1')) + return + case ev.IsCtrl('r'): + a.refresh() + return + case ev.IsRune('/') && a.tab != tabNode: + a.filterForm() + return + case ev.Is(tui.KeyEsc): + a.filter[a.tab] = "" + return + } + if a.tab != tabNode { + _, rows := a.table(a.tab) + a.selection(a.tab, rows) + if a.lists[a.tab].Handle(ev, len(rows), a.listRows(a.tab)) { + if len(rows) > 0 { + a.selID[a.tab] = rows[a.lists[a.tab].Sel].id + } + return + } + } + switch a.tab { + case tabNode: + a.nodeKey(ev) + case tabKeys: + a.keysKey(ev) + case tabMembers: + a.membersKey(ev) + case tabInbox: + a.inboxKey(ev) + case tabAudit: + if ev.IsRune('v') { + a.verifyForm() + } + } +} + +func (a *app) askQuit() { + if a.job == nil { + a.quit = true + return + } + a.confirm(a.t("Quit"), []string{a.tf("%s is still running. Quit anyway? The operation is cancelled.", a.job.title)}, "", false, func(a *app) { a.quit = true }) +} + +func (a *app) help() { + lines := []string{ + a.t("Tab, Shift+Tab or 1-6 switch tabs. Up/Down or j/k move, PgUp/PgDn and Home/End jump."), + a.t("/ filters the list, Esc clears the filter or cancels a running action, Ctrl+R refreshes, Ctrl+L redraws, q or Ctrl+C quits."), + "", + a.t("Node c export card (card) R renew card (card renew)"), + a.t("Keys Enter info (key info) n new (key gen) s send to file (key send) r receive file (key receive)"), + a.t(" e encrypt file (encrypt) d decrypt file (decrypt) p push to kmsd (key push)"), + a.t("Members a add card (member add) w export witnessed heads (member witness) h health (peer health)"), + a.t("Inbox Enter accept (inbox accept) x reject (inbox reject) i import envelope file (key receive)"), + a.t("Audit v verify with anchors, an anchor file or a peer (audit verify)"), + "", + a.t("Fingerprints are never filled in for you, type them from the other channel."), + a.t("Decrypted data only goes to new files created for your user. Nothing is copied to the clipboard."), + } + if a.opts.Offline { + lines = append(lines, a.t("Offline mode hides push, health and peer audit.")) + } + if a.catalog != nil { + lines = append(lines, a.t("Shortcuts also work while the Korean input method is on.")) + } + a.message(a.t("Help"), lines, false) +} diff --git a/host/internal/fsx/fsx.go b/host/internal/fsx/fsx.go index 6d00ad8..f939dc4 100644 --- a/host/internal/fsx/fsx.go +++ b/host/internal/fsx/fsx.go @@ -1,5 +1,48 @@ package fsx -import "errors" +import ( + "errors" + "fmt" + "io" + "os" +) var ErrInsecure = errors.New("fsx: insecure path") + +func WriteNew(path string, data []byte) error { + f, err := CreatePrivate(path) + if err != nil { + return err + } + _, err = f.Write(data) + if err == nil { + err = f.Sync() + } + if cerr := f.Close(); err == nil { + err = cerr + } + if err != nil { + _ = os.Remove(path) + } + return err +} + +func ReadLimited(r io.Reader, limit int) ([]byte, error) { + b, err := io.ReadAll(io.LimitReader(r, int64(limit)+1)) + if err != nil { + return nil, err + } + if len(b) > limit { + return nil, fmt.Errorf("input exceeds %d bytes", limit) + } + return b, nil +} + +func ReadFileLimited(path string, limit int) ([]byte, error) { + f, err := os.Open(path) + if err != nil { + return nil, err + } + defer f.Close() + return ReadLimited(f, limit) +} diff --git a/host/internal/fsx/fsx_test.go b/host/internal/fsx/fsx_test.go index 3af8ecf..3967d65 100644 --- a/host/internal/fsx/fsx_test.go +++ b/host/internal/fsx/fsx_test.go @@ -100,3 +100,38 @@ func TestLockRenameAndExecutable(t *testing.T) { t.Fatalf("data executable: %v %v", fi, err) } } + +func TestWriteNewIsPrivateAndExclusive(t *testing.T) { + dir := t.TempDir() + out := filepath.Join(dir, "out.bin") + if err := WriteNew(out, []byte("secret")); err != nil { + t.Fatal(err) + } + if err := CheckPrivateFile(out); err != nil { + t.Fatalf("new file is not private: %v", err) + } + if err := WriteNew(out, []byte("other")); !errors.Is(err, fs.ErrExist) { + t.Fatalf("existing file overwritten: %v", err) + } + got, err := ReadFileLimited(out, 6) + if err != nil || string(got) != "secret" { + t.Fatalf("read back %q %v", got, err) + } + if _, err := ReadFileLimited(out, 5); err == nil { + t.Fatal("limit not enforced") + } + if _, err := ReadFileLimited(dir, 5); err == nil { + t.Fatal("directory read as a file") + } + target := filepath.Join(dir, "target") + link := filepath.Join(dir, "link") + if err := os.Symlink(target, link); err != nil { + t.Skipf("symlink: %v", err) + } + if err := WriteNew(link, []byte("x")); err == nil { + t.Fatal("dangling symlink followed") + } + if _, err := os.Lstat(target); !errors.Is(err, fs.ErrNotExist) { + t.Fatalf("symlink target created: %v", err) + } +} diff --git a/host/internal/fsx/fsx_unix.go b/host/internal/fsx/fsx_unix.go index c816ebd..5379739 100644 --- a/host/internal/fsx/fsx_unix.go +++ b/host/internal/fsx/fsx_unix.go @@ -83,6 +83,10 @@ func OpenNoFollow(path string, flag int, perm fs.FileMode) (*os.File, error) { return os.OpenFile(path, flag|syscall.O_NOFOLLOW, perm) } +func CreatePrivate(path string) (*os.File, error) { + return os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL|syscall.O_NOFOLLOW, 0o600) +} + func Lock(f *os.File) error { return syscall.Flock(int(f.Fd()), syscall.LOCK_EX) } diff --git a/host/internal/fsx/fsx_windows.go b/host/internal/fsx/fsx_windows.go index b7cc5b1..9bfc45b 100644 --- a/host/internal/fsx/fsx_windows.go +++ b/host/internal/fsx/fsx_windows.go @@ -106,6 +106,26 @@ func OpenNoFollow(path string, flag int, perm fs.FileMode) (*os.File, error) { return os.OpenFile(path, flag, perm) } +func CreatePrivate(path string) (*os.File, error) { + if _, err := os.Lstat(path); err == nil { + return nil, &os.PathError{Op: "open", Path: path, Err: fs.ErrExist} + } + name, err := syscall.UTF16PtrFromString(path) + if err != nil { + return nil, err + } + sa, free, err := winsys.PrivateAttributes("file") + if err != nil { + return nil, err + } + defer free() + h, err := syscall.CreateFile(name, syscall.GENERIC_WRITE, 0, sa, syscall.CREATE_NEW, syscall.FILE_ATTRIBUTE_NORMAL|syscall.FILE_FLAG_OPEN_REPARSE_POINT, 0) + if err != nil { + return nil, &os.PathError{Op: "open", Path: path, Err: err} + } + return os.NewFile(uintptr(h), path), nil +} + func Lock(f *os.File) error { return winsys.Lock(syscall.Handle(f.Fd())) } diff --git a/host/internal/term/pty_darwin_test.go b/host/internal/term/pty_darwin_test.go new file mode 100644 index 0000000..814a3be --- /dev/null +++ b/host/internal/term/pty_darwin_test.go @@ -0,0 +1,35 @@ +package term + +import ( + "bytes" + "os" + "syscall" + "unsafe" +) + +func openPTY() (*os.File, *os.File, error) { + master, err := os.OpenFile("/dev/ptmx", os.O_RDWR|syscall.O_NOCTTY, 0) + if err != nil { + return nil, nil, err + } + if err := ioctl(master.Fd(), syscall.TIOCPTYGRANT, nil); err != nil { + master.Close() + return nil, nil, err + } + if err := ioctl(master.Fd(), syscall.TIOCPTYUNLK, nil); err != nil { + master.Close() + return nil, nil, err + } + var name [128]byte + if err := ioctl(master.Fd(), syscall.TIOCPTYGNAME, unsafe.Pointer(&name)); err != nil { + master.Close() + return nil, nil, err + } + path := string(name[:bytes.IndexByte(name[:], 0)]) + slave, err := os.OpenFile(path, os.O_RDWR|syscall.O_NOCTTY, 0) + if err != nil { + master.Close() + return nil, nil, err + } + return master, slave, nil +} diff --git a/host/internal/term/pty_linux_test.go b/host/internal/term/pty_linux_test.go new file mode 100644 index 0000000..4a9f744 --- /dev/null +++ b/host/internal/term/pty_linux_test.go @@ -0,0 +1,31 @@ +package term + +import ( + "fmt" + "os" + "syscall" + "unsafe" +) + +func openPTY() (*os.File, *os.File, error) { + master, err := os.OpenFile("/dev/ptmx", os.O_RDWR|syscall.O_NOCTTY, 0) + if err != nil { + return nil, nil, err + } + var unlock int32 + if err := ioctl(master.Fd(), syscall.TIOCSPTLCK, unsafe.Pointer(&unlock)); err != nil { + master.Close() + return nil, nil, err + } + var n uint32 + if err := ioctl(master.Fd(), syscall.TIOCGPTN, unsafe.Pointer(&n)); err != nil { + master.Close() + return nil, nil, err + } + slave, err := os.OpenFile(fmt.Sprintf("/dev/pts/%d", n), os.O_RDWR|syscall.O_NOCTTY, 0) + if err != nil { + master.Close() + return nil, nil, err + } + return master, slave, nil +} diff --git a/host/internal/term/term.go b/host/internal/term/term.go new file mode 100644 index 0000000..5a50208 --- /dev/null +++ b/host/internal/term/term.go @@ -0,0 +1,55 @@ +package term + +import ( + "errors" + "os" + "sync" + + "github.com/Quant-Off/pairier/host/internal/tui" +) + +var ( + ErrNotTerminal = errors.New("term: standard input and output must be an interactive terminal") + ErrNoVT = errors.New("term: the console does not support virtual terminal sequences") +) + +type TTY struct { + in *os.File + out *os.File + events chan tui.Event + done chan struct{} + once sync.Once + restore func() error + stop func() +} + +func newTTY(in, out *os.File) *TTY { + return &TTY{in: in, out: out, events: make(chan tui.Event, 64), done: make(chan struct{})} +} + +func (t *TTY) Events() <-chan tui.Event { return t.events } + +func (t *TTY) Write(p []byte) (int, error) { return t.out.Write(p) } + +func (t *TTY) send(ev tui.Event) bool { + select { + case t.events <- ev: + return true + case <-t.done: + return false + } +} + +func (t *TTY) Close() error { + var err error + t.once.Do(func() { + close(t.done) + if t.stop != nil { + t.stop() + } + if t.restore != nil { + err = t.restore() + } + }) + return err +} diff --git a/host/internal/term/term_unix.go b/host/internal/term/term_unix.go new file mode 100644 index 0000000..aae716f --- /dev/null +++ b/host/internal/term/term_unix.go @@ -0,0 +1,114 @@ +//go:build linux || darwin + +package term + +import ( + "fmt" + "os" + "os/signal" + "syscall" + "unsafe" + + "github.com/Quant-Off/pairier/host/internal/tui" +) + +type winsize struct { + Row, Col, X, Y uint16 +} + +func ioctl(fd, req uintptr, arg unsafe.Pointer) error { + if _, _, e := syscall.Syscall(syscall.SYS_IOCTL, fd, req, uintptr(arg)); e != 0 { + return e + } + return nil +} + +func getTermios(fd uintptr) (*syscall.Termios, error) { + var t syscall.Termios + if err := ioctl(fd, ioctlGetTermios, unsafe.Pointer(&t)); err != nil { + return nil, err + } + return &t, nil +} + +func setTermios(fd uintptr, t *syscall.Termios) error { + return ioctl(fd, ioctlSetTermios, unsafe.Pointer(t)) +} + +func makeRaw(t *syscall.Termios) { + t.Iflag &^= syscall.IGNBRK | syscall.BRKINT | syscall.PARMRK | syscall.ISTRIP | syscall.INLCR | syscall.IGNCR | syscall.ICRNL | syscall.IXON + t.Oflag &^= syscall.OPOST + t.Lflag &^= syscall.ECHO | syscall.ECHONL | syscall.ICANON | syscall.ISIG | syscall.IEXTEN + t.Cflag &^= syscall.CSIZE | syscall.PARENB + t.Cflag |= syscall.CS8 + t.Cc[syscall.VMIN] = 1 + t.Cc[syscall.VTIME] = 0 +} + +func Open(in, out *os.File) (*TTY, error) { + ifd, ofd := in.Fd(), out.Fd() + old, err := getTermios(ifd) + if err != nil { + return nil, ErrNotTerminal + } + if _, err := getTermios(ofd); err != nil { + return nil, ErrNotTerminal + } + raw := *old + makeRaw(&raw) + if err := setTermios(ifd, &raw); err != nil { + return nil, fmt.Errorf("term: raw mode: %w", err) + } + t := newTTY(in, out) + t.restore = func() error { return setTermios(ifd, old) } + sig := make(chan os.Signal, 1) + signal.Notify(sig, syscall.SIGWINCH) + t.stop = func() { signal.Stop(sig) } + chunks := make(chan []byte, 16) + go t.read(chunks) + go tui.Pump(chunks, t.send) + go t.watch(sig) + return t, nil +} + +func (t *TTY) read(chunks chan<- []byte) { + defer close(chunks) + buf := make([]byte, 1024) + for { + n, err := t.in.Read(buf) + if n > 0 { + select { + case chunks <- append([]byte(nil), buf[:n]...): + case <-t.done: + return + } + } + if err != nil { + return + } + } +} + +func (t *TTY) watch(sig <-chan os.Signal) { + for { + select { + case <-sig: + if w, h, err := t.Size(); err == nil && !t.send(tui.ResizeEvent(w, h)) { + return + } + case <-t.done: + return + } + } +} + +func (t *TTY) Size() (int, int, error) { + var ws winsize + if err := ioctl(t.out.Fd(), syscall.TIOCGWINSZ, unsafe.Pointer(&ws)); err != nil { + return 0, 0, err + } + if ws.Col == 0 || ws.Row == 0 { + return 80, 24, nil + } + return int(ws.Col), int(ws.Row), nil +} diff --git a/host/internal/term/term_unix_test.go b/host/internal/term/term_unix_test.go new file mode 100644 index 0000000..f4eb091 --- /dev/null +++ b/host/internal/term/term_unix_test.go @@ -0,0 +1,84 @@ +//go:build linux || darwin + +package term + +import ( + "errors" + "os" + "path/filepath" + "syscall" + "testing" + "time" + "unsafe" + + "github.com/Quant-Off/pairier/host/internal/tui" +) + +func TestOpenRefusesNonTerminal(t *testing.T) { + f, err := os.Create(filepath.Join(t.TempDir(), "plain")) + if err != nil { + t.Fatal(err) + } + defer f.Close() + if _, err := Open(f, f); !errors.Is(err, ErrNotTerminal) { + t.Fatalf("regular file accepted as a terminal: %v", err) + } +} + +func TestRawModeOnPTY(t *testing.T) { + master, slave, err := openPTY() + if err != nil { + t.Skipf("pty: %v", err) + } + defer master.Close() + defer slave.Close() + ws := winsize{Row: 30, Col: 100} + if err := ioctl(master.Fd(), syscall.TIOCSWINSZ, unsafe.Pointer(&ws)); err != nil { + t.Fatal(err) + } + before, err := getTermios(slave.Fd()) + if err != nil { + t.Fatal(err) + } + tty, err := Open(slave, slave) + if err != nil { + t.Fatal(err) + } + raw, err := getTermios(slave.Fd()) + if err != nil { + t.Fatal(err) + } + if raw.Lflag&(syscall.ICANON|syscall.ECHO|syscall.ISIG) != 0 || raw.Iflag&(syscall.IXON|syscall.ICRNL) != 0 || raw.Oflag&syscall.OPOST != 0 { + t.Fatalf("not raw: %+v", raw) + } + if w, h, err := tty.Size(); err != nil || w != 100 || h != 30 { + t.Fatalf("size %d %d %v", w, h, err) + } + if _, err := master.Write([]byte("a\x1b[A\x03")); err != nil { + t.Fatal(err) + } + want := []tui.Event{tui.RuneEvent('a'), tui.KeyEvent(tui.KeyUp), tui.CtrlEvent('c')} + for _, w := range want { + select { + case ev := <-tty.Events(): + if ev != w { + t.Fatalf("got %v want %v", ev, w) + } + case <-time.After(2 * time.Second): + t.Fatalf("no event, want %v", w) + } + } + if err := tty.Close(); err != nil { + t.Fatal(err) + } + after, err := getTermios(slave.Fd()) + if err != nil { + t.Fatal(err) + } + if *after != *before { + t.Fatalf("terminal not restored\nbefore %+v\nafter %+v", before, after) + } + if err := tty.Close(); err != nil { + t.Fatal(err) + } +} diff --git a/host/internal/term/term_windows.go b/host/internal/term/term_windows.go new file mode 100644 index 0000000..a758f20 --- /dev/null +++ b/host/internal/term/term_windows.go @@ -0,0 +1,91 @@ +//go:build windows + +package term + +import ( + "errors" + "fmt" + "os" + "syscall" + "time" + + "github.com/Quant-Off/pairier/host/internal/tui" + "github.com/Quant-Off/pairier/host/internal/winsys" +) + +const pollInterval = 500 * time.Millisecond + +func Open(in, out *os.File) (*TTY, error) { + ih, oh := syscall.Handle(in.Fd()), syscall.Handle(out.Fd()) + inMode, err := winsys.GetConsoleMode(ih) + if err != nil { + return nil, ErrNotTerminal + } + outMode, err := winsys.GetConsoleMode(oh) + if err != nil { + return nil, ErrNotTerminal + } + vt := outMode | winsys.ConsoleProcessedOutput | winsys.ConsoleVirtualTerminalProcessing + if err := winsys.SetConsoleMode(oh, vt|winsys.ConsoleDisableNewlineAutoReturn); err != nil { + if err := winsys.SetConsoleMode(oh, vt); err != nil { + return nil, ErrNoVT + } + } + if err := winsys.SetConsoleMode(ih, winsys.ConsoleWindowInput); err != nil { + return nil, errors.Join(fmt.Errorf("term: console input mode: %w", err), winsys.SetConsoleMode(oh, outMode)) + } + t := newTTY(in, out) + t.restore = func() error { + return errors.Join(winsys.SetConsoleMode(ih, inMode), winsys.SetConsoleMode(oh, outMode)) + } + go t.read(ih) + go t.poll() + return t, nil +} + +func (t *TTY) read(h syscall.Handle) { + var d tui.ConsoleDecoder + recs := make([]winsys.InputRecord, 16) + for { + n, err := winsys.ReadConsoleInput(h, recs) + if err != nil { + return + } + for i := range recs[:n] { + if recs[i].EventType != winsys.KeyEventType { + continue + } + k := recs[i].Key() + for _, ev := range d.Key(k.Down, k.Repeat, k.VirtualKey, k.Char, k.ControlState) { + if !t.send(ev) { + return + } + } + } + } +} + +func (t *TTY) poll() { + tick := time.NewTicker(pollInterval) + defer tick.Stop() + lw, lh, _ := t.Size() + for { + select { + case <-tick.C: + w, h, err := t.Size() + if err != nil || (w == lw && h == lh) { + continue + } + lw, lh = w, h + if !t.send(tui.ResizeEvent(w, h)) { + return + } + case <-t.done: + return + } + } +} + +func (t *TTY) Size() (int, int, error) { + return winsys.ConsoleWindowSize(syscall.Handle(t.out.Fd())) +} diff --git a/host/internal/term/termios_darwin.go b/host/internal/term/termios_darwin.go new file mode 100644 index 0000000..3943fdd --- /dev/null +++ b/host/internal/term/termios_darwin.go @@ -0,0 +1,8 @@ +package term + +import "syscall" + +const ( + ioctlGetTermios = syscall.TIOCGETA + ioctlSetTermios = syscall.TIOCSETA +) diff --git a/host/internal/term/termios_linux.go b/host/internal/term/termios_linux.go new file mode 100644 index 0000000..0653ba1 --- /dev/null +++ b/host/internal/term/termios_linux.go @@ -0,0 +1,8 @@ +package term + +import "syscall" + +const ( + ioctlGetTermios = syscall.TCGETS + ioctlSetTermios = syscall.TCSETS +) diff --git a/host/internal/tui/console.go b/host/internal/tui/console.go new file mode 100644 index 0000000..d7be08f --- /dev/null +++ b/host/internal/tui/console.go @@ -0,0 +1,102 @@ +package tui + +import "unicode/utf16" + +const ( + vkBack = 0x08 + vkTab = 0x09 + vkReturn = 0x0d + vkEscape = 0x1b + vkPrior = 0x21 + vkNext = 0x22 + vkEnd = 0x23 + vkHome = 0x24 + vkLeft = 0x25 + vkUp = 0x26 + vkRight = 0x27 + vkDown = 0x28 + vkDelete = 0x2e + + shiftPressed = 0x10 + maxRepeat = 64 +) + +type ConsoleDecoder struct { + high rune +} + +func (d *ConsoleDecoder) Key(down bool, repeat, vk, ch uint16, state uint32) []Event { + if !down { + return nil + } + ev, ok := d.key(vk, ch, state) + if !ok { + return nil + } + n := min(max(int(repeat), 1), maxRepeat) + out := make([]Event, n) + for i := range out { + out[i] = ev + } + return out +} + +func (d *ConsoleDecoder) key(vk, ch uint16, state uint32) (Event, bool) { + switch vk { + case vkBack: + return KeyEvent(KeyBackspace), true + case vkTab: + if state&shiftPressed != 0 { + return KeyEvent(KeyBacktab), true + } + return KeyEvent(KeyTab), true + case vkReturn: + return KeyEvent(KeyEnter), true + case vkEscape: + return KeyEvent(KeyEsc), true + case vkPrior: + return KeyEvent(KeyPgUp), true + case vkNext: + return KeyEvent(KeyPgDn), true + case vkEnd: + return KeyEvent(KeyEnd), true + case vkHome: + return KeyEvent(KeyHome), true + case vkLeft: + return KeyEvent(KeyLeft), true + case vkUp: + return KeyEvent(KeyUp), true + case vkRight: + return KeyEvent(KeyRight), true + case vkDown: + return KeyEvent(KeyDown), true + case vkDelete: + return KeyEvent(KeyDelete), true + } + if ch == 0 { + return Event{}, false + } + r := rune(ch) + if utf16.IsSurrogate(r) { + if r < 0xdc00 { + d.high = r + return Event{}, false + } + if d.high == 0 { + return Event{}, false + } + r = utf16.DecodeRune(d.high, r) + } + d.high = 0 + switch { + case r == 0x1b: + return KeyEvent(KeyEsc), true + case r == 0x7f: + return KeyEvent(KeyBackspace), true + case r < 0x20: + return CtrlEvent('a' + r - 1), true + case cleanRune(r) != r: + return Event{}, false + } + return RuneEvent(r), true +} diff --git a/host/internal/tui/decode.go b/host/internal/tui/decode.go new file mode 100644 index 0000000..5809dda --- /dev/null +++ b/host/internal/tui/decode.go @@ -0,0 +1,279 @@ +package tui + +import ( + "bytes" + "strings" + "time" + "unicode/utf8" +) + +const ( + MaxPaste = 4096 + maxSequence = 32 + EscDelay = 30 * time.Millisecond + PasteDelay = 2 * time.Second +) + +var pasteEnd = []byte("\x1b[201~") + +type Decoder struct { + buf []byte + paste bool + text []byte +} + +func (d *Decoder) Feed(p []byte) []Event { + d.buf = append(d.buf, p...) + var out []Event + for len(d.buf) > 0 { + if d.paste { + ev, ok := d.feedPaste() + if !ok { + break + } + out = append(out, ev) + continue + } + ev, n, ok := d.next() + if !ok { + break + } + d.buf = d.buf[n:] + if ev.Kind == EventKey && ev.Key == KeyNone { + continue + } + out = append(out, ev) + } + if len(d.buf) == 0 { + d.buf = nil + } + return out +} + +func (d *Decoder) Pending() time.Duration { + switch { + case d.paste: + return PasteDelay + case len(d.buf) > 0: + return EscDelay + } + return 0 +} + +func (d *Decoder) Flush() []Event { + if d.paste { + d.paste = false + d.buf = nil + return []Event{d.takePaste()} + } + if len(d.buf) == 0 { + return nil + } + rest := d.buf + d.buf = nil + if rest[0] != 0x1b { + return nil + } + out := []Event{KeyEvent(KeyEsc)} + out = append(out, d.Feed(rest[1:])...) + d.buf = nil + d.paste = false + return out +} + +func (d *Decoder) feedPaste() (Event, bool) { + if i := bytes.Index(d.buf, pasteEnd); i >= 0 { + d.addPaste(d.buf[:i]) + d.buf = d.buf[i+len(pasteEnd):] + d.paste = false + return d.takePaste(), true + } + keep := 0 + for k := len(pasteEnd) - 1; k > 0; k-- { + if bytes.HasSuffix(d.buf, pasteEnd[:k]) { + keep = k + break + } + } + d.addPaste(d.buf[:len(d.buf)-keep]) + d.buf = append([]byte(nil), d.buf[len(d.buf)-keep:]...) + return Event{}, false +} + +func (d *Decoder) addPaste(b []byte) { + room := MaxPaste - len(d.text) + if room <= 0 { + return + } + if len(b) > room { + b = b[:room] + } + d.text = append(d.text, b...) +} + +func (d *Decoder) takePaste() Event { + s := CleanPaste(string(d.text)) + d.text = d.text[:0] + return PasteEvent(s) +} + +func CleanPaste(s string) string { + s = strings.ToValidUTF8(s, "?") + var b strings.Builder + for _, r := range s { + switch r { + case '\r', '\n', '\t': + b.WriteByte(' ') + default: + b.WriteRune(cleanRune(r)) + } + } + return b.String() +} + +func (d *Decoder) next() (Event, int, bool) { + b := d.buf + c := b[0] + switch { + case c == 0x1b: + if len(b) == 1 { + return Event{}, 0, false + } + switch b[1] { + case '[': + return d.csi(b) + case 'O': + if len(b) < 3 { + return Event{}, 0, false + } + return ss3(b[2]), 3, true + } + return KeyEvent(KeyEsc), 1, true + case c == '\r' || c == '\n': + return KeyEvent(KeyEnter), 1, true + case c == '\t': + return KeyEvent(KeyTab), 1, true + case c == 0x7f || c == 0x08: + return KeyEvent(KeyBackspace), 1, true + case c == 0: + return Event{}, 1, true + case c < 0x20: + return CtrlEvent(rune('a' + c - 1)), 1, true + case c < 0x80: + return RuneEvent(rune(c)), 1, true + } + if !utf8.FullRune(b) { + return Event{}, 0, false + } + r, n := utf8.DecodeRune(b) + if r == utf8.RuneError || cleanRune(r) != r { + return Event{}, n, true + } + return RuneEvent(r), n, true +} + +func (d *Decoder) csi(b []byte) (Event, int, bool) { + i := 2 + for i < len(b) && b[i] >= 0x30 && b[i] <= 0x3f { + i++ + } + for i < len(b) && b[i] >= 0x20 && b[i] <= 0x2f { + i++ + } + if i >= len(b) { + if len(b) >= maxSequence { + return Event{}, len(b), true + } + return Event{}, 0, false + } + final := b[i] + if final < 0x40 || final > 0x7e { + return Event{}, i, true + } + params := string(b[2:i]) + n := i + 1 + switch final { + case 'A': + return KeyEvent(KeyUp), n, true + case 'B': + return KeyEvent(KeyDown), n, true + case 'C': + return KeyEvent(KeyRight), n, true + case 'D': + return KeyEvent(KeyLeft), n, true + case 'H': + return KeyEvent(KeyHome), n, true + case 'F': + return KeyEvent(KeyEnd), n, true + case 'Z': + return KeyEvent(KeyBacktab), n, true + case '~': + if j := strings.IndexByte(params, ';'); j >= 0 { + params = params[:j] + } + switch params { + case "1", "7": + return KeyEvent(KeyHome), n, true + case "4", "8": + return KeyEvent(KeyEnd), n, true + case "3": + return KeyEvent(KeyDelete), n, true + case "5": + return KeyEvent(KeyPgUp), n, true + case "6": + return KeyEvent(KeyPgDn), n, true + case "200": + d.paste = true + d.text = d.text[:0] + } + } + return Event{}, n, true +} + +func ss3(c byte) Event { + switch c { + case 'A': + return KeyEvent(KeyUp) + case 'B': + return KeyEvent(KeyDown) + case 'C': + return KeyEvent(KeyRight) + case 'D': + return KeyEvent(KeyLeft) + case 'H': + return KeyEvent(KeyHome) + case 'F': + return KeyEvent(KeyEnd) + } + return Event{} +} + +func Pump(chunks <-chan []byte, send func(Event) bool) { + var d Decoder + timer := time.NewTimer(time.Hour) + timer.Stop() + for { + select { + case b, ok := <-chunks: + if !ok { + timer.Stop() + return + } + timer.Stop() + for _, ev := range d.Feed(b) { + if !send(ev) { + return + } + } + if wait := d.Pending(); wait > 0 { + timer.Reset(wait) + } + case <-timer.C: + for _, ev := range d.Flush() { + if !send(ev) { + return + } + } + } + } +} diff --git a/host/internal/tui/event.go b/host/internal/tui/event.go new file mode 100644 index 0000000..9c25d31 --- /dev/null +++ b/host/internal/tui/event.go @@ -0,0 +1,56 @@ +package tui + +type Key uint8 + +const ( + KeyNone Key = iota + KeyRune + KeyCtrl + KeyEnter + KeyTab + KeyBacktab + KeyBackspace + KeyDelete + KeyEsc + KeyUp + KeyDown + KeyLeft + KeyRight + KeyHome + KeyEnd + KeyPgUp + KeyPgDn +) + +type Kind uint8 + +const ( + EventKey Kind = iota + EventPaste + EventResize +) + +type Event struct { + Kind Kind + Key Key + Rune rune + Text string + Width int + Height int +} + +func KeyEvent(k Key) Event { return Event{Kind: EventKey, Key: k} } + +func RuneEvent(r rune) Event { return Event{Kind: EventKey, Key: KeyRune, Rune: r} } + +func CtrlEvent(r rune) Event { return Event{Kind: EventKey, Key: KeyCtrl, Rune: r} } + +func PasteEvent(s string) Event { return Event{Kind: EventPaste, Text: s} } + +func ResizeEvent(w, h int) Event { return Event{Kind: EventResize, Width: w, Height: h} } + +func (e Event) Is(k Key) bool { return e.Kind == EventKey && e.Key == k } + +func (e Event) IsRune(r rune) bool { return e.Kind == EventKey && e.Key == KeyRune && e.Rune == r } + +func (e Event) IsCtrl(r rune) bool { return e.Kind == EventKey && e.Key == KeyCtrl && e.Rune == r } diff --git a/host/internal/tui/keymap.go b/host/internal/tui/keymap.go new file mode 100644 index 0000000..bb2cdac --- /dev/null +++ b/host/internal/tui/keymap.go @@ -0,0 +1,55 @@ +package tui + +var dubeolsik = map[rune]rune{ + 'ㅂ': 'q', 'ㅈ': 'w', 'ㄷ': 'e', 'ㄱ': 'r', 'ㅅ': 't', 'ㅛ': 'y', 'ㅕ': 'u', 'ㅑ': 'i', 'ㅐ': 'o', 'ㅔ': 'p', + 'ㅁ': 'a', 'ㄴ': 's', 'ㅇ': 'd', 'ㄹ': 'f', 'ㅎ': 'g', 'ㅗ': 'h', 'ㅓ': 'j', 'ㅏ': 'k', 'ㅣ': 'l', + 'ㅋ': 'z', 'ㅌ': 'x', 'ㅊ': 'c', 'ㅍ': 'v', 'ㅠ': 'b', 'ㅜ': 'n', 'ㅡ': 'm', + 'ㅃ': 'Q', 'ㅉ': 'W', 'ㄸ': 'E', 'ㄲ': 'R', 'ㅆ': 'T', 'ㅒ': 'O', 'ㅖ': 'P', +} + +func Latin(r rune) rune { + if l, ok := dubeolsik[r]; ok { + return l + } + return r +} + +func Shortcut(ev Event) Event { + if ev.Kind == EventKey && ev.Key == KeyRune { + ev.Rune = Latin(ev.Rune) + } + return ev +} + +type Texts struct { + FormHint string + Close string + Confirm string + ConfirmTyped string + More string + Yes string + No string + None string + Mismatch string + Type string +} + +var English = Texts{ + FormHint: " Tab move Space toggle Enter next Esc cancel ", + Close: " Enter/Esc close ", + Confirm: " y confirm n/Esc cancel ", + ConfirmTyped: " Enter confirm Esc cancel ", + More: " Up/Down more ", + Yes: "[x] yes", + No: "[ ] no", + None: "(none)", + Mismatch: "the text does not match", + Type: "type %s: ", +} + +func textsOr(t *Texts) *Texts { + if t == nil { + return &English + } + return t +} diff --git a/host/internal/tui/render.go b/host/internal/tui/render.go new file mode 100644 index 0000000..1108a93 --- /dev/null +++ b/host/internal/tui/render.go @@ -0,0 +1,135 @@ +package tui + +import ( + "bytes" + "io" + "strconv" +) + +const ( + enterSeq = "\x1b[?1049h\x1b[?7l\x1b[?25l\x1b[0m\x1b[2J\x1b[H" + leaveSeq = "\x1b[0m\x1b[2J\x1b[H\x1b[?7h\x1b[?25h\x1b[?1049l" + pasteOn = "\x1b[?2004h" + pasteOff = "\x1b[?2004l" +) + +type Renderer struct { + Paste bool + out io.Writer + color bool + prev []string + width int + buf bytes.Buffer + active bool +} + +func NewRenderer(out io.Writer, color bool) *Renderer { + return &Renderer{out: out, color: color} +} + +func (r *Renderer) Begin() error { + r.active = true + r.prev = nil + seq := enterSeq + if r.Paste { + seq += pasteOn + } + _, err := io.WriteString(r.out, seq) + return err +} + +func (r *Renderer) End() error { + if !r.active { + return nil + } + r.active = false + r.prev = nil + seq := leaveSeq + if r.Paste { + seq = pasteOff + seq + } + _, err := io.WriteString(r.out, seq) + return err +} + +func (r *Renderer) Invalidate() { r.prev = nil } + +func (r *Renderer) Draw(s *Screen) error { + r.buf.Reset() + if len(r.prev) != s.H || r.width != s.W { + r.prev = make([]string, s.H) + r.width = s.W + r.buf.WriteString("\x1b[0m\x1b[2J") + } + r.buf.WriteString("\x1b[?25l") + for y := 0; y < s.H; y++ { + line := r.row(s, y) + if line == r.prev[y] { + continue + } + r.buf.WriteString("\x1b[") + r.buf.WriteString(strconv.Itoa(y + 1)) + r.buf.WriteString(";1H") + r.buf.WriteString(line) + r.prev[y] = line + } + if s.CursorOn { + r.buf.WriteString("\x1b[") + r.buf.WriteString(strconv.Itoa(s.CursorY + 1)) + r.buf.WriteByte(';') + r.buf.WriteString(strconv.Itoa(s.CursorX + 1)) + r.buf.WriteString("H\x1b[?25h") + } + _, err := r.out.Write(r.buf.Bytes()) + return err +} + +func (r *Renderer) row(s *Screen, y int) string { + var b bytes.Buffer + cur := Style{} + b.WriteString("\x1b[0m") + for x := 0; x < s.W; x++ { + c := s.at(x, y) + if c.cont { + continue + } + if c.st != cur { + b.WriteString(r.sgr(c.st)) + cur = c.st + } + if c.s == "" { + b.WriteByte(' ') + } else { + b.WriteString(c.s) + } + } + b.WriteString("\x1b[0m") + return b.String() +} + +func (r *Renderer) sgr(st Style) string { + b := []byte("\x1b[0") + if st.Bold { + b = append(b, ";1"...) + } + if st.Dim { + b = append(b, ";2"...) + } + if st.Underline { + b = append(b, ";4"...) + } + if st.Reverse { + b = append(b, ";7"...) + } + if r.color { + if st.Fg != Default { + b = append(b, ';') + b = strconv.AppendInt(b, int64(29+int(st.Fg)), 10) + } + if st.Bg != Default { + b = append(b, ';') + b = strconv.AppendInt(b, int64(39+int(st.Bg)), 10) + } + } + return string(append(b, 'm')) +} diff --git a/host/internal/tui/screen.go b/host/internal/tui/screen.go new file mode 100644 index 0000000..d353fa3 --- /dev/null +++ b/host/internal/tui/screen.go @@ -0,0 +1,188 @@ +package tui + +import "strings" + +type Color uint8 + +const ( + Default Color = iota + Black + Red + Green + Yellow + Blue + Magenta + Cyan + White +) + +type Style struct { + Fg Color + Bg Color + Bold bool + Dim bool + Reverse bool + Underline bool +} + +type cell struct { + s string + st Style + cont bool +} + +type Screen struct { + W, H int + cells []cell + CursorX int + CursorY int + CursorOn bool +} + +func NewScreen(w, h int) *Screen { + s := &Screen{} + s.Resize(w, h) + return s +} + +func (s *Screen) Resize(w, h int) { + if w < 0 { + w = 0 + } + if h < 0 { + h = 0 + } + s.W, s.H = w, h + s.cells = make([]cell, w*h) + s.CursorOn = false +} + +func (s *Screen) Clear() { + for i := range s.cells { + s.cells[i] = cell{} + } + s.CursorOn = false +} + +func (s *Screen) at(x, y int) *cell { return &s.cells[y*s.W+x] } + +func (s *Screen) set(x, y int, text string, st Style, w int) { + c := s.at(x, y) + if c.cont && x > 0 { + *s.at(x-1, y) = cell{st: s.at(x-1, y).st} + } + if !c.cont && x+1 < s.W && s.at(x+1, y).cont && w == 1 { + *s.at(x+1, y) = cell{st: st} + } + *c = cell{s: text, st: st} + if w == 2 { + n := s.at(x+1, y) + if !n.cont && x+2 < s.W && s.at(x+2, y).cont { + *s.at(x+2, y) = cell{st: st} + } + *n = cell{st: st, cont: true} + } +} + +func (s *Screen) Put(x, y int, text string, st Style) int { + if y < 0 || y >= s.H || x >= s.W { + return 0 + } + col := x + last := -1 + for _, r := range Clean(text) { + w := RuneWidth(r) + if w == 0 { + if last >= 0 { + c := s.at(last, y) + if len(c.s) < 32 { + c.s += string(r) + } + } + continue + } + if col+w > s.W { + break + } + if col >= 0 { + s.set(col, y, string(r), st, w) + last = col + } else { + last = -1 + } + col += w + } + if col < x { + return 0 + } + return col - x +} + +func (s *Screen) Field(x, y, w int, text string, st Style) { + if x+w > s.W { + w = s.W - x + } + s.Put(x, y, Fit(text, w), st) +} + +func (s *Screen) Fill(x, y, w, h int, st Style) { + for row := y; row < y+h; row++ { + if row < 0 || row >= s.H { + continue + } + for col := x; col < x+w; col++ { + if col < 0 || col >= s.W { + continue + } + s.set(col, row, "", st, 1) + } + } +} + +func (s *Screen) Box(x, y, w, h int, title string, st Style) { + if w < 2 || h < 2 { + return + } + s.Fill(x, y, w, h, st) + edge := "+" + strings.Repeat("-", w-2) + "+" + s.Put(x, y, edge, st) + s.Put(x, y+h-1, edge, st) + for row := y + 1; row < y+h-1; row++ { + s.Put(x, row, "|", st) + s.Put(x+w-1, row, "|", st) + } + if title != "" { + t := st + t.Bold = true + s.Put(x+2, y, " "+Fit(title, min(StringWidth(title), w-6))+" ", t) + } +} + +func (s *Screen) Cursor(x, y int) { + if x < 0 || y < 0 || x >= s.W || y >= s.H { + s.CursorOn = false + return + } + s.CursorX, s.CursorY, s.CursorOn = x, y, true +} + +func (s *Screen) Lines() []string { + out := make([]string, s.H) + for y := 0; y < s.H; y++ { + var b strings.Builder + for x := 0; x < s.W; x++ { + c := s.at(x, y) + switch { + case c.cont: + case c.s == "": + b.WriteByte(' ') + default: + b.WriteString(c.s) + } + } + out[y] = strings.TrimRight(b.String(), " ") + } + return out +} + +func (s *Screen) Text() string { return strings.Join(s.Lines(), "\n") } diff --git a/host/internal/tui/tui_test.go b/host/internal/tui/tui_test.go new file mode 100644 index 0000000..55b63a3 --- /dev/null +++ b/host/internal/tui/tui_test.go @@ -0,0 +1,447 @@ +package tui + +import ( + "bytes" + "strings" + "testing" + "time" +) + +func feedAll(chunks ...string) []Event { + var d Decoder + var out []Event + for _, c := range chunks { + out = append(out, d.Feed([]byte(c))...) + } + return append(out, d.Flush()...) +} + +func TestDecoderKeys(t *testing.T) { + cases := []struct { + in string + want []Event + }{ + {"a", []Event{RuneEvent('a')}}, + {"\r", []Event{KeyEvent(KeyEnter)}}, + {"\x7f", []Event{KeyEvent(KeyBackspace)}}, + {"\x03", []Event{CtrlEvent('c')}}, + {"\x1b[A\x1b[B\x1b[C\x1b[D", []Event{KeyEvent(KeyUp), KeyEvent(KeyDown), KeyEvent(KeyRight), KeyEvent(KeyLeft)}}, + {"\x1bOA\x1bOH", []Event{KeyEvent(KeyUp), KeyEvent(KeyHome)}}, + {"\x1b[1;5A", []Event{KeyEvent(KeyUp)}}, + {"\x1b[3~\x1b[5~\x1b[6~\x1b[Z", []Event{KeyEvent(KeyDelete), KeyEvent(KeyPgUp), KeyEvent(KeyPgDn), KeyEvent(KeyBacktab)}}, + {"\x1b", []Event{KeyEvent(KeyEsc)}}, + {"\x1bq", []Event{KeyEvent(KeyEsc), RuneEvent('q')}}, + {"가", []Event{RuneEvent('가')}}, + {"\xc2\x9b", nil}, + {"\xff", nil}, + {"\x1b[99x", nil}, + } + for _, c := range cases { + got := feedAll(c.in) + if len(got) != len(c.want) { + t.Fatalf("%q: got %v want %v", c.in, got, c.want) + } + for i := range got { + if got[i] != c.want[i] { + t.Fatalf("%q: event %d got %v want %v", c.in, i, got[i], c.want[i]) + } + } + } +} + +func TestDecoderSplitInput(t *testing.T) { + got := feedAll("\x1b", "[", "A", "\xea\xb0", "\x80") + if len(got) != 2 || got[0] != KeyEvent(KeyUp) || got[1] != RuneEvent('가') { + t.Fatalf("%v", got) + } + var d Decoder + if ev := d.Feed([]byte("\x1b")); len(ev) != 0 || d.Pending() != EscDelay { + t.Fatalf("lone escape not held: %v %v", ev, d.Pending()) + } + if ev := d.Flush(); len(ev) != 1 || ev[0] != KeyEvent(KeyEsc) { + t.Fatalf("flush %v", ev) + } + if d.Pending() != 0 { + t.Fatal("still pending") + } +} + +func TestDecoderPaste(t *testing.T) { + got := feedAll("x\x1b[200~ab\r\ncd\x1b]52;c;ZXZpbA==\x07\x1b[20", "1~y") + if len(got) != 3 || got[0] != RuneEvent('x') || got[2] != RuneEvent('y') { + t.Fatalf("%v", got) + } + if got[1].Kind != EventPaste || got[1].Text != "ab cd?]52;c;ZXZpbA==?" { + t.Fatalf("paste %q", got[1].Text) + } + var d Decoder + d.Feed([]byte("\x1b[200~" + strings.Repeat("z", MaxPaste*2))) + if d.Pending() != PasteDelay { + t.Fatal("unterminated paste not pending") + } + ev := d.Flush() + if len(ev) != 1 || len(ev[0].Text) != MaxPaste { + t.Fatalf("paste not bounded: %d", len(ev[0].Text)) + } + if ev := d.Feed([]byte("q")); len(ev) != 1 || ev[0] != RuneEvent('q') { + t.Fatalf("decoder stuck in paste mode: %v", ev) + } +} + +func TestDecoderBoundsGarbage(t *testing.T) { + var d Decoder + d.Feed([]byte("\x1b[" + strings.Repeat("1", maxSequence*4))) + if len(d.buf) > maxSequence { + t.Fatalf("unbounded sequence buffer %d", len(d.buf)) + } +} + +func TestPump(t *testing.T) { + chunks := make(chan []byte) + events := make(chan Event, 8) + done := make(chan struct{}) + go func() { + Pump(chunks, func(ev Event) bool { events <- ev; return true }) + close(done) + }() + chunks <- []byte("\x1b") + select { + case ev := <-events: + if ev != KeyEvent(KeyEsc) { + t.Fatalf("%v", ev) + } + case <-time.After(time.Second): + t.Fatal("escape not flushed") + } + chunks <- []byte("ok") + if a, b := <-events, <-events; a != RuneEvent('o') || b != RuneEvent('k') { + t.Fatalf("%v %v", a, b) + } + close(chunks) + <-done +} + +func FuzzDecoder(f *testing.F) { + f.Add([]byte("\x1b[200~a\x1b[201~\x1b[A\x1bO")) + f.Add([]byte("\xea\xb0\x80\x1b\x1b[1;2~")) + f.Fuzz(func(t *testing.T, b []byte) { + var d Decoder + for i := 0; i < len(b); i += 3 { + evs := d.Feed(b[i:min(i+3, len(b))]) + for _, ev := range evs { + if ev.Kind == EventKey && ev.Key == KeyRune && cleanRune(ev.Rune) != ev.Rune { + t.Fatalf("unsafe rune %U", ev.Rune) + } + if strings.ContainsAny(ev.Text, "\x1b\x07\r\n") { + t.Fatalf("control in paste %q", ev.Text) + } + } + if len(d.buf) > maxSequence+len(pasteEnd)+4 && !d.paste { + t.Fatalf("buffer grew to %d", len(d.buf)) + } + } + d.Flush() + }) +} + +func TestCleanAndWidth(t *testing.T) { + cases := map[string]string{ + "plain": "plain", + "a\x1b[2Jb": "a?[2Jb", + "\x9b31m": "?31m", + "evil‮gnp.exe": "evil?gnp.exe", + "x⁦y‏z؜": "x?y?z?", + "tab\there": "tab here", + "bad\xffutf8": "bad?utf8", + "line
sep": "line?sep", + "한글 라벨": "한글 라벨", + " wide": " wide", + } + for in, want := range cases { + if got := Clean(in); got != want { + t.Errorf("Clean(%q) = %q want %q", in, got, want) + } + } + if StringWidth("한글ab") != 6 || StringWidth("é") != 1 || StringWidth("\x1b") != 1 { + t.Fatalf("widths %d %d %d", StringWidth("한글ab"), StringWidth("é"), StringWidth("\x1b")) + } + for _, c := range []struct { + in string + w int + want string + }{ + {"abc", 5, "abc "}, + {"abcdef", 4, "abc~"}, + {"한글라벨", 5, "한글~"}, + {"한글라벨", 4, "한~ "}, + {"x", 0, ""}, + } { + if got := Fit(c.in, c.w); got != c.want || StringWidth(got) != c.w { + t.Errorf("Fit(%q, %d) = %q want %q", c.in, c.w, got, c.want) + } + } +} + +func TestScreenWideCellsAndRender(t *testing.T) { + s := NewScreen(10, 2) + s.Put(0, 0, "가나다라마바", Style{}) + if got := s.Lines()[0]; got != "가나다라마" { + t.Fatalf("%q", got) + } + s.Put(1, 0, "x", Style{}) + if got := s.Lines()[0]; got != " x나다라마" { + t.Fatalf("overwrite right half %q", got) + } + s.Put(2, 0, "yz", Style{}) + if got := s.Lines()[0]; got != " xyz다라마" { + t.Fatalf("overwrite left half %q", got) + } + s.Put(9, 1, "가", Style{}) + if got := s.Lines()[1]; got != "" { + t.Fatalf("wide rune at the edge %q", got) + } + s.Put(0, 1, "\x1b]0;pwned\x07", Style{}) + var out bytes.Buffer + r := NewRenderer(&out, true) + if err := r.Draw(s); err != nil { + t.Fatal(err) + } + if bytes.Contains(out.Bytes(), []byte("\x1b]")) || bytes.Contains(out.Bytes(), []byte{0x07}) { + t.Fatalf("control sequence reached the terminal: %q", out.String()) + } + out.Reset() + if err := r.Draw(s); err != nil { + t.Fatal(err) + } + if bytes.Contains(out.Bytes(), []byte(";1H")) { + t.Fatalf("unchanged frame redrawn: %q", out.String()) + } + s.Put(0, 1, "Z", Style{Fg: Red, Bold: true}) + out.Reset() + _ = r.Draw(s) + if !bytes.Contains(out.Bytes(), []byte("\x1b[2;1H")) || bytes.Contains(out.Bytes(), []byte("\x1b[1;1H")) || !bytes.Contains(out.Bytes(), []byte("\x1b[0;1;31m")) { + t.Fatalf("diff render %q", out.String()) + } + plain := NewRenderer(&out, false) + out.Reset() + _ = plain.Draw(s) + if bytes.Contains(out.Bytes(), []byte(";31")) { + t.Fatal("color emitted with color off") + } +} + +func TestInputEditing(t *testing.T) { + var in Input + in.Max = 8 + for _, ev := range []Event{RuneEvent('a'), RuneEvent('한'), RuneEvent('b'), KeyEvent(KeyLeft), KeyEvent(KeyBackspace), RuneEvent('c')} { + in.Handle(ev) + } + if in.Value() != "acb" { + t.Fatalf("%q", in.Value()) + } + in.Handle(PasteEvent("123456789")) + if len(in.Value()) > 8 { + t.Fatalf("max not enforced %q", in.Value()) + } + in.SetValue("one two") + in.Handle(CtrlEvent('w')) + if in.Value() != "one " { + t.Fatalf("ctrl-w %q", in.Value()) + } + in.Handle(CtrlEvent('u')) + if in.Value() != "" { + t.Fatalf("ctrl-u %q", in.Value()) + } + in.SetValue("a\x1bb") + if in.Value() != "a?b" { + t.Fatalf("SetValue kept a control %q", in.Value()) + } + s := NewScreen(6, 1) + in.SetValue("가나다라마") + in.Draw(s, 0, 0, 6, Style{}, true) + if !s.CursorOn || s.CursorX > 5 { + t.Fatalf("cursor %v %d", s.CursorOn, s.CursorX) + } +} + +func TestFormAndDialog(t *testing.T) { + f := &Form{Title: "t", Fields: []*Field{ + TextField("Label", "", 0), + FlagsField("Usage", []string{"a", "b"}, []bool{true, false}), + ChoiceField("To", []string{"x", "y"}, 0), + }} + for _, ev := range []Event{RuneEvent('k'), KeyEvent(KeyTab), KeyEvent(KeyRight), RuneEvent(' '), KeyEvent(KeyEnter), KeyEvent(KeyRight)} { + if r := f.Handle(ev); r != None { + t.Fatalf("early result %v", r) + } + } + if f.Handle(KeyEvent(KeyEnter)) != Submit { + t.Fatal("no submit on the last field") + } + if f.Fields[0].Value() != "k" || strings.Join(f.Fields[1].Selected(), ",") != "a,b" || f.Fields[2].Value() != "y" { + t.Fatalf("%q %v %q", f.Fields[0].Value(), f.Fields[1].Selected(), f.Fields[2].Value()) + } + if f.Handle(KeyEvent(KeyEsc)) != Cancel { + t.Fatal("esc") + } + s := NewScreen(80, 24) + f.Draw(s, Style{}) + if !strings.Contains(s.Text(), "[x] a") { + t.Fatalf("form render\n%s", s.Text()) + } + d := &Dialog{Title: "renew", Ask: true, Confirm: "alice"} + if d.Handle(RuneEvent('y')) != None || d.Handle(KeyEvent(KeyEnter)) != None || d.Err == "" { + t.Fatal("typed confirmation bypassed") + } + d.Input.SetValue("alice") + if d.Handle(KeyEvent(KeyEnter)) != Submit { + t.Fatal("typed confirmation refused") + } + yn := &Dialog{Ask: true} + if yn.Handle(KeyEvent(KeyEnter)) != None || yn.Handle(RuneEvent('y')) != Submit { + t.Fatal("y/n dialog") + } +} + +func TestListClamp(t *testing.T) { + var l List + l.Handle(KeyEvent(KeyEnd), 10, 4) + if l.Sel != 9 || l.Off != 6 { + t.Fatalf("%+v", l) + } + l.Clamp(3, 4) + if l.Sel != 2 || l.Off != 0 { + t.Fatalf("%+v", l) + } + l.Clamp(0, 4) + if l.Sel != 0 || l.Off != 0 { + t.Fatalf("%+v", l) + } +} + +func TestConsoleDecoder(t *testing.T) { + var d ConsoleDecoder + if ev := d.Key(true, 1, vkTab, 9, shiftPressed); len(ev) != 1 || ev[0] != KeyEvent(KeyBacktab) { + t.Fatalf("%v", ev) + } + if ev := d.Key(true, 3, 'A', 'a', 0); len(ev) != 3 || ev[2] != RuneEvent('a') { + t.Fatalf("%v", ev) + } + if ev := d.Key(false, 1, 'A', 'a', 0); ev != nil { + t.Fatal("key up produced input") + } + if ev := d.Key(true, 1, 'C', 3, 0x08); len(ev) != 1 || ev[0] != CtrlEvent('c') { + t.Fatalf("%v", ev) + } + if ev := d.Key(true, 1, 0xe7, 0xd83d, 0); ev != nil { + t.Fatal("high surrogate emitted") + } + if ev := d.Key(true, 1, 0xe7, 0xde00, 0); len(ev) != 1 || ev[0] != RuneEvent(0x1f600) { + t.Fatalf("%v", ev) + } + if ev := d.Key(true, 1, 0xe7, 0x202e, 0); ev != nil { + t.Fatal("bidi override accepted") + } + if ev := d.Key(true, 1000, 'A', 'a', 0); len(ev) != maxRepeat { + t.Fatalf("repeat not bounded %d", len(ev)) + } +} + +func TestWrap(t *testing.T) { + got := Wrap("node: fingerprint does not match the card abcdefghijklmnop", 12) + for _, l := range got { + if StringWidth(l) > 12 { + t.Fatalf("line too wide %q", l) + } + } + if strings.Join(got, " ") != "node: fingerprint does not match the card abcdefghijkl mnop" { + t.Fatalf("%q", got) + } + if got := Wrap("짧은 한글", 20); len(got) != 1 { + t.Fatalf("%q", got) + } + f := &Form{Fields: []*Field{FlagsField("Recipient usage", []string{"encrypt", "decrypt", "wrap", "unwrap", "derive", "export"}, make([]bool, 6))}} + s := NewScreen(80, 24) + f.Draw(s, Style{}) + if !strings.Contains(s.Text(), "[ ] export") { + t.Fatalf("flags not wrapped\n%s", s.Text()) + } +} + +func TestDialogScrollsLongContent(t *testing.T) { + var lines []string + for i := 0; i < 30; i++ { + lines = append(lines, "line "+string(rune('a'+i%26))+strings.Repeat("x", i)) + } + lines = append(lines, "LAST LINE") + d := &Dialog{Title: "t", Lines: lines, Ask: true} + s := NewScreen(64, 18) + d.Draw(s, Style{}) + if strings.Contains(s.Text(), "LAST LINE") || !strings.Contains(s.Text(), "Up/Down more") { + t.Fatalf("overflow not signalled\n%s", s.Text()) + } + for i := 0; i < 40; i++ { + d.Handle(KeyEvent(KeyDown)) + } + s.Clear() + d.Draw(s, Style{}) + if !strings.Contains(s.Text(), "LAST LINE") { + t.Fatalf("cannot scroll to the end\n%s", s.Text()) + } + if d.Handle(KeyEvent(KeyDown)) != None || d.Handle(RuneEvent('y')) != Submit { + t.Fatal("scrolling changed the answer keys") + } + var out bytes.Buffer + r := NewRenderer(&out, false) + _ = r.Begin() + _ = r.End() + if bytes.Contains(out.Bytes(), []byte("?2004")) { + t.Fatal("bracketed paste requested without Paste") + } + out.Reset() + r.Paste = true + _ = r.Begin() + if !bytes.Contains(out.Bytes(), []byte("\x1b[?2004h")) { + t.Fatal("bracketed paste not requested") + } +} + +func TestKoreanLayoutShortcutsAndTexts(t *testing.T) { + if Latin('ㅂ') != 'q' || Latin('ㄲ') != 'R' || Latin('가') != '가' || Latin('x') != 'x' { + t.Fatal("dubeolsik mapping") + } + if ev := Shortcut(RuneEvent('ㅛ')); ev != RuneEvent('y') { + t.Fatalf("%v", ev) + } + d := &Dialog{Ask: true} + if d.Handle(RuneEvent('ㅛ')) != Submit { + t.Fatal("y typed with the Korean input method did not confirm") + } + typed := &Dialog{Ask: true, Confirm: "alice"} + typed.Handle(RuneEvent('ㅁ')) + if typed.Input.Value() != "ㅁ" { + t.Fatalf("typed confirmation input was remapped: %q", typed.Input.Value()) + } + var l List + l.Handle(RuneEvent('ㅓ'), 5, 3) + if l.Sel != 1 { + t.Fatal("j typed with the Korean input method did not move") + } + ko := Texts{FormHint: " 이동 ", Close: " 닫기 ", Confirm: " 확인 ", ConfirmTyped: " 입력 확인 ", More: " 더 ", Yes: "[x] 예", No: "[ ] 아니요", None: "(없음)", Mismatch: "불일치", Type: "%s 입력: "} + f := &Form{Title: "폼", T: &ko, Fields: []*Field{ToggleField("켜기", false), ChoiceField("고르기", nil, 0)}} + s := NewScreen(80, 24) + f.Draw(s, Style{}) + for _, want := range []string{"[ ] 아니요", "(없음)", " 이동 "} { + if !strings.Contains(s.Text(), want) { + t.Fatalf("form text %q missing\n%s", want, s.Text()) + } + } + typed.T = &ko + typed.Input.SetValue("x") + typed.Handle(KeyEvent(KeyEnter)) + s.Clear() + typed.Draw(s, Style{}) + if !strings.Contains(s.Text(), "alice 입력:") || !strings.Contains(s.Text(), "불일치") || !strings.Contains(s.Text(), " 입력 확인 ") { + t.Fatalf("dialog texts\n%s", s.Text()) + } +} diff --git a/host/internal/tui/widgets.go b/host/internal/tui/widgets.go new file mode 100644 index 0000000..a67c303 --- /dev/null +++ b/host/internal/tui/widgets.go @@ -0,0 +1,540 @@ +package tui + +import ( + "fmt" + "strings" + "unicode/utf8" +) + +type Input struct { + runes []rune + pos int + off int + Max int +} + +func (in *Input) Value() string { return string(in.runes) } + +func (in *Input) SetValue(s string) { + in.runes = in.runes[:0] + in.pos, in.off = 0, 0 + in.insert(CleanPaste(s)) +} + +func (in *Input) insert(s string) { + for _, r := range s { + if in.Max > 0 && len(string(in.runes))+utf8.RuneLen(r) > in.Max { + return + } + in.runes = append(in.runes, 0) + copy(in.runes[in.pos+1:], in.runes[in.pos:]) + in.runes[in.pos] = r + in.pos++ + } +} + +func (in *Input) Handle(ev Event) bool { + if ev.Kind == EventPaste { + in.insert(ev.Text) + return true + } + if ev.Kind != EventKey { + return false + } + switch ev.Key { + case KeyRune: + in.insert(string(cleanRune(ev.Rune))) + case KeyBackspace: + if in.pos > 0 { + in.runes = append(in.runes[:in.pos-1], in.runes[in.pos:]...) + in.pos-- + } + case KeyDelete: + if in.pos < len(in.runes) { + in.runes = append(in.runes[:in.pos], in.runes[in.pos+1:]...) + } + case KeyLeft: + if in.pos > 0 { + in.pos-- + } + case KeyRight: + if in.pos < len(in.runes) { + in.pos++ + } + case KeyHome: + in.pos = 0 + case KeyEnd: + in.pos = len(in.runes) + case KeyCtrl: + switch ev.Rune { + case 'a': + in.pos = 0 + case 'e': + in.pos = len(in.runes) + case 'u': + in.runes = append(in.runes[:0], in.runes[in.pos:]...) + in.pos = 0 + case 'k': + in.runes = in.runes[:in.pos] + case 'w': + i := in.pos + for i > 0 && in.runes[i-1] == ' ' { + i-- + } + for i > 0 && in.runes[i-1] != ' ' { + i-- + } + in.runes = append(in.runes[:i], in.runes[in.pos:]...) + in.pos = i + default: + return false + } + default: + return false + } + return true +} + +func (in *Input) Draw(s *Screen, x, y, w int, st Style, focus bool) { + if w <= 1 { + return + } + if in.off > in.pos { + in.off = in.pos + } + for runesWidth(in.runes[in.off:in.pos]) > w-1 { + in.off++ + } + var b strings.Builder + used := 0 + for _, r := range in.runes[in.off:] { + rw := RuneWidth(r) + if used+rw > w { + break + } + b.WriteRune(r) + used += rw + } + s.Field(x, y, w, b.String(), st) + if focus { + s.Cursor(x+runesWidth(in.runes[in.off:in.pos]), y) + } +} + +func runesWidth(rs []rune) int { + w := 0 + for _, r := range rs { + w += RuneWidth(r) + } + return w +} + +type List struct { + Sel int + Off int +} + +func (l *List) Clamp(n, h int) { + if l.Sel >= n { + l.Sel = n - 1 + } + if l.Sel < 0 { + l.Sel = 0 + } + if h < 1 { + h = 1 + } + if l.Off > l.Sel { + l.Off = l.Sel + } + if l.Sel >= l.Off+h { + l.Off = l.Sel - h + 1 + } + if l.Off > n-h { + l.Off = max(n-h, 0) + } + if l.Off < 0 { + l.Off = 0 + } +} + +func (l *List) Handle(ev Event, n, h int) bool { + ev = Shortcut(ev) + switch { + case ev.Is(KeyUp), ev.IsRune('k'): + l.Sel-- + case ev.Is(KeyDown), ev.IsRune('j'): + l.Sel++ + case ev.Is(KeyPgUp): + l.Sel -= max(h-1, 1) + case ev.Is(KeyPgDn): + l.Sel += max(h-1, 1) + case ev.Is(KeyHome), ev.IsRune('g'): + l.Sel = 0 + case ev.Is(KeyEnd), ev.IsRune('G'): + l.Sel = n - 1 + default: + return false + } + l.Clamp(n, h) + return true +} + +type FieldKind uint8 + +const ( + FieldText FieldKind = iota + FieldToggle + FieldChoice + FieldFlags +) + +type Field struct { + Label string + Kind FieldKind + Input Input + On bool + Options []string + Index int + Checked []bool + Hint string +} + +func TextField(label, value string, max int) *Field { + f := &Field{Label: label, Kind: FieldText} + f.Input.Max = max + f.Input.SetValue(value) + return f +} + +func ToggleField(label string, on bool) *Field { + return &Field{Label: label, Kind: FieldToggle, On: on} +} + +func ChoiceField(label string, options []string, index int) *Field { + return &Field{Label: label, Kind: FieldChoice, Options: options, Index: index} +} + +func FlagsField(label string, options []string, checked []bool) *Field { + return &Field{Label: label, Kind: FieldFlags, Options: options, Checked: checked} +} + +func (f *Field) Value() string { + switch f.Kind { + case FieldText: + return f.Input.Value() + case FieldChoice: + if f.Index >= 0 && f.Index < len(f.Options) { + return f.Options[f.Index] + } + } + return "" +} + +func (f *Field) Selected() []string { + var out []string + for i, on := range f.Checked { + if on { + out = append(out, f.Options[i]) + } + } + return out +} + +func (f *Field) handle(ev Event) bool { + switch f.Kind { + case FieldText: + return f.Input.Handle(ev) + case FieldToggle: + if ev.IsRune(' ') || ev.Is(KeyLeft) || ev.Is(KeyRight) { + f.On = !f.On + return true + } + case FieldChoice: + if len(f.Options) == 0 { + return false + } + switch { + case ev.Is(KeyLeft): + f.Index = (f.Index + len(f.Options) - 1) % len(f.Options) + case ev.Is(KeyRight), ev.IsRune(' '): + f.Index = (f.Index + 1) % len(f.Options) + default: + return false + } + return true + case FieldFlags: + switch { + case ev.Is(KeyLeft): + if f.Index > 0 { + f.Index-- + } + case ev.Is(KeyRight): + if f.Index < len(f.Options)-1 { + f.Index++ + } + case ev.IsRune(' '): + if f.Index < len(f.Checked) { + f.Checked[f.Index] = !f.Checked[f.Index] + } + default: + return false + } + return true + } + return false +} + +type Result uint8 + +const ( + None Result = iota + Submit + Cancel +) + +type Form struct { + Title string + Note []string + Fields []*Field + Focus int + Err string + T *Texts +} + +func (f *Form) Handle(ev Event) Result { + switch { + case ev.Is(KeyEsc): + return Cancel + case ev.Is(KeyTab), ev.Is(KeyDown): + f.Focus = (f.Focus + 1) % len(f.Fields) + return None + case ev.Is(KeyBacktab), ev.Is(KeyUp): + f.Focus = (f.Focus + len(f.Fields) - 1) % len(f.Fields) + return None + case ev.Is(KeyEnter): + if f.Focus == len(f.Fields)-1 { + return Submit + } + f.Focus++ + return None + } + if f.Focus < len(f.Fields) { + f.Fields[f.Focus].handle(ev) + } + return None +} + +func (f *Form) Draw(s *Screen, base Style) { + tx := textsOr(f.T) + w := min(s.W-4, 78) + labelW := 0 + for _, fl := range f.Fields { + labelW = max(labelW, StringWidth(fl.Label)) + } + labelW = min(labelW, w/3) + var notes []string + for _, n := range f.Note { + notes = append(notes, Wrap(n, w-4)...) + } + errs := Wrap(f.Err, w-4) + h := 4 + len(notes) + len(f.Fields)*2 + 1 + if len(errs) > 0 { + h += len(errs) + 1 + } + h = min(h, s.H) + x := (s.W - w) / 2 + y := max((s.H-h)/2, 0) + s.Box(x, y, w, h, f.Title, base) + row := y + 2 + for _, line := range notes { + s.Field(x+2, row, w-4, line, base) + row++ + } + if len(notes) > 0 { + row++ + } + valueX := x + 2 + labelW + 2 + valueW := w - (valueX - x) - 2 + focus := Style{Reverse: true} + for i, fl := range f.Fields { + if row >= y+h-1 { + break + } + wrapped := false + lst := base + if i == f.Focus { + lst.Bold = true + } + s.Field(x+2, row, labelW, fl.Label, lst) + vst := Style{Underline: true} + if i == f.Focus { + vst = focus + } + switch fl.Kind { + case FieldText: + fl.Input.Draw(s, valueX, row, valueW, vst, i == f.Focus) + case FieldToggle: + mark := tx.No + if fl.On { + mark = tx.Yes + } + s.Field(valueX, row, valueW, mark, vst) + case FieldChoice: + v := tx.None + if len(fl.Options) > 0 { + v = "< " + fl.Value() + " >" + } + s.Field(valueX, row, valueW, v, vst) + case FieldFlags: + col, line := valueX, row + for j, opt := range fl.Options { + mark := "[ ]" + if fl.Checked[j] { + mark = "[x]" + } + item := mark + " " + opt + ost := base + if i == f.Focus && j == fl.Index { + ost = focus + } + if col > valueX && col+StringWidth(item) > valueX+valueW { + if line+1 >= y+h-1 || line > row { + break + } + col, line = valueX, line+1 + wrapped = true + } + col += s.Put(col, line, item, ost) + 1 + } + } + if fl.Hint != "" && !wrapped && row+1 < y+h-1 { + s.Field(valueX, row+1, valueW, fl.Hint, Style{Dim: true}) + } + row += 2 + } + for _, line := range errs { + if row >= y+h-1 { + break + } + s.Field(x+2, row, w-4, line, Style{Fg: Red, Bold: true}) + row++ + } + s.Field(x+2, y+h-1, w-4, tx.FormHint, base) +} + +type Dialog struct { + Title string + Lines []string + Ask bool + Confirm string + Input Input + Err string + Danger bool + Off int + T *Texts +} + +func (d *Dialog) Handle(ev Event) Result { + switch { + case ev.Is(KeyUp): + d.Off = max(d.Off-1, 0) + return None + case ev.Is(KeyDown): + d.Off++ + return None + case ev.Is(KeyPgUp): + d.Off = max(d.Off-5, 0) + return None + case ev.Is(KeyPgDn): + d.Off += 5 + return None + } + if d.Confirm == "" { + ev = Shortcut(ev) + } + if !d.Ask { + if ev.Is(KeyEnter) || ev.Is(KeyEsc) || ev.IsRune('q') || ev.IsRune(' ') { + return Cancel + } + return None + } + if ev.Is(KeyEsc) { + return Cancel + } + if d.Confirm != "" { + if ev.Is(KeyEnter) { + if d.Input.Value() == d.Confirm { + return Submit + } + d.Err = textsOr(d.T).Mismatch + return None + } + d.Input.Handle(ev) + return None + } + switch { + case ev.IsRune('y'), ev.IsRune('Y'): + return Submit + case ev.IsRune('n'), ev.IsRune('N'): + return Cancel + } + return None +} + +func (d *Dialog) Draw(s *Screen, base Style) { + tx := textsOr(d.T) + w := min(s.W-4, 78) + var lines []string + for _, l := range d.Lines { + lines = append(lines, Wrap(l, w-4)...) + } + extra := 0 + if d.Ask && d.Confirm != "" { + extra += 2 + } + if d.Err != "" { + extra++ + } + h := min(4+len(lines)+extra, s.H) + room := max(h-4-extra, 1) + more := len(lines) > room + d.Off = min(d.Off, max(len(lines)-room, 0)) + lines = lines[d.Off:min(d.Off+room, len(lines))] + x := (s.W - w) / 2 + y := max((s.H-h)/2, 0) + st := base + if d.Danger { + st.Fg = Red + } + s.Box(x, y, w, h, d.Title, st) + row := y + 2 + for _, line := range lines { + if row >= y+h-1 { + break + } + s.Field(x+2, row, w-4, line, base) + row++ + } + if d.Ask && d.Confirm != "" && row+1 < y+h-1 { + row++ + label := fmt.Sprintf(tx.Type, d.Confirm) + n := s.Put(x+2, row, label, Style{Bold: true}) + d.Input.Draw(s, x+2+n, row, w-4-n, Style{Reverse: true}, true) + row++ + } + if d.Err != "" && row < y+h-1 { + s.Field(x+2, row, w-4, d.Err, Style{Fg: Red, Bold: true}) + } + hint := tx.Close + if d.Ask { + hint = tx.Confirm + if d.Confirm != "" { + hint = tx.ConfirmTyped + } + } + if more { + hint += tx.More + } + s.Field(x+2, y+h-1, w-4, hint, st) +} diff --git a/host/internal/tui/width.go b/host/internal/tui/width.go new file mode 100644 index 0000000..94c8e9c --- /dev/null +++ b/host/internal/tui/width.go @@ -0,0 +1,168 @@ +package tui + +import ( + "strings" + "unicode" + "unicode/utf8" +) + +var wide = [][2]rune{ + {0x1100, 0x115f}, {0x231a, 0x231b}, {0x2329, 0x232a}, {0x23e9, 0x23ec}, {0x23f0, 0x23f0}, + {0x23f3, 0x23f3}, {0x25fd, 0x25fe}, {0x2614, 0x2615}, {0x2648, 0x2653}, {0x267f, 0x267f}, + {0x2693, 0x2693}, {0x26a1, 0x26a1}, {0x26aa, 0x26ab}, {0x26bd, 0x26be}, {0x26c4, 0x26c5}, + {0x26ce, 0x26ce}, {0x26d4, 0x26d4}, {0x26ea, 0x26ea}, {0x26f2, 0x26f3}, {0x26f5, 0x26f5}, + {0x26fa, 0x26fa}, {0x26fd, 0x26fd}, {0x2705, 0x2705}, {0x270a, 0x270b}, {0x2728, 0x2728}, + {0x274c, 0x274c}, {0x274e, 0x274e}, {0x2753, 0x2755}, {0x2757, 0x2757}, {0x2795, 0x2797}, + {0x27b0, 0x27b0}, {0x27bf, 0x27bf}, {0x2b1b, 0x2b1c}, {0x2b50, 0x2b50}, {0x2b55, 0x2b55}, + {0x2e80, 0x303e}, {0x3041, 0x33ff}, {0x3400, 0x4dbf}, {0x4e00, 0x9fff}, {0xa000, 0xa4cf}, + {0xa960, 0xa97f}, {0xac00, 0xd7a3}, {0xf900, 0xfaff}, {0xfe10, 0xfe19}, {0xfe30, 0xfe6f}, + {0xff00, 0xff60}, {0xffe0, 0xffe6}, {0x16fe0, 0x16fe4}, {0x17000, 0x18aff}, {0x1b000, 0x1b2ff}, + {0x1f004, 0x1f004}, {0x1f0cf, 0x1f0cf}, {0x1f18e, 0x1f18e}, {0x1f191, 0x1f19a}, {0x1f200, 0x1f251}, + {0x1f300, 0x1f64f}, {0x1f680, 0x1f6ff}, {0x1f900, 0x1f9ff}, {0x1fa70, 0x1faff}, {0x20000, 0x2fffd}, + {0x30000, 0x3fffd}, +} + +func isWide(r rune) bool { + lo, hi := 0, len(wide) + for lo < hi { + m := (lo + hi) / 2 + switch { + case r < wide[m][0]: + hi = m + case r > wide[m][1]: + lo = m + 1 + default: + return true + } + } + return false +} + +func RuneWidth(r rune) int { + switch { + case r < 0x20 || r == 0x7f || (r >= 0x80 && r < 0xa0): + return 0 + case r < 0x300: + return 1 + case unicode.In(r, unicode.Mn, unicode.Me): + return 0 + case r >= 0x1160 && r <= 0x11ff, r >= 0xd7b0 && r <= 0xd7ff: + return 0 + case isWide(r): + return 2 + } + return 1 +} + +func StringWidth(s string) int { + w := 0 + for _, r := range Clean(s) { + w += RuneWidth(r) + } + return w +} + +func cleanRune(r rune) rune { + switch { + case r == '\t': + return ' ' + case r == utf8.RuneError, r < 0x20, r == 0x7f, r >= 0x80 && r < 0xa0: + return '?' + case r < 0x7f: + return r + case unicode.In(r, unicode.Cf, unicode.Co, unicode.Cs, unicode.Zl, unicode.Zp): + return '?' + case unicode.Is(unicode.Zs, r): + return ' ' + case !unicode.IsPrint(r) && !unicode.In(r, unicode.Mn, unicode.Me): + return '?' + } + return r +} + +func Clean(s string) string { + plain := true + for i := 0; i < len(s); i++ { + if c := s[i]; c < 0x20 || c >= 0x7f { + plain = false + break + } + } + if plain { + return s + } + var b strings.Builder + b.Grow(len(s)) + for _, r := range s { + b.WriteRune(cleanRune(r)) + } + return b.String() +} + +func Fit(s string, w int) string { + if w <= 0 { + return "" + } + s = Clean(s) + var b strings.Builder + used := 0 + cut := false + for _, r := range s { + rw := RuneWidth(r) + if used+rw > w { + cut = true + break + } + b.WriteRune(r) + used += rw + } + if !cut { + return b.String() + strings.Repeat(" ", w-used) + } + out := []rune(b.String()) + for len(out) > 0 && used > w-1 { + used -= RuneWidth(out[len(out)-1]) + out = out[:len(out)-1] + } + return string(out) + "~" + strings.Repeat(" ", w-1-used) +} + +func Wrap(s string, w int) []string { + s = Clean(s) + if w <= 0 { + return nil + } + if StringWidth(s) <= w { + return []string{s} + } + var out []string + var line []rune + used := 0 + flush := func() { + out = append(out, strings.TrimRight(string(line), " ")) + line, used = line[:0], 0 + } + for _, word := range strings.SplitAfter(s, " ") { + ww := StringWidth(word) + if used > 0 && used+StringWidth(strings.TrimRight(word, " ")) > w { + flush() + } + if ww > w { + for _, r := range word { + rw := RuneWidth(r) + if used+rw > w { + flush() + } + line = append(line, r) + used += rw + } + continue + } + line = append(line, []rune(word)...) + used += ww + } + if used > 0 { + flush() + } + return out +} diff --git a/host/internal/winsys/console_windows.go b/host/internal/winsys/console_windows.go new file mode 100644 index 0000000..07b6913 --- /dev/null +++ b/host/internal/winsys/console_windows.go @@ -0,0 +1,90 @@ +//go:build windows + +package winsys + +import ( + "syscall" + "unsafe" +) + +const ( + ConsoleProcessedOutput = 0x1 + ConsoleVirtualTerminalProcessing = 0x4 + ConsoleDisableNewlineAutoReturn = 0x8 + ConsoleWindowInput = 0x8 + + KeyEventType = 0x1 + BufferSizeEventType = 0x4 +) + +type InputRecord struct { + EventType uint16 + _ uint16 + Event [4]uint32 +} + +type KeyRecord struct { + Down bool + Repeat uint16 + VirtualKey uint16 + Char uint16 + ControlState uint32 +} + +func (r *InputRecord) Key() KeyRecord { + return KeyRecord{ + Down: r.Event[0] != 0, + Repeat: uint16(r.Event[1]), + VirtualKey: uint16(r.Event[1] >> 16), + Char: uint16(r.Event[2] >> 16), + ControlState: r.Event[3], + } +} + +type consoleScreenBufferInfo struct { + size [2]int16 + cursor [2]int16 + attributes uint16 + window [4]int16 + maxWindow [2]int16 +} + +func GetConsoleMode(h syscall.Handle) (uint32, error) { + var m uint32 + err := syscall.GetConsoleMode(h, &m) + return m, err +} + +func SetConsoleMode(h syscall.Handle, mode uint32) error { + r, _, err := procSetConsoleMode.Call(uintptr(h), uintptr(mode)) + if r == 0 { + return err + } + return nil +} + +func ConsoleWindowSize(h syscall.Handle) (int, int, error) { + var info consoleScreenBufferInfo + r, _, err := procGetConsoleScreenBufferInfo.Call(uintptr(h), uintptr(unsafe.Pointer(&info))) + if r == 0 { + return 0, 0, err + } + return int(info.window[2]-info.window[0]) + 1, int(info.window[3]-info.window[1]) + 1, nil +} + +func ReadConsoleInput(h syscall.Handle, recs []InputRecord) (int, error) { + if len(recs) == 0 { + return 0, nil + } + var n uint32 + r, _, err := procReadConsoleInputW.Call(uintptr(h), uintptr(unsafe.Pointer(&recs[0])), uintptr(len(recs)), uintptr(unsafe.Pointer(&n))) + if r == 0 { + return 0, err + } + return int(n), nil +} + +func UserUILanguage() uint16 { + r, _, _ := procGetUserDefaultUILanguage.Call() + return uint16(r) +} diff --git a/host/internal/winsys/dll_windows.go b/host/internal/winsys/dll_windows.go index 8cc357c..d477abf 100644 --- a/host/internal/winsys/dll_windows.go +++ b/host/internal/winsys/dll_windows.go @@ -18,6 +18,10 @@ var ( procGetDriveTypeW = kernel32.NewProc("GetDriveTypeW") procGetVolumePathNameW = kernel32.NewProc("GetVolumePathNameW") procLocalFree = kernel32.NewProc("LocalFree") + procSetConsoleMode = kernel32.NewProc("SetConsoleMode") + procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo") + procReadConsoleInputW = kernel32.NewProc("ReadConsoleInputW") + procGetUserDefaultUILanguage = kernel32.NewProc("GetUserDefaultUILanguage") procGetNamedSecurityInfoW = advapi32.NewProc("GetNamedSecurityInfoW") procSetNamedSecurityInfoW = advapi32.NewProc("SetNamedSecurityInfoW") procConvertStringSDToSD = advapi32.NewProc("ConvertStringSecurityDescriptorToSecurityDescriptorW") diff --git a/host/internal/winsys/winsys_windows_test.go b/host/internal/winsys/winsys_windows_test.go index c45811b..0db9c22 100644 --- a/host/internal/winsys/winsys_windows_test.go +++ b/host/internal/winsys/winsys_windows_test.go @@ -178,3 +178,17 @@ func TestNewFilesAreOwnedByCurrentUser(t *testing.T) { t.Fatalf("new file owned by %s", s) } } + +func TestConsoleRecordLayout(t *testing.T) { + if unsafe.Sizeof(InputRecord{}) != 20 || unsafe.Alignof(InputRecord{}) != 4 { + t.Fatalf("INPUT_RECORD layout %d %d", unsafe.Sizeof(InputRecord{}), unsafe.Alignof(InputRecord{})) + } + if unsafe.Sizeof(consoleScreenBufferInfo{}) != 22 { + t.Fatalf("CONSOLE_SCREEN_BUFFER_INFO size %d", unsafe.Sizeof(consoleScreenBufferInfo{})) + } + r := InputRecord{EventType: KeyEventType, Event: [4]uint32{1, 0x0026_0002, 0xac00_0048, 0x10}} + k := r.Key() + if !k.Down || k.Repeat != 2 || k.VirtualKey != 0x26 || k.Char != 0xac00 || k.ControlState != 0x10 { + t.Fatalf("%+v", k) + } +} diff --git a/host/internal/wire/names.go b/host/internal/wire/names.go new file mode 100644 index 0000000..dab78e5 --- /dev/null +++ b/host/internal/wire/names.go @@ -0,0 +1,80 @@ +package wire + +import ( + "errors" + "fmt" + "strings" +) + +type UsageName struct { + Name string + Bit uint32 +} + +var Usages = []UsageName{ + {"encrypt", UsageEncrypt}, + {"decrypt", UsageDecrypt}, + {"sign", UsageSign}, + {"verify", UsageVerify}, + {"wrap", UsageWrap}, + {"unwrap", UsageUnwrap}, + {"derive", UsageDerive}, + {"decapsulate", UsageDecapsulate}, + {"export", UsageExport}, +} + +var algNames = map[uint16]string{ + AlgAES256GCM: "aes-256-gcm", + AlgECDSAP256SHA256: "ecdsa-p256-sha256", + AlgECDSAP384SHA384: "ecdsa-p384-sha384", + AlgEd25519: "ed25519", + AlgDHKEMP256: "dhkem-p256", + AlgMLDSA65: "ml-dsa-65", + AlgMLDSA87: "ml-dsa-87", + AlgMLKEM768: "ml-kem-768", + AlgMLKEM1024: "ml-kem-1024", + AlgHybridP256MLKEM768: "hybrid-p256-ml-kem-768", + AlgMLKEM768P256: "mlkem768-p256", +} + +func AlgName(alg uint16) string { + if s, ok := algNames[alg]; ok { + return s + } + return fmt.Sprintf("0x%04x", alg) +} + +func ParseUsage(s string) (uint32, error) { + var bits uint32 + for _, part := range strings.Split(s, ",") { + part = strings.TrimSpace(strings.ToLower(part)) + if part == "" { + continue + } + found := false + for _, u := range Usages { + if u.Name == part { + bits |= u.Bit + found = true + break + } + } + if !found { + return 0, fmt.Errorf("unknown usage %q", part) + } + } + if bits == 0 { + return 0, errors.New("usage list is empty") + } + return bits, nil +} + +func FormatUsage(bits uint32) string { + var parts []string + for _, u := range Usages { + if bits&u.Bit != 0 { + parts = append(parts, u.Name) + } + } + return strings.Join(parts, ",") +} diff --git a/host/internal/wire/names_test.go b/host/internal/wire/names_test.go new file mode 100644 index 0000000..c89ac21 --- /dev/null +++ b/host/internal/wire/names_test.go @@ -0,0 +1,19 @@ +package wire + +import "testing" + +func TestParseAndFormatUsage(t *testing.T) { + bits, err := ParseUsage("Encrypt, decrypt,export") + if err != nil || FormatUsage(bits) != "encrypt,decrypt,export" { + t.Fatalf("%v %v", bits, err) + } + if _, err := ParseUsage("encrypt,bogus"); err == nil { + t.Fatal("unknown usage accepted") + } + if _, err := ParseUsage(""); err == nil { + t.Fatal("empty usage accepted") + } + if AlgName(AlgAES256GCM) != "aes-256-gcm" || AlgName(0xfffe) != "0xfffe" { + t.Fatal("alg names") + } +}