mirror of
https://github.com/luxfi/crypto.git
synced 2026-07-27 01:54:50 +00:00
Hanzo AI
ecaca10cdb
luxfi/crypto becomes the single Go entry point for ALL Lux-family crypto. Every public function in this module now dispatches between three implementations through a runtime-selectable backend: - vanilla: pure-Go reference (always available) - cgo: native binding (blst, libsecp256k1, ckzg) where present - gpu: batch acceleration via github.com/luxfi/accel The dispatcher reads LUX_CRYPTO_BACKEND (auto|vanilla|cgo|gpu); auto picks the most capable backend the binary was compiled and linked with. New canonical packages: backend/ runtime backend selector (env + programmatic) internal/gpuhost/ accel session lifecycle, single per-process keccak/ Keccak-256 with batch GPU dispatch sha256/ SHA-256 with batch GPU dispatch sha3/ SHA3 / SHAKE family ripemd160/ RIPEMD-160 (Bitcoin/Lux address derivation) ed25519/ Ed25519 with batch GPU verify bn254/ canonical alias for bn256 (matches FIPS naming) modexp/ canonical alias for bigmodexp evm256/ EIP-196/197 precompile ABI wrappers poseidon/ Poseidon2 hash via gnark-crypto pedersen/ Pedersen commitments over BN254 ntt/ Number-Theoretic Transform reference polymul/ negacyclic polynomial multiplication Extended existing packages with batch GPU paths: bls/batch.go BatchVerify routes through accel.BLSVerifyBatch mldsa/batch.go BatchVerify (ML-DSA-65) via accel.DilithiumVerifyBatch mlkem/batch.go BatchEncapsulate / BatchDecapsulate via Kyber kernels secp256k1/batch.go BatchVerifySignature via accel.ECDSAVerifyBatch GPU dispatch is gated on (a) backend.Default(), (b) batch size threshold, and (c) accel.Available(). When any gate fails the call falls through to the vanilla CPU path; output is byte-identical. The legacy gpu/ stub is replaced with a thin probe surface (Available, Backend, Devices, Version) that delegates to the same gpuhost session. Tests show vanilla and gpu backends produce identical outputs across all batch entry points (-race clean). See AUDIT.md for the per-algorithm state matrix and honest gaps.
136 lines
3.1 KiB
Go
136 lines
3.1 KiB
Go
// Copyright (C) 2020-2026, Lux Industries Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package mlkem
|
|
|
|
import (
|
|
"github.com/luxfi/accel"
|
|
"github.com/luxfi/crypto/backend"
|
|
"github.com/luxfi/crypto/internal/gpuhost"
|
|
)
|
|
|
|
// accel publishes Kyber768 batch kernels — the closest match to ML-KEM-768.
|
|
// Other modes fall through.
|
|
|
|
func batchEncapsulateGPU(pubs []*PublicKey, cts [][]byte, sss [][]byte) (bool, error) {
|
|
if backend.Resolve(gpuhost.Available(), false) != backend.GPU {
|
|
return false, nil
|
|
}
|
|
sess := gpuhost.Session()
|
|
if sess == nil {
|
|
return false, nil
|
|
}
|
|
|
|
n := len(pubs)
|
|
pkSize := MLKEM768PublicKeySize
|
|
ctSize := MLKEM768CiphertextSize
|
|
ssSize := MLKEM768SharedKeySize
|
|
|
|
pkFlat := make([]uint8, n*pkSize)
|
|
for i, p := range pubs {
|
|
b := p.Bytes()
|
|
if len(b) != pkSize {
|
|
return false, nil
|
|
}
|
|
copy(pkFlat[i*pkSize:(i+1)*pkSize], b)
|
|
}
|
|
|
|
pkT, err := accel.NewTensorWithData[uint8](sess, []int{n, pkSize}, pkFlat)
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
defer pkT.Close()
|
|
ctT, err := accel.NewTensor[uint8](sess, []int{n, ctSize})
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
defer ctT.Close()
|
|
ssT, err := accel.NewTensor[uint8](sess, []int{n, ssSize})
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
defer ssT.Close()
|
|
|
|
if err := sess.Lattice().KyberEncapsBatch(pkT.Untyped(), ctT.Untyped(), ssT.Untyped()); err != nil {
|
|
return false, nil
|
|
}
|
|
ctBytes, err := ctT.ToSlice()
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
ssBytes, err := ssT.ToSlice()
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
for i := 0; i < n; i++ {
|
|
c := make([]byte, ctSize)
|
|
copy(c, ctBytes[i*ctSize:(i+1)*ctSize])
|
|
cts[i] = c
|
|
s := make([]byte, ssSize)
|
|
copy(s, ssBytes[i*ssSize:(i+1)*ssSize])
|
|
sss[i] = s
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func batchDecapsulateGPU(sks []*PrivateKey, cts [][]byte, sss [][]byte) (bool, error) {
|
|
if backend.Resolve(gpuhost.Available(), false) != backend.GPU {
|
|
return false, nil
|
|
}
|
|
sess := gpuhost.Session()
|
|
if sess == nil {
|
|
return false, nil
|
|
}
|
|
|
|
n := len(sks)
|
|
skSize := MLKEM768PrivateKeySize
|
|
ctSize := MLKEM768CiphertextSize
|
|
ssSize := MLKEM768SharedKeySize
|
|
|
|
skFlat := make([]uint8, n*skSize)
|
|
for i, s := range sks {
|
|
b := s.Bytes()
|
|
if len(b) != skSize {
|
|
return false, nil
|
|
}
|
|
copy(skFlat[i*skSize:(i+1)*skSize], b)
|
|
}
|
|
ctFlat := make([]uint8, n*ctSize)
|
|
for i, c := range cts {
|
|
if len(c) != ctSize {
|
|
return false, nil
|
|
}
|
|
copy(ctFlat[i*ctSize:(i+1)*ctSize], c)
|
|
}
|
|
|
|
skT, err := accel.NewTensorWithData[uint8](sess, []int{n, skSize}, skFlat)
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
defer skT.Close()
|
|
ctT, err := accel.NewTensorWithData[uint8](sess, []int{n, ctSize}, ctFlat)
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
defer ctT.Close()
|
|
ssT, err := accel.NewTensor[uint8](sess, []int{n, ssSize})
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
defer ssT.Close()
|
|
|
|
if err := sess.Lattice().KyberDecapsBatch(ctT.Untyped(), skT.Untyped(), ssT.Untyped()); err != nil {
|
|
return false, nil
|
|
}
|
|
ssBytes, err := ssT.ToSlice()
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
for i := 0; i < n; i++ {
|
|
s := make([]byte, ssSize)
|
|
copy(s, ssBytes[i*ssSize:(i+1)*ssSize])
|
|
sss[i] = s
|
|
}
|
|
return true, nil
|
|
}
|