package neofscrypto import ( "errors" "fmt" "github.com/nspcc-dev/neofs-api-go/v2/refs" ) // Signature represents a confirmation of data integrity received by the // digital signature mechanism. // // Signature is mutually compatible with github.com/nspcc-dev/neofs-api-go/v2/refs.Signature // message. See ReadFromV2 / WriteToV2 methods. // // Note that direct typecast is not safe and may result in loss of compatibility: // _ = Signature(refs.Signature{}) // not recommended type Signature refs.Signature // ReadFromV2 reads Signature from the refs.Signature message. Checks if the // message conforms to NeoFS API V2 protocol. // // See also WriteToV2. func (x *Signature) ReadFromV2(m refs.Signature) error { if len(m.GetKey()) == 0 { return errors.New("missing public key") } else if len(m.GetSign()) == 0 { return errors.New("missing signature") } switch m.GetScheme() { default: return fmt.Errorf("unsupported scheme %v", m.GetSign()) case refs.ECDSA_SHA512, refs.ECDSA_RFC6979_SHA256, refs.ECDSA_RFC6979_SHA256_WALLET_CONNECT: } *x = Signature(m) return nil } // WriteToV2 writes Signature to the refs.Signature message. // The message must not be nil. // // See also ReadFromV2. func (x Signature) WriteToV2(m *refs.Signature) { *m = (refs.Signature)(x) } // Calculate signs data using Signer and encodes public key for subsequent // verification. // // Signer MUST NOT be nil. // // See also Verify. func (x *Signature) Calculate(signer Signer, data []byte) error { signature, err := signer.Sign(data) if err != nil { return fmt.Errorf("signer %T failure: %w", signer, err) } pub := signer.Public() key := make([]byte, pub.MaxEncodedSize()) key = key[:pub.Encode(key)] m := (*refs.Signature)(x) m.SetScheme(refs.SignatureScheme(signer.Scheme())) m.SetSign(signature) m.SetKey(key) return nil } // Verify verifies data signature using encoded public key. True means valid // signature. // // Verify fails if signature scheme is not supported (see RegisterScheme). // // See also Calculate. func (x Signature) Verify(data []byte) bool { m := (*refs.Signature)(&x) f, ok := publicKeys[Scheme(m.GetScheme())] if !ok { return false } key := f() err := key.Decode(m.GetKey()) if err != nil { return false } return key.Verify(data, m.GetSign()) }