175 lines
4 KiB
Go
175 lines
4 KiB
Go
package object
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
"crypto/sha256"
|
|
"errors"
|
|
"fmt"
|
|
|
|
signatureV2 "github.com/nspcc-dev/neofs-api-go/v2/signature"
|
|
"github.com/nspcc-dev/neofs-sdk-go/checksum"
|
|
"github.com/nspcc-dev/neofs-sdk-go/signature"
|
|
sigutil "github.com/nspcc-dev/neofs-sdk-go/util/signature"
|
|
)
|
|
|
|
var errCheckSumMismatch = errors.New("payload checksum mismatch")
|
|
|
|
var errIncorrectID = errors.New("incorrect object identifier")
|
|
|
|
// CalculatePayloadChecksum calculates and returns checksum of
|
|
// object payload bytes.
|
|
func CalculatePayloadChecksum(payload []byte) *checksum.Checksum {
|
|
res := checksum.New()
|
|
res.SetSHA256(sha256.Sum256(payload))
|
|
|
|
return res
|
|
}
|
|
|
|
// CalculateAndSetPayloadChecksum calculates checksum of current
|
|
// object payload and writes it to the object.
|
|
func CalculateAndSetPayloadChecksum(obj *RawObject) {
|
|
obj.SetPayloadChecksum(
|
|
CalculatePayloadChecksum(obj.Payload()),
|
|
)
|
|
}
|
|
|
|
// VerifyPayloadChecksum checks if payload checksum in the object
|
|
// corresponds to its payload.
|
|
func VerifyPayloadChecksum(obj *Object) error {
|
|
actual := CalculatePayloadChecksum(obj.Payload())
|
|
if !checksum.Equal(obj.PayloadChecksum(), actual) {
|
|
return errCheckSumMismatch
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// CalculateID calculates identifier for the object.
|
|
func CalculateID(obj *Object) (*ID, error) {
|
|
data, err := obj.ToV2().GetHeader().StableMarshal(nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
id := NewID()
|
|
id.SetSHA256(sha256.Sum256(data))
|
|
|
|
return id, nil
|
|
}
|
|
|
|
// CalculateAndSetID calculates identifier for the object
|
|
// and writes the result to it.
|
|
func CalculateAndSetID(obj *RawObject) error {
|
|
id, err := CalculateID(obj.Object())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
obj.SetID(id)
|
|
|
|
return nil
|
|
}
|
|
|
|
// VerifyID checks if identifier in the object corresponds to
|
|
// its structure.
|
|
func VerifyID(obj *Object) error {
|
|
id, err := CalculateID(obj)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !id.Equal(obj.ID()) {
|
|
return errIncorrectID
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func CalculateIDSignature(key *ecdsa.PrivateKey, id *ID) (*signature.Signature, error) {
|
|
sig := signature.New()
|
|
|
|
if err := sigutil.SignDataWithHandler(
|
|
key,
|
|
signatureV2.StableMarshalerWrapper{
|
|
SM: id.ToV2(),
|
|
},
|
|
func(key, sign []byte) {
|
|
sig.SetKey(key)
|
|
sig.SetSign(sign)
|
|
},
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return sig, nil
|
|
}
|
|
|
|
func CalculateAndSetSignature(key *ecdsa.PrivateKey, obj *RawObject) error {
|
|
sig, err := CalculateIDSignature(key, obj.ID())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
obj.SetSignature(sig)
|
|
|
|
return nil
|
|
}
|
|
|
|
func VerifyIDSignature(obj *Object) error {
|
|
return sigutil.VerifyDataWithSource(
|
|
signatureV2.StableMarshalerWrapper{
|
|
SM: obj.ID().ToV2(),
|
|
},
|
|
func() ([]byte, []byte) {
|
|
sig := obj.Signature()
|
|
|
|
return sig.Key(), sig.Sign()
|
|
},
|
|
)
|
|
}
|
|
|
|
// SetIDWithSignature sets object identifier and signature.
|
|
func SetIDWithSignature(key *ecdsa.PrivateKey, obj *RawObject) error {
|
|
if err := CalculateAndSetID(obj); err != nil {
|
|
return fmt.Errorf("could not set identifier: %w", err)
|
|
}
|
|
|
|
if err := CalculateAndSetSignature(key, obj); err != nil {
|
|
return fmt.Errorf("could not set signature: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SetVerificationFields calculates and sets all verification fields of the object.
|
|
func SetVerificationFields(key *ecdsa.PrivateKey, obj *RawObject) error {
|
|
CalculateAndSetPayloadChecksum(obj)
|
|
|
|
return SetIDWithSignature(key, obj)
|
|
}
|
|
|
|
// CheckVerificationFields checks all verification fields of the object.
|
|
func CheckVerificationFields(obj *Object) error {
|
|
if err := CheckHeaderVerificationFields(obj); err != nil {
|
|
return fmt.Errorf("invalid header structure: %w", err)
|
|
}
|
|
|
|
if err := VerifyPayloadChecksum(obj); err != nil {
|
|
return fmt.Errorf("invalid payload checksum: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// CheckHeaderVerificationFields checks all verification fields except payload.
|
|
func CheckHeaderVerificationFields(obj *Object) error {
|
|
if err := VerifyIDSignature(obj); err != nil {
|
|
return fmt.Errorf("invalid signature: %w", err)
|
|
}
|
|
|
|
if err := VerifyID(obj); err != nil {
|
|
return fmt.Errorf("invalid identifier: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|