mirror of
https://github.com/mautrix/signal.git
synced 2026-05-15 05:36:53 -04:00
275 lines
8.2 KiB
Go
275 lines
8.2 KiB
Go
// mautrix-signal - A Matrix-signal puppeting bridge.
|
|
// Copyright (C) 2023 Scott Weber
|
|
// Copyright (C) 2025 Tulir Asokan
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
package libsignalgo
|
|
|
|
/*
|
|
#include "./libsignal-ffi.h"
|
|
*/
|
|
import "C"
|
|
import (
|
|
"runtime"
|
|
"time"
|
|
)
|
|
|
|
type KyberPreKeyRecord struct {
|
|
nc noCopy
|
|
ptr *C.SignalKyberPreKeyRecord
|
|
}
|
|
|
|
type KyberKeyPair struct {
|
|
nc noCopy
|
|
ptr *C.SignalKyberKeyPair
|
|
}
|
|
|
|
type KyberPublicKey struct {
|
|
nc noCopy
|
|
ptr *C.SignalKyberPublicKey
|
|
}
|
|
|
|
type KyberSecretKey struct {
|
|
nc noCopy
|
|
ptr *C.SignalKyberSecretKey
|
|
}
|
|
|
|
func wrapKyberKeyPair(ptr *C.SignalKyberKeyPair) *KyberKeyPair {
|
|
kp := &KyberKeyPair{ptr: ptr}
|
|
runtime.SetFinalizer(kp, (*KyberKeyPair).Destroy)
|
|
return kp
|
|
}
|
|
|
|
func (kp *KyberKeyPair) mutPtr() C.SignalMutPointerKyberKeyPair {
|
|
return C.SignalMutPointerKyberKeyPair{kp.ptr}
|
|
}
|
|
|
|
func (kp *KyberKeyPair) constPtr() C.SignalConstPointerKyberKeyPair {
|
|
return C.SignalConstPointerKyberKeyPair{kp.ptr}
|
|
}
|
|
|
|
func (kp *KyberKeyPair) Destroy() error {
|
|
kp.CancelFinalizer()
|
|
return wrapError(C.signal_kyber_key_pair_destroy(kp.mutPtr()))
|
|
}
|
|
|
|
func (kp *KyberKeyPair) CancelFinalizer() {
|
|
runtime.SetFinalizer(kp, nil)
|
|
}
|
|
|
|
func wrapKyberPublicKey(ptr *C.SignalKyberPublicKey) *KyberPublicKey {
|
|
publicKey := &KyberPublicKey{ptr: ptr}
|
|
runtime.SetFinalizer(publicKey, (*KyberPublicKey).Destroy)
|
|
return publicKey
|
|
}
|
|
|
|
func (k *KyberPublicKey) mutPtr() C.SignalMutPointerKyberPublicKey {
|
|
return C.SignalMutPointerKyberPublicKey{k.ptr}
|
|
}
|
|
|
|
func (k *KyberPublicKey) constPtr() C.SignalConstPointerKyberPublicKey {
|
|
return C.SignalConstPointerKyberPublicKey{k.ptr}
|
|
}
|
|
|
|
func (k *KyberPublicKey) Destroy() error {
|
|
k.CancelFinalizer()
|
|
return wrapError(C.signal_kyber_public_key_destroy(k.mutPtr()))
|
|
}
|
|
|
|
func (k *KyberPublicKey) CancelFinalizer() {
|
|
runtime.SetFinalizer(k, nil)
|
|
}
|
|
|
|
func wrapKyberSecretKey(ptr *C.SignalKyberSecretKey) *KyberSecretKey {
|
|
secretKey := &KyberSecretKey{ptr: ptr}
|
|
runtime.SetFinalizer(secretKey, (*KyberSecretKey).Destroy)
|
|
return secretKey
|
|
}
|
|
|
|
func (k *KyberSecretKey) mutPtr() C.SignalMutPointerKyberSecretKey {
|
|
return C.SignalMutPointerKyberSecretKey{k.ptr}
|
|
}
|
|
|
|
func (k *KyberSecretKey) constPtr() C.SignalConstPointerKyberSecretKey {
|
|
return C.SignalConstPointerKyberSecretKey{k.ptr}
|
|
}
|
|
|
|
func (k *KyberSecretKey) Destroy() error {
|
|
k.CancelFinalizer()
|
|
return wrapError(C.signal_kyber_secret_key_destroy(k.mutPtr()))
|
|
}
|
|
|
|
func (k *KyberSecretKey) CancelFinalizer() {
|
|
runtime.SetFinalizer(k, nil)
|
|
}
|
|
|
|
func wrapKyberPreKeyRecord(ptr *C.SignalKyberPreKeyRecord) *KyberPreKeyRecord {
|
|
kpkr := &KyberPreKeyRecord{ptr: ptr}
|
|
runtime.SetFinalizer(kpkr, (*KyberPreKeyRecord).Destroy)
|
|
return kpkr
|
|
}
|
|
|
|
func (kp *KyberKeyPair) GetPublicKey() (*KyberPublicKey, error) {
|
|
var pub C.SignalMutPointerKyberPublicKey
|
|
signalFfiError := C.signal_kyber_key_pair_get_public_key(&pub, kp.constPtr())
|
|
runtime.KeepAlive(kp)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return wrapKyberPublicKey(pub.raw), nil
|
|
}
|
|
|
|
func (kp *KyberPublicKey) Serialize() ([]byte, error) {
|
|
var serialized C.SignalOwnedBuffer = C.SignalOwnedBuffer{}
|
|
signalFfiError := C.signal_kyber_public_key_serialize(&serialized, kp.constPtr())
|
|
runtime.KeepAlive(kp)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return CopySignalOwnedBufferToBytes(serialized), nil
|
|
}
|
|
|
|
func DeserializeKyberPublicKey(serialized []byte) (*KyberPublicKey, error) {
|
|
var kyberPublicKey C.SignalMutPointerKyberPublicKey
|
|
signalFfiError := C.signal_kyber_public_key_deserialize(&kyberPublicKey, BytesToBuffer(serialized))
|
|
runtime.KeepAlive(serialized)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return wrapKyberPublicKey(kyberPublicKey.raw), nil
|
|
}
|
|
|
|
func NewKyberPreKeyRecord(id uint32, timestamp time.Time, keyPair *KyberKeyPair, signature []byte) (*KyberPreKeyRecord, error) {
|
|
var kpkr C.SignalMutPointerKyberPreKeyRecord
|
|
signalFfiError := C.signal_kyber_pre_key_record_new(
|
|
&kpkr,
|
|
C.uint32_t(id),
|
|
C.uint64_t(timestamp.UnixMilli()),
|
|
keyPair.constPtr(),
|
|
BytesToBuffer(signature),
|
|
)
|
|
runtime.KeepAlive(keyPair)
|
|
runtime.KeepAlive(signature)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return wrapKyberPreKeyRecord(kpkr.raw), nil
|
|
}
|
|
|
|
func DeserializeKyberPreKeyRecord(serialized []byte) (*KyberPreKeyRecord, error) {
|
|
var kpkr C.SignalMutPointerKyberPreKeyRecord
|
|
signalFfiError := C.signal_kyber_pre_key_record_deserialize(&kpkr, BytesToBuffer(serialized))
|
|
runtime.KeepAlive(serialized)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return wrapKyberPreKeyRecord(kpkr.raw), nil
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) mutPtr() C.SignalMutPointerKyberPreKeyRecord {
|
|
return C.SignalMutPointerKyberPreKeyRecord{kpkr.ptr}
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) constPtr() C.SignalConstPointerKyberPreKeyRecord {
|
|
return C.SignalConstPointerKyberPreKeyRecord{kpkr.ptr}
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) Clone() (*KyberPreKeyRecord, error) {
|
|
var cloned C.SignalMutPointerKyberPreKeyRecord
|
|
signalFfiError := C.signal_kyber_pre_key_record_clone(&cloned, kpkr.constPtr())
|
|
runtime.KeepAlive(kpkr)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return wrapKyberPreKeyRecord(cloned.raw), nil
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) Destroy() error {
|
|
kpkr.CancelFinalizer()
|
|
return wrapError(C.signal_kyber_pre_key_record_destroy(kpkr.mutPtr()))
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) CancelFinalizer() {
|
|
runtime.SetFinalizer(kpkr, nil)
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) Serialize() ([]byte, error) {
|
|
var serialized C.SignalOwnedBuffer = C.SignalOwnedBuffer{}
|
|
signalFfiError := C.signal_kyber_pre_key_record_serialize(&serialized, kpkr.constPtr())
|
|
runtime.KeepAlive(kpkr)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return CopySignalOwnedBufferToBytes(serialized), nil
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) GetSignature() ([]byte, error) {
|
|
var signature C.SignalOwnedBuffer = C.SignalOwnedBuffer{}
|
|
signalFfiError := C.signal_kyber_pre_key_record_get_signature(&signature, kpkr.constPtr())
|
|
runtime.KeepAlive(kpkr)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return CopySignalOwnedBufferToBytes(signature), nil
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) GetID() (uint32, error) {
|
|
var id C.uint32_t
|
|
signalFfiError := C.signal_kyber_pre_key_record_get_id(&id, kpkr.constPtr())
|
|
runtime.KeepAlive(kpkr)
|
|
if signalFfiError != nil {
|
|
return 0, wrapError(signalFfiError)
|
|
}
|
|
return uint32(id), nil
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) GetTimestamp() (time.Time, error) {
|
|
var ts C.uint64_t
|
|
signalFfiError := C.signal_kyber_pre_key_record_get_timestamp(&ts, kpkr.constPtr())
|
|
runtime.KeepAlive(kpkr)
|
|
if signalFfiError != nil {
|
|
return time.Time{}, wrapError(signalFfiError)
|
|
}
|
|
return time.UnixMilli(int64(ts)), nil
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) GetPublicKey() (*KyberPublicKey, error) {
|
|
var pub C.SignalMutPointerKyberPublicKey
|
|
signalFfiError := C.signal_kyber_pre_key_record_get_public_key(&pub, kpkr.constPtr())
|
|
runtime.KeepAlive(kpkr)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return wrapKyberPublicKey(pub.raw), nil
|
|
}
|
|
|
|
func (kpkr *KyberPreKeyRecord) GetSecretKey() (*KyberSecretKey, error) {
|
|
var sec C.SignalMutPointerKyberSecretKey
|
|
signalFfiError := C.signal_kyber_pre_key_record_get_secret_key(&sec, kpkr.constPtr())
|
|
runtime.KeepAlive(kpkr)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return wrapKyberSecretKey(sec.raw), nil
|
|
}
|
|
|
|
func KyberKeyPairGenerate() (*KyberKeyPair, error) {
|
|
var kp C.SignalMutPointerKyberKeyPair
|
|
signalFfiError := C.signal_kyber_key_pair_generate(&kp)
|
|
if signalFfiError != nil {
|
|
return nil, wrapError(signalFfiError)
|
|
}
|
|
return wrapKyberKeyPair(kp.raw), nil
|
|
}
|