diff --git a/swarm/storage/resource.go b/swarm/storage/resource.go index 34444f92c2..3d6c653716 100644 --- a/swarm/storage/resource.go +++ b/swarm/storage/resource.go @@ -1,7 +1,6 @@ package storage import ( - "crypto/ecdsa" "encoding/binary" "fmt" "path/filepath" @@ -18,14 +17,23 @@ import ( ) const ( - signatureLength = 65 - indexSize = 24 + signatureLength = 65 + indexSize = 16 + dbDirName = "resource" + chunkSize = 4096 // temporary until we implement DPA in the resourcehandler + defaultStoreTimeout = 4000 * time.Millisecond ) -// Encapsulates an actual resource update. When synced it contains the most recent +type Signature [signatureLength]byte + +type SignFunc func(common.Hash) (Signature, error) + +type nameHashFunc func(string) common.Hash + +// Encapsulates an specific resource update. When synced it contains the most recent // version of the resource update data. type resource struct { - name string + name *string nameHash common.Hash startBlock uint64 lastPeriod uint32 @@ -35,6 +43,19 @@ type resource struct { updated time.Time } +// TODO Expire content after a defined period (to force resync) +func (r *resource) isSynced() bool { + return !r.updated.IsZero() +} + +// Implement to activate validation of resource updates +// Specifically signing data and verification of signatures +type ResourceValidator interface { + checkAccess(string, common.Address) (bool, error) + nameHash(string) common.Hash // nameHashFunc + sign(common.Hash) (Signature, error) // SignFunc +} + // Mutable resource is an entity which allows updates to a resource // without resorting to ENS on each update. // The update scheme is built on swarm chunks with chunk keys following @@ -44,8 +65,9 @@ type resource struct { // expressed in terms of number of blocks. // // The root entry of a mutable resource is tied to a unique identifier, -// typically - but not necessarily - an ens name. It also contains the -// block number when the resource update was first registered, and +// typically - but not necessarily - an ens name. The identifier must be +// an valid IDNA string. It also contains the block number +// when the resource update was first registered, and // the block frequency with which the resource will be updated, both of // which are stored as little-endian uint64 values in the database (for a // total of 16 bytes). @@ -56,10 +78,6 @@ type resource struct { // starting at block 4200 with frequency 42 will have updates on block 4242, // 4284, 4326 and so on. // -// The identifier is supplied as a string, but will be IDNA converted and -// passed through the ENS namehash function. Pure ascii identifiers without -// periods will thus merely be hashed. -// // Note that the root entry is not required for the resource update scheme to // work. A normal chunk of the blocknumber/frequency data can also be created, // and pointed to by an external resource (ENS or manifest entry) @@ -67,7 +85,7 @@ type resource struct { // Actual data updates are also made in the form of swarm chunks. The keys // of the updates are the hash of a concatenation of properties as follows: // -// sha256(namehash|period|version) +// sha256(period|version|namehash) // // The period is (currentblock - startblock) / frequency // @@ -79,8 +97,12 @@ type resource struct { // // A lookup agent need only know the identifier name in order to get the versions // -// the chunk data is: sign(resourcedata)|resourcedata -// the resourcedata is: headerlength|period|version|name|data +// the resourcedata is: +// headerlength|period|version|identifier|data +// +// if a validator is active, the chunk data is: +// sign(resourcedata)|resourcedata +// otherwise, the chunk data is the same as the resourcedata // // headerlength is a 16 bit value containing the byte length of period|version|name // period and version are both 32 bit values. name can have arbitrary length @@ -91,12 +113,6 @@ type resource struct { // stored using a separate store, and forwarding/syncing protocols carry per-chunk // flags to tell whether the chunk can be validated or not; if not it is to be // treated as a resource update chunk. - -type ResourceValidator interface { - isOwner(string) (bool, error) - nameHash(string) common.Hash -} - type ResourceHandler struct { ChunkStore validator ResourceValidator @@ -105,14 +121,19 @@ type ResourceHandler struct { hashLock sync.Mutex resourceLock sync.RWMutex hasher SwarmHash - privKey *ecdsa.PrivateKey - maxChunkData int64 + nameHash nameHashFunc + storeTimeout time.Duration } // Create or open resource update chunk store -func NewResourceHandler(privKey *ecdsa.PrivateKey, datadir string, cloudStore CloudStore, rpcClient *rpc.Client, validator ResourceValidator) (*ResourceHandler, error) { - path := filepath.Join(datadir, "resource") - dbStore, err := NewDbStore(datadir, nil, singletonSwarmDbCapacity, 0) +// +// If validator is nil, signature and access validation will be deactivated +func NewResourceHandler(datadir string, cloudStore CloudStore, rpcClient *rpc.Client, validator ResourceValidator) (*ResourceHandler, error) { + + hashfunc := MakeHashFunc(SHA3Hash) + + path := filepath.Join(datadir, dbDirName) + dbStore, err := NewDbStore(datadir, hashfunc, singletonSwarmDbCapacity, 0) if err != nil { return nil, err } @@ -120,88 +141,70 @@ func NewResourceHandler(privKey *ecdsa.PrivateKey, datadir string, cloudStore Cl memStore: NewMemStore(dbStore, singletonSwarmDbCapacity), DbStore: dbStore, } - hasher := MakeHashFunc("SHA3") rh := &ResourceHandler{ - ChunkStore: newResourceChunkStore(path, hasher, localStore, cloudStore), + ChunkStore: newResourceChunkStore(path, hashfunc, localStore, cloudStore), rpcClient: rpcClient, resources: make(map[string]*resource), - hasher: hasher(), - privKey: privKey, - maxChunkData: DefaultBranches * int64(hasher().Size()), + hasher: hashfunc(), + validator: validator, + storeTimeout: defaultStoreTimeout, } - if validator != nil { - rh.validator = validator + if rh.validator != nil { + rh.nameHash = rh.validator.nameHash } else { - rh.validator = NewGenericValidator(func(name string) common.Hash { + rh.nameHash = func(name string) common.Hash { rh.hashLock.Lock() defer rh.hashLock.Unlock() rh.hasher.Reset() rh.hasher.Write([]byte(name)) return common.BytesToHash(rh.hasher.Sum(nil)) - }) + } } return rh, nil } -func validateInput(name string, frequency uint64) (string, error) { - // frequency 0 is invalid - if frequency == 0 { - return "", fmt.Errorf("Frequency cannot be 0") - } - - // must have name - if name == "" { - return "", fmt.Errorf("Name cannot be empty") - } - - // make sure our ens identifier is idna safe - validname, err := idna.ToASCII(name) - if err != nil { - return "", err - } - - return validname, nil -} - -// Creates a standalone resource object -// -// Can be passed to SetResource if external root data lookups are used -func NewResource(name string, startBlock uint64, frequency uint64, nameHashFunc func(name string) common.Hash) (*resource, error) { - - validname, err := validateInput(name, frequency) - if err != nil { - return nil, err - } - - return &resource{ - name: validname, - nameHash: nameHashFunc(validname), - startBlock: startBlock, - frequency: frequency, - }, nil +// \TODO should be hashsize * branches from the chosen chunker, implement with dpa +func (self *ResourceHandler) chunkSize() int64 { + return chunkSize } // Creates a new root entry for a mutable resource identified by `name` with the specified `frequency`. // +// The signature data should match the hash of the idna-converted name by the validator's namehash function, NOT the raw name bytes. +// // The start block of the resource update will be the actual current block height of the connected network. func (self *ResourceHandler) NewResource(name string, frequency uint64) (*resource, error) { - ok, err := self.validator.isOwner(name) - if err != nil { - return nil, err - } else if !ok { - return nil, fmt.Errorf("Not owner of '%s'", name) + // frequency 0 is invalid + if frequency == 0 { + return nil, fmt.Errorf("Frequency cannot be 0") } - validname, err := validateInput(name, frequency) - if err != nil { - return nil, err + if !isSafeName(name) { + return nil, fmt.Errorf("Invalid name: '%s'", name) } - nameHash := self.validator.nameHash(validname) + nameHash := self.nameHash(name) + + if self.validator != nil { + signature, err := self.validator.sign(nameHash) + if err != nil { + return nil, fmt.Errorf("Sign fail: %v", err) + } + addr, err := getAddressFromDataSig(nameHash, signature) + if err != nil { + return nil, fmt.Errorf("Retrieve address from signature fail: %v", err) + } + ok, err := self.validator.checkAccess(name, addr) + if err != nil { + return nil, err + } else if !ok { + return nil, fmt.Errorf("Not owner of '%s'", name) + } + } // get our blockheight at this time currentblock, err := self.getBlock() @@ -211,22 +214,19 @@ func (self *ResourceHandler) NewResource(name string, frequency uint64) (*resour // chunk with key equal to namehash points to data of first blockheight + update frequency // from this we know from what blockheight we should look for updates, and how often - chunk := NewChunk(Key(nameHash[:]), nil) + chunk := NewChunk(Key(nameHash.Bytes()), nil) chunk.SData = make([]byte, indexSize) - // resource update root chunks follow same convention as "normal" chunks - // with 8 bytes prefix specifying size val := make([]byte, 8) - chunk.SData[0] = 16 // size, little-endian binary.LittleEndian.PutUint64(val, currentblock) - copy(chunk.SData[8:16], val) + copy(chunk.SData[:8], val) binary.LittleEndian.PutUint64(val, frequency) - copy(chunk.SData[16:], val) + copy(chunk.SData[8:], val) self.Put(chunk) - log.Debug("new resource", "name", validname, "key", nameHash, "startBlock", currentblock, "frequency", frequency) + log.Debug("new resource", "name", name, "key", nameHash, "startBlock", currentblock, "frequency", frequency) rsrc := &resource{ - name: validname, + name: &name, nameHash: nameHash, startBlock: currentblock, frequency: frequency, @@ -234,43 +234,7 @@ func (self *ResourceHandler) NewResource(name string, frequency uint64) (*resour } self.setResource(name, rsrc) - return self.resources[name], nil -} - -// Set an externally defined resource object -// -// If the resource update root chunk is located externally (for example as a normal -// chunk looked up by ENS) the data would be manually added with this method). -// -// Method will fail if resource is already registered in this session, unless -// `allowOverwrite` is set -func (self *ResourceHandler) SetExternalResource(rsrc *resource, allowOverwrite bool) error { - - utfname, err := idna.ToUnicode(rsrc.name) - if err != nil { - return fmt.Errorf("Invalid IDNA rsrc name '%s'", rsrc.name) - } - if !allowOverwrite { - self.resourceLock.Lock() - _, ok := self.resources[utfname] - self.resourceLock.Unlock() - if ok { - return fmt.Errorf("Resource exists") - } - } - - // get our blockheight at this time - currentblock, err := self.getBlock() - if err != nil { - return err - } - - if rsrc.startBlock > currentblock { - return fmt.Errorf("Startblock cannot be higher than current block (%d > %d)", rsrc.startBlock, currentblock) - } - - self.resources[utfname] = rsrc - return nil + return rsrc, nil } // Searches and retrieves the specific version of the resource update identified by `name` @@ -286,7 +250,7 @@ func (self *ResourceHandler) LookupVersion(name string, period uint32, version u if err != nil { return nil, err } - return self.lookup(rsrc, name, period, version, refresh) + return self.lookup(rsrc, period, version, refresh) } // Retrieves the latest version of the resource update identified by `name` @@ -302,7 +266,7 @@ func (self *ResourceHandler) LookupHistorical(name string, period uint32, refres if err != nil { return nil, err } - return self.lookup(rsrc, name, period, 0, refresh) + return self.lookup(rsrc, period, 0, refresh) } // Retrieves the latest version of the resource update identified by `name` @@ -327,11 +291,11 @@ func (self *ResourceHandler) LookupLatest(name string, refresh bool) (*resource, return nil, err } nextperiod := getNextPeriod(rsrc.startBlock, currentblock, rsrc.frequency) - return self.lookup(rsrc, name, nextperiod, 0, refresh) + return self.lookup(rsrc, nextperiod, 0, refresh) } // base code for public lookup methods -func (self *ResourceHandler) lookup(rsrc *resource, name string, period uint32, version uint32, refresh bool) (*resource, error) { +func (self *ResourceHandler) lookup(rsrc *resource, period uint32, version uint32, refresh bool) (*resource, error) { if period == 0 { return nil, fmt.Errorf("period must be >0") @@ -347,20 +311,20 @@ func (self *ResourceHandler) lookup(rsrc *resource, name string, period uint32, } for period > 0 { - key := self.resourceHash(rsrc.nameHash, period, version) + key := self.resourceHash(period, version, rsrc.nameHash) chunk, err := self.Get(key) if err == nil { if specificversion { - return self.updateResourceIndex(rsrc, chunk, &name) + return self.updateResourceIndex(rsrc, chunk) } // check if we have versions > 1. If a version fails, the previous version is used and returned. log.Trace("rsrc update version 1 found, checking for version updates", "period", period, "key", key) for { newversion := version + 1 - key := self.resourceHash(rsrc.nameHash, period, newversion) + key := self.resourceHash(period, newversion, rsrc.nameHash) newchunk, err := self.Get(key) if err != nil { - return self.updateResourceIndex(rsrc, chunk, &name) + return self.updateResourceIndex(rsrc, chunk) } log.Trace("version update found, checking next", "version", version, "period", period, "key", key) chunk = newchunk @@ -375,19 +339,18 @@ func (self *ResourceHandler) lookup(rsrc *resource, name string, period uint32, // load existing mutable resource into resource struct func (self *ResourceHandler) loadResource(name string, refresh bool) (*resource, error) { + // if the resource is not known to this session we must load it // if refresh is set, we force load - rsrc := self.getResource(name) if rsrc == nil || refresh { rsrc = &resource{} - // make sure our ens identifier is idna safe - validname, err := idna.ToASCII(name) - if err != nil { - return nil, err + // make sure our name is safe to use + if !isSafeName(name) { + return nil, fmt.Errorf("Invalid name '%s'", name) } - rsrc.name = validname - rsrc.nameHash = self.validator.nameHash(validname) + rsrc.name = &name + rsrc.nameHash = self.nameHash(name) // get the root info chunk and update the cached value chunk, err := self.Get(Key(rsrc.nameHash[:])) @@ -395,18 +358,12 @@ func (self *ResourceHandler) loadResource(name string, refresh bool) (*resource, return nil, err } - // sanity check for chunk data - // data is prefixed by 8 bytes of size - if len(chunk.SData) < indexSize { - return nil, fmt.Errorf("Invalid chunk length %d", len(chunk.SData)) - } else { - chunklength := binary.LittleEndian.Uint64(chunk.SData[:8]) - if chunklength != uint64(16) { - return nil, fmt.Errorf("Invalid chunk length header %d", chunklength) - } + // minimum sanity check for chunk data + if len(chunk.SData) != indexSize { + return nil, fmt.Errorf("Invalid chunk length %d, should be %d", len(chunk.SData), indexSize) } - rsrc.startBlock = binary.LittleEndian.Uint64(chunk.SData[8:16]) - rsrc.frequency = binary.LittleEndian.Uint64(chunk.SData[16:]) + rsrc.startBlock = binary.LittleEndian.Uint64(chunk.SData[:8]) + rsrc.frequency = binary.LittleEndian.Uint64(chunk.SData[8:]) } else { rsrc.name = self.resources[name].name rsrc.nameHash = self.resources[name].nameHash @@ -417,44 +374,69 @@ func (self *ResourceHandler) loadResource(name string, refresh bool) (*resource, } // update mutable resource index map with specified content -func (self *ResourceHandler) updateResourceIndex(rsrc *resource, chunk *Chunk, indexname *string) (*resource, error) { +func (self *ResourceHandler) updateResourceIndex(rsrc *resource, chunk *Chunk) (*resource, error) { - // rsrc update data chunks are total hacks - // and have no size prefix :D - err := self.verifyContent(chunk.SData) - if err != nil { - return nil, err + // retrieve metadata from chunk data and check that it matches this mutable resource + signature, period, version, name, data, err := self.parseUpdate(chunk.SData) + if *rsrc.name != name { + return nil, fmt.Errorf("Update belongs to '%s', but have '%s'", name, *rsrc.name) + } + // only check signature if validator is present + if self.validator != nil { + digest := self.keyDataHash(chunk.Key, data) + _, err = getAddressFromDataSig(digest, *signature) + if err != nil { + return nil, fmt.Errorf("Invalid signature: %v", err) + } } // update our rsrcs entry map - period, version, _, data, err := parseUpdate(chunk.SData[signatureLength:]) rsrc.lastPeriod = period rsrc.version = version rsrc.updated = time.Now() rsrc.data = make([]byte, len(data)) copy(rsrc.data, data) - log.Debug("Resource synced", "name", rsrc.name, "key", chunk.Key, "period", rsrc.lastPeriod, "version", rsrc.version) - self.setResource(*indexname, rsrc) + log.Debug("Resource synced", "name", *rsrc.name, "key", chunk.Key, "period", rsrc.lastPeriod, "version", rsrc.version) + self.setResource(*rsrc.name, rsrc) return rsrc, nil } -func parseUpdate(blob []byte) (period uint32, version uint32, ensname []byte, data []byte, err error) { - headerlength := binary.LittleEndian.Uint16(blob[:2]) - if int(headerlength+2) > len(blob) { - return 0, 0, nil, nil, fmt.Errorf("Reported header length %d longer than actual data length %d", headerlength, len(blob)) +// retrieve update metadata from chunk data +// mirrors newUpdateChunk() +func (self *ResourceHandler) parseUpdate(chunkdata []byte) (*Signature, uint32, uint32, string, []byte, error) { + var err error + cursor := 0 + var signature *Signature + // omit signatures if we have no validator + var sigoffset int + if self.validator != nil { + signature = &Signature{} + copy(signature[:], chunkdata[:signatureLength]) + sigoffset = signatureLength + cursor = sigoffset } - cursor := 2 - period = binary.LittleEndian.Uint32(blob[cursor : cursor+4]) + + headerlength := binary.LittleEndian.Uint16(chunkdata[cursor : cursor+2]) + if int(headerlength+2) > len(chunkdata) { + err = fmt.Errorf("Reported header length %d longer than actual data length %d", headerlength, len(chunkdata)) + return nil, 0, 0, "", nil, err + } + + var period uint32 + var version uint32 + var name string + var data []byte + cursor += 2 + period = binary.LittleEndian.Uint32(chunkdata[cursor : cursor+4]) cursor += 4 - version = binary.LittleEndian.Uint32(blob[cursor : cursor+4]) + version = binary.LittleEndian.Uint32(chunkdata[cursor : cursor+4]) cursor += 4 - namelength := int(headerlength) - cursor + 2 - ensname = make([]byte, namelength) - copy(ensname, blob[cursor:]) + namelength := int(headerlength) - cursor + sigoffset + 2 + name = string(chunkdata[cursor : cursor+namelength]) cursor += namelength - data = make([]byte, len(blob)-cursor) - copy(data, blob[cursor:]) - return + data = make([]byte, len(chunkdata)-cursor) + copy(data, chunkdata[cursor:]) + return signature, period, version, name, data, err } // Adds an actual data update @@ -465,26 +447,24 @@ func parseUpdate(blob []byte) (period uint32, version uint32, ensname []byte, da // A resource update cannot span chunks, and thus has max length 4096 func (self *ResourceHandler) Update(name string, data []byte) (Key, error) { - ok, err := self.validator.isOwner(name) - if err != nil { - return nil, err - } else if !ok { - return nil, fmt.Errorf("Not owner of '%s'", name) - } - - // can be only one chunk long minus 65 byte signature - if int64(len(data)) > self.maxChunkData { - return nil, fmt.Errorf("Data overflow: %d / %d bytes", len(data), 4096-signatureLength) + var sigoffset int + if self.validator != nil { + sigoffset = signatureLength } // get the cached information - self.resourceLock.Lock() - defer self.resourceLock.Unlock() - resource, ok := self.resources[name] - if !ok { - return nil, fmt.Errorf("No such resource") - } else if resource.updated.IsZero() { - return nil, fmt.Errorf("Invalid resource") + rsrc := self.getResource(name) + if rsrc == nil { + return nil, fmt.Errorf("Resource object not in index") + } + if !rsrc.isSynced() { + return nil, fmt.Errorf("Resource object not in sync") + } + + // an update can be only one chunk long + datalimit := self.chunkSize() - int64(sigoffset-len(name)-8) + if int64(len(data)) > datalimit { + return nil, fmt.Errorf("Data overflow: %d / %d bytes", len(data), datalimit) } // get our blockheight at this time and the next block of the update period @@ -492,51 +472,61 @@ func (self *ResourceHandler) Update(name string, data []byte) (Key, error) { if err != nil { return nil, err } - nextperiod := getNextPeriod(resource.startBlock, currentblock, resource.frequency) + nextperiod := getNextPeriod(rsrc.startBlock, currentblock, rsrc.frequency) // if we already have an update for this block then increment version + // (resource object MUST be in sync for version to be correct) var version uint32 if self.hasUpdate(name, nextperiod) { - version = resource.version + version = rsrc.version } version++ - // prepend version and period to allow reverse lookups - // data header length does NOT include the header length prefix bytes themselves - headerlength := uint16(len(resource.nameHash) + 4 + 4) - fulldata := make([]byte, int(headerlength)+2+len(data)) + // calculate the chunk key + key := self.resourceHash(nextperiod, version, rsrc.nameHash) - cursor := 0 - binary.LittleEndian.PutUint16(fulldata, headerlength) - cursor += 2 + var signature *Signature + if self.validator != nil { + // sign the data hash with the key + digest := self.keyDataHash(key, data) + sig, err := self.validator.sign(digest) + if err != nil { + return nil, err + } + signature = &sig - binary.LittleEndian.PutUint32(fulldata[cursor:], nextperiod) - cursor += 4 + // get the address of the signer (which also checks that it's a valid signature) + addr, err := getAddressFromDataSig(digest, *signature) + if err != nil { + return nil, fmt.Errorf("Invalid data/signature: %v", err) + } - binary.LittleEndian.PutUint32(fulldata[cursor:], version) - cursor += 4 - - copy(fulldata[cursor:], resource.nameHash[:]) - cursor += len(resource.nameHash) - - copy(fulldata[cursor:], data) - - // create the update chunk and send it - key := self.resourceHash(resource.nameHash, nextperiod, version) - chunk := NewChunk(key, nil) - chunk.SData, err = self.signContent(fulldata) - if err != nil { - return nil, err + // check if the signer has access to update + ok, err := self.validator.checkAccess(name, addr) + if err != nil { + return nil, err + } else if !ok { + return nil, fmt.Errorf("Address %x does not have access to update %s", addr, name) + } } - chunk.Size = int64(len(fulldata)) + + chunk := newUpdateChunk(key, signature, nextperiod, version, name, data) + + // send the chunk self.Put(chunk) - log.Trace("resource update", "name", resource.name, "key", key, "currentblock", currentblock, "lastperiod", nextperiod, "version", version, "data", chunk.SData) + timeout := time.NewTimer(self.storeTimeout) + select { + case <-chunk.dbStored: + case <-timeout.C: + + } + log.Trace("resource update", "name", name, "key", key, "currentblock", currentblock, "lastperiod", nextperiod, "version", version, "data", chunk.SData) // update our resources map entry and return the new key - resource.lastPeriod = nextperiod - resource.version = version - resource.data = make([]byte, len(data)) - copy(resource.data, data) + rsrc.lastPeriod = nextperiod + rsrc.version = version + rsrc.data = make([]byte, len(data)) + copy(rsrc.data, data) return key, nil } @@ -559,10 +549,12 @@ func (self *ResourceHandler) getBlock() (uint64, error) { return strconv.ParseUint(currentblock, 10, 64) } +// Calculate the period index (aka major version number) from a given block number func (self *ResourceHandler) BlockToPeriod(name string, blocknumber uint64) uint32 { return getNextPeriod(self.resources[name].startBlock, blocknumber, self.resources[name].frequency) } +// Calculate the block number from a given period index (aka major version number) func (self *ResourceHandler) PeriodToBlock(name string, period uint32) uint64 { return self.resources[name].startBlock + (uint64(period) * self.resources[name].frequency) } @@ -580,69 +572,82 @@ func (self *ResourceHandler) setResource(name string, rsrc *resource) { self.resources[name] = rsrc } -func (self *ResourceHandler) resourceHash(namehash common.Hash, period uint32, version uint32) Key { - // format is: hash(namehash|period|version) +// used for chunk keys +func (self *ResourceHandler) resourceHash(period uint32, version uint32, namehash common.Hash) Key { + // format is: hash(period|version|namehash) self.hashLock.Lock() defer self.hashLock.Unlock() self.hasher.Reset() - self.hasher.Write(namehash[:]) b := make([]byte, 4) binary.LittleEndian.PutUint32(b, period) self.hasher.Write(b) binary.LittleEndian.PutUint32(b, version) self.hasher.Write(b) + self.hasher.Write(namehash[:]) return self.hasher.Sum(nil) } -func (self *ResourceHandler) signContent(data []byte) ([]byte, error) { - self.hashLock.Lock() - self.hasher.Reset() - self.hasher.Write(data) - datahash := self.hasher.Sum(nil) - self.hashLock.Unlock() - - signature, err := crypto.Sign(datahash, self.privKey) - if err != nil { - return nil, err +func (self *ResourceHandler) hasUpdate(name string, period uint32) bool { + if self.resources[name].lastPeriod == period { + return true } - datawithsign := make([]byte, len(data)+signatureLength) - copy(datawithsign[:signatureLength], signature) - copy(datawithsign[signatureLength:], data) - return datawithsign, nil + return false } -func (self *ResourceHandler) getContentAccount(chunkdata []byte) (common.Address, error) { - if len(chunkdata) <= signatureLength { - return common.Address{}, fmt.Errorf("zero-length data") - } - self.hashLock.Lock() - self.hasher.Reset() - self.hasher.Write(chunkdata[signatureLength:]) - datahash := self.hasher.Sum(nil) - self.hashLock.Unlock() - pub, err := crypto.SigToPub(datahash, chunkdata[:signatureLength]) +func getAddressFromDataSig(datahash common.Hash, signature Signature) (common.Address, error) { + pub, err := crypto.SigToPub(datahash.Bytes(), signature[:]) if err != nil { return common.Address{}, err } return crypto.PubkeyToAddress(*pub), nil } -func (self *ResourceHandler) verifyContent(chunkdata []byte) error { - address, err := self.getContentAccount(chunkdata) - if err != nil { - return err +// create an update chunk +func newUpdateChunk(key Key, signature *Signature, period uint32, version uint32, name string, data []byte) *Chunk { + + // no signatures if no validator + var sigoffset int + if signature != nil { + sigoffset = signatureLength } - log.Warn("ens owner lookup not implemented, verify will return true in all cases", "address", address) - return nil -} - -func (self *ResourceHandler) hasUpdate(name string, period uint32) bool { - return self.resources[name].lastPeriod == period + + // prepend version and period to allow reverse lookups + headerlength := uint16(len(name) + 4 + 4) + + chunk := NewChunk(key, nil) + chunk.SData = make([]byte, sigoffset+int(headerlength)+2+len(data)) + + cursor := 0 + if signature != nil { + copy(chunk.SData, (*signature)[:]) + cursor += signatureLength + } + + // data header length does NOT include the header length prefix bytes themselves + binary.LittleEndian.PutUint16(chunk.SData[cursor:], headerlength) + cursor += 2 + + binary.LittleEndian.PutUint32(chunk.SData[cursor:], period) + cursor += 4 + + binary.LittleEndian.PutUint32(chunk.SData[cursor:], version) + cursor += 4 + + namebytes := []byte(name) + copy(chunk.SData[cursor:], namebytes) + cursor += len(namebytes) + + copy(chunk.SData[cursor:], data) + + chunk.Size = int64(len(chunk.SData)) + return chunk } +// \TODO chunkSize is a workaround until the ChunkStore interface exports a method to get the chunk size directly type resourceChunkStore struct { localStore ChunkStore netStore ChunkStore + chunkSize int64 } func newResourceChunkStore(path string, hasher SwarmHasher, localStore *LocalStore, cloudStore CloudStore) *resourceChunkStore { @@ -687,3 +692,36 @@ func getNextPeriod(start uint64, current uint64, frequency uint64) uint32 { period := blockdiff / frequency return uint32(period + 1) } + +func ToSafeName(name string) (string, error) { + validname, err := idna.ToASCII(name) + if err != nil { + return "", err + } + return validname, nil +} + +// check that name identifiers contain valid bytes +func isSafeName(name string) bool { + if name == "" { + return false + } + validname, err := idna.ToASCII(name) + if err != nil { + return false + } + if validname != name { + return false + } + return true +} + +// convenience for creating signature hashes of update data +func (self *ResourceHandler) keyDataHash(key Key, data []byte) common.Hash { + self.hashLock.Lock() + defer self.hashLock.Unlock() + self.hasher.Reset() + self.hasher.Write(key[:]) + self.hasher.Write(data) + return common.BytesToHash(self.hasher.Sum(nil)) +} diff --git a/swarm/storage/resource_ens.go b/swarm/storage/resource_ens.go index a82311b08f..0a4500309d 100644 --- a/swarm/storage/resource_ens.go +++ b/swarm/storage/resource_ens.go @@ -1,54 +1,52 @@ package storage import ( + "fmt" + "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/contracts/ens" ) -// ENS validation of mutable resource owners -type ENSValidator struct { - owner common.Address - api *ens.ENS +type baseValidator struct { + signFunc SignFunc } -func NewENSValidator(owneraddress common.Address, contractaddress common.Address, backend bind.ContractBackend, transactOpts *bind.TransactOpts) (*ENSValidator, error) { +func (b *baseValidator) sign(datahash common.Hash) (signature Signature, err error) { + if b.signFunc == nil { + return signature, fmt.Errorf("No signature function") + } + return b.signFunc(datahash) +} + +// ENS validation of mutable resource owners +type ENSValidator struct { + *baseValidator + api *ens.ENS +} + +func NewENSValidator(contractaddress common.Address, backend bind.ContractBackend, transactOpts *bind.TransactOpts, signFunc SignFunc) (*ENSValidator, error) { var err error - validator := &ENSValidator{} + validator := &ENSValidator{ + baseValidator: &baseValidator{ + signFunc: signFunc, + }, + } validator.api, err = ens.NewENS(transactOpts, contractaddress, backend) if err != nil { return nil, err } - validator.owner = owneraddress return validator, nil } -func (self *ENSValidator) isOwner(name string) (bool, error) { +func (self *ENSValidator) checkAccess(name string, address common.Address) (bool, error) { owneraddr, err := self.api.Owner(self.nameHash(name)) if err != nil { return false, err } - return owneraddr == self.owner, nil + return owneraddr == address, nil } func (self *ENSValidator) nameHash(name string) common.Hash { return ens.EnsNode(name) } - -// Default fallthrough validation of mutable resource ownership -type GenericValidator struct { - hashFunc func(string) common.Hash -} - -func NewGenericValidator(hashFunc func(string) common.Hash) *GenericValidator { - return &GenericValidator{ - hashFunc: hashFunc, - } -} -func (self *GenericValidator) isOwner(name string) (bool, error) { - return true, nil -} - -func (self *GenericValidator) nameHash(name string) common.Hash { - return self.hashFunc(name) -} diff --git a/swarm/storage/resource_test.go b/swarm/storage/resource_test.go index 951899ebfa..d130709428 100644 --- a/swarm/storage/resource_test.go +++ b/swarm/storage/resource_test.go @@ -15,8 +15,6 @@ import ( "testing" "time" - "golang.org/x/net/idna" - "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/common" @@ -29,16 +27,22 @@ import ( ) var ( - hasher = MakeHashFunc("SHA3")() + testHasher = MakeHashFunc(SHA3Hash)() zeroAddr = common.Address{} startBlock = uint64(4200) resourceFrequency = uint64(42) cleanF func() domainName = "føø.bar" + safeName string ) func init() { + var err error log.Root().SetHandler(log.CallerFileHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))) + safeName, err = ToSafeName(domainName) + if err != nil { + panic(err) + } } // simulated backend does not have the blocknumber call @@ -65,29 +69,25 @@ func (r *FakeRPC) BlockNumber() (string, error) { } // check that signature address matches update signer address -func TestResourceSignature(t *testing.T) { +func TestResourceReverse(t *testing.T) { - // privkey for signing updates - privkey, err := crypto.GenerateKey() + period := uint32(4) + version := uint32(2) + + // signer containing private key + signer, err := newTestSigner() if err != nil { - return + t.Fatal(err) } // set up rpc and create resourcehandler - rh, _, err, teardownTest := setupTest(privkey, nil, nil) - if err != nil { - teardownTest(t, err) - } - - // create a new resource - validname, err := idna.ToASCII(domainName) + rh, _, _, teardownTest, err := setupTest(nil, newTestValidator(signer.signContent)) if err != nil { teardownTest(t, err) } // generate a hash for block 4200 version 1 - key := rh.resourceHash(ens.EnsNode(validname), 1, 1) - chunk := NewChunk(key, nil) + key := rh.resourceHash(period, version, rh.nameHash(safeName)) // generate some bogus data for the chunk and sign it data := make([]byte, 8) @@ -95,131 +95,76 @@ func TestResourceSignature(t *testing.T) { if err != nil { teardownTest(t, err) } - hasher.Reset() - hasher.Write(data) - datahash := hasher.Sum(nil) - sig, err := crypto.Sign(datahash, privkey) + testHasher.Reset() + testHasher.Write(data) + digest := rh.keyDataHash(key, data) + sig, err := rh.validator.sign(digest) if err != nil { teardownTest(t, err) } - // put sig and data in the chunk - chunk.SData = make([]byte, 8+signatureLength) - copy(chunk.SData[:signatureLength], sig) - copy(chunk.SData[signatureLength:], data) + chunk := newUpdateChunk(key, &sig, period, version, safeName, data) // check that we can recover the owner account from the update chunk's signature - // TODO: change this to verifyContent on ENS integration - recoveredaddress, err := rh.getContentAccount(chunk.SData) + checksig, checkperiod, checkversion, checkname, checkdata, err := rh.parseUpdate(chunk.SData) + checkdigest := rh.keyDataHash(chunk.Key, checkdata) + recoveredaddress, err := getAddressFromDataSig(checkdigest, *checksig) if err != nil { - teardownTest(t, err) + teardownTest(t, fmt.Errorf("Retrieve address from signature fail: %v", err)) } - originaladdress := crypto.PubkeyToAddress(privkey.PublicKey) + originaladdress := crypto.PubkeyToAddress(signer.privKey.PublicKey) + // check that the metadata retrieved from the chunk matches what we gave it if recoveredaddress != originaladdress { teardownTest(t, fmt.Errorf("addresses dont match: %x != %x", originaladdress, recoveredaddress)) } + + if !bytes.Equal(key[:], chunk.Key[:]) { + teardownTest(t, fmt.Errorf("Expected chunk key '%x', was '%x'", key, chunk.Key)) + } + if period != checkperiod { + teardownTest(t, fmt.Errorf("Expected period '%d', was '%d'", period, checkperiod)) + } + if version != checkversion { + teardownTest(t, fmt.Errorf("Expected version '%d', was '%d'", version, checkversion)) + } + if safeName != checkname { + teardownTest(t, fmt.Errorf("Expected name '%s', was '%s'", safeName, checkname)) + } + if !bytes.Equal(data, checkdata) { + teardownTest(t, fmt.Errorf("Expectedn data '%x', was '%x'", data, checkdata)) + } teardownTest(t, nil) } -// determine resource update metadata from chunk data -func TestResourceReverseLookup(t *testing.T) { - - // privkey for signing updates - privkey, err := crypto.GenerateKey() - if err != nil { - return - } - - // make fake backend, set up rpc and create resourcehandler - backend := &fakeBackend{ - blocknumber: startBlock, - } - rh, _, err, teardownTest := setupTest(privkey, backend, nil) - if err != nil { - teardownTest(t, err) - } - - // create a new resource - rsrc, err := rh.NewResource(domainName, resourceFrequency) - if err != nil { - teardownTest(t, err) - } - - // update data - fwdBlocks(int(resourceFrequency+1), backend) - data := []byte("foo") - resourcekey, err := rh.Update(domainName, data) - if err != nil { - teardownTest(t, err) - } - chunk, err := rh.ChunkStore.(*resourceChunkStore).localStore.(*LocalStore).memStore.Get(Key(resourcekey)) - if err != nil { - teardownTest(t, err) - } - - // check if data after header length offset is as expected - headerlength := binary.LittleEndian.Uint16(chunk.SData[signatureLength : signatureLength+2]) - if !bytes.Equal(chunk.SData[signatureLength+headerlength+2:], data) { - teardownTest(t, fmt.Errorf("Expected chunk data with header length %d (pos %d) to match %x, but was %x", headerlength, signatureLength+headerlength+2, data, chunk.SData[signatureLength+headerlength+2:])) - } - - // get name, period, version from chunk and check - revperiod, revversion, revname, revdata, err := parseUpdate(chunk.SData[signatureLength:]) - - if !bytes.Equal(revname, rsrc.nameHash.Bytes()) { - teardownTest(t, fmt.Errorf("Expected retrieved name from chunk data to be '%x', was '%x'", rsrc.nameHash.Bytes(), revname)) - } - if !bytes.Equal(revdata, data) { - teardownTest(t, fmt.Errorf("Expected retrieved data from chunk data to be '%x', was '%x'", data, revdata)) - } - - if revperiod != 2 { - teardownTest(t, fmt.Errorf("Expected retrieved period from chunk data to be 1, was %d", revperiod)) - } - if revversion != 1 { - teardownTest(t, fmt.Errorf("Expected retrieved version from chunk data to be 1, was %d", revversion)) - } -} - // make updates and retrieve them based on periods and versions func TestResourceHandler(t *testing.T) { - // privkey for signing updates - privkey, err := crypto.GenerateKey() - if err != nil { - return - } - // make fake backend, set up rpc and create resourcehandler backend := &fakeBackend{ blocknumber: startBlock, } - rh, datadir, err, teardownTest := setupTest(privkey, backend, nil) + rh, datadir, _, teardownTest, err := setupTest(backend, nil) if err != nil { teardownTest(t, err) } // create a new resource - resourcevalidname, err := idna.ToASCII(domainName) - if err != nil { - teardownTest(t, err) - } - _, err = rh.NewResource(domainName, resourceFrequency) + _, err = rh.NewResource(safeName, resourceFrequency) if err != nil { teardownTest(t, err) } // check that the new resource is stored correctly - namehash := rh.validator.nameHash(resourcevalidname) + namehash := rh.nameHash(safeName) chunk, err := rh.ChunkStore.(*resourceChunkStore).localStore.(*LocalStore).memStore.Get(Key(namehash[:])) if err != nil { teardownTest(t, err) } else if len(chunk.SData) < 16 { teardownTest(t, fmt.Errorf("chunk data must be minimum 16 bytes, is %d", len(chunk.SData))) } - startblocknumber := binary.LittleEndian.Uint64(chunk.SData[8:16]) - chunkfrequency := binary.LittleEndian.Uint64(chunk.SData[16:]) + startblocknumber := binary.LittleEndian.Uint64(chunk.SData[:8]) + chunkfrequency := binary.LittleEndian.Uint64(chunk.SData[8:]) if startblocknumber != backend.blocknumber { teardownTest(t, fmt.Errorf("stored block number %d does not match provided block number %d", startblocknumber, backend.blocknumber)) } @@ -230,28 +175,32 @@ func TestResourceHandler(t *testing.T) { // update halfway to first period resourcekey := make(map[string]Key) fwdBlocks(int(resourceFrequency/2), backend) - resourcekey["blinky"], err = rh.Update(domainName, []byte("blinky")) + data := []byte("blinky") + resourcekey["blinky"], err = rh.Update(safeName, data) if err != nil { teardownTest(t, err) } // update on first period fwdBlocks(int(resourceFrequency/2), backend) - resourcekey["pinky"], err = rh.Update(domainName, []byte("pinky")) + data = []byte("pinky") + resourcekey["pinky"], err = rh.Update(safeName, data) if err != nil { teardownTest(t, err) } // update on second period fwdBlocks(int(resourceFrequency), backend) - resourcekey["inky"], err = rh.Update(domainName, []byte("inky")) + data = []byte("inky") + resourcekey["inky"], err = rh.Update(safeName, data) if err != nil { teardownTest(t, err) } // update just after second period fwdBlocks(1, backend) - resourcekey["clyde"], err = rh.Update(domainName, []byte("clyde")) + data = []byte("clyde") + resourcekey["clyde"], err = rh.Update(safeName, data) if err != nil { teardownTest(t, err) } @@ -262,64 +211,45 @@ func TestResourceHandler(t *testing.T) { // it will match on second iteration startblocknumber + (resourceFrequency * 3) fwdBlocks(int(resourceFrequency*2)-1, backend) - rh2, err := NewResourceHandler(privkey, datadir, &testCloudStore{}, rh.rpcClient, nil) - _, err = rh2.LookupLatest(domainName, true) + rh2, err := NewResourceHandler(datadir, &testCloudStore{}, rh.rpcClient, nil) + _, err = rh2.LookupLatest(safeName, true) if err != nil { teardownTest(t, err) } // last update should be "clyde", version two, blockheight startblocknumber + (resourcefrequency * 3) - if !bytes.Equal(rh2.resources[domainName].data, []byte("clyde")) { - teardownTest(t, fmt.Errorf("resource data was %v, expected %v", rh2.resources[domainName].data, []byte("clyde"))) + if !bytes.Equal(rh2.resources[safeName].data, []byte("clyde")) { + teardownTest(t, fmt.Errorf("resource data was %v, expected %v", rh2.resources[safeName].data, []byte("clyde"))) } - if rh2.resources[domainName].version != 2 { - teardownTest(t, fmt.Errorf("resource version was %d, expected 2", rh2.resources[domainName].version)) + if rh2.resources[safeName].version != 2 { + teardownTest(t, fmt.Errorf("resource version was %d, expected 2", rh2.resources[safeName].version)) } - if rh2.resources[domainName].lastPeriod != 3 { - teardownTest(t, fmt.Errorf("resource period was %d, expected 3", rh2.resources[domainName].lastPeriod)) - } - - rsrc, err := NewResource(domainName, startblocknumber, resourceFrequency, rh2.validator.nameHash) - if err != nil { - teardownTest(t, err) - } - err = rh2.SetExternalResource(rsrc, true) - if err != nil { - teardownTest(t, err) - } - - // latest block, latest version - resource, err := rh2.LookupLatest(domainName, false) // if key is specified, refresh is implicit - if err != nil { - teardownTest(t, err) - } - - // check data - if !bytes.Equal(resource.data, []byte("clyde")) { - teardownTest(t, fmt.Errorf("resource data (latest) was %v, expected %v", rh2.resources[domainName].data, []byte("clyde"))) + if rh2.resources[safeName].lastPeriod != 3 { + teardownTest(t, fmt.Errorf("resource period was %d, expected 3", rh2.resources[safeName].lastPeriod)) } + log.Debug("Latest lookup", "period", rh2.resources[safeName].lastPeriod, "version", rh2.resources[safeName].version, "data", rh2.resources[safeName].data) // specific block, latest version - resource, err = rh2.LookupHistorical(domainName, 3, true) + rsrc, err := rh2.LookupHistorical(safeName, 3, true) if err != nil { teardownTest(t, err) } - // check data - if !bytes.Equal(resource.data, []byte("clyde")) { + if !bytes.Equal(rsrc.data, []byte("clyde")) { teardownTest(t, fmt.Errorf("resource data (historical) was %v, expected %v", rh2.resources[domainName].data, []byte("clyde"))) } + log.Debug("Historical lookup", "period", rh2.resources[safeName].lastPeriod, "version", rh2.resources[safeName].version, "data", rh2.resources[safeName].data) // specific block, specific version - resource, err = rh2.LookupVersion(domainName, 3, 1, true) + rsrc, err = rh2.LookupVersion(safeName, 3, 1, true) if err != nil { teardownTest(t, err) } - // check data - if !bytes.Equal(resource.data, []byte("inky")) { + if !bytes.Equal(rsrc.data, []byte("inky")) { teardownTest(t, fmt.Errorf("resource data (historical) was %v, expected %v", rh2.resources[domainName].data, []byte("inky"))) } + log.Debug("Specific version lookup", "period", rh2.resources[safeName].lastPeriod, "version", rh2.resources[safeName].version, "data", rh2.resources[safeName].data) teardownTest(t, nil) } @@ -327,62 +257,54 @@ func TestResourceHandler(t *testing.T) { // create ENS enabled resource update, with and without valid owner func TestResourceENSOwner(t *testing.T) { - // privkey for signing updates - privkey, err := crypto.GenerateKey() + // signer containing private key + signer, err := newTestSigner() if err != nil { - return - } - - // privkey for checking wrong owner - privkeytwo, err := crypto.GenerateKey() - if err != nil { - return + t.Fatal(err) } // ens address and transact options - addr := crypto.PubkeyToAddress(privkey.PublicKey) - transactOpts := bind.NewKeyedTransactor(privkey) + addr := crypto.PubkeyToAddress(signer.privKey.PublicKey) + transactOpts := bind.NewKeyedTransactor(signer.privKey) // set up ENS sim - domainparts := strings.Split(domainName, ".") + domainparts := strings.Split(safeName, ".") contractAddr, contractbackend, err := setupENS(addr, transactOpts, domainparts[0], domainparts[1]) if err != nil { t.Fatal(err) } - validator, err := NewENSValidator(addr, contractAddr, contractbackend, transactOpts) + validator, err := NewENSValidator(contractAddr, contractbackend, transactOpts, signer.signContent) if err != nil { t.Fatal(err) } // set up rpc and create resourcehandler with ENS sim backend - rh, _, err, teardownTest := setupTest(privkey, contractbackend, validator) + rh, _, _, teardownTest, err := setupTest(contractbackend, validator) if err != nil { teardownTest(t, err) } // create new resource when we are owner = ok - _, err = rh.NewResource(domainName, 42) + _, err = rh.NewResource(safeName, resourceFrequency) if err != nil { teardownTest(t, fmt.Errorf("Create resource fail: %v", err)) } + data := []byte("foo") // update resource when we are owner = ok - _, err = rh.Update(domainName, []byte("foo")) + _, err = rh.Update(safeName, data) if err != nil { teardownTest(t, fmt.Errorf("Update resource fail: %v", err)) } - // create new resource when we are NOT owner = !ok - addrtwo := crypto.PubkeyToAddress(privkeytwo.PublicKey) - validator.owner = addrtwo - - _, err = rh.NewResource(domainName, 42) - if err == nil { - teardownTest(t, fmt.Errorf("Expected resource create fail due to owner mismatch")) - } // update resource when we are owner = ok - _, err = rh.Update(domainName, []byte("foo")) + signertwo, err := newTestSigner() + if err != nil { + teardownTest(t, err) + } + rh.validator.(*ENSValidator).signFunc = signertwo.signContent + _, err = rh.Update(safeName, data) if err == nil { teardownTest(t, fmt.Errorf("Expected resource update fail due to owner mismatch")) } @@ -398,7 +320,7 @@ func fwdBlocks(count int, backend *fakeBackend) { } // create rpc and resourcehandler -func setupTest(privkey *ecdsa.PrivateKey, contractbackend bind.ContractBackend, validator ResourceValidator) (rh *ResourceHandler, datadir string, err error, teardown func(*testing.T, error)) { +func setupTest(contractbackend bind.ContractBackend, validator ResourceValidator) (rh *ResourceHandler, datadir string, signer *testSigner, teardown func(*testing.T, error), err error) { var fsClean func() var rpcClean func() @@ -448,8 +370,7 @@ func setupTest(privkey *ecdsa.PrivateKey, contractbackend bind.ContractBackend, return } - // choose if with ens or not - rh, err = NewResourceHandler(privkey, datadir, &testCloudStore{}, rpcclient, validator) + rh, err = NewResourceHandler(datadir, &testCloudStore{}, rpcclient, validator) teardown = func(t *testing.T, err error) { cleanF() if err != nil { @@ -467,12 +388,12 @@ func setupENS(addr common.Address, transactOpts *bind.TransactOpts, sub string, var tophash [32]byte var subhash [32]byte - hasher.Reset() - hasher.Write([]byte(top)) - copy(tophash[:], hasher.Sum(nil)) - hasher.Reset() - hasher.Write([]byte(sub)) - copy(subhash[:], hasher.Sum(nil)) + testHasher.Reset() + testHasher.Write([]byte(top)) + copy(tophash[:], testHasher.Sum(nil)) + testHasher.Reset() + testHasher.Write([]byte(sub)) + copy(subhash[:], testHasher.Sum(nil)) // initialize contract backend and deploy contractBackend := &fakeBackend{ @@ -503,6 +424,33 @@ func setupENS(addr common.Address, transactOpts *bind.TransactOpts, sub string, return contractAddress, contractBackend, nil } +// implementation of an external signer to pass to validator +type testSigner struct { + privKey *ecdsa.PrivateKey + hasher SwarmHash +} + +func newTestSigner() (*testSigner, error) { + privKey, err := crypto.GenerateKey() + if err != nil { + return nil, err + } + return &testSigner{ + privKey: privKey, + hasher: testHasher, + }, nil +} + +// matches the SignFunc type +func (self *testSigner) signContent(data common.Hash) (signature Signature, err error) { + signaturebytes, err := crypto.Sign(data.Bytes(), self.privKey) + if err != nil { + return + } + copy(signature[:], signaturebytes) + return +} + type testCloudStore struct { } @@ -514,3 +462,31 @@ func (c *testCloudStore) Deliver(*Chunk) { func (c *testCloudStore) Retrieve(*Chunk) { } + +// Default fallthrough validation of mutable resource ownership +type testValidator struct { + *baseValidator + hashFunc func(string) common.Hash +} + +func newTestValidator(signFunc SignFunc) *testValidator { + return &testValidator{ + baseValidator: &baseValidator{ + signFunc: signFunc, + }, + hashFunc: func(name string) common.Hash { + testHasher.Reset() + testHasher.Write([]byte(name)) + return common.BytesToHash(testHasher.Sum(nil)) + }, + } + +} + +func (self *testValidator) checkAccess(name string, address common.Address) (bool, error) { + return true, nil +} + +func (self *testValidator) nameHash(name string) common.Hash { + return self.hashFunc(name) +}