libsignalgo

package

Go to main page

Versions in this module

v0

v0.8.6

Aug 16, 2025

Changes in this version

+ const GroupIdentifierLength

type GroupIdentifier

+ func (gid *GroupIdentifier) String() string

v0.8.5

Jul 16, 2025

v0.8.4

Jun 16, 2025

v0.8.3

May 16, 2025

v0.8.2

Apr 16, 2025

v0.8.1

Mar 16, 2025

v0.8.0

Feb 16, 2025

Changes in this version

+ const BackupIDLength

+ type BackupID [BackupIDLength]byte

+ type BackupKey [C.SignalBACKUP_KEY_LEN]byte

+ func BytesToBackupKey(bytes []byte) *BackupKey

+ func GenerateRandomBackupKey() *BackupKey

+ func (bk *BackupKey) DeriveBackupID(aci ServiceID) (*BackupID, error)

+ func (bk *BackupKey) DeriveECKey(aci ServiceID) (*PrivateKey, error)

+ func (bk *BackupKey) DeriveLocalBackupMetadataKey() (*BackupMetadataKey, error)

+ func (bk *BackupKey) DeriveMediaEncryptionKey(mediaID *BackupMediaID) (*BackupMediaKey, error)

+ func (bk *BackupKey) DeriveMediaID(mediaName string) (*BackupMediaID, error)

+ func (bk *BackupKey) DeriveThumbnailTransitEncryptionKey(mediaID *BackupMediaID) (*BackupMediaKey, error)

+ func (bk *BackupKey) Slice() []byte

+ type BackupMediaID [C.SignalMEDIA_ID_LEN]byte

+ type BackupMediaKey [C.SignalMEDIA_ENCRYPTION_KEY_LEN]byte

+ type BackupMetadataKey [C.SignalLOCAL_BACKUP_METADATA_KEY_LEN]byte

type GroupMasterKey

+ func (gmk GroupMasterKey) GroupIdentifier() (*GroupIdentifier, error)

+ type MessageBackupKey struct

+ func MessageBackupKeyFromAccountEntropyPool(aep AccountEntropyPool, aci ServiceID) (*MessageBackupKey, error)

+ func MessageBackupKeyFromBackupKeyAndID(backupKey *BackupKey, backupID *BackupID) (*MessageBackupKey, error)

+ func (bk *MessageBackupKey) Destroy() error

+ func (bk *MessageBackupKey) GetAESKey() ([32]byte, error)

+ func (bk *MessageBackupKey) GetHMACKey() ([32]byte, error)

v0.7.5

Jan 16, 2025

v0.7.4

Dec 16, 2024

Changes in this version

+ type AccountEntropyPool string

+ func (aep AccountEntropyPool) DeriveBackupKey() ([]byte, error)

+ func (aep AccountEntropyPool) DeriveSVRKey() ([]byte, error)

v0.7.3

Nov 16, 2024

v0.7.2

Oct 16, 2024

v0.7.1

Sep 16, 2024

v0.7.0

Aug 16, 2024

v0.6.3

Jul 16, 2024

Changes in this version

type ServiceID

+ func (s ServiceID) ToACIAndPNI() (aci, pni uuid.UUID)

v0.6.2

Jun 16, 2024

Changes in this version

type ServerPublicParams

+ func DeserializeServerPublicParams(params []byte) (out *ServerPublicParams, err error)

v0.6.1

May 16, 2024

v0.6.0

Apr 16, 2024

Changes in this version

+ const GroupMasterKeyLength

+ const ProfileKeyLength

type Address

+ func (pa *Address) NameServiceID() (ServiceID, error)

+ type ExpiringProfileKeyCredential [C.SignalEXPIRING_PROFILE_KEY_CREDENTIAL_LEN]byte

+ func ReceiveExpiringProfileKeyCredential(spp ServerPublicParams, requestContext *ProfileKeyCredentialRequestContext, ...) (*ExpiringProfileKeyCredential, error)

+ type ExpiringProfileKeyCredentialResponse [C.SignalEXPIRING_PROFILE_KEY_CREDENTIAL_RESPONSE_LEN]byte

+ func NewExpiringProfileKeyCredentialResponse(b []byte) (*ExpiringProfileKeyCredentialResponse, error)

type GroupSecretParams

+ func (gsp *GroupSecretParams) CreateExpiringProfileKeyCredentialPresentation(spp ServerPublicParams, credential ExpiringProfileKeyCredential) (*ProfileKeyCredentialPresentation, error)

+ func (gsp *GroupSecretParams) DecryptServiceID(ciphertextServiceID UUIDCiphertext) (ServiceID, error)

+ func (gsp *GroupSecretParams) EncryptBlobWithPaddingDeterministic(randomness Randomness, plaintext []byte, padding_len uint32) ([]byte, error)

+ func (gsp *GroupSecretParams) EncryptProfileKey(profileKey ProfileKey, u uuid.UUID) (*ProfileKeyCiphertext, error)

+ func (gsp *GroupSecretParams) EncryptServiceID(serviceID ServiceID) (*UUIDCiphertext, error)

+ func (gsp *GroupSecretParams) GetMasterKey() (*GroupMasterKey, error)

type IdentityKey

+ func (i *IdentityKey) TrySerialize() []byte

type ProfileKey

+ func DeserializeProfileKey(bytes []byte) (*ProfileKey, error)

type ProfileKeyCredentialPresentation

+ func (a ProfileKeyCredentialPresentation) CheckValidContents() error

+ func (a ProfileKeyCredentialPresentation) ProfileKeyCiphertext() (ProfileKeyCiphertext, error)

+ func (a ProfileKeyCredentialPresentation) UUIDCiphertext() (UUIDCiphertext, error)

+ type ServiceID struct

+ Type ServiceIDType

+ UUID uuid.UUID

+ var EmptyServiceID ServiceID

+ func NewACIServiceID(uuid uuid.UUID) ServiceID

+ func NewPNIServiceID(uuid uuid.UUID) ServiceID

+ func ServiceIDFromCFixedBytes(serviceID *C.SignalServiceIdFixedWidthBinaryBytes) ServiceID

+ func ServiceIDFromString(val string) (ServiceID, error)

+ func (s ServiceID) Address(deviceID uint) (*Address, error)

+ func (s ServiceID) Bytes() []byte

+ func (s ServiceID) CFixedBytes() cPNIType

+ func (s ServiceID) FixedBytes() *ServiceIDFixedBytes

+ func (s ServiceID) GoString() string

+ func (s ServiceID) IsEmpty() bool

+ func (s ServiceID) MarshalZerologObject(e *zerolog.Event)

+ func (s ServiceID) String() string

+ func (s ServiceID) Value() (driver.Value, error)

+ type ServiceIDFixedBytes [17]byte

+ type ServiceIDType byte

+ const ServiceIDTypeACI

+ const ServiceIDTypePNI

+ func (st ServiceIDType) GoString() string

+ func (st ServiceIDType) String() string

v0.5.1

Mar 16, 2024

Changes in this version

type ProfileKey

+ func (pk *ProfileKey) IsEmpty() bool

v0.5.0

Feb 16, 2024

Changes in this version

+ const Version

+ func BorrowedMutableBuffer(length int) C.SignalBorrowedMutableBuffer

+ func BytesToBuffer(data []byte) C.SignalBorrowedBuffer

+ func CopyBufferToBytes(buffer *C.uchar, length C.size_t) (b []byte)

+ func CopyCStringToString(cString *C.char) (s string)

+ func CopySignalOwnedBufferToBytes(buffer C.SignalOwnedBuffer) (b []byte)

+ func Decrypt(ctx context.Context, message *Message, fromAddress *Address, ...) ([]byte, error)

+ func DecryptPreKey(ctx context.Context, preKeyMessage *PreKeyMessage, fromAddress *Address, ...) ([]byte, error)

+ func EmptyBorrowedBuffer() C.SignalBorrowedBuffer

+ func GroupDecrypt(ctx context.Context, ctext []byte, sender *Address, store SenderKeyStore) ([]byte, error)

+ func HKDFDerive(outputLength int, inputKeyMaterial, salt, info []byte) ([]byte, error)

+ func InitLogger(level LogLevel, logger Logger)

+ func ProcessPreKeyBundle(ctx context.Context, bundle *PreKeyBundle, forAddress *Address, ...) error

+ func ProcessSenderKeyDistributionMessage(ctx context.Context, message *SenderKeyDistributionMessage, ...) error

+ func SealedSenderEncrypt(ctx context.Context, usmc *UnidentifiedSenderMessageContent, ...) ([]byte, error)

+ func SealedSenderEncryptPlaintext(ctx context.Context, message []byte, forAddress *Address, ...) ([]byte, error)

+ func SealedSenderMultiRecipientEncrypt(messageContent *UnidentifiedSenderMessageContent, forRecipients []*Address, ...) ([]byte, error)

+ func ServerPublicParamsVerifySignature(serverPublicParams ServerPublicParams, messageBytes []byte, ...) error

+ func SignalPNIServiceIDFromUUID(uuid uuid.UUID) (cPNIType, error)

+ func SignalServiceIDFromUUID(uuid uuid.UUID) (cPNIType, error)

+ func SignalServiceIDToUUID(serviceId *C.SignalServiceIdFixedWidthBinaryBytes) (uuid.UUID, error)

+ type AES256_GCM_SIV struct

+ func NewAES256_GCM_SIV(key []byte) (*AES256_GCM_SIV, error)

+ func (aes *AES256_GCM_SIV) Decrypt(ciphertext, nonce, associatedData []byte) ([]byte, error)

+ func (aes *AES256_GCM_SIV) Destroy() error

+ func (aes *AES256_GCM_SIV) Encrypt(plaintext, nonce, associatedData []byte) ([]byte, error)

+ type AccessKey [C.SignalACCESS_KEY_LEN]byte

+ func (ak *AccessKey) String() string

+ type Address struct

+ func NewPhoneAddress(phone string, deviceID uint) (*Address, error)

+ func NewUUIDAddress(u uuid.UUID, deviceID uint) (*Address, error)

+ func NewUUIDAddressFromString(uuidStr string, deviceID uint) (*Address, error)

+ func (pa *Address) CancelFinalizer()

+ func (pa *Address) Clone() (*Address, error)

+ func (pa *Address) Destroy() error

+ func (pa *Address) DeviceID() (uint, error)

+ func (pa *Address) Name() (string, error)

+ func (pa *Address) NameUUID() (uuid.UUID, error)

+ type AuthCredentialPresentation []byte

+ func CreateAuthCredentialWithPniPresentation(serverPublicParams ServerPublicParams, randomness Randomness, ...) (*AuthCredentialPresentation, error)

+ type AuthCredentialWithPni [C.SignalAUTH_CREDENTIAL_WITH_PNI_LEN]byte

+ func ReceiveAuthCredentialWithPni(serverPublicParams ServerPublicParams, aci uuid.UUID, pni uuid.UUID, ...) (*AuthCredentialWithPni, error)

+ func (ac *AuthCredentialWithPni) Slice() []byte

+ type AuthCredentialWithPniResponse [C.SignalAUTH_CREDENTIAL_WITH_PNI_RESPONSE_LEN]byte

+ func NewAuthCredentialWithPniResponse(b []byte) (*AuthCredentialWithPniResponse, error)

+ type CallbackContext struct

+ Ctx context.Context

+ Error error

+ Unrefs []unsafe.Pointer

+ func NewCallbackContext(ctx context.Context) *CallbackContext

+ func (ctx *CallbackContext) Unref()

+ type CiphertextMessage struct

+ func Encrypt(ctx context.Context, plaintext []byte, forAddress *Address, ...) (*CiphertextMessage, error)

+ func GroupEncrypt(ctx context.Context, ptext []byte, sender *Address, distributionID uuid.UUID, ...) (*CiphertextMessage, error)

+ func NewCiphertextMessage(plaintext *PlaintextContent) (*CiphertextMessage, error)

+ func (c *CiphertextMessage) CancelFinalizer()

+ func (c *CiphertextMessage) Destroy() error

+ func (c *CiphertextMessage) MessageType() (CiphertextMessageType, error)

+ func (c *CiphertextMessage) Serialize() ([]byte, error)

+ type CiphertextMessageType uint8

+ const CiphertextMessageTypePlaintext

+ const CiphertextMessageTypePreKey

+ const CiphertextMessageTypeSenderKey

+ const CiphertextMessageTypeWhisper

+ type DecryptionErrorMessage struct

+ func DecryptionErrorMessageForOriginalMessage(originalBytes []byte, originalType uint8, originalTs uint64, ...) (*DecryptionErrorMessage, error)

+ func DecryptionErrorMessageFromSerializedContent(serialized []byte) (*DecryptionErrorMessage, error)

+ func DeserializeDecryptionErrorMessage(messageBytes []byte) (*DecryptionErrorMessage, error)

+ func (dem *DecryptionErrorMessage) CancelFinalizer()

+ func (dem *DecryptionErrorMessage) Clone() (*DecryptionErrorMessage, error)

+ func (dem *DecryptionErrorMessage) Destroy() error

+ func (dem *DecryptionErrorMessage) GetDeviceID() (uint32, error)

+ func (dem *DecryptionErrorMessage) GetRatchetKey() (*PublicKey, error)

+ func (dem *DecryptionErrorMessage) GetTimestamp() (time.Time, error)

+ func (dem *DecryptionErrorMessage) Serialize() ([]byte, error)

+ type DeviceTransferKey struct

+ func GenerateDeviceTransferKey() (*DeviceTransferKey, error)

+ func (dtk *DeviceTransferKey) GenerateCertificate(name string, days int) ([]byte, error)

+ func (dtk *DeviceTransferKey) PrivateKeyMaterial() []byte

+ type ErrorCode int

+ const ErrorCodeCallbackError

+ const ErrorCodeDuplicatedMessage

+ const ErrorCodeFingerprintParsingError

+ const ErrorCodeFingerprintVersionMismatch

+ const ErrorCodeInternalError

+ const ErrorCodeInvalidArgument

+ const ErrorCodeInvalidAttestationData

+ const ErrorCodeInvalidKey

+ const ErrorCodeInvalidKeyIdentifier

+ const ErrorCodeInvalidMessage

+ const ErrorCodeInvalidRegistrationId

+ const ErrorCodeInvalidSenderKeySession

+ const ErrorCodeInvalidSession

+ const ErrorCodeInvalidSignature

+ const ErrorCodeInvalidState

+ const ErrorCodeInvalidType

+ const ErrorCodeInvalidUtf8String

+ const ErrorCodeLegacyCiphertextVersion

+ const ErrorCodeNullParameter

+ const ErrorCodeProtobufError

+ const ErrorCodeSealedSenderSelfSend

+ const ErrorCodeSessionNotFound

+ const ErrorCodeUnknownCiphertextVersion

+ const ErrorCodeUnknownError

+ const ErrorCodeUnrecognizedMessageVersion

+ const ErrorCodeUntrustedIdentity

+ const ErrorCodeVerificationFailure

+ type Fingerprint struct

+ func NewFingerprint(iterations, version FingerprintVersion, localIdentifier []byte, ...) (*Fingerprint, error)

+ func (f *Fingerprint) Clone() (*Fingerprint, error)

+ func (f *Fingerprint) Compare(fingerprint1, fingerprint2 []byte) (bool, error)

+ func (f *Fingerprint) Destroy() error

+ func (f *Fingerprint) DisplayString() (string, error)

+ func (f *Fingerprint) ScannableEncoding() ([]byte, error)

+ type FingerprintVersion uint32

+ const FingerprintVersionV1

+ const FingerprintVersionV2

+ type GroupIdentifier [C.SignalGROUP_IDENTIFIER_LEN]byte

+ func GetGroupIdentifier(groupPublicParams GroupPublicParams) (*GroupIdentifier, error)

+ type GroupMasterKey [C.SignalGROUP_MASTER_KEY_LEN]byte

+ type GroupPublicParams [C.SignalGROUP_PUBLIC_PARAMS_LEN]byte

+ type GroupSecretParams [C.SignalGROUP_SECRET_PARAMS_LEN]byte

+ func DeriveGroupSecretParamsFromMasterKey(groupMasterKey GroupMasterKey) (GroupSecretParams, error)

+ func GenerateGroupSecretParams() (GroupSecretParams, error)

+ func GenerateGroupSecretParamsWithRandomness(randomness Randomness) (GroupSecretParams, error)

+ func (gsp *GroupSecretParams) DecryptBlobWithPadding(blob []byte) ([]byte, error)

+ func (gsp *GroupSecretParams) DecryptProfileKey(ciphertextProfileKey ProfileKeyCiphertext, u uuid.UUID) (*ProfileKey, error)

+ func (gsp *GroupSecretParams) DecryptUUID(ciphertextUUID UUIDCiphertext) (uuid.UUID, error)

+ func (gsp *GroupSecretParams) GetPublicParams() (*GroupPublicParams, error)

+ type HSMEnclaveClient struct

+ func NewHSMEnclaveClient(trustedPublicKey, trustedCodeHashes []byte) (*HSMEnclaveClient, error)

+ func (hsm *HSMEnclaveClient) CompleteHandshake(handshakeReceived []byte) error

+ func (hsm *HSMEnclaveClient) Destroy() error

+ func (hsm *HSMEnclaveClient) EstablishedReceive(ciphertext []byte) ([]byte, error)

+ func (hsm *HSMEnclaveClient) EstablishedSend(plaintext []byte) ([]byte, error)

+ func (hsm *HSMEnclaveClient) InitialRequest() ([]byte, error)

+ type IdentityKey struct

+ func DeserializeIdentityKey(bytes []byte) (*IdentityKey, error)

+ func NewIdentityKeyFromBytes(bytes []byte) (*IdentityKey, error)

+ func NewIdentityKeyFromPublicKey(publicKey *PublicKey) (*IdentityKey, error)

+ func (i *IdentityKey) Equal(other *IdentityKey) (bool, error)

+ func (i *IdentityKey) Serialize() ([]byte, error)

+ func (i *IdentityKey) VerifyAlternateIdentity(other *IdentityKey, signature []byte) (bool, error)

+ type IdentityKeyPair struct

+ func DeserializeIdentityKeyPair(bytes []byte) (*IdentityKeyPair, error)

+ func GenerateIdentityKeyPair() (*IdentityKeyPair, error)

+ func NewIdentityKeyPair(publicKey *PublicKey, privateKey *PrivateKey) (*IdentityKeyPair, error)

+ func (i *IdentityKeyPair) GetIdentityKey() *IdentityKey

+ func (i *IdentityKeyPair) GetPrivateKey() *PrivateKey

+ func (i *IdentityKeyPair) GetPublicKey() *PublicKey

+ func (i *IdentityKeyPair) Serialize() ([]byte, error)

+ func (i *IdentityKeyPair) SignAlternateIdentity(other *IdentityKey) ([]byte, error)

+ type IdentityKeyStore interface

+ GetIdentityKey func(ctx context.Context, address *Address) (*IdentityKey, error)

+ GetIdentityKeyPair func(ctx context.Context) (*IdentityKeyPair, error)

+ GetLocalRegistrationID func(ctx context.Context) (uint32, error)

+ IsTrustedIdentity func(ctx context.Context, address *Address, identityKey *IdentityKey, ...) (bool, error)

+ SaveIdentityKey func(ctx context.Context, address *Address, identityKey *IdentityKey) (bool, error)

+ type KyberKeyPair struct

+ func KyberKeyPairGenerate() (*KyberKeyPair, error)

+ func (kp *KyberKeyPair) CancelFinalizer()

+ func (kp *KyberKeyPair) Destroy() error

+ func (kp *KyberKeyPair) GetPublicKey() (*KyberPublicKey, error)

+ type KyberPreKeyRecord struct

+ func DeserializeKyberPreKeyRecord(serialized []byte) (*KyberPreKeyRecord, error)

+ func NewKyberPreKeyRecord(id uint32, timestamp time.Time, keyPair *KyberKeyPair, signature []byte) (*KyberPreKeyRecord, error)

+ func (kpkr *KyberPreKeyRecord) CancelFinalizer()

+ func (kpkr *KyberPreKeyRecord) Clone() (*KyberPreKeyRecord, error)

+ func (kpkr *KyberPreKeyRecord) Destroy() error

+ func (kpkr *KyberPreKeyRecord) GetID() (uint, error)

+ func (kpkr *KyberPreKeyRecord) GetPublicKey() (*KyberPublicKey, error)

+ func (kpkr *KyberPreKeyRecord) GetSecretKey() (*KyberSecretKey, error)

+ func (kpkr *KyberPreKeyRecord) GetSignature() ([]byte, error)

+ func (kpkr *KyberPreKeyRecord) GetTimestamp() (time.Time, error)

+ func (kpkr *KyberPreKeyRecord) Serialize() ([]byte, error)

+ type KyberPreKeyStore interface

+ LoadKyberPreKey func(ctx context.Context, id uint32) (*KyberPreKeyRecord, error)

+ MarkKyberPreKeyUsed func(ctx context.Context, id uint32) error

+ StoreKyberPreKey func(ctx context.Context, id uint32, kyberPreKeyRecord *KyberPreKeyRecord) error

+ type KyberPublicKey struct

+ func DeserializeKyberPublicKey(serialized []byte) (*KyberPublicKey, error)

+ func (k *KyberPublicKey) CancelFinalizer()

+ func (k *KyberPublicKey) Destroy() error

+ func (kp *KyberPublicKey) Serialize() ([]byte, error)

+ type KyberSecretKey struct

+ func (k *KyberSecretKey) CancelFinalizer()

+ func (k *KyberSecretKey) Destroy() error

+ type LogLevel int

+ const LogLevelDebug

+ const LogLevelError

+ const LogLevelInfo

+ const LogLevelTrace

+ const LogLevelWarn

+ type Logger interface

+ Enabled func(target string, level LogLevel) bool

+ Flush func()

+ Log func(target string, level LogLevel, file string, line uint, message string)

+ type Message struct

+ func DeserializeMessage(serialized []byte) (*Message, error)

+ func (m *Message) CancelFinalizer()

+ func (m *Message) Clone() (*Message, error)

+ func (m *Message) Destroy() error

+ func (m *Message) GetBody() ([]byte, error)

+ func (m *Message) GetCounter() (uint32, error)

+ func (m *Message) GetMessageVersion() (uint32, error)

+ func (m *Message) Serialize() ([]byte, error)

+ func (m *Message) VerifyMAC(sender, receiver *PublicKey, macKey []byte) (bool, error)

+ type NotarySignature [C.SignalSIGNATURE_LEN]byte

+ type PlaintextContent struct

+ func DeserializePlaintextContent(plaintextContentBytes []byte) (*PlaintextContent, error)

+ func PlaintextContentFromDecryptionErrorMessage(message *DecryptionErrorMessage) (*PlaintextContent, error)

+ func (pc *PlaintextContent) CancelFinalizer()

+ func (pc *PlaintextContent) Clone() (*PlaintextContent, error)

+ func (pc *PlaintextContent) Destroy() error

+ func (pc *PlaintextContent) GetBody() ([]byte, error)

+ func (pc *PlaintextContent) Serialize() ([]byte, error)

+ type PreKeyBundle struct

+ func NewPreKeyBundle(registrationID uint32, deviceID uint32, preKeyID uint32, preKey *PublicKey, ...) (*PreKeyBundle, error)

+ func (pkb *PreKeyBundle) CancelFinalizer()

+ func (pkb *PreKeyBundle) Clone() (*PreKeyBundle, error)

+ func (pkb *PreKeyBundle) Destroy() error

+ func (pkb *PreKeyBundle) GetIdentityKey() (*IdentityKey, error)

+ type PreKeyMessage struct

+ func DeserializePreKeyMessage(serialized []byte) (*PreKeyMessage, error)

+ func (m *PreKeyMessage) CancelFinalizer()

+ func (m *PreKeyMessage) Clone() (*PreKeyMessage, error)

+ func (m *PreKeyMessage) Destroy() error

+ func (m *PreKeyMessage) GetBaseKey() (*PublicKey, error)

+ func (m *PreKeyMessage) GetIdentityKey() (*IdentityKey, error)

+ func (m *PreKeyMessage) GetPreKeyID() (*uint32, error)

+ func (m *PreKeyMessage) GetRegistrationID() (uint32, error)

+ func (m *PreKeyMessage) GetSignalMessage() (*Message, error)

+ func (m *PreKeyMessage) GetSignedPreKeyID() (uint32, error)

+ func (m *PreKeyMessage) GetVersion() (uint32, error)

+ func (m *PreKeyMessage) Serialize() ([]byte, error)

+ type PreKeyRecord struct

+ func DeserializePreKeyRecord(serialized []byte) (*PreKeyRecord, error)

+ func NewPreKeyRecord(id uint32, publicKey *PublicKey, privateKey *PrivateKey) (*PreKeyRecord, error)

+ func NewPreKeyRecordFromPrivateKey(id uint32, privateKey *PrivateKey) (*PreKeyRecord, error)

+ func (pkr *PreKeyRecord) CancelFinalizer()

+ func (pkr *PreKeyRecord) Clone() (*PreKeyRecord, error)

+ func (pkr *PreKeyRecord) Destroy() error

+ func (pkr *PreKeyRecord) GetID() (uint, error)

+ func (pkr *PreKeyRecord) GetPrivateKey() (*PrivateKey, error)

+ func (pkr *PreKeyRecord) GetPublicKey() (*PublicKey, error)

+ func (pkr *PreKeyRecord) Serialize() ([]byte, error)

+ type PreKeyStore interface

+ LoadPreKey func(ctx context.Context, id uint32) (*PreKeyRecord, error)

+ RemovePreKey func(ctx context.Context, id uint32) error

+ StorePreKey func(ctx context.Context, id uint32, preKeyRecord *PreKeyRecord) error

+ type PrivateKey struct

+ func DeserializePrivateKey(keyData []byte) (*PrivateKey, error)

+ func GeneratePrivateKey() (*PrivateKey, error)

+ func (pk *PrivateKey) Agree(publicKey *PublicKey) ([]byte, error)

+ func (pk *PrivateKey) CancelFinalizer()

+ func (pk *PrivateKey) Clone() (*PrivateKey, error)

+ func (pk *PrivateKey) Destroy() error

+ func (pk *PrivateKey) GetPublicKey() (*PublicKey, error)

+ func (pk *PrivateKey) Serialize() ([]byte, error)

+ func (pk *PrivateKey) Sign(message []byte) ([]byte, error)

+ type ProfileKey [C.SignalPROFILE_KEY_LEN]byte

+ func (pk *ProfileKey) DeriveAccessKey() (*AccessKey, error)

+ func (pk *ProfileKey) GetCommitment(u uuid.UUID) (*ProfileKeyCommitment, error)

+ func (pk *ProfileKey) GetProfileKeyVersion(u uuid.UUID) (*ProfileKeyVersion, error)

+ func (pk *ProfileKey) Slice() []byte

+ type ProfileKeyCiphertext [C.SignalPROFILE_KEY_CIPHERTEXT_LEN]byte

+ type ProfileKeyCommitment [C.SignalPROFILE_KEY_COMMITMENT_LEN]byte

+ type ProfileKeyCredentialPresentation []byte

+ type ProfileKeyCredentialRequest [C.SignalPROFILE_KEY_CREDENTIAL_REQUEST_LEN]byte

+ type ProfileKeyCredentialRequestContext [C.SignalPROFILE_KEY_CREDENTIAL_REQUEST_CONTEXT_LEN]byte

+ func CreateProfileKeyCredentialRequestContext(serverPublicParams ServerPublicParams, u uuid.UUID, profileKey ProfileKey) (*ProfileKeyCredentialRequestContext, error)

+ func (p *ProfileKeyCredentialRequestContext) ProfileKeyCredentialRequestContextGetRequest() (*ProfileKeyCredentialRequest, error)

+ type ProfileKeyCredentialResponse []byte

+ func NewProfileKeyCredentialResponse(b []byte) (ProfileKeyCredentialResponse, error)

+ type ProfileKeyVersion [C.SignalPROFILE_KEY_VERSION_ENCODED_LEN]byte

+ func (pv *ProfileKeyVersion) String() string

+ type PublicKey struct

+ func DeserializePublicKey(keyData []byte) (*PublicKey, error)

+ func (k *PublicKey) Bytes() ([]byte, error)

+ func (k *PublicKey) CancelFinalizer()

+ func (k *PublicKey) Compare(other *PublicKey) (int, error)

+ func (k *PublicKey) Destroy() error

+ func (k *PublicKey) Verify(message, signature []byte) (bool, error)

+ func (pk *PublicKey) Clone() (*PublicKey, error)

+ func (pk *PublicKey) Serialize() ([]byte, error)

+ type Randomness [C.SignalRANDOMNESS_LEN]byte

+ func GenerateRandomness() Randomness

+ type SGXClientState struct

+ func NewCDS2ClientState(mrenclave, attestationMessage []byte, currentTime time.Time) (*SGXClientState, error)

+ func (cds *SGXClientState) CompleteHandshake(handshakeReceived []byte) error

+ func (cds *SGXClientState) Destroy() error

+ func (cds *SGXClientState) EstablishedReceive(ciphertext []byte) ([]byte, error)

+ func (cds *SGXClientState) EstablishedSend(plaintext []byte) ([]byte, error)

+ func (cds *SGXClientState) InitialRequest() ([]byte, error)

+ type SealedSenderAddress struct

+ DeviceID uint32

+ E164 string

+ UUID uuid.UUID

+ func NewSealedSenderAddress(e164 string, uuid uuid.UUID, deviceID uint32) *SealedSenderAddress

+ type SealedSenderResult struct

+ Message []byte

+ Sender SealedSenderAddress

+ func SealedSenderDecrypt(ctx context.Context, ciphertext []byte, localAddress *SealedSenderAddress, ...) (result SealedSenderResult, err error)

+ type SenderCertificate struct

+ func DeserializeSenderCertificate(serialized []byte) (*SenderCertificate, error)

+ func NewSenderCertificate(sender *SealedSenderAddress, publicKey *PublicKey, expiration time.Time, ...) (*SenderCertificate, error)

+ func (sc *SenderCertificate) CancelFinalizer()

+ func (sc *SenderCertificate) Clone() (*SenderCertificate, error)

+ func (sc *SenderCertificate) Destroy() error

+ func (sc *SenderCertificate) GetCertificate() ([]byte, error)

+ func (sc *SenderCertificate) GetDeviceID() (uint32, error)

+ func (sc *SenderCertificate) GetExpiration() (time.Time, error)

+ func (sc *SenderCertificate) GetKey() (*PublicKey, error)

+ func (sc *SenderCertificate) GetSenderE164() (string, error)

+ func (sc *SenderCertificate) GetSenderUUID() (uuid.UUID, error)

+ func (sc *SenderCertificate) GetServerCertificate() (*ServerCertificate, error)

+ func (sc *SenderCertificate) GetSignature() ([]byte, error)

+ func (sc *SenderCertificate) Serialize() ([]byte, error)

+ func (sc *SenderCertificate) Validate(trustRoot *PublicKey, ts time.Time) (bool, error)

+ type SenderKeyDistributionMessage struct

+ func DeserializeSenderKeyDistributionMessage(serialized []byte) (*SenderKeyDistributionMessage, error)

+ func NewSenderKeyDistributionMessage(ctx context.Context, sender *Address, distributionID uuid.UUID, ...) (*SenderKeyDistributionMessage, error)

+ func (sc *SenderKeyDistributionMessage) CancelFinalizer()

+ func (sc *SenderKeyDistributionMessage) Destroy() error

+ func (sc *SenderKeyDistributionMessage) Process(ctx context.Context, sender *Address, store SenderKeyStore) error

+ func (sc *SenderKeyDistributionMessage) Serialize() ([]byte, error)

+ type SenderKeyRecord struct

+ func DeserializeSenderKeyRecord(serialized []byte) (*SenderKeyRecord, error)

+ func (skr *SenderKeyRecord) CancelFinalizer()

+ func (skr *SenderKeyRecord) Clone() (*SenderKeyRecord, error)

+ func (skr *SenderKeyRecord) Destroy() error

+ func (skr *SenderKeyRecord) Serialize() ([]byte, error)

+ type SenderKeyStore interface

+ LoadSenderKey func(ctx context.Context, sender *Address, distributionID uuid.UUID) (*SenderKeyRecord, error)

+ StoreSenderKey func(ctx context.Context, sender *Address, distributionID uuid.UUID, ...) error

+ type ServerCertificate struct

+ func DeserializeServerCertificate(serialized []byte) (*ServerCertificate, error)

+ func NewServerCertificate(keyID uint32, publicKey *PublicKey, trustRoot *PrivateKey) (*ServerCertificate, error)

+ func (sc *ServerCertificate) CancelFinalizer()

+ func (sc *ServerCertificate) Clone() (*ServerCertificate, error)

+ func (sc *ServerCertificate) Destroy() error

+ func (sc *ServerCertificate) GetCertificate() ([]byte, error)

+ func (sc *ServerCertificate) GetKey() (*PublicKey, error)

+ func (sc *ServerCertificate) GetKeyID() (uint32, error)

+ func (sc *ServerCertificate) GetSignature() ([]byte, error)

+ func (sc *ServerCertificate) Serialize() ([]byte, error)

+ type ServerPublicParams [C.SignalSERVER_PUBLIC_PARAMS_LEN]byte

+ type SessionRecord struct

+ func DeserializeSessionRecord(serialized []byte) (*SessionRecord, error)

+ func (sr *SessionRecord) ArchiveCurrentState() error

+ func (sr *SessionRecord) CancelFinalizer()

+ func (sr *SessionRecord) Clone() (*SessionRecord, error)

+ func (sr *SessionRecord) CurrentRatchetKeyMatches(key *PublicKey) (bool, error)

+ func (sr *SessionRecord) Destroy() error

+ func (sr *SessionRecord) GetLocalRegistrationID() (uint32, error)

+ func (sr *SessionRecord) GetRemoteRegistrationID() (uint32, error)

+ func (sr *SessionRecord) HasCurrentState() (bool, error)

+ func (sr *SessionRecord) Serialize() ([]byte, error)

+ type SessionStore interface

+ LoadSession func(ctx context.Context, address *Address) (*SessionRecord, error)

+ StoreSession func(ctx context.Context, address *Address, record *SessionRecord) error

+ type SignalDirection uint

+ const SignalDirectionReceiving

+ const SignalDirectionSending

+ type SignalError struct

+ Code ErrorCode

+ Message string

+ func (e *SignalError) Error() string

+ type SignedPreKeyRecord struct

+ func DeserializeSignedPreKeyRecord(serialized []byte) (*SignedPreKeyRecord, error)

+ func NewSignedPreKeyRecord(id uint32, timestamp time.Time, publicKey *PublicKey, privateKey *PrivateKey, ...) (*SignedPreKeyRecord, error)

+ func NewSignedPreKeyRecordFromPrivateKey(id uint32, timestamp time.Time, privateKey *PrivateKey, signature []byte) (*SignedPreKeyRecord, error)

+ func (spkr *SignedPreKeyRecord) CancelFinalizer()

+ func (spkr *SignedPreKeyRecord) Clone() (*SignedPreKeyRecord, error)

+ func (spkr *SignedPreKeyRecord) Destroy() error

+ func (spkr *SignedPreKeyRecord) GetID() (uint, error)

+ func (spkr *SignedPreKeyRecord) GetPrivateKey() (*PrivateKey, error)

+ func (spkr *SignedPreKeyRecord) GetPublicKey() (*PublicKey, error)

+ func (spkr *SignedPreKeyRecord) GetSignature() ([]byte, error)

+ func (spkr *SignedPreKeyRecord) GetTimestamp() (time.Time, error)

+ func (spkr *SignedPreKeyRecord) Serialize() ([]byte, error)

+ type SignedPreKeyStore interface

+ LoadSignedPreKey func(ctx context.Context, id uint32) (*SignedPreKeyRecord, error)

+ StoreSignedPreKey func(ctx context.Context, id uint32, signedPreKeyRecord *SignedPreKeyRecord) error

+ type UUIDCiphertext [C.SignalUUID_CIPHERTEXT_LEN]byte

+ type UnidentifiedSenderMessageContent struct

+ func DeserializeUnidentifiedSenderMessageContent(serialized []byte) (*UnidentifiedSenderMessageContent, error)

+ func NewUnidentifiedSenderMessageContent(message *CiphertextMessage, senderCertificate *SenderCertificate, ...) (*UnidentifiedSenderMessageContent, error)

+ func SealedSenderDecryptToUSMC(ctx context.Context, ciphertext []byte, identityStore IdentityKeyStore) (*UnidentifiedSenderMessageContent, error)

+ func (usmc *UnidentifiedSenderMessageContent) CancelFinalizer()

+ func (usmc *UnidentifiedSenderMessageContent) Destroy() error

+ func (usmc *UnidentifiedSenderMessageContent) GetContentHint() (UnidentifiedSenderMessageContentHint, error)

+ func (usmc *UnidentifiedSenderMessageContent) GetContents() ([]byte, error)

+ func (usmc *UnidentifiedSenderMessageContent) GetMessageType() (CiphertextMessageType, error)

+ func (usmc *UnidentifiedSenderMessageContent) GetSenderCertificate() (*SenderCertificate, error)

+ func (usmc *UnidentifiedSenderMessageContent) Serialize() ([]byte, error)

+ type UnidentifiedSenderMessageContentHint uint32

+ const UnidentifiedSenderMessageContentHintDefault

+ const UnidentifiedSenderMessageContentHintImplicit

+ const UnidentifiedSenderMessageContentHintResendable

+ type WrappedStore struct

+ Ctx *CallbackContext

+ Store T

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL