From 359abc954e4c0fcd0c883ec4abb8c8611fe9d511 Mon Sep 17 00:00:00 2001 From: Marko Bencun Date: Fri, 19 Jun 2026 00:51:19 +0000 Subject: [PATCH 1/2] ci: update golangci-lint and modernize workflows file --- .github/workflows/ci.yml | 93 +++++++++++++------------------- .golangci.yml | 1 + api/firmware/attestation_test.go | 31 +++++------ 3 files changed, 53 insertions(+), 72 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d6a6ccb..711f4a4 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,84 +1,63 @@ -# See reference docs at -# https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions name: ci -on: [push, pull_request] + +on: + push: + pull_request: + +permissions: + contents: read + env: - GO_VERSION: "^1.24" - GOLANGCI_LINT_VERSION: "v2.8.0" + GOLANGCI_LINT_VERSION: "v2.12.2" jobs: lint: - runs-on: ubuntu-22.04 + runs-on: ubuntu-latest steps: - - name: Clone the repo - uses: actions/checkout@v4 - - name: Enable caching - uses: actions/cache@v4 + - name: Check out repository + uses: actions/checkout@v7 + - name: Set up Go + uses: actions/setup-go@v6 with: - # Increment cache number to invalidate. - key: ${{runner.os}}-cache-1 - path: | - ~/go/pkg - ~/.cache/go-build - ~/.cache/golangci-lint - - name: Install Go - uses: actions/setup-go@v4 + go-version-file: go.mod + cache-dependency-path: go.sum + - name: Run golangci-lint + uses: golangci/golangci-lint-action@v9 with: - go-version: ${{env.GO_VERSION}} - # Keep the linter version and its config in .golangci.yml in sync with the app repo at - # https://github.com/BitBoxSwiss/bitbox-wallet-app/blob/98e815c25950dc7f55a27551d053239e6fd804ca/Makefile#L24 - - name: Install golangci-lint - run: | - curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | \ - sh -s -- -b $HOME $GOLANGCI_LINT_VERSION - - name: Lint - run: ~/golangci-lint run + version: ${{ env.GOLANGCI_LINT_VERSION }} + args: ./... + test: - runs-on: ubuntu-22.04 + runs-on: ubuntu-latest steps: - - name: Clone the repo - uses: actions/checkout@v4 - - name: Enable caching - uses: actions/cache@v4 + - name: Check out repository + uses: actions/checkout@v7 + - name: Set up Go + uses: actions/setup-go@v6 with: - # Increment cache number to invalidate. - key: ${{runner.os}}-cache-1 - path: | - ~/go/pkg - ~/.cache/go-build - ~/.cache/golangci-lint + go-version-file: go.mod + cache-dependency-path: go.sum - name: Enable simulators caching uses: actions/cache@v4 with: key: ${{runner.os}}-simulators-cache-${{hashFiles('./api/firmware/testdata/simulators.json')}} path: | ./api/firmware/testdata/simulators - - name: Install Go - uses: actions/setup-go@v4 - with: - go-version: ${{env.GO_VERSION}} - name: Test run: | go version go test ./... -v + build: - runs-on: ubuntu-22.04 + runs-on: ubuntu-latest steps: - - name: Clone the repo - uses: actions/checkout@v4 - - name: Enable caching - uses: actions/cache@v4 - with: - # Increment cache number to invalidate. - key: ${{runner.os}}-cache-1 - path: | - ~/go/pkg - ~/.cache/go-build - ~/.cache/golangci-lint - - name: Install Go - uses: actions/setup-go@v4 + - name: Check out repository + uses: actions/checkout@v7 + - name: Set up Go + uses: actions/setup-go@v6 with: - go-version: ${{env.GO_VERSION}} + go-version-file: go.mod + cache-dependency-path: go.sum - name: Build run: | go version diff --git a/.golangci.yml b/.golangci.yml index 772398b..332fdec 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -25,6 +25,7 @@ linters: - gocognit - gocyclo - godox + - gomodguard - gosec - gosmopolitan - inamedparam diff --git a/api/firmware/attestation_test.go b/api/firmware/attestation_test.go index 19ffcc4..85b1a9a 100644 --- a/api/firmware/attestation_test.go +++ b/api/firmware/attestation_test.go @@ -10,7 +10,6 @@ import ( "crypto/sha256" "encoding/hex" "errors" - "math/big" "testing" "github.com/BitBoxSwiss/bitbox02-api-go/api/common" @@ -44,16 +43,24 @@ func makeCertificate(rootPrivkey *btcec.PrivateKey, bootloaderHash []byte, devic return signature[1:] } -// adapted from ecdsa.GenerateKey() func p256PrivKeyFromBytes(k []byte) *ecdsa.PrivateKey { - priv := new(ecdsa.PrivateKey) - c := elliptic.P256() - priv.Curve = c - priv.D = new(big.Int).SetBytes(k) - priv.X, priv.Y = c.ScalarBaseMult(k) + priv, err := ecdsa.ParseRawPrivateKey(elliptic.P256(), k) + if err != nil { + panic(err) + } return priv } +func p256PubkeyBytes(t *testing.T, priv *ecdsa.PrivateKey) []byte { + t.Helper() + publicKey, ok := priv.Public().(*ecdsa.PublicKey) + require.True(t, ok) + encoded, err := publicKey.Bytes() + require.NoError(t, err) + require.Len(t, encoded, 65) + return encoded[1:] +} + func TestPerformAttestation(t *testing.T) { // Arbitrary values, they do not have any special meaning. @@ -66,10 +73,7 @@ func TestPerformAttestation(t *testing.T) { devicePrivateKey := p256PrivKeyFromBytes( unhex("9b1a4d293a6eef1960d8afab5e58dd581b135152ec3399bde9268fa23051321b"), ) - devicePublicKey := devicePrivateKey.PublicKey - devicePubkeyBytes := make([]byte, 64) - copy(devicePubkeyBytes[:32], devicePublicKey.X.Bytes()) - copy(devicePubkeyBytes[32:], devicePublicKey.Y.Bytes()) + devicePubkeyBytes := p256PubkeyBytes(t, devicePrivateKey) undo := addAttestationPubkey(hex.EncodeToString(rootPublicKey.SerializeUncompressed())) defer undo() @@ -205,10 +209,7 @@ func TestVerifyAttestation(t *testing.T) { devicePrivateKey := p256PrivKeyFromBytes( unhex("9b1a4d293a6eef1960d8afab5e58dd581b135152ec3399bde9268fa23051321b"), ) - devicePublicKey := devicePrivateKey.PublicKey - devicePubkeyBytes := make([]byte, 64) - copy(devicePubkeyBytes[:32], devicePublicKey.X.Bytes()) - copy(devicePubkeyBytes[32:], devicePublicKey.Y.Bytes()) + devicePubkeyBytes := p256PubkeyBytes(t, devicePrivateKey) certificate := makeCertificate(rootPrivateKey, bootloaderHash, devicePubkeyBytes) undo := addAttestationPubkey(hex.EncodeToString(rootPublicKey.SerializeUncompressed())) From 467b4eb62ae009ea2abfafea7ac6b1c6664ca1ac Mon Sep 17 00:00:00 2001 From: Marko Bencun Date: Wed, 6 May 2026 13:47:19 +0000 Subject: [PATCH 2/2] firmware/api: add support for BitBoxSync --- api/firmware/bitboxsync.go | 223 +++++ api/firmware/bitboxsync_test.go | 337 +++++++ api/firmware/messages/antiklepto.pb.go | 2 +- api/firmware/messages/backup_commands.pb.go | 2 +- api/firmware/messages/bitbox02_system.pb.go | 2 +- api/firmware/messages/bitboxsync.pb.go | 932 ++++++++++++++++++ api/firmware/messages/bitboxsync.proto | 72 ++ api/firmware/messages/bluetooth.pb.go | 2 +- api/firmware/messages/btc.pb.go | 2 +- api/firmware/messages/cardano.pb.go | 2 +- api/firmware/messages/common.pb.go | 2 +- api/firmware/messages/eth.pb.go | 2 +- api/firmware/messages/generate.sh | 1 + api/firmware/messages/hww.pb.go | 125 ++- api/firmware/messages/hww.proto | 3 + api/firmware/messages/keystore.pb.go | 2 +- api/firmware/messages/mnemonic.pb.go | 2 +- .../messages/perform_attestation.pb.go | 2 +- api/firmware/messages/system.pb.go | 2 +- go.mod | 13 +- go.sum | 14 +- 21 files changed, 1679 insertions(+), 65 deletions(-) create mode 100644 api/firmware/bitboxsync.go create mode 100644 api/firmware/bitboxsync_test.go create mode 100644 api/firmware/messages/bitboxsync.pb.go create mode 100644 api/firmware/messages/bitboxsync.proto diff --git a/api/firmware/bitboxsync.go b/api/firmware/bitboxsync.go new file mode 100644 index 0000000..e6ec108 --- /dev/null +++ b/api/firmware/bitboxsync.go @@ -0,0 +1,223 @@ +// SPDX-License-Identifier: Apache-2.0 + +package firmware + +import ( + "crypto/ed25519" + + "github.com/BitBoxSwiss/bitbox02-api-go/api/firmware/messages" + "github.com/BitBoxSwiss/bitbox02-api-go/util/errp" + "github.com/BitBoxSwiss/bitbox02-api-go/util/semver" +) + +const ( + bitBoxSyncChallengeLength = 32 + bitBoxSyncWrapPublicKeyLen = 32 + bitBoxSyncNamespaceIDLen = 16 + bitBoxSyncNamespaceDEKLen = 32 + bitBoxSyncInviteIDLen = 16 + bitBoxSyncInviteServerSecretHashLen = 32 + bitBoxSyncWrappedDEKLenV1 = 97 +) + +var bitBoxSyncMinVersion = semver.NewSemVer(9, 27, 0) + +// BitBoxSyncIdentity contains the public keys of the hardware BitBoxSync identity. +type BitBoxSyncIdentity struct { + AuthPublicKey ed25519.PublicKey + WrapPublicKey []byte +} + +func requireLen(name string, value []byte, expected int) error { + if len(value) != expected { + return errp.Newf("%s must be %d bytes", name, expected) + } + return nil +} + +func (device *Device) queryBitBoxSync(request *messages.BitBoxSyncRequest) (*messages.BitBoxSyncResponse, error) { + if !device.version.AtLeast(bitBoxSyncMinVersion) { + return nil, UnsupportedError(bitBoxSyncMinVersion.String()) + } + response, err := device.query(&messages.Request{ + Request: &messages.Request_BitboxSync{ + BitboxSync: request, + }, + }) + if err != nil { + return nil, err + } + bitBoxSyncResponse, ok := response.Response.(*messages.Response_BitboxSync) + if !ok { + return nil, errp.New("unexpected response") + } + return bitBoxSyncResponse.BitboxSync, nil +} + +// BitBoxSyncIdentity returns the hardware BitBoxSync identity public keys. +func (device *Device) BitBoxSyncIdentity() (*BitBoxSyncIdentity, error) { + response, err := device.queryBitBoxSync(&messages.BitBoxSyncRequest{ + Request: &messages.BitBoxSyncRequest_Identity{ + Identity: &messages.BitBoxSyncIdentityRequest{}, + }, + }) + if err != nil { + return nil, err + } + identity := response.GetIdentity() + if identity == nil { + return nil, errp.New("unexpected response") + } + if err := requireLen("auth public key", identity.AuthPublicKey, ed25519.PublicKeySize); err != nil { + return nil, err + } + if err := requireLen("wrap public key", identity.WrapPublicKey, bitBoxSyncWrapPublicKeyLen); err != nil { + return nil, err + } + return &BitBoxSyncIdentity{ + AuthPublicKey: ed25519.PublicKey(identity.AuthPublicKey), + WrapPublicKey: identity.WrapPublicKey, + }, nil +} + +func (device *Device) bitBoxSyncSignature(request *messages.BitBoxSyncRequest) ([]byte, error) { + response, err := device.queryBitBoxSync(request) + if err != nil { + return nil, err + } + signature := response.GetSignature() + if signature == nil { + return nil, errp.New("unexpected response") + } + if err := requireLen("signature", signature.Signature, ed25519.SignatureSize); err != nil { + return nil, err + } + return signature.Signature, nil +} + +// BitBoxSyncSignLoginIntent signs the canonical BitBoxSync login intent. +func (device *Device) BitBoxSyncSignLoginIntent(challenge []byte) ([]byte, error) { + if err := requireLen("challenge", challenge, bitBoxSyncChallengeLength); err != nil { + return nil, err + } + return device.bitBoxSyncSignature(&messages.BitBoxSyncRequest{ + Request: &messages.BitBoxSyncRequest_SignLoginIntent{ + SignLoginIntent: &messages.BitBoxSyncSignLoginIntentRequest{ + Challenge: challenge, + }, + }, + }) +} + +// BitBoxSyncSignRefreshIntent signs the canonical BitBoxSync refresh intent. +func (device *Device) BitBoxSyncSignRefreshIntent(challenge []byte) ([]byte, error) { + if err := requireLen("challenge", challenge, bitBoxSyncChallengeLength); err != nil { + return nil, err + } + return device.bitBoxSyncSignature(&messages.BitBoxSyncRequest{ + Request: &messages.BitBoxSyncRequest_SignRefreshIntent{ + SignRefreshIntent: &messages.BitBoxSyncSignRefreshIntentRequest{ + Challenge: challenge, + }, + }, + }) +} + +// BitBoxSyncSignRevokeAllTokensIntent signs the canonical BitBoxSync revoke-all-tokens intent. +func (device *Device) BitBoxSyncSignRevokeAllTokensIntent(challenge []byte) ([]byte, error) { + if err := requireLen("challenge", challenge, bitBoxSyncChallengeLength); err != nil { + return nil, err + } + return device.bitBoxSyncSignature(&messages.BitBoxSyncRequest{ + Request: &messages.BitBoxSyncRequest_SignRevokeAllTokensIntent{ + SignRevokeAllTokensIntent: &messages.BitBoxSyncSignRevokeAllTokensIntentRequest{ + Challenge: challenge, + }, + }, + }) +} + +// BitBoxSyncSignCreateNamespaceInviteIntent signs the canonical BitBoxSync create-namespace-invite intent. +func (device *Device) BitBoxSyncSignCreateNamespaceInviteIntent( + challenge, namespaceID, inviteID, inviteServerSecretHash []byte, + expiresAt uint64, + maxAccepted uint32, +) ([]byte, error) { + if err := requireLen("challenge", challenge, bitBoxSyncChallengeLength); err != nil { + return nil, err + } + if err := requireLen("namespace ID", namespaceID, bitBoxSyncNamespaceIDLen); err != nil { + return nil, err + } + if err := requireLen("invite ID", inviteID, bitBoxSyncInviteIDLen); err != nil { + return nil, err + } + if err := requireLen("invite server secret hash", inviteServerSecretHash, bitBoxSyncInviteServerSecretHashLen); err != nil { + return nil, err + } + return device.bitBoxSyncSignature(&messages.BitBoxSyncRequest{ + Request: &messages.BitBoxSyncRequest_SignCreateNamespaceInviteIntent{ + SignCreateNamespaceInviteIntent: &messages.BitBoxSyncSignCreateNamespaceInviteIntentRequest{ + Challenge: challenge, + NamespaceId: namespaceID, + InviteId: inviteID, + InviteServerSecretHash: inviteServerSecretHash, + ExpiresAt: expiresAt, + MaxAccepted: maxAccepted, + }, + }, + }) +} + +// BitBoxSyncSignJoinRequestIntent signs the canonical BitBoxSync join-request payload. +func (device *Device) BitBoxSyncSignJoinRequestIntent( + namespaceID, inviteID []byte, + serverOrigin string, + expiresAt uint64, +) ([]byte, error) { + if err := requireLen("namespace ID", namespaceID, bitBoxSyncNamespaceIDLen); err != nil { + return nil, err + } + if err := requireLen("invite ID", inviteID, bitBoxSyncInviteIDLen); err != nil { + return nil, err + } + return device.bitBoxSyncSignature(&messages.BitBoxSyncRequest{ + Request: &messages.BitBoxSyncRequest_SignJoinRequestIntent{ + SignJoinRequestIntent: &messages.BitBoxSyncSignJoinRequestIntentRequest{ + NamespaceId: namespaceID, + InviteId: inviteID, + ServerOrigin: serverOrigin, + ExpiresAt: expiresAt, + }, + }, + }) +} + +// BitBoxSyncUnwrapNamespaceDEK unwraps a namespace DEK with the hardware BitBoxSync identity. +func (device *Device) BitBoxSyncUnwrapNamespaceDEK(namespaceID, wrappedDEK []byte) ([]byte, error) { + if err := requireLen("namespace ID", namespaceID, bitBoxSyncNamespaceIDLen); err != nil { + return nil, err + } + if err := requireLen("wrapped DEK", wrappedDEK, bitBoxSyncWrappedDEKLenV1); err != nil { + return nil, err + } + response, err := device.queryBitBoxSync(&messages.BitBoxSyncRequest{ + Request: &messages.BitBoxSyncRequest_UnwrapNamespaceDek{ + UnwrapNamespaceDek: &messages.BitBoxSyncUnwrapNamespaceDEKRequest{ + NamespaceId: namespaceID, + WrappedDek: wrappedDEK, + }, + }, + }) + if err != nil { + return nil, err + } + unwrapped := response.GetUnwrapNamespaceDek() + if unwrapped == nil { + return nil, errp.New("unexpected response") + } + if err := requireLen("namespace DEK", unwrapped.NamespaceDek, bitBoxSyncNamespaceDEKLen); err != nil { + return nil, err + } + return unwrapped.NamespaceDek, nil +} diff --git a/api/firmware/bitboxsync_test.go b/api/firmware/bitboxsync_test.go new file mode 100644 index 0000000..8a8d803 --- /dev/null +++ b/api/firmware/bitboxsync_test.go @@ -0,0 +1,337 @@ +// SPDX-License-Identifier: Apache-2.0 + +package firmware + +import ( + "bytes" + "crypto/ecdh" + "crypto/ed25519" + "encoding/hex" + "testing" + + "github.com/BitBoxSwiss/bitboxsync-client-go/protocol" + "github.com/stretchr/testify/require" +) + +func requireBitBoxSyncSignature(t *testing.T, identity *BitBoxSyncIdentity, payload, signature []byte) { + t.Helper() + require.Len(t, signature, ed25519.SignatureSize) + require.True(t, ed25519.Verify(identity.AuthPublicKey, payload, signature)) +} + +func mustDecodeHex(t *testing.T, input string) []byte { + t.Helper() + bytes, err := hex.DecodeString(input) + require.NoError(t, err) + return bytes +} + +func fixedBitBoxSyncIdentity(t *testing.T) *BitBoxSyncIdentity { + t.Helper() + return &BitBoxSyncIdentity{ + AuthPublicKey: ed25519.PublicKey(mustDecodeHex(t, "8a88e3dd7409f195fd52db2d3cba5d72ca6709bf1d94121bf3748801b40f6f5c")), + WrapPublicKey: mustDecodeHex(t, "ce8d3ad1ccb633ec7b70c17814a5c76ecd029685050d344745ba05870e587d59"), + } +} + +func bitBoxSyncWrapPublicKey(t *testing.T, identity *BitBoxSyncIdentity) *ecdh.PublicKey { + t.Helper() + wrapPublicKey, err := ecdh.X25519().NewPublicKey(identity.WrapPublicKey) + require.NoError(t, err) + return wrapPublicKey +} + +func TestBitBoxSyncPayloadVectors(t *testing.T) { + identity := fixedBitBoxSyncIdentity(t) + keyID := protocol.KeyIDFromAuthPublicKey(identity.AuthPublicKey) + + actionFields, err := protocol.CreateNamespaceInviteActionFields( + bytes.Repeat([]byte{0x20}, bitBoxSyncNamespaceIDLen), + bytes.Repeat([]byte{0x21}, bitBoxSyncInviteIDLen), + bytes.Repeat([]byte{0x22}, bitBoxSyncInviteServerSecretHashLen), + 0x0102030405060708, + 10, + ) + require.NoError(t, err) + createPayload, err := protocol.SensitiveActionIntent( + bytes.Repeat([]byte{0x13}, bitBoxSyncChallengeLength), + protocol.SensitiveActionCreateNamespaceInvite, + protocol.IdentityKindKeystore, + keyID[:], + actionFields, + ) + require.NoError(t, err) + require.Equal(t, + mustDecodeHex(t, "626974626f7873796e632d696e74656e7401030213131313131313131313131313131313131313131313131313131313131313130134750f98bd59fcfc946da45aaabe933be154a4b5094e1c4abf42866505f3c97e2020202020202020202020202020202021212121212121212121212121212121222222222222222222222222222222222222222222222222222222222222222201020304050607080000000a"), + createPayload, + ) + + serverOrigin := "https://sync.example" + serverOriginHash, err := protocol.ServerOriginHash(serverOrigin) + require.NoError(t, err) + joinPayload, err := protocol.JoinRequestPayload( + protocol.IdentityKindKeystore, + bytes.Repeat([]byte{0x20}, bitBoxSyncNamespaceIDLen), + bytes.Repeat([]byte{0x21}, bitBoxSyncInviteIDLen), + serverOriginHash, + keyID[:], + identity.AuthPublicKey, + bitBoxSyncWrapPublicKey(t, identity), + 0x0102030405060708, + ) + require.NoError(t, err) + require.Equal(t, + mustDecodeHex(t, "626974626f7873796e632d6a6f696e2d72657175657374012020202020202020202020202020202021212121212121212121212121212121ff93ec0a47d8af4a6dc161a681c24d41e1a2ddb9ea6d5c9dc55b106f4c1b6c150134750f98bd59fcfc946da45aaabe933be154a4b5094e1c4abf42866505f3c97e8a88e3dd7409f195fd52db2d3cba5d72ca6709bf1d94121bf3748801b40f6f5cce8d3ad1ccb633ec7b70c17814a5c76ecd029685050d344745ba05870e587d590102030405060708"), + joinPayload, + ) +} + +func TestBitBoxSyncHostSideValidation(t *testing.T) { + device := &Device{} + challenge := bytes.Repeat([]byte{0x01}, bitBoxSyncChallengeLength) + namespaceID := bytes.Repeat([]byte{0x02}, bitBoxSyncNamespaceIDLen) + inviteID := bytes.Repeat([]byte{0x03}, bitBoxSyncInviteIDLen) + inviteServerSecretHash := bytes.Repeat([]byte{0x04}, bitBoxSyncInviteServerSecretHashLen) + + tests := []struct { + name string + sign func() error + errorContains string + }{ + { + name: "create namespace invite challenge", + sign: func() error { + _, err := device.BitBoxSyncSignCreateNamespaceInviteIntent( + challenge[:bitBoxSyncChallengeLength-1], + namespaceID, + inviteID, + inviteServerSecretHash, + 123, + 1, + ) + return err + }, + errorContains: "challenge", + }, + { + name: "create namespace invite namespace ID", + sign: func() error { + _, err := device.BitBoxSyncSignCreateNamespaceInviteIntent( + challenge, + namespaceID[:bitBoxSyncNamespaceIDLen-1], + inviteID, + inviteServerSecretHash, + 123, + 1, + ) + return err + }, + errorContains: "namespace ID", + }, + { + name: "create namespace invite ID", + sign: func() error { + _, err := device.BitBoxSyncSignCreateNamespaceInviteIntent( + challenge, + namespaceID, + inviteID[:bitBoxSyncInviteIDLen-1], + inviteServerSecretHash, + 123, + 1, + ) + return err + }, + errorContains: "invite ID", + }, + { + name: "create namespace invite secret hash", + sign: func() error { + _, err := device.BitBoxSyncSignCreateNamespaceInviteIntent( + challenge, + namespaceID, + inviteID, + inviteServerSecretHash[:bitBoxSyncInviteServerSecretHashLen-1], + 123, + 1, + ) + return err + }, + errorContains: "invite server secret hash", + }, + { + name: "join request namespace ID", + sign: func() error { + _, err := device.BitBoxSyncSignJoinRequestIntent( + namespaceID[:bitBoxSyncNamespaceIDLen-1], + inviteID, + "not host-validated", + 123, + ) + return err + }, + errorContains: "namespace ID", + }, + { + name: "join request invite ID", + sign: func() error { + _, err := device.BitBoxSyncSignJoinRequestIntent( + namespaceID, + inviteID[:bitBoxSyncInviteIDLen-1], + "not host-validated", + 123, + ) + return err + }, + errorContains: "invite ID", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.sign() + require.Error(t, err) + require.Contains(t, err.Error(), tt.errorContains) + }) + } +} + +func TestSimulatorBitBoxSyncIdentity(t *testing.T) { + testInitializedSimulators(t, func(t *testing.T, device *Device, stdOut *bytes.Buffer) { + t.Helper() + if !device.Version().AtLeast(bitBoxSyncMinVersion) { + identity, err := device.BitBoxSyncIdentity() + require.Nil(t, identity) + require.EqualError(t, err, UnsupportedError(bitBoxSyncMinVersion.String()).Error()) + require.NotContains(t, stdOut.String(), "TITLE: BitBoxSync") + return + } + + identity, err := device.BitBoxSyncIdentity() + require.NoError(t, err) + require.Len(t, identity.AuthPublicKey, ed25519.PublicKeySize) + require.Len(t, identity.WrapPublicKey, bitBoxSyncWrapPublicKeyLen) + require.NotContains(t, stdOut.String(), "TITLE: BitBoxSync") + }) +} + +func TestSimulatorBitBoxSyncSignaturesAndUnwrap(t *testing.T) { + testInitializedSimulators(t, func(t *testing.T, device *Device, stdOut *bytes.Buffer) { + t.Helper() + challenge := bytes.Repeat([]byte{0x42}, bitBoxSyncChallengeLength) + namespaceID := bytes.Repeat([]byte{0x11}, bitBoxSyncNamespaceIDLen) + if !device.Version().AtLeast(bitBoxSyncMinVersion) { + _, err := device.BitBoxSyncSignLoginIntent(challenge) + require.EqualError(t, err, UnsupportedError(bitBoxSyncMinVersion.String()).Error()) + + _, err = device.BitBoxSyncUnwrapNamespaceDEK(namespaceID, bytes.Repeat([]byte{0x00}, bitBoxSyncWrappedDEKLenV1)) + require.EqualError(t, err, UnsupportedError(bitBoxSyncMinVersion.String()).Error()) + require.NotContains(t, stdOut.String(), "TITLE: BitBoxSync") + return + } + + identity, err := device.BitBoxSyncIdentity() + require.NoError(t, err) + keyID := protocol.KeyIDFromAuthPublicKey(identity.AuthPublicKey) + wrapPublicKey := bitBoxSyncWrapPublicKey(t, identity) + + loginSig, err := device.BitBoxSyncSignLoginIntent(challenge) + require.NoError(t, err) + loginPayload, err := protocol.LoginIntent( + challenge, + protocol.IdentityKindKeystore, + keyID[:], + identity.AuthPublicKey, + wrapPublicKey, + ) + require.NoError(t, err) + requireBitBoxSyncSignature(t, identity, loginPayload, loginSig) + + refreshSig, err := device.BitBoxSyncSignRefreshIntent(challenge) + require.NoError(t, err) + refreshPayload, err := protocol.RefreshIntent(challenge, protocol.IdentityKindKeystore, keyID[:]) + require.NoError(t, err) + requireBitBoxSyncSignature(t, identity, refreshPayload, refreshSig) + + revokeSig, err := device.BitBoxSyncSignRevokeAllTokensIntent(challenge) + require.NoError(t, err) + revokePayload, err := protocol.SensitiveActionIntent( + challenge, + protocol.SensitiveActionRevokeAllTokens, + protocol.IdentityKindKeystore, + keyID[:], + nil, + ) + require.NoError(t, err) + requireBitBoxSyncSignature(t, identity, revokePayload, revokeSig) + + inviteID := bytes.Repeat([]byte{0x33}, bitBoxSyncInviteIDLen) + inviteServerSecretHash := bytes.Repeat([]byte{0x44}, bitBoxSyncInviteServerSecretHashLen) + createInviteSig, err := device.BitBoxSyncSignCreateNamespaceInviteIntent( + challenge, + namespaceID, + inviteID, + inviteServerSecretHash, + 123456789, + 8, + ) + require.NoError(t, err) + createActionFields, err := protocol.CreateNamespaceInviteActionFields( + namespaceID, + inviteID, + inviteServerSecretHash, + 123456789, + 8, + ) + require.NoError(t, err) + createInvitePayload, err := protocol.SensitiveActionIntent( + challenge, + protocol.SensitiveActionCreateNamespaceInvite, + protocol.IdentityKindKeystore, + keyID[:], + createActionFields, + ) + require.NoError(t, err) + requireBitBoxSyncSignature(t, identity, createInvitePayload, createInviteSig) + + serverOrigin := "https://sync.example" + joinRequestSig, err := device.BitBoxSyncSignJoinRequestIntent(namespaceID, inviteID, serverOrigin, 123456789) + require.NoError(t, err) + serverOriginHash, err := protocol.ServerOriginHash(serverOrigin) + require.NoError(t, err) + joinRequestPayload, err := protocol.JoinRequestPayload( + protocol.IdentityKindKeystore, + namespaceID, + inviteID, + serverOriginHash, + keyID[:], + identity.AuthPublicKey, + wrapPublicKey, + 123456789, + ) + require.NoError(t, err) + requireBitBoxSyncSignature( + t, + identity, + joinRequestPayload, + joinRequestSig, + ) + + namespaceDEK := bytes.Repeat([]byte{0x22}, bitBoxSyncNamespaceDEKLen) + wrappedDEK, err := protocol.WrapNamespaceDEK(wrapPublicKey, namespaceID, namespaceDEK) + require.NoError(t, err) + unwrappedDEK, err := device.BitBoxSyncUnwrapNamespaceDEK(namespaceID, wrappedDEK) + require.NoError(t, err) + require.Equal(t, namespaceDEK, unwrappedDEK) + + wrappedDEK[len(wrappedDEK)-1] ^= 0x01 + _, err = device.BitBoxSyncUnwrapNamespaceDEK(namespaceID, wrappedDEK) + require.Error(t, err) + + stdout := stdOut.String() + require.Contains(t, stdout, "TITLE: BitBoxSync") + require.Contains(t, stdout, "BODY: Login") + require.Contains(t, stdout, "BODY: Refresh session") + require.Contains(t, stdout, "BODY: Revoke all sessions") + require.Contains(t, stdout, "BODY: Create invite") + require.Contains(t, stdout, "BODY: Join namespace") + }) +} diff --git a/api/firmware/messages/antiklepto.pb.go b/api/firmware/messages/antiklepto.pb.go index 9b0c918..6297aa6 100644 --- a/api/firmware/messages/antiklepto.pb.go +++ b/api/firmware/messages/antiklepto.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: antiklepto.proto diff --git a/api/firmware/messages/backup_commands.pb.go b/api/firmware/messages/backup_commands.pb.go index 8ba9ceb..17362e9 100644 --- a/api/firmware/messages/backup_commands.pb.go +++ b/api/firmware/messages/backup_commands.pb.go @@ -4,7 +4,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: backup_commands.proto diff --git a/api/firmware/messages/bitbox02_system.pb.go b/api/firmware/messages/bitbox02_system.pb.go index 259d20b..b623c46 100644 --- a/api/firmware/messages/bitbox02_system.pb.go +++ b/api/firmware/messages/bitbox02_system.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: bitbox02_system.proto diff --git a/api/firmware/messages/bitboxsync.pb.go b/api/firmware/messages/bitboxsync.pb.go new file mode 100644 index 0000000..7bd1d14 --- /dev/null +++ b/api/firmware/messages/bitboxsync.pb.go @@ -0,0 +1,932 @@ +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.6 +// protoc v3.21.12 +// source: bitboxsync.proto + +package messages + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type BitBoxSyncIdentityRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncIdentityRequest) Reset() { + *x = BitBoxSyncIdentityRequest{} + mi := &file_bitboxsync_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncIdentityRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncIdentityRequest) ProtoMessage() {} + +func (x *BitBoxSyncIdentityRequest) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncIdentityRequest.ProtoReflect.Descriptor instead. +func (*BitBoxSyncIdentityRequest) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{0} +} + +type BitBoxSyncIdentityResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + AuthPublicKey []byte `protobuf:"bytes,1,opt,name=auth_public_key,json=authPublicKey,proto3" json:"auth_public_key,omitempty"` + WrapPublicKey []byte `protobuf:"bytes,2,opt,name=wrap_public_key,json=wrapPublicKey,proto3" json:"wrap_public_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncIdentityResponse) Reset() { + *x = BitBoxSyncIdentityResponse{} + mi := &file_bitboxsync_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncIdentityResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncIdentityResponse) ProtoMessage() {} + +func (x *BitBoxSyncIdentityResponse) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncIdentityResponse.ProtoReflect.Descriptor instead. +func (*BitBoxSyncIdentityResponse) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{1} +} + +func (x *BitBoxSyncIdentityResponse) GetAuthPublicKey() []byte { + if x != nil { + return x.AuthPublicKey + } + return nil +} + +func (x *BitBoxSyncIdentityResponse) GetWrapPublicKey() []byte { + if x != nil { + return x.WrapPublicKey + } + return nil +} + +type BitBoxSyncSignLoginIntentRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Challenge []byte `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncSignLoginIntentRequest) Reset() { + *x = BitBoxSyncSignLoginIntentRequest{} + mi := &file_bitboxsync_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncSignLoginIntentRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncSignLoginIntentRequest) ProtoMessage() {} + +func (x *BitBoxSyncSignLoginIntentRequest) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncSignLoginIntentRequest.ProtoReflect.Descriptor instead. +func (*BitBoxSyncSignLoginIntentRequest) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{2} +} + +func (x *BitBoxSyncSignLoginIntentRequest) GetChallenge() []byte { + if x != nil { + return x.Challenge + } + return nil +} + +type BitBoxSyncSignRefreshIntentRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Challenge []byte `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncSignRefreshIntentRequest) Reset() { + *x = BitBoxSyncSignRefreshIntentRequest{} + mi := &file_bitboxsync_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncSignRefreshIntentRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncSignRefreshIntentRequest) ProtoMessage() {} + +func (x *BitBoxSyncSignRefreshIntentRequest) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncSignRefreshIntentRequest.ProtoReflect.Descriptor instead. +func (*BitBoxSyncSignRefreshIntentRequest) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{3} +} + +func (x *BitBoxSyncSignRefreshIntentRequest) GetChallenge() []byte { + if x != nil { + return x.Challenge + } + return nil +} + +type BitBoxSyncSignRevokeAllTokensIntentRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Challenge []byte `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncSignRevokeAllTokensIntentRequest) Reset() { + *x = BitBoxSyncSignRevokeAllTokensIntentRequest{} + mi := &file_bitboxsync_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncSignRevokeAllTokensIntentRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncSignRevokeAllTokensIntentRequest) ProtoMessage() {} + +func (x *BitBoxSyncSignRevokeAllTokensIntentRequest) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncSignRevokeAllTokensIntentRequest.ProtoReflect.Descriptor instead. +func (*BitBoxSyncSignRevokeAllTokensIntentRequest) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{4} +} + +func (x *BitBoxSyncSignRevokeAllTokensIntentRequest) GetChallenge() []byte { + if x != nil { + return x.Challenge + } + return nil +} + +type BitBoxSyncSignCreateNamespaceInviteIntentRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Challenge []byte `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"` + NamespaceId []byte `protobuf:"bytes,2,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + InviteId []byte `protobuf:"bytes,3,opt,name=invite_id,json=inviteId,proto3" json:"invite_id,omitempty"` + InviteServerSecretHash []byte `protobuf:"bytes,4,opt,name=invite_server_secret_hash,json=inviteServerSecretHash,proto3" json:"invite_server_secret_hash,omitempty"` + ExpiresAt uint64 `protobuf:"varint,5,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"` + MaxAccepted uint32 `protobuf:"varint,6,opt,name=max_accepted,json=maxAccepted,proto3" json:"max_accepted,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncSignCreateNamespaceInviteIntentRequest) Reset() { + *x = BitBoxSyncSignCreateNamespaceInviteIntentRequest{} + mi := &file_bitboxsync_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncSignCreateNamespaceInviteIntentRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncSignCreateNamespaceInviteIntentRequest) ProtoMessage() {} + +func (x *BitBoxSyncSignCreateNamespaceInviteIntentRequest) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncSignCreateNamespaceInviteIntentRequest.ProtoReflect.Descriptor instead. +func (*BitBoxSyncSignCreateNamespaceInviteIntentRequest) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{5} +} + +func (x *BitBoxSyncSignCreateNamespaceInviteIntentRequest) GetChallenge() []byte { + if x != nil { + return x.Challenge + } + return nil +} + +func (x *BitBoxSyncSignCreateNamespaceInviteIntentRequest) GetNamespaceId() []byte { + if x != nil { + return x.NamespaceId + } + return nil +} + +func (x *BitBoxSyncSignCreateNamespaceInviteIntentRequest) GetInviteId() []byte { + if x != nil { + return x.InviteId + } + return nil +} + +func (x *BitBoxSyncSignCreateNamespaceInviteIntentRequest) GetInviteServerSecretHash() []byte { + if x != nil { + return x.InviteServerSecretHash + } + return nil +} + +func (x *BitBoxSyncSignCreateNamespaceInviteIntentRequest) GetExpiresAt() uint64 { + if x != nil { + return x.ExpiresAt + } + return 0 +} + +func (x *BitBoxSyncSignCreateNamespaceInviteIntentRequest) GetMaxAccepted() uint32 { + if x != nil { + return x.MaxAccepted + } + return 0 +} + +type BitBoxSyncSignJoinRequestIntentRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId []byte `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + InviteId []byte `protobuf:"bytes,2,opt,name=invite_id,json=inviteId,proto3" json:"invite_id,omitempty"` + ServerOrigin string `protobuf:"bytes,3,opt,name=server_origin,json=serverOrigin,proto3" json:"server_origin,omitempty"` + ExpiresAt uint64 `protobuf:"varint,4,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncSignJoinRequestIntentRequest) Reset() { + *x = BitBoxSyncSignJoinRequestIntentRequest{} + mi := &file_bitboxsync_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncSignJoinRequestIntentRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncSignJoinRequestIntentRequest) ProtoMessage() {} + +func (x *BitBoxSyncSignJoinRequestIntentRequest) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncSignJoinRequestIntentRequest.ProtoReflect.Descriptor instead. +func (*BitBoxSyncSignJoinRequestIntentRequest) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{6} +} + +func (x *BitBoxSyncSignJoinRequestIntentRequest) GetNamespaceId() []byte { + if x != nil { + return x.NamespaceId + } + return nil +} + +func (x *BitBoxSyncSignJoinRequestIntentRequest) GetInviteId() []byte { + if x != nil { + return x.InviteId + } + return nil +} + +func (x *BitBoxSyncSignJoinRequestIntentRequest) GetServerOrigin() string { + if x != nil { + return x.ServerOrigin + } + return "" +} + +func (x *BitBoxSyncSignJoinRequestIntentRequest) GetExpiresAt() uint64 { + if x != nil { + return x.ExpiresAt + } + return 0 +} + +type BitBoxSyncUnwrapNamespaceDEKRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId []byte `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + WrappedDek []byte `protobuf:"bytes,2,opt,name=wrapped_dek,json=wrappedDek,proto3" json:"wrapped_dek,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncUnwrapNamespaceDEKRequest) Reset() { + *x = BitBoxSyncUnwrapNamespaceDEKRequest{} + mi := &file_bitboxsync_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncUnwrapNamespaceDEKRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncUnwrapNamespaceDEKRequest) ProtoMessage() {} + +func (x *BitBoxSyncUnwrapNamespaceDEKRequest) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncUnwrapNamespaceDEKRequest.ProtoReflect.Descriptor instead. +func (*BitBoxSyncUnwrapNamespaceDEKRequest) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{7} +} + +func (x *BitBoxSyncUnwrapNamespaceDEKRequest) GetNamespaceId() []byte { + if x != nil { + return x.NamespaceId + } + return nil +} + +func (x *BitBoxSyncUnwrapNamespaceDEKRequest) GetWrappedDek() []byte { + if x != nil { + return x.WrappedDek + } + return nil +} + +type BitBoxSyncSignatureResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncSignatureResponse) Reset() { + *x = BitBoxSyncSignatureResponse{} + mi := &file_bitboxsync_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncSignatureResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncSignatureResponse) ProtoMessage() {} + +func (x *BitBoxSyncSignatureResponse) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncSignatureResponse.ProtoReflect.Descriptor instead. +func (*BitBoxSyncSignatureResponse) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{8} +} + +func (x *BitBoxSyncSignatureResponse) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +type BitBoxSyncUnwrapNamespaceDEKResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceDek []byte `protobuf:"bytes,1,opt,name=namespace_dek,json=namespaceDek,proto3" json:"namespace_dek,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncUnwrapNamespaceDEKResponse) Reset() { + *x = BitBoxSyncUnwrapNamespaceDEKResponse{} + mi := &file_bitboxsync_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncUnwrapNamespaceDEKResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncUnwrapNamespaceDEKResponse) ProtoMessage() {} + +func (x *BitBoxSyncUnwrapNamespaceDEKResponse) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncUnwrapNamespaceDEKResponse.ProtoReflect.Descriptor instead. +func (*BitBoxSyncUnwrapNamespaceDEKResponse) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{9} +} + +func (x *BitBoxSyncUnwrapNamespaceDEKResponse) GetNamespaceDek() []byte { + if x != nil { + return x.NamespaceDek + } + return nil +} + +type BitBoxSyncRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Request: + // + // *BitBoxSyncRequest_Identity + // *BitBoxSyncRequest_SignLoginIntent + // *BitBoxSyncRequest_SignRefreshIntent + // *BitBoxSyncRequest_SignRevokeAllTokensIntent + // *BitBoxSyncRequest_SignCreateNamespaceInviteIntent + // *BitBoxSyncRequest_SignJoinRequestIntent + // *BitBoxSyncRequest_UnwrapNamespaceDek + Request isBitBoxSyncRequest_Request `protobuf_oneof:"request"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncRequest) Reset() { + *x = BitBoxSyncRequest{} + mi := &file_bitboxsync_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncRequest) ProtoMessage() {} + +func (x *BitBoxSyncRequest) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncRequest.ProtoReflect.Descriptor instead. +func (*BitBoxSyncRequest) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{10} +} + +func (x *BitBoxSyncRequest) GetRequest() isBitBoxSyncRequest_Request { + if x != nil { + return x.Request + } + return nil +} + +func (x *BitBoxSyncRequest) GetIdentity() *BitBoxSyncIdentityRequest { + if x != nil { + if x, ok := x.Request.(*BitBoxSyncRequest_Identity); ok { + return x.Identity + } + } + return nil +} + +func (x *BitBoxSyncRequest) GetSignLoginIntent() *BitBoxSyncSignLoginIntentRequest { + if x != nil { + if x, ok := x.Request.(*BitBoxSyncRequest_SignLoginIntent); ok { + return x.SignLoginIntent + } + } + return nil +} + +func (x *BitBoxSyncRequest) GetSignRefreshIntent() *BitBoxSyncSignRefreshIntentRequest { + if x != nil { + if x, ok := x.Request.(*BitBoxSyncRequest_SignRefreshIntent); ok { + return x.SignRefreshIntent + } + } + return nil +} + +func (x *BitBoxSyncRequest) GetSignRevokeAllTokensIntent() *BitBoxSyncSignRevokeAllTokensIntentRequest { + if x != nil { + if x, ok := x.Request.(*BitBoxSyncRequest_SignRevokeAllTokensIntent); ok { + return x.SignRevokeAllTokensIntent + } + } + return nil +} + +func (x *BitBoxSyncRequest) GetSignCreateNamespaceInviteIntent() *BitBoxSyncSignCreateNamespaceInviteIntentRequest { + if x != nil { + if x, ok := x.Request.(*BitBoxSyncRequest_SignCreateNamespaceInviteIntent); ok { + return x.SignCreateNamespaceInviteIntent + } + } + return nil +} + +func (x *BitBoxSyncRequest) GetSignJoinRequestIntent() *BitBoxSyncSignJoinRequestIntentRequest { + if x != nil { + if x, ok := x.Request.(*BitBoxSyncRequest_SignJoinRequestIntent); ok { + return x.SignJoinRequestIntent + } + } + return nil +} + +func (x *BitBoxSyncRequest) GetUnwrapNamespaceDek() *BitBoxSyncUnwrapNamespaceDEKRequest { + if x != nil { + if x, ok := x.Request.(*BitBoxSyncRequest_UnwrapNamespaceDek); ok { + return x.UnwrapNamespaceDek + } + } + return nil +} + +type isBitBoxSyncRequest_Request interface { + isBitBoxSyncRequest_Request() +} + +type BitBoxSyncRequest_Identity struct { + Identity *BitBoxSyncIdentityRequest `protobuf:"bytes,1,opt,name=identity,proto3,oneof"` +} + +type BitBoxSyncRequest_SignLoginIntent struct { + SignLoginIntent *BitBoxSyncSignLoginIntentRequest `protobuf:"bytes,2,opt,name=sign_login_intent,json=signLoginIntent,proto3,oneof"` +} + +type BitBoxSyncRequest_SignRefreshIntent struct { + SignRefreshIntent *BitBoxSyncSignRefreshIntentRequest `protobuf:"bytes,3,opt,name=sign_refresh_intent,json=signRefreshIntent,proto3,oneof"` +} + +type BitBoxSyncRequest_SignRevokeAllTokensIntent struct { + SignRevokeAllTokensIntent *BitBoxSyncSignRevokeAllTokensIntentRequest `protobuf:"bytes,4,opt,name=sign_revoke_all_tokens_intent,json=signRevokeAllTokensIntent,proto3,oneof"` +} + +type BitBoxSyncRequest_SignCreateNamespaceInviteIntent struct { + SignCreateNamespaceInviteIntent *BitBoxSyncSignCreateNamespaceInviteIntentRequest `protobuf:"bytes,5,opt,name=sign_create_namespace_invite_intent,json=signCreateNamespaceInviteIntent,proto3,oneof"` +} + +type BitBoxSyncRequest_SignJoinRequestIntent struct { + SignJoinRequestIntent *BitBoxSyncSignJoinRequestIntentRequest `protobuf:"bytes,6,opt,name=sign_join_request_intent,json=signJoinRequestIntent,proto3,oneof"` +} + +type BitBoxSyncRequest_UnwrapNamespaceDek struct { + UnwrapNamespaceDek *BitBoxSyncUnwrapNamespaceDEKRequest `protobuf:"bytes,7,opt,name=unwrap_namespace_dek,json=unwrapNamespaceDek,proto3,oneof"` +} + +func (*BitBoxSyncRequest_Identity) isBitBoxSyncRequest_Request() {} + +func (*BitBoxSyncRequest_SignLoginIntent) isBitBoxSyncRequest_Request() {} + +func (*BitBoxSyncRequest_SignRefreshIntent) isBitBoxSyncRequest_Request() {} + +func (*BitBoxSyncRequest_SignRevokeAllTokensIntent) isBitBoxSyncRequest_Request() {} + +func (*BitBoxSyncRequest_SignCreateNamespaceInviteIntent) isBitBoxSyncRequest_Request() {} + +func (*BitBoxSyncRequest_SignJoinRequestIntent) isBitBoxSyncRequest_Request() {} + +func (*BitBoxSyncRequest_UnwrapNamespaceDek) isBitBoxSyncRequest_Request() {} + +type BitBoxSyncResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Response: + // + // *BitBoxSyncResponse_Identity + // *BitBoxSyncResponse_Signature + // *BitBoxSyncResponse_UnwrapNamespaceDek + Response isBitBoxSyncResponse_Response `protobuf_oneof:"response"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BitBoxSyncResponse) Reset() { + *x = BitBoxSyncResponse{} + mi := &file_bitboxsync_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BitBoxSyncResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BitBoxSyncResponse) ProtoMessage() {} + +func (x *BitBoxSyncResponse) ProtoReflect() protoreflect.Message { + mi := &file_bitboxsync_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BitBoxSyncResponse.ProtoReflect.Descriptor instead. +func (*BitBoxSyncResponse) Descriptor() ([]byte, []int) { + return file_bitboxsync_proto_rawDescGZIP(), []int{11} +} + +func (x *BitBoxSyncResponse) GetResponse() isBitBoxSyncResponse_Response { + if x != nil { + return x.Response + } + return nil +} + +func (x *BitBoxSyncResponse) GetIdentity() *BitBoxSyncIdentityResponse { + if x != nil { + if x, ok := x.Response.(*BitBoxSyncResponse_Identity); ok { + return x.Identity + } + } + return nil +} + +func (x *BitBoxSyncResponse) GetSignature() *BitBoxSyncSignatureResponse { + if x != nil { + if x, ok := x.Response.(*BitBoxSyncResponse_Signature); ok { + return x.Signature + } + } + return nil +} + +func (x *BitBoxSyncResponse) GetUnwrapNamespaceDek() *BitBoxSyncUnwrapNamespaceDEKResponse { + if x != nil { + if x, ok := x.Response.(*BitBoxSyncResponse_UnwrapNamespaceDek); ok { + return x.UnwrapNamespaceDek + } + } + return nil +} + +type isBitBoxSyncResponse_Response interface { + isBitBoxSyncResponse_Response() +} + +type BitBoxSyncResponse_Identity struct { + Identity *BitBoxSyncIdentityResponse `protobuf:"bytes,1,opt,name=identity,proto3,oneof"` +} + +type BitBoxSyncResponse_Signature struct { + Signature *BitBoxSyncSignatureResponse `protobuf:"bytes,2,opt,name=signature,proto3,oneof"` +} + +type BitBoxSyncResponse_UnwrapNamespaceDek struct { + UnwrapNamespaceDek *BitBoxSyncUnwrapNamespaceDEKResponse `protobuf:"bytes,3,opt,name=unwrap_namespace_dek,json=unwrapNamespaceDek,proto3,oneof"` +} + +func (*BitBoxSyncResponse_Identity) isBitBoxSyncResponse_Response() {} + +func (*BitBoxSyncResponse_Signature) isBitBoxSyncResponse_Response() {} + +func (*BitBoxSyncResponse_UnwrapNamespaceDek) isBitBoxSyncResponse_Response() {} + +var File_bitboxsync_proto protoreflect.FileDescriptor + +const file_bitboxsync_proto_rawDesc = "" + + "\n" + + "\x10bitboxsync.proto\x12\x14shiftcrypto.bitbox02\"\x1b\n" + + "\x19BitBoxSyncIdentityRequest\"l\n" + + "\x1aBitBoxSyncIdentityResponse\x12&\n" + + "\x0fauth_public_key\x18\x01 \x01(\fR\rauthPublicKey\x12&\n" + + "\x0fwrap_public_key\x18\x02 \x01(\fR\rwrapPublicKey\"@\n" + + " BitBoxSyncSignLoginIntentRequest\x12\x1c\n" + + "\tchallenge\x18\x01 \x01(\fR\tchallenge\"B\n" + + "\"BitBoxSyncSignRefreshIntentRequest\x12\x1c\n" + + "\tchallenge\x18\x01 \x01(\fR\tchallenge\"J\n" + + "*BitBoxSyncSignRevokeAllTokensIntentRequest\x12\x1c\n" + + "\tchallenge\x18\x01 \x01(\fR\tchallenge\"\x8d\x02\n" + + "0BitBoxSyncSignCreateNamespaceInviteIntentRequest\x12\x1c\n" + + "\tchallenge\x18\x01 \x01(\fR\tchallenge\x12!\n" + + "\fnamespace_id\x18\x02 \x01(\fR\vnamespaceId\x12\x1b\n" + + "\tinvite_id\x18\x03 \x01(\fR\binviteId\x129\n" + + "\x19invite_server_secret_hash\x18\x04 \x01(\fR\x16inviteServerSecretHash\x12\x1d\n" + + "\n" + + "expires_at\x18\x05 \x01(\x04R\texpiresAt\x12!\n" + + "\fmax_accepted\x18\x06 \x01(\rR\vmaxAccepted\"\xac\x01\n" + + "&BitBoxSyncSignJoinRequestIntentRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\fR\vnamespaceId\x12\x1b\n" + + "\tinvite_id\x18\x02 \x01(\fR\binviteId\x12#\n" + + "\rserver_origin\x18\x03 \x01(\tR\fserverOrigin\x12\x1d\n" + + "\n" + + "expires_at\x18\x04 \x01(\x04R\texpiresAt\"i\n" + + "#BitBoxSyncUnwrapNamespaceDEKRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\fR\vnamespaceId\x12\x1f\n" + + "\vwrapped_dek\x18\x02 \x01(\fR\n" + + "wrappedDek\";\n" + + "\x1bBitBoxSyncSignatureResponse\x12\x1c\n" + + "\tsignature\x18\x01 \x01(\fR\tsignature\"K\n" + + "$BitBoxSyncUnwrapNamespaceDEKResponse\x12#\n" + + "\rnamespace_dek\x18\x01 \x01(\fR\fnamespaceDek\"\xc7\x06\n" + + "\x11BitBoxSyncRequest\x12M\n" + + "\bidentity\x18\x01 \x01(\v2/.shiftcrypto.bitbox02.BitBoxSyncIdentityRequestH\x00R\bidentity\x12d\n" + + "\x11sign_login_intent\x18\x02 \x01(\v26.shiftcrypto.bitbox02.BitBoxSyncSignLoginIntentRequestH\x00R\x0fsignLoginIntent\x12j\n" + + "\x13sign_refresh_intent\x18\x03 \x01(\v28.shiftcrypto.bitbox02.BitBoxSyncSignRefreshIntentRequestH\x00R\x11signRefreshIntent\x12\x84\x01\n" + + "\x1dsign_revoke_all_tokens_intent\x18\x04 \x01(\v2@.shiftcrypto.bitbox02.BitBoxSyncSignRevokeAllTokensIntentRequestH\x00R\x19signRevokeAllTokensIntent\x12\x96\x01\n" + + "#sign_create_namespace_invite_intent\x18\x05 \x01(\v2F.shiftcrypto.bitbox02.BitBoxSyncSignCreateNamespaceInviteIntentRequestH\x00R\x1fsignCreateNamespaceInviteIntent\x12w\n" + + "\x18sign_join_request_intent\x18\x06 \x01(\v2<.shiftcrypto.bitbox02.BitBoxSyncSignJoinRequestIntentRequestH\x00R\x15signJoinRequestIntent\x12m\n" + + "\x14unwrap_namespace_dek\x18\a \x01(\v29.shiftcrypto.bitbox02.BitBoxSyncUnwrapNamespaceDEKRequestH\x00R\x12unwrapNamespaceDekB\t\n" + + "\arequest\"\xb3\x02\n" + + "\x12BitBoxSyncResponse\x12N\n" + + "\bidentity\x18\x01 \x01(\v20.shiftcrypto.bitbox02.BitBoxSyncIdentityResponseH\x00R\bidentity\x12Q\n" + + "\tsignature\x18\x02 \x01(\v21.shiftcrypto.bitbox02.BitBoxSyncSignatureResponseH\x00R\tsignature\x12n\n" + + "\x14unwrap_namespace_dek\x18\x03 \x01(\v2:.shiftcrypto.bitbox02.BitBoxSyncUnwrapNamespaceDEKResponseH\x00R\x12unwrapNamespaceDekB\n" + + "\n" + + "\bresponseb\x06proto3" + +var ( + file_bitboxsync_proto_rawDescOnce sync.Once + file_bitboxsync_proto_rawDescData []byte +) + +func file_bitboxsync_proto_rawDescGZIP() []byte { + file_bitboxsync_proto_rawDescOnce.Do(func() { + file_bitboxsync_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_bitboxsync_proto_rawDesc), len(file_bitboxsync_proto_rawDesc))) + }) + return file_bitboxsync_proto_rawDescData +} + +var file_bitboxsync_proto_msgTypes = make([]protoimpl.MessageInfo, 12) +var file_bitboxsync_proto_goTypes = []any{ + (*BitBoxSyncIdentityRequest)(nil), // 0: shiftcrypto.bitbox02.BitBoxSyncIdentityRequest + (*BitBoxSyncIdentityResponse)(nil), // 1: shiftcrypto.bitbox02.BitBoxSyncIdentityResponse + (*BitBoxSyncSignLoginIntentRequest)(nil), // 2: shiftcrypto.bitbox02.BitBoxSyncSignLoginIntentRequest + (*BitBoxSyncSignRefreshIntentRequest)(nil), // 3: shiftcrypto.bitbox02.BitBoxSyncSignRefreshIntentRequest + (*BitBoxSyncSignRevokeAllTokensIntentRequest)(nil), // 4: shiftcrypto.bitbox02.BitBoxSyncSignRevokeAllTokensIntentRequest + (*BitBoxSyncSignCreateNamespaceInviteIntentRequest)(nil), // 5: shiftcrypto.bitbox02.BitBoxSyncSignCreateNamespaceInviteIntentRequest + (*BitBoxSyncSignJoinRequestIntentRequest)(nil), // 6: shiftcrypto.bitbox02.BitBoxSyncSignJoinRequestIntentRequest + (*BitBoxSyncUnwrapNamespaceDEKRequest)(nil), // 7: shiftcrypto.bitbox02.BitBoxSyncUnwrapNamespaceDEKRequest + (*BitBoxSyncSignatureResponse)(nil), // 8: shiftcrypto.bitbox02.BitBoxSyncSignatureResponse + (*BitBoxSyncUnwrapNamespaceDEKResponse)(nil), // 9: shiftcrypto.bitbox02.BitBoxSyncUnwrapNamespaceDEKResponse + (*BitBoxSyncRequest)(nil), // 10: shiftcrypto.bitbox02.BitBoxSyncRequest + (*BitBoxSyncResponse)(nil), // 11: shiftcrypto.bitbox02.BitBoxSyncResponse +} +var file_bitboxsync_proto_depIdxs = []int32{ + 0, // 0: shiftcrypto.bitbox02.BitBoxSyncRequest.identity:type_name -> shiftcrypto.bitbox02.BitBoxSyncIdentityRequest + 2, // 1: shiftcrypto.bitbox02.BitBoxSyncRequest.sign_login_intent:type_name -> shiftcrypto.bitbox02.BitBoxSyncSignLoginIntentRequest + 3, // 2: shiftcrypto.bitbox02.BitBoxSyncRequest.sign_refresh_intent:type_name -> shiftcrypto.bitbox02.BitBoxSyncSignRefreshIntentRequest + 4, // 3: shiftcrypto.bitbox02.BitBoxSyncRequest.sign_revoke_all_tokens_intent:type_name -> shiftcrypto.bitbox02.BitBoxSyncSignRevokeAllTokensIntentRequest + 5, // 4: shiftcrypto.bitbox02.BitBoxSyncRequest.sign_create_namespace_invite_intent:type_name -> shiftcrypto.bitbox02.BitBoxSyncSignCreateNamespaceInviteIntentRequest + 6, // 5: shiftcrypto.bitbox02.BitBoxSyncRequest.sign_join_request_intent:type_name -> shiftcrypto.bitbox02.BitBoxSyncSignJoinRequestIntentRequest + 7, // 6: shiftcrypto.bitbox02.BitBoxSyncRequest.unwrap_namespace_dek:type_name -> shiftcrypto.bitbox02.BitBoxSyncUnwrapNamespaceDEKRequest + 1, // 7: shiftcrypto.bitbox02.BitBoxSyncResponse.identity:type_name -> shiftcrypto.bitbox02.BitBoxSyncIdentityResponse + 8, // 8: shiftcrypto.bitbox02.BitBoxSyncResponse.signature:type_name -> shiftcrypto.bitbox02.BitBoxSyncSignatureResponse + 9, // 9: shiftcrypto.bitbox02.BitBoxSyncResponse.unwrap_namespace_dek:type_name -> shiftcrypto.bitbox02.BitBoxSyncUnwrapNamespaceDEKResponse + 10, // [10:10] is the sub-list for method output_type + 10, // [10:10] is the sub-list for method input_type + 10, // [10:10] is the sub-list for extension type_name + 10, // [10:10] is the sub-list for extension extendee + 0, // [0:10] is the sub-list for field type_name +} + +func init() { file_bitboxsync_proto_init() } +func file_bitboxsync_proto_init() { + if File_bitboxsync_proto != nil { + return + } + file_bitboxsync_proto_msgTypes[10].OneofWrappers = []any{ + (*BitBoxSyncRequest_Identity)(nil), + (*BitBoxSyncRequest_SignLoginIntent)(nil), + (*BitBoxSyncRequest_SignRefreshIntent)(nil), + (*BitBoxSyncRequest_SignRevokeAllTokensIntent)(nil), + (*BitBoxSyncRequest_SignCreateNamespaceInviteIntent)(nil), + (*BitBoxSyncRequest_SignJoinRequestIntent)(nil), + (*BitBoxSyncRequest_UnwrapNamespaceDek)(nil), + } + file_bitboxsync_proto_msgTypes[11].OneofWrappers = []any{ + (*BitBoxSyncResponse_Identity)(nil), + (*BitBoxSyncResponse_Signature)(nil), + (*BitBoxSyncResponse_UnwrapNamespaceDek)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_bitboxsync_proto_rawDesc), len(file_bitboxsync_proto_rawDesc)), + NumEnums: 0, + NumMessages: 12, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_bitboxsync_proto_goTypes, + DependencyIndexes: file_bitboxsync_proto_depIdxs, + MessageInfos: file_bitboxsync_proto_msgTypes, + }.Build() + File_bitboxsync_proto = out.File + file_bitboxsync_proto_goTypes = nil + file_bitboxsync_proto_depIdxs = nil +} diff --git a/api/firmware/messages/bitboxsync.proto b/api/firmware/messages/bitboxsync.proto new file mode 100644 index 0000000..6c0e8f1 --- /dev/null +++ b/api/firmware/messages/bitboxsync.proto @@ -0,0 +1,72 @@ +// SPDX-License-Identifier: Apache-2.0 + +syntax = "proto3"; +package shiftcrypto.bitbox02; + +message BitBoxSyncIdentityRequest {} + +message BitBoxSyncIdentityResponse { + bytes auth_public_key = 1; + bytes wrap_public_key = 2; +} + +message BitBoxSyncSignLoginIntentRequest { + bytes challenge = 1; +} + +message BitBoxSyncSignRefreshIntentRequest { + bytes challenge = 1; +} + +message BitBoxSyncSignRevokeAllTokensIntentRequest { + bytes challenge = 1; +} + +message BitBoxSyncSignCreateNamespaceInviteIntentRequest { + bytes challenge = 1; + bytes namespace_id = 2; + bytes invite_id = 3; + bytes invite_server_secret_hash = 4; + uint64 expires_at = 5; + uint32 max_accepted = 6; +} + +message BitBoxSyncSignJoinRequestIntentRequest { + bytes namespace_id = 1; + bytes invite_id = 2; + string server_origin = 3; + uint64 expires_at = 4; +} + +message BitBoxSyncUnwrapNamespaceDEKRequest { + bytes namespace_id = 1; + bytes wrapped_dek = 2; +} + +message BitBoxSyncSignatureResponse { + bytes signature = 1; +} + +message BitBoxSyncUnwrapNamespaceDEKResponse { + bytes namespace_dek = 1; +} + +message BitBoxSyncRequest { + oneof request { + BitBoxSyncIdentityRequest identity = 1; + BitBoxSyncSignLoginIntentRequest sign_login_intent = 2; + BitBoxSyncSignRefreshIntentRequest sign_refresh_intent = 3; + BitBoxSyncSignRevokeAllTokensIntentRequest sign_revoke_all_tokens_intent = 4; + BitBoxSyncSignCreateNamespaceInviteIntentRequest sign_create_namespace_invite_intent = 5; + BitBoxSyncSignJoinRequestIntentRequest sign_join_request_intent = 6; + BitBoxSyncUnwrapNamespaceDEKRequest unwrap_namespace_dek = 7; + } +} + +message BitBoxSyncResponse { + oneof response { + BitBoxSyncIdentityResponse identity = 1; + BitBoxSyncSignatureResponse signature = 2; + BitBoxSyncUnwrapNamespaceDEKResponse unwrap_namespace_dek = 3; + } +} diff --git a/api/firmware/messages/bluetooth.pb.go b/api/firmware/messages/bluetooth.pb.go index dcd965f..a7eed77 100644 --- a/api/firmware/messages/bluetooth.pb.go +++ b/api/firmware/messages/bluetooth.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: bluetooth.proto diff --git a/api/firmware/messages/btc.pb.go b/api/firmware/messages/btc.pb.go index c6c9cb8..d1b2c9f 100644 --- a/api/firmware/messages/btc.pb.go +++ b/api/firmware/messages/btc.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: btc.proto diff --git a/api/firmware/messages/cardano.pb.go b/api/firmware/messages/cardano.pb.go index 0bf1c78..96a3350 100644 --- a/api/firmware/messages/cardano.pb.go +++ b/api/firmware/messages/cardano.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: cardano.proto diff --git a/api/firmware/messages/common.pb.go b/api/firmware/messages/common.pb.go index 21459b7..9edaab9 100644 --- a/api/firmware/messages/common.pb.go +++ b/api/firmware/messages/common.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: common.proto diff --git a/api/firmware/messages/eth.pb.go b/api/firmware/messages/eth.pb.go index 8845194..d996253 100644 --- a/api/firmware/messages/eth.pb.go +++ b/api/firmware/messages/eth.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: eth.proto diff --git a/api/firmware/messages/generate.sh b/api/firmware/messages/generate.sh index fc041e9..da140ff 100755 --- a/api/firmware/messages/generate.sh +++ b/api/firmware/messages/generate.sh @@ -10,6 +10,7 @@ do OPTS="${OPTS} --go_opt=M$(basename ${f})=github.com/BitBoxSwiss/bitbox02-api-go/api/firmware/messages" done protoc --proto_path=${DIR} \ + --proto_path=/usr/include \ ${OPTS} \ --go_out="paths=source_relative:${DIR}" \ $FILES diff --git a/api/firmware/messages/hww.pb.go b/api/firmware/messages/hww.pb.go index 8f38d28..8b931d2 100644 --- a/api/firmware/messages/hww.pb.go +++ b/api/firmware/messages/hww.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: hww.proto @@ -143,6 +143,7 @@ type Request struct { // *Request_Bip85 // *Request_Bluetooth // *Request_ChangePassword + // *Request_BitboxSync Request isRequest_Request `protobuf_oneof:"request"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -437,6 +438,15 @@ func (x *Request) GetChangePassword() *ChangePasswordRequest { return nil } +func (x *Request) GetBitboxSync() *BitBoxSyncRequest { + if x != nil { + if x, ok := x.Request.(*Request_BitboxSync); ok { + return x.BitboxSync + } + } + return nil +} + type isRequest_Request interface { isRequest_Request() } @@ -555,6 +565,10 @@ type Request_ChangePassword struct { ChangePassword *ChangePasswordRequest `protobuf:"bytes,30,opt,name=change_password,json=changePassword,proto3,oneof"` } +type Request_BitboxSync struct { + BitboxSync *BitBoxSyncRequest `protobuf:"bytes,31,opt,name=bitbox_sync,json=bitboxSync,proto3,oneof"` +} + func (*Request_DeviceName) isRequest_Request() {} func (*Request_DeviceLanguage) isRequest_Request() {} @@ -611,6 +625,8 @@ func (*Request_Bluetooth) isRequest_Request() {} func (*Request_ChangePassword) isRequest_Request() {} +func (*Request_BitboxSync) isRequest_Request() {} + type Response struct { state protoimpl.MessageState `protogen:"open.v1"` // Types that are valid to be assigned to Response: @@ -631,6 +647,7 @@ type Response struct { // *Response_Cardano // *Response_Bip85 // *Response_Bluetooth + // *Response_BitboxSync Response isResponse_Response `protobuf_oneof:"response"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -817,6 +834,15 @@ func (x *Response) GetBluetooth() *BluetoothResponse { return nil } +func (x *Response) GetBitboxSync() *BitBoxSyncResponse { + if x != nil { + if x, ok := x.Response.(*Response_BitboxSync); ok { + return x.BitboxSync + } + } + return nil +} + type isResponse_Response interface { isResponse_Response() } @@ -886,6 +912,10 @@ type Response_Bluetooth struct { Bluetooth *BluetoothResponse `protobuf:"bytes,17,opt,name=bluetooth,proto3,oneof"` } +type Response_BitboxSync struct { + BitboxSync *BitBoxSyncResponse `protobuf:"bytes,18,opt,name=bitbox_sync,json=bitboxSync,proto3,oneof"` +} + func (*Response_Success) isResponse_Response() {} func (*Response_Error) isResponse_Response() {} @@ -918,15 +948,17 @@ func (*Response_Bip85) isResponse_Response() {} func (*Response_Bluetooth) isResponse_Response() {} +func (*Response_BitboxSync) isResponse_Response() {} + var File_hww_proto protoreflect.FileDescriptor const file_hww_proto_rawDesc = "" + "\n" + - "\thww.proto\x12\x14shiftcrypto.bitbox02\x1a\fcommon.proto\x1a\x15backup_commands.proto\x1a\x15bitbox02_system.proto\x1a\x0fbluetooth.proto\x1a\tbtc.proto\x1a\rcardano.proto\x1a\teth.proto\x1a\x0ekeystore.proto\x1a\x0emnemonic.proto\x1a\fsystem.proto\x1a\x19perform_attestation.proto\"5\n" + + "\thww.proto\x12\x14shiftcrypto.bitbox02\x1a\fcommon.proto\x1a\x15backup_commands.proto\x1a\x15bitbox02_system.proto\x1a\x10bitboxsync.proto\x1a\x0fbluetooth.proto\x1a\tbtc.proto\x1a\rcardano.proto\x1a\teth.proto\x1a\x0ekeystore.proto\x1a\x0emnemonic.proto\x1a\fsystem.proto\x1a\x19perform_attestation.proto\"5\n" + "\x05Error\x12\x12\n" + "\x04code\x18\x01 \x01(\x05R\x04code\x12\x18\n" + "\amessage\x18\x02 \x01(\tR\amessage\"\t\n" + - "\aSuccess\"\xff\x11\n" + + "\aSuccess\"\xcb\x12\n" + "\aRequest\x12M\n" + "\vdevice_name\x18\x02 \x01(\v2*.shiftcrypto.bitbox02.SetDeviceNameRequestH\x00R\n" + "deviceName\x12Y\n" + @@ -958,8 +990,10 @@ const file_hww_proto_rawDesc = "" + "\acardano\x18\x1b \x01(\v2$.shiftcrypto.bitbox02.CardanoRequestH\x00R\acardano\x12:\n" + "\x05bip85\x18\x1c \x01(\v2\".shiftcrypto.bitbox02.BIP85RequestH\x00R\x05bip85\x12F\n" + "\tbluetooth\x18\x1d \x01(\v2&.shiftcrypto.bitbox02.BluetoothRequestH\x00R\tbluetooth\x12V\n" + - "\x0fchange_password\x18\x1e \x01(\v2+.shiftcrypto.bitbox02.ChangePasswordRequestH\x00R\x0echangePasswordB\t\n" + - "\arequestJ\x04\b\x01\x10\x02J\x04\b\x17\x10\x18\"\xaf\t\n" + + "\x0fchange_password\x18\x1e \x01(\v2+.shiftcrypto.bitbox02.ChangePasswordRequestH\x00R\x0echangePassword\x12J\n" + + "\vbitbox_sync\x18\x1f \x01(\v2'.shiftcrypto.bitbox02.BitBoxSyncRequestH\x00R\n" + + "bitboxSyncB\t\n" + + "\arequestJ\x04\b\x01\x10\x02J\x04\b\x17\x10\x18\"\xfc\t\n" + "\bResponse\x129\n" + "\asuccess\x18\x01 \x01(\v2\x1d.shiftcrypto.bitbox02.SuccessH\x00R\asuccess\x123\n" + "\x05error\x18\x02 \x01(\v2\x1b.shiftcrypto.bitbox02.ErrorH\x00R\x05error\x12K\n" + @@ -978,7 +1012,9 @@ const file_hww_proto_rawDesc = "" + "\x17electrum_encryption_key\x18\x0e \x01(\v23.shiftcrypto.bitbox02.ElectrumEncryptionKeyResponseH\x00R\x15electrumEncryptionKey\x12A\n" + "\acardano\x18\x0f \x01(\v2%.shiftcrypto.bitbox02.CardanoResponseH\x00R\acardano\x12;\n" + "\x05bip85\x18\x10 \x01(\v2#.shiftcrypto.bitbox02.BIP85ResponseH\x00R\x05bip85\x12G\n" + - "\tbluetooth\x18\x11 \x01(\v2'.shiftcrypto.bitbox02.BluetoothResponseH\x00R\tbluetoothB\n" + + "\tbluetooth\x18\x11 \x01(\v2'.shiftcrypto.bitbox02.BluetoothResponseH\x00R\tbluetooth\x12K\n" + + "\vbitbox_sync\x18\x12 \x01(\v2(.shiftcrypto.bitbox02.BitBoxSyncResponseH\x00R\n" + + "bitboxSyncB\n" + "\n" + "\bresponseJ\x04\b\x03\x10\x04b\x06proto3" @@ -1028,20 +1064,22 @@ var file_hww_proto_goTypes = []any{ (*BIP85Request)(nil), // 29: shiftcrypto.bitbox02.BIP85Request (*BluetoothRequest)(nil), // 30: shiftcrypto.bitbox02.BluetoothRequest (*ChangePasswordRequest)(nil), // 31: shiftcrypto.bitbox02.ChangePasswordRequest - (*DeviceInfoResponse)(nil), // 32: shiftcrypto.bitbox02.DeviceInfoResponse - (*PubResponse)(nil), // 33: shiftcrypto.bitbox02.PubResponse - (*BTCSignNextResponse)(nil), // 34: shiftcrypto.bitbox02.BTCSignNextResponse - (*ListBackupsResponse)(nil), // 35: shiftcrypto.bitbox02.ListBackupsResponse - (*CheckBackupResponse)(nil), // 36: shiftcrypto.bitbox02.CheckBackupResponse - (*PerformAttestationResponse)(nil), // 37: shiftcrypto.bitbox02.PerformAttestationResponse - (*CheckSDCardResponse)(nil), // 38: shiftcrypto.bitbox02.CheckSDCardResponse - (*ETHResponse)(nil), // 39: shiftcrypto.bitbox02.ETHResponse - (*RootFingerprintResponse)(nil), // 40: shiftcrypto.bitbox02.RootFingerprintResponse - (*BTCResponse)(nil), // 41: shiftcrypto.bitbox02.BTCResponse - (*ElectrumEncryptionKeyResponse)(nil), // 42: shiftcrypto.bitbox02.ElectrumEncryptionKeyResponse - (*CardanoResponse)(nil), // 43: shiftcrypto.bitbox02.CardanoResponse - (*BIP85Response)(nil), // 44: shiftcrypto.bitbox02.BIP85Response - (*BluetoothResponse)(nil), // 45: shiftcrypto.bitbox02.BluetoothResponse + (*BitBoxSyncRequest)(nil), // 32: shiftcrypto.bitbox02.BitBoxSyncRequest + (*DeviceInfoResponse)(nil), // 33: shiftcrypto.bitbox02.DeviceInfoResponse + (*PubResponse)(nil), // 34: shiftcrypto.bitbox02.PubResponse + (*BTCSignNextResponse)(nil), // 35: shiftcrypto.bitbox02.BTCSignNextResponse + (*ListBackupsResponse)(nil), // 36: shiftcrypto.bitbox02.ListBackupsResponse + (*CheckBackupResponse)(nil), // 37: shiftcrypto.bitbox02.CheckBackupResponse + (*PerformAttestationResponse)(nil), // 38: shiftcrypto.bitbox02.PerformAttestationResponse + (*CheckSDCardResponse)(nil), // 39: shiftcrypto.bitbox02.CheckSDCardResponse + (*ETHResponse)(nil), // 40: shiftcrypto.bitbox02.ETHResponse + (*RootFingerprintResponse)(nil), // 41: shiftcrypto.bitbox02.RootFingerprintResponse + (*BTCResponse)(nil), // 42: shiftcrypto.bitbox02.BTCResponse + (*ElectrumEncryptionKeyResponse)(nil), // 43: shiftcrypto.bitbox02.ElectrumEncryptionKeyResponse + (*CardanoResponse)(nil), // 44: shiftcrypto.bitbox02.CardanoResponse + (*BIP85Response)(nil), // 45: shiftcrypto.bitbox02.BIP85Response + (*BluetoothResponse)(nil), // 46: shiftcrypto.bitbox02.BluetoothResponse + (*BitBoxSyncResponse)(nil), // 47: shiftcrypto.bitbox02.BitBoxSyncResponse } var file_hww_proto_depIdxs = []int32{ 4, // 0: shiftcrypto.bitbox02.Request.device_name:type_name -> shiftcrypto.bitbox02.SetDeviceNameRequest @@ -1072,27 +1110,29 @@ var file_hww_proto_depIdxs = []int32{ 29, // 25: shiftcrypto.bitbox02.Request.bip85:type_name -> shiftcrypto.bitbox02.BIP85Request 30, // 26: shiftcrypto.bitbox02.Request.bluetooth:type_name -> shiftcrypto.bitbox02.BluetoothRequest 31, // 27: shiftcrypto.bitbox02.Request.change_password:type_name -> shiftcrypto.bitbox02.ChangePasswordRequest - 1, // 28: shiftcrypto.bitbox02.Response.success:type_name -> shiftcrypto.bitbox02.Success - 0, // 29: shiftcrypto.bitbox02.Response.error:type_name -> shiftcrypto.bitbox02.Error - 32, // 30: shiftcrypto.bitbox02.Response.device_info:type_name -> shiftcrypto.bitbox02.DeviceInfoResponse - 33, // 31: shiftcrypto.bitbox02.Response.pub:type_name -> shiftcrypto.bitbox02.PubResponse - 34, // 32: shiftcrypto.bitbox02.Response.btc_sign_next:type_name -> shiftcrypto.bitbox02.BTCSignNextResponse - 35, // 33: shiftcrypto.bitbox02.Response.list_backups:type_name -> shiftcrypto.bitbox02.ListBackupsResponse - 36, // 34: shiftcrypto.bitbox02.Response.check_backup:type_name -> shiftcrypto.bitbox02.CheckBackupResponse - 37, // 35: shiftcrypto.bitbox02.Response.perform_attestation:type_name -> shiftcrypto.bitbox02.PerformAttestationResponse - 38, // 36: shiftcrypto.bitbox02.Response.check_sdcard:type_name -> shiftcrypto.bitbox02.CheckSDCardResponse - 39, // 37: shiftcrypto.bitbox02.Response.eth:type_name -> shiftcrypto.bitbox02.ETHResponse - 40, // 38: shiftcrypto.bitbox02.Response.fingerprint:type_name -> shiftcrypto.bitbox02.RootFingerprintResponse - 41, // 39: shiftcrypto.bitbox02.Response.btc:type_name -> shiftcrypto.bitbox02.BTCResponse - 42, // 40: shiftcrypto.bitbox02.Response.electrum_encryption_key:type_name -> shiftcrypto.bitbox02.ElectrumEncryptionKeyResponse - 43, // 41: shiftcrypto.bitbox02.Response.cardano:type_name -> shiftcrypto.bitbox02.CardanoResponse - 44, // 42: shiftcrypto.bitbox02.Response.bip85:type_name -> shiftcrypto.bitbox02.BIP85Response - 45, // 43: shiftcrypto.bitbox02.Response.bluetooth:type_name -> shiftcrypto.bitbox02.BluetoothResponse - 44, // [44:44] is the sub-list for method output_type - 44, // [44:44] is the sub-list for method input_type - 44, // [44:44] is the sub-list for extension type_name - 44, // [44:44] is the sub-list for extension extendee - 0, // [0:44] is the sub-list for field type_name + 32, // 28: shiftcrypto.bitbox02.Request.bitbox_sync:type_name -> shiftcrypto.bitbox02.BitBoxSyncRequest + 1, // 29: shiftcrypto.bitbox02.Response.success:type_name -> shiftcrypto.bitbox02.Success + 0, // 30: shiftcrypto.bitbox02.Response.error:type_name -> shiftcrypto.bitbox02.Error + 33, // 31: shiftcrypto.bitbox02.Response.device_info:type_name -> shiftcrypto.bitbox02.DeviceInfoResponse + 34, // 32: shiftcrypto.bitbox02.Response.pub:type_name -> shiftcrypto.bitbox02.PubResponse + 35, // 33: shiftcrypto.bitbox02.Response.btc_sign_next:type_name -> shiftcrypto.bitbox02.BTCSignNextResponse + 36, // 34: shiftcrypto.bitbox02.Response.list_backups:type_name -> shiftcrypto.bitbox02.ListBackupsResponse + 37, // 35: shiftcrypto.bitbox02.Response.check_backup:type_name -> shiftcrypto.bitbox02.CheckBackupResponse + 38, // 36: shiftcrypto.bitbox02.Response.perform_attestation:type_name -> shiftcrypto.bitbox02.PerformAttestationResponse + 39, // 37: shiftcrypto.bitbox02.Response.check_sdcard:type_name -> shiftcrypto.bitbox02.CheckSDCardResponse + 40, // 38: shiftcrypto.bitbox02.Response.eth:type_name -> shiftcrypto.bitbox02.ETHResponse + 41, // 39: shiftcrypto.bitbox02.Response.fingerprint:type_name -> shiftcrypto.bitbox02.RootFingerprintResponse + 42, // 40: shiftcrypto.bitbox02.Response.btc:type_name -> shiftcrypto.bitbox02.BTCResponse + 43, // 41: shiftcrypto.bitbox02.Response.electrum_encryption_key:type_name -> shiftcrypto.bitbox02.ElectrumEncryptionKeyResponse + 44, // 42: shiftcrypto.bitbox02.Response.cardano:type_name -> shiftcrypto.bitbox02.CardanoResponse + 45, // 43: shiftcrypto.bitbox02.Response.bip85:type_name -> shiftcrypto.bitbox02.BIP85Response + 46, // 44: shiftcrypto.bitbox02.Response.bluetooth:type_name -> shiftcrypto.bitbox02.BluetoothResponse + 47, // 45: shiftcrypto.bitbox02.Response.bitbox_sync:type_name -> shiftcrypto.bitbox02.BitBoxSyncResponse + 46, // [46:46] is the sub-list for method output_type + 46, // [46:46] is the sub-list for method input_type + 46, // [46:46] is the sub-list for extension type_name + 46, // [46:46] is the sub-list for extension extendee + 0, // [0:46] is the sub-list for field type_name } func init() { file_hww_proto_init() } @@ -1103,6 +1143,7 @@ func file_hww_proto_init() { file_common_proto_init() file_backup_commands_proto_init() file_bitbox02_system_proto_init() + file_bitboxsync_proto_init() file_bluetooth_proto_init() file_btc_proto_init() file_cardano_proto_init() @@ -1140,6 +1181,7 @@ func file_hww_proto_init() { (*Request_Bip85)(nil), (*Request_Bluetooth)(nil), (*Request_ChangePassword)(nil), + (*Request_BitboxSync)(nil), } file_hww_proto_msgTypes[3].OneofWrappers = []any{ (*Response_Success)(nil), @@ -1158,6 +1200,7 @@ func file_hww_proto_init() { (*Response_Cardano)(nil), (*Response_Bip85)(nil), (*Response_Bluetooth)(nil), + (*Response_BitboxSync)(nil), } type x struct{} out := protoimpl.TypeBuilder{ diff --git a/api/firmware/messages/hww.proto b/api/firmware/messages/hww.proto index 07cb660..39c7a05 100644 --- a/api/firmware/messages/hww.proto +++ b/api/firmware/messages/hww.proto @@ -7,6 +7,7 @@ import "common.proto"; import "backup_commands.proto"; import "bitbox02_system.proto"; +import "bitboxsync.proto"; import "bluetooth.proto"; import "btc.proto"; import "cardano.proto"; @@ -58,6 +59,7 @@ message Request { BIP85Request bip85 = 28; BluetoothRequest bluetooth = 29; ChangePasswordRequest change_password = 30; + BitBoxSyncRequest bitbox_sync = 31; } } @@ -81,5 +83,6 @@ message Response { CardanoResponse cardano = 15; BIP85Response bip85 = 16; BluetoothResponse bluetooth = 17; + BitBoxSyncResponse bitbox_sync = 18; } } diff --git a/api/firmware/messages/keystore.pb.go b/api/firmware/messages/keystore.pb.go index ef2563d..e8120a5 100644 --- a/api/firmware/messages/keystore.pb.go +++ b/api/firmware/messages/keystore.pb.go @@ -5,7 +5,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: keystore.proto diff --git a/api/firmware/messages/mnemonic.pb.go b/api/firmware/messages/mnemonic.pb.go index ca26bc6..eac7df7 100644 --- a/api/firmware/messages/mnemonic.pb.go +++ b/api/firmware/messages/mnemonic.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: mnemonic.proto diff --git a/api/firmware/messages/perform_attestation.pb.go b/api/firmware/messages/perform_attestation.pb.go index 1c3ed23..52788f5 100644 --- a/api/firmware/messages/perform_attestation.pb.go +++ b/api/firmware/messages/perform_attestation.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: perform_attestation.proto diff --git a/api/firmware/messages/system.pb.go b/api/firmware/messages/system.pb.go index 28b16b4..73560c7 100644 --- a/api/firmware/messages/system.pb.go +++ b/api/firmware/messages/system.pb.go @@ -2,7 +2,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: system.proto diff --git a/go.mod b/go.mod index 60917e2..5b7f7c5 100644 --- a/go.mod +++ b/go.mod @@ -1,28 +1,29 @@ module github.com/BitBoxSwiss/bitbox02-api-go -go 1.24 +go 1.26 require ( + github.com/BitBoxSwiss/bitboxsync-client-go v0.0.0-20260701061324-f7e835814680 github.com/benma/miniscript-go v0.0.0-20240226152043-f7c34099edf9 github.com/btcsuite/btcd v0.24.2 github.com/btcsuite/btcd/btcec/v2 v2.3.3 github.com/btcsuite/btcd/btcutil v1.1.6 + github.com/btcsuite/btcd/btcutil/psbt v1.1.10 github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 + github.com/davecgh/go-spew v1.1.1 github.com/flynn/noise v1.1.0 github.com/karalabe/hid v1.0.1-0.20240306101548-573246063e52 github.com/pkg/errors v0.8.1 - github.com/stretchr/testify v1.9.0 - golang.org/x/crypto v0.27.0 + github.com/stretchr/testify v1.11.1 + golang.org/x/crypto v0.43.0 google.golang.org/protobuf v1.33.0 ) require ( - github.com/btcsuite/btcd/btcutil/psbt v1.1.10 // indirect github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f // indirect - github.com/davecgh/go-spew v1.1.1 // indirect github.com/decred/dcrd/crypto/blake256 v1.0.1 // indirect github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - golang.org/x/sys v0.25.0 // indirect + golang.org/x/sys v0.37.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 5b90956..a39760c 100644 --- a/go.sum +++ b/go.sum @@ -1,3 +1,5 @@ +github.com/BitBoxSwiss/bitboxsync-client-go v0.0.0-20260701061324-f7e835814680 h1:yGUYDddOzTmUdyBUX4FDGUW+O3VX2g2OfjtdZGIuRZ4= +github.com/BitBoxSwiss/bitboxsync-client-go v0.0.0-20260701061324-f7e835814680/go.mod h1:NlTH3nCt38trIQH357yq7ugzI61WbZ+SFeq6B0bK/EU= github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= github.com/benma/miniscript-go v0.0.0-20240226152043-f7c34099edf9 h1:uXJp0+aJzVl2gckSB9rRVP0hTQk7PHG8lak9MUkbCP0= github.com/benma/miniscript-go v0.0.0-20240226152043-f7c34099edf9/go.mod h1:qtNCDVwDj3ftKLgSoFJSIfW6vCOqoroo6stk9yY2BgM= @@ -92,15 +94,15 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= -golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= -golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70= +golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04= +golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0= golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= @@ -118,8 +120,8 @@ golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= -golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ= +golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=