beaconcrypt 0.2.0__tar.gz → 0.3.0__tar.gz

beaconcrypt-0.3.0/.github/workflows/go.yml

@@ -0,0 +1,44 @@
+name: Go Module
+
+on:
+  push:
+    tags:
+      - "*"
+
+permissions:
+  contents: read
+
+env:
+  CARGO_TERM_COLOR: always
+  GOPROXY: https://proxy.golang.org
+  GONOSUMDB: ""
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Set up Go
+        uses: actions/setup-go@v6
+        with:
+          go-version-file: go.mod
+          check-latest: true
+
+      - name: Install cap'n proto
+        run: sudo apt update && sudo apt install capnproto
+
+      - name: Build native library
+        run: cargo build --verbose
+
+      - name: Test Go module
+        run: go test ./...
+
+      - name: Publish module to Go proxy
+        run: |
+          module_path="$(go list -m)"
+          version="${GITHUB_REF_NAME}"
+          encoded_module="${module_path,,}"
+          curl --fail --show-error --location --retry 5 --retry-all-errors --retry-delay 10 \
+            "https://proxy.golang.org/${encoded_module}/@v/v${version}.info"

{beaconcrypt-0.2.0 → beaconcrypt-0.3.0}/.gitignore

@@ -70,3 +70,8 @@ docs/_build/
 
 # Pyenv
 .python-version
+
+.gocache/
+.go-appdata/
+.go-localappdata/
+.gotelemetry/

{beaconcrypt-0.2.0 → beaconcrypt-0.3.0}/Cargo.lock

@@ -84,7 +84,7 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "beaconcrypt"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "capnp",
  "capnpc",
@@ -181,18 +181,18 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.6.1"
+version = "4.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"
+checksum = "dd059f9da4f5c36b3787f65d38ccaab1cc315f07b01f89abc8359ee6a8205011"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.6.0"
+version = "4.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
+checksum = "f09628afdcc538b57f3c6341e9c8e9970f18e4a481690a64974d7023bd33548b"
 dependencies = [
  "anstream",
  "anstyle",
@@ -978,9 +978,9 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "simd-adler32"
-version = "0.3.9"
+version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
 
 [[package]]
 name = "slab"
@@ -996,9 +996,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.118"
+version = "2.0.119"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
 dependencies = [
  "proc-macro2",
  "quote",

{beaconcrypt-0.2.0 → beaconcrypt-0.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "beaconcrypt"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2024"
 license-file = "LICENSE"
 readme = "README.md"
@@ -10,7 +10,7 @@ repository = "https://github.com/0xd6cb6d73/beaconcrypt"
 
 [lib]
 name = "beaconcrypt"
-crate-type = ["cdylib", "rlib"]
+crate-type = ["cdylib", "staticlib", "rlib"]
 
 [build-dependencies]
 capnpc = "0.26"

{beaconcrypt-0.2.0 → beaconcrypt-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beaconcrypt
-Version: 0.2.0
+Version: 0.3.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

beaconcrypt-0.3.0/beaconcrypt.go

@@ -0,0 +1,255 @@
+// SPDX-License-Identifier: 0BSD
+
+package beaconcrypt
+
+/*
+#cgo windows LDFLAGS: -L${SRCDIR}/target/x86_64-pc-windows-gnu/debug -l:libbeaconcrypt.a -lbcrypt -lws2_32 -luserenv -ldbghelp -lntdll
+#cgo !windows LDFLAGS: -L${SRCDIR}/target/debug -l:libbeaconcrypt.a
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+	uint8_t *ptr;
+	uintptr_t len;
+	uintptr_t cap;
+} beaconcrypt_go_buffer;
+
+typedef struct {
+	beaconcrypt_go_buffer response;
+	beaconcrypt_go_buffer beacon_pk;
+	uint64_t key_id;
+} beaconcrypt_go_registration_response;
+
+void beaconcrypt_go_free_buffer(beaconcrypt_go_buffer buffer);
+void *beaconcrypt_go_server_new(uint64_t server_kid);
+void *beaconcrypt_go_server_new_from_seed(uint64_t server_kid, const uint8_t *seed_ptr, uintptr_t seed_len);
+void *beaconcrypt_go_beacon_new(uint64_t server_kid, const uint8_t *server_pk_ptr, uintptr_t server_pk_len);
+void beaconcrypt_go_free(void *handle);
+beaconcrypt_go_buffer beaconcrypt_go_identity_pk(const void *handle);
+beaconcrypt_go_buffer beaconcrypt_go_generate_registration(void *handle);
+beaconcrypt_go_registration_response beaconcrypt_go_register_beacon(void *handle, const uint8_t *reg_ptr, uintptr_t reg_len, const uint8_t *msg_ptr, uintptr_t msg_len);
+beaconcrypt_go_buffer beaconcrypt_go_process_initial_message(void *handle, const uint8_t *ptr, uintptr_t len);
+beaconcrypt_go_buffer beaconcrypt_go_encrypt_to_beacon(void *handle, uint64_t key_id, const uint8_t *ptr, uintptr_t len);
+beaconcrypt_go_buffer beaconcrypt_go_encrypt_to_beacon_signed(void *handle, uint64_t key_id, const uint8_t *ptr, uintptr_t len);
+beaconcrypt_go_buffer beaconcrypt_go_decrypt_beacon_message(void *handle, uint64_t key_id, const uint8_t *ptr, uintptr_t len);
+beaconcrypt_go_buffer beaconcrypt_go_encrypt_to_server(void *handle, const uint8_t *ptr, uintptr_t len);
+beaconcrypt_go_buffer beaconcrypt_go_decrypt_server_message(void *handle, const uint8_t *ptr, uintptr_t len);
+beaconcrypt_go_buffer beaconcrypt_go_decrypt_server_message_signed(void *handle, const uint8_t *ptr, uintptr_t len);
+*/
+import "C"
+
+import (
+	"errors"
+	"runtime"
+	"unsafe"
+)
+
+var (
+	ErrClosed    = errors.New("beaconcrypt: handle is closed")
+	ErrCrypto    = errors.New("beaconcrypt: cryptographic operation failed")
+	ErrSeedSize  = errors.New("beaconcrypt: server seed must be 32 bytes")
+	ErrEmptyData = errors.New("beaconcrypt: input must not be empty")
+)
+
+type Server struct {
+	handle unsafe.Pointer
+}
+
+type Beacon struct {
+	handle unsafe.Pointer
+}
+
+type RegistrationResponse struct {
+	Serialized []byte
+	BeaconPK   []byte
+	KeyID      uint64
+}
+
+func NewServer(serverKID uint64) (*Server, error) {
+	handle := C.beaconcrypt_go_server_new(C.uint64_t(serverKID))
+	if handle == nil {
+		return nil, ErrCrypto
+	}
+	server := &Server{handle: handle}
+	runtime.SetFinalizer(server, (*Server).Close)
+	return server, nil
+}
+
+func NewServerFromSeed(serverKID uint64, seed []byte) (*Server, error) {
+	if len(seed) != 32 {
+		return nil, ErrSeedSize
+	}
+	ptr, free := cBytes(seed)
+	defer free()
+	handle := C.beaconcrypt_go_server_new_from_seed(C.uint64_t(serverKID), ptr, C.uintptr_t(len(seed)))
+	if handle == nil {
+		return nil, ErrCrypto
+	}
+	server := &Server{handle: handle}
+	runtime.SetFinalizer(server, (*Server).Close)
+	return server, nil
+}
+
+func NewBeacon(serverKID uint64, serverPK []byte) (*Beacon, error) {
+	ptr, free := cBytes(serverPK)
+	defer free()
+	handle := C.beaconcrypt_go_beacon_new(C.uint64_t(serverKID), ptr, C.uintptr_t(len(serverPK)))
+	if handle == nil {
+		return nil, ErrCrypto
+	}
+	beacon := &Beacon{handle: handle}
+	runtime.SetFinalizer(beacon, (*Beacon).Close)
+	return beacon, nil
+}
+
+func (s *Server) Close() {
+	if s != nil && s.handle != nil {
+		C.beaconcrypt_go_free(s.handle)
+		s.handle = nil
+		runtime.SetFinalizer(s, nil)
+	}
+}
+
+func (b *Beacon) Close() {
+	if b != nil && b.handle != nil {
+		C.beaconcrypt_go_free(b.handle)
+		b.handle = nil
+		runtime.SetFinalizer(b, nil)
+	}
+}
+
+func (s *Server) IdentityPK() ([]byte, error) {
+	if s == nil || s.handle == nil {
+		return nil, ErrClosed
+	}
+	return copyBuffer(C.beaconcrypt_go_identity_pk(s.handle))
+}
+
+func (b *Beacon) GenerateRegistration() ([]byte, error) {
+	if b == nil || b.handle == nil {
+		return nil, ErrClosed
+	}
+	return copyBuffer(C.beaconcrypt_go_generate_registration(b.handle))
+}
+
+func (s *Server) RegisterBeacon(registration, initialMessage []byte) (*RegistrationResponse, error) {
+	if s == nil || s.handle == nil {
+		return nil, ErrClosed
+	}
+	if len(registration) == 0 {
+		return nil, ErrEmptyData
+	}
+	regPtr, regFree := cBytes(registration)
+	defer regFree()
+	msgPtr, msgFree := cBytes(initialMessage)
+	defer msgFree()
+	response := C.beaconcrypt_go_register_beacon(
+		s.handle,
+		regPtr,
+		C.uintptr_t(len(registration)),
+		msgPtr,
+		C.uintptr_t(len(initialMessage)),
+	)
+	serialized, err := copyBuffer(response.response)
+	if err != nil {
+		C.beaconcrypt_go_free_buffer(response.beacon_pk)
+		return nil, err
+	}
+	beaconPK, err := copyBuffer(response.beacon_pk)
+	if err != nil {
+		return nil, err
+	}
+	return &RegistrationResponse{
+		Serialized: serialized,
+		BeaconPK:   beaconPK,
+		KeyID:      uint64(response.key_id),
+	}, nil
+}
+
+func (b *Beacon) ProcessInitialMessage(data []byte) ([]byte, error) {
+	if b == nil || b.handle == nil {
+		return nil, ErrClosed
+	}
+	return callUnary(data, func(ptr *C.uint8_t, len C.uintptr_t) C.beaconcrypt_go_buffer {
+		return C.beaconcrypt_go_process_initial_message(b.handle, ptr, len)
+	})
+}
+
+func (s *Server) EncryptToBeacon(keyID uint64, plaintext []byte) ([]byte, error) {
+	if s == nil || s.handle == nil {
+		return nil, ErrClosed
+	}
+	return callUnary(plaintext, func(ptr *C.uint8_t, len C.uintptr_t) C.beaconcrypt_go_buffer {
+		return C.beaconcrypt_go_encrypt_to_beacon(s.handle, C.uint64_t(keyID), ptr, len)
+	})
+}
+
+func (s *Server) EncryptToBeaconSigned(keyID uint64, plaintext []byte) ([]byte, error) {
+	if s == nil || s.handle == nil {
+		return nil, ErrClosed
+	}
+	return callUnary(plaintext, func(ptr *C.uint8_t, len C.uintptr_t) C.beaconcrypt_go_buffer {
+		return C.beaconcrypt_go_encrypt_to_beacon_signed(s.handle, C.uint64_t(keyID), ptr, len)
+	})
+}
+
+func (s *Server) DecryptBeaconMessage(keyID uint64, ciphertext []byte) ([]byte, error) {
+	if s == nil || s.handle == nil {
+		return nil, ErrClosed
+	}
+	return callUnary(ciphertext, func(ptr *C.uint8_t, len C.uintptr_t) C.beaconcrypt_go_buffer {
+		return C.beaconcrypt_go_decrypt_beacon_message(s.handle, C.uint64_t(keyID), ptr, len)
+	})
+}
+
+func (b *Beacon) EncryptToServer(plaintext []byte) ([]byte, error) {
+	if b == nil || b.handle == nil {
+		return nil, ErrClosed
+	}
+	return callUnary(plaintext, func(ptr *C.uint8_t, len C.uintptr_t) C.beaconcrypt_go_buffer {
+		return C.beaconcrypt_go_encrypt_to_server(b.handle, ptr, len)
+	})
+}
+
+func (b *Beacon) DecryptServerMessage(ciphertext []byte) ([]byte, error) {
+	if b == nil || b.handle == nil {
+		return nil, ErrClosed
+	}
+	return callUnary(ciphertext, func(ptr *C.uint8_t, len C.uintptr_t) C.beaconcrypt_go_buffer {
+		return C.beaconcrypt_go_decrypt_server_message(b.handle, ptr, len)
+	})
+}
+
+func (b *Beacon) DecryptServerMessageSigned(ciphertext []byte) ([]byte, error) {
+	if b == nil || b.handle == nil {
+		return nil, ErrClosed
+	}
+	return callUnary(ciphertext, func(ptr *C.uint8_t, len C.uintptr_t) C.beaconcrypt_go_buffer {
+		return C.beaconcrypt_go_decrypt_server_message_signed(b.handle, ptr, len)
+	})
+}
+
+func callUnary(data []byte, call func(*C.uint8_t, C.uintptr_t) C.beaconcrypt_go_buffer) ([]byte, error) {
+	if len(data) == 0 {
+		return nil, ErrEmptyData
+	}
+	ptr, free := cBytes(data)
+	defer free()
+	return copyBuffer(call(ptr, C.uintptr_t(len(data))))
+}
+
+func copyBuffer(buffer C.beaconcrypt_go_buffer) ([]byte, error) {
+	if buffer.ptr == nil || buffer.len == 0 {
+		return nil, ErrCrypto
+	}
+	defer C.beaconcrypt_go_free_buffer(buffer)
+	return C.GoBytes(unsafe.Pointer(buffer.ptr), C.int(buffer.len)), nil
+}
+
+func cBytes(data []byte) (*C.uint8_t, func()) {
+	if len(data) == 0 {
+		return nil, func() {}
+	}
+	ptr := C.CBytes(data)
+	return (*C.uint8_t)(ptr), func() { C.free(ptr) }
+}

beaconcrypt-0.3.0/beaconcrypt_test.go

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: 0BSD
+
+package beaconcrypt
+
+import (
+	"bytes"
+	"testing"
+)
+
+func registerBeacon(t *testing.T, server *Server, beacon *Beacon) []byte {
+	t.Helper()
+
+	message := bytes.Repeat([]byte{0xff}, 32)
+	phase1, err := beacon.GenerateRegistration()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	regOut, err := server.RegisterBeacon(phase1, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if regOut.KeyID == 0 {
+		t.Fatal("expected non-zero beacon key id")
+	}
+
+	phase2, err := beacon.ProcessInitialMessage(regOut.Serialized)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(phase2, message) {
+		t.Fatalf("initial message mismatch: got %x want %x", phase2, message)
+	}
+	return phase2
+}
+
+func newServer(t *testing.T) *Server {
+	t.Helper()
+
+	server, err := NewServer(0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(server.Close)
+	return server
+}
+
+func newBeacon(t *testing.T, serverPK []byte) *Beacon {
+	t.Helper()
+
+	beacon, err := NewBeacon(0, serverPK)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(beacon.Close)
+	return beacon
+}
+
+func TestRegister(t *testing.T) {
+	server := newServer(t)
+	beacon := newBeacon(t, nil)
+
+	if registerBeacon(t, server, beacon) == nil {
+		t.Fatal("expected registration to return initial message")
+	}
+}
+
+func TestEncryptToMultiple(t *testing.T) {
+	server := newServer(t)
+	b1 := newBeacon(t, nil)
+	b2 := newBeacon(t, nil)
+	message := bytes.Repeat([]byte{0x01}, 32)
+
+	b1Initial := registerBeacon(t, server, b1)
+	b2Initial := registerBeacon(t, server, b2)
+	if !bytes.Equal(b2Initial, b1Initial) {
+		t.Fatalf("initial messages differ: got %x want %x", b2Initial, b1Initial)
+	}
+
+	b1M1, err := server.EncryptToBeacon(1, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	b2M1, err := server.EncryptToBeacon(2, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if bytes.Equal(b1M1, b2M1) {
+		t.Fatal("expected different ciphertexts for different beacons")
+	}
+}
+
+func TestEncryptMultiple(t *testing.T) {
+	server := newServer(t)
+	b1 := newBeacon(t, nil)
+	message := bytes.Repeat([]byte{0x01}, 32)
+
+	registerBeacon(t, server, b1)
+
+	b1M1, err := server.EncryptToBeacon(1, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	b1M2, err := server.EncryptToBeacon(1, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if bytes.Equal(b1M1, b1M2) {
+		t.Fatal("expected repeated encryption to produce different ciphertexts")
+	}
+}
+
+func TestDecryptMultiple(t *testing.T) {
+	server := newServer(t)
+	beacon := newBeacon(t, nil)
+	message := bytes.Repeat([]byte{0x01}, 32)
+
+	registerBeacon(t, server, beacon)
+	m1, err := server.EncryptToBeacon(1, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	m2, err := server.EncryptToBeacon(1, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if bytes.Equal(m1, m2) {
+		t.Fatal("expected different ciphertexts")
+	}
+
+	plain1, err := beacon.DecryptServerMessage(m1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	plain2, err := beacon.DecryptServerMessage(m2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(plain1, message) || !bytes.Equal(plain2, message) {
+		t.Fatalf("decrypted messages mismatch: got %x and %x want %x", plain1, plain2, message)
+	}
+}
+
+func TestDecryptMultipleSigned(t *testing.T) {
+	server := newServer(t)
+	beacon := newBeacon(t, nil)
+	message := bytes.Repeat([]byte{0x01}, 32)
+
+	registerBeacon(t, server, beacon)
+	m1, err := server.EncryptToBeaconSigned(1, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	m2, err := server.EncryptToBeaconSigned(1, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if bytes.Equal(m1, m2) {
+		t.Fatal("expected different signed ciphertexts")
+	}
+
+	plain1, err := beacon.DecryptServerMessageSigned(m1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	plain2, err := beacon.DecryptServerMessageSigned(m2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(plain1, message) || !bytes.Equal(plain2, message) {
+		t.Fatalf("decrypted signed messages mismatch: got %x and %x want %x", plain1, plain2, message)
+	}
+}
+
+func TestDecryptCatchUp(t *testing.T) {
+	server := newServer(t)
+	serverPK, err := server.IdentityPK()
+	if err != nil {
+		t.Fatal(err)
+	}
+	beacon := newBeacon(t, serverPK)
+	message := bytes.Repeat([]byte{0x01}, 32)
+
+	registerBeacon(t, server, beacon)
+	m1, err := server.EncryptToBeacon(1, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	m2, err := server.EncryptToBeacon(1, message)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if bytes.Equal(m1, m2) {
+		t.Fatal("expected different ciphertexts")
+	}
+
+	plain2, err := beacon.DecryptServerMessage(m2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	plain1, err := beacon.DecryptServerMessage(m1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(plain1, message) || !bytes.Equal(plain2, message) {
+		t.Fatalf("catch-up decrypt mismatch: got %x and %x want %x", plain1, plain2, message)
+	}
+}

{beaconcrypt-0.2.0 → beaconcrypt-0.3.0}/bindings.h

@@ -47,6 +47,20 @@
 
 #define beaconcrypt_KEM_SHARED_SECRET_SIZE 32
 
+typedef struct beaconcrypt_BeaconCryptPqxdh beaconcrypt_BeaconCryptPqxdh;
+
+typedef struct beaconcrypt_GoBuffer {
+  uint8_t *ptr;
+  uintptr_t len;
+  uintptr_t cap;
+} beaconcrypt_GoBuffer;
+
+typedef struct beaconcrypt_GoRegistrationResponse {
+  struct beaconcrypt_GoBuffer response;
+  struct beaconcrypt_GoBuffer beacon_pk;
+  uint64_t key_id;
+} beaconcrypt_GoRegistrationResponse;
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
@@ -398,6 +412,61 @@ int32_t sign_message(const uint8_t *bytes,
                      uintptr_t *out_len,
                      uintptr_t *out_capa);
 
+void beaconcrypt_go_free_buffer(struct beaconcrypt_GoBuffer buffer);
+
+struct beaconcrypt_BeaconCryptPqxdh *beaconcrypt_go_server_new(uint64_t server_kid);
+
+struct beaconcrypt_BeaconCryptPqxdh *beaconcrypt_go_server_new_from_seed(uint64_t server_kid,
+                                                                         const uint8_t *seed_ptr,
+                                                                         uintptr_t seed_len);
+
+struct beaconcrypt_BeaconCryptPqxdh *beaconcrypt_go_beacon_new(uint64_t server_kid,
+                                                               const uint8_t *server_pk_ptr,
+                                                               uintptr_t server_pk_len);
+
+void beaconcrypt_go_free(struct beaconcrypt_BeaconCryptPqxdh *handle);
+
+struct beaconcrypt_GoBuffer beaconcrypt_go_identity_pk(const struct beaconcrypt_BeaconCryptPqxdh *handle);
+
+struct beaconcrypt_GoBuffer beaconcrypt_go_generate_registration(struct beaconcrypt_BeaconCryptPqxdh *handle);
+
+struct beaconcrypt_GoRegistrationResponse beaconcrypt_go_register_beacon(struct beaconcrypt_BeaconCryptPqxdh *handle,
+                                                                         const uint8_t *reg_ptr,
+                                                                         uintptr_t reg_len,
+                                                                         const uint8_t *msg_ptr,
+                                                                         uintptr_t msg_len);
+
+struct beaconcrypt_GoBuffer beaconcrypt_go_process_initial_message(struct beaconcrypt_BeaconCryptPqxdh *handle,
+                                                                   const uint8_t *ptr,
+                                                                   uintptr_t len);
+
+struct beaconcrypt_GoBuffer beaconcrypt_go_encrypt_to_beacon(struct beaconcrypt_BeaconCryptPqxdh *handle,
+                                                             uint64_t key_id,
+                                                             const uint8_t *ptr,
+                                                             uintptr_t len);
+
+struct beaconcrypt_GoBuffer beaconcrypt_go_encrypt_to_beacon_signed(struct beaconcrypt_BeaconCryptPqxdh *handle,
+                                                                    uint64_t key_id,
+                                                                    const uint8_t *ptr,
+                                                                    uintptr_t len);
+
+struct beaconcrypt_GoBuffer beaconcrypt_go_decrypt_beacon_message(struct beaconcrypt_BeaconCryptPqxdh *handle,
+                                                                  uint64_t key_id,
+                                                                  const uint8_t *ptr,
+                                                                  uintptr_t len);
+
+struct beaconcrypt_GoBuffer beaconcrypt_go_encrypt_to_server(struct beaconcrypt_BeaconCryptPqxdh *handle,
+                                                             const uint8_t *ptr,
+                                                             uintptr_t len);
+
+struct beaconcrypt_GoBuffer beaconcrypt_go_decrypt_server_message(struct beaconcrypt_BeaconCryptPqxdh *handle,
+                                                                  const uint8_t *ptr,
+                                                                  uintptr_t len);
+
+struct beaconcrypt_GoBuffer beaconcrypt_go_decrypt_server_message_signed(struct beaconcrypt_BeaconCryptPqxdh *handle,
+                                                                         const uint8_t *ptr,
+                                                                         uintptr_t len);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

{beaconcrypt-0.2.0 → beaconcrypt-0.3.0}/build.rs

@@ -1,6 +1,10 @@
 // SPDX-License-Identifier: 0BSD
 
 fn main() {
+	if cfg!(windows) {
+		println!("cargo:rustc-link-lib=bcrypt");
+	}
+
 	capnpc::CompilerCommand::new()
 		.src_prefix("src/schema")
 		.import_path("src/schema")
@@ -26,6 +30,8 @@ fn main() {
 		.with_autogen_warning("// Do not modify manually.")
 		.with_item_prefix("beaconcrypt_")
 		.with_std_types(true)
+		.exclude_item("memset_explicit")
+		.exclude_item("SystemFunction036")
 		.generate()
 		.expect("Unable to generate bindings")
 		.write_to_file("bindings.h");