package object import ( "bytes" "crypto/ecdsa" "crypto/sha256" crypto "github.com/nspcc-dev/neofs-crypto" "github.com/pkg/errors" ) func (m Object) headersData(check bool) ([]byte, error) { var bytebuf = new(bytes.Buffer) // fixme: we must marshal fields one by one without protobuf marshaling // protobuf marshaling does not guarantee the same result if sysheader, err := m.SystemHeader.Marshal(); err != nil { return nil, err } else if _, err := bytebuf.Write(sysheader); err != nil { return nil, err } n, _ := m.LastHeader(HeaderType(IntegrityHdr)) for i := range m.Headers { if check && i == n { // ignore last integrity header in order to check headers data continue } if header, err := m.Headers[i].Marshal(); err != nil { return nil, err } else if _, err := bytebuf.Write(header); err != nil { return nil, err } } return bytebuf.Bytes(), nil } func (m Object) headersChecksum(check bool) ([]byte, error) { data, err := m.headersData(check) if err != nil { return nil, err } checksum := sha256.Sum256(data) return checksum[:], nil } // PayloadChecksum calculates sha256 checksum of object payload. func (m Object) PayloadChecksum() []byte { checksum := sha256.Sum256(m.Payload) return checksum[:] } func (m Object) verifySignature(key []byte, ih *IntegrityHeader) error { pk := crypto.UnmarshalPublicKey(key) if crypto.Verify(pk, ih.HeadersChecksum, ih.ChecksumSignature) == nil { return nil } return ErrVerifySignature } // Verify performs local integrity check by finding verification header and // integrity header. If header integrity is passed, function verifies // checksum of the object payload. // todo: move this verification logic into separate library func (m Object) Verify() error { var ( err error checksum []byte pubkey []byte ) ind, ih := m.LastHeader(HeaderType(IntegrityHdr)) if ih == nil || ind != len(m.Headers) - 1{ return ErrHeaderNotFound } integrity := ih.Value.(*Header_Integrity).Integrity // Prepare structures _, vh := m.LastHeader(HeaderType(VerifyHdr)) if vh == nil { _, pkh := m.LastHeader(HeaderType(PublicKeyHdr)) if pkh == nil { return ErrHeaderNotFound } pubkey = pkh.Value.(*Header_PublicKey).PublicKey.Value } else { pubkey = vh.Value.(*Header_Verify).Verify.PublicKey } // Verify signature err = m.verifySignature(pubkey, integrity) if err != nil { return errors.Wrapf(err, "public key: %x", pubkey) } // Verify checksum of header checksum, err = m.headersChecksum(true) if err != nil { return err } if !bytes.Equal(integrity.HeadersChecksum, checksum) { return ErrVerifyHeader } // Verify checksum of payload if m.SystemHeader.PayloadLength > 0 && !m.IsLinking() { checksum = m.PayloadChecksum() _, ph := m.LastHeader(HeaderType(PayloadChecksumHdr)) if ph == nil { return ErrHeaderNotFound } if !bytes.Equal(ph.Value.(*Header_PayloadChecksum).PayloadChecksum, checksum) { return ErrVerifyPayload } } return nil } // CreateIntegrityHeader returns signed integrity header for the object func CreateIntegrityHeader(obj *Object, key *ecdsa.PrivateKey) (*Header, error) { headerChecksum, err := obj.headersChecksum(false) if err != nil { return nil, err } headerChecksumSignature, err := crypto.Sign(key, headerChecksum) if err != nil { return nil, err } return &Header{Value: &Header_Integrity{ Integrity: &IntegrityHeader{ HeadersChecksum: headerChecksum, ChecksumSignature: headerChecksumSignature, }, }}, nil } // Sign creates new integrity header and adds it to the end of the list of // extended headers. func (m *Object) Sign(key *ecdsa.PrivateKey) error { ih, err := CreateIntegrityHeader(m, key) if err != nil { return err } m.AddHeader(ih) return nil }