lotus/chain/vm/syscalls.go

340 lines
10 KiB
Go
Raw Normal View History

package vm
import (
2020-04-10 15:14:43 +00:00
"bytes"
2020-02-26 22:54:34 +00:00
"context"
"fmt"
goruntime "runtime"
"sync"
2020-02-26 22:54:34 +00:00
"github.com/ipfs/go-cid"
2020-04-10 15:14:43 +00:00
cbor "github.com/ipfs/go-ipld-cbor"
2020-04-16 17:17:56 +00:00
"github.com/minio/blake2b-simd"
mh "github.com/multiformats/go-multihash"
"golang.org/x/xerrors"
2020-03-26 19:34:38 +00:00
2020-11-24 12:27:35 +00:00
"github.com/filecoin-project/go-address"
2020-09-07 03:49:10 +00:00
"github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/crypto"
2020-11-24 12:27:35 +00:00
"github.com/filecoin-project/go-state-types/network"
"github.com/filecoin-project/lotus/build"
2020-09-18 21:46:55 +00:00
"github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
2020-11-24 12:27:35 +00:00
"github.com/filecoin-project/lotus/chain/actors/policy"
2020-04-10 15:14:43 +00:00
"github.com/filecoin-project/lotus/chain/state"
"github.com/filecoin-project/lotus/chain/types"
2020-11-24 12:27:35 +00:00
"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
2020-04-10 15:14:43 +00:00
"github.com/filecoin-project/lotus/lib/sigs"
2020-10-08 01:09:33 +00:00
2021-03-10 15:16:44 +00:00
runtime5 "github.com/filecoin-project/specs-actors/v5/actors/runtime"
proof5 "github.com/filecoin-project/specs-actors/v5/actors/runtime/proof"
)
func init() {
mh.Codes[0xf104] = "filecoin"
}
// Actual type is defined in chain/types/vmcontext.go because the VMContext interface is there
2021-03-10 15:16:44 +00:00
type SyscallBuilder func(ctx context.Context, rt *Runtime) runtime5.Syscalls
2020-07-18 13:46:47 +00:00
func Syscalls(verifier ffiwrapper.Verifier) SyscallBuilder {
2021-03-10 15:16:44 +00:00
return func(ctx context.Context, rt *Runtime) runtime5.Syscalls {
2020-07-18 13:46:47 +00:00
return &syscallShim{
2020-11-17 05:53:26 +00:00
ctx: ctx,
epoch: rt.CurrEpoch(),
networkVersion: rt.NetworkVersion(),
2020-07-18 13:46:47 +00:00
actor: rt.Receiver(),
cstate: rt.state,
cst: rt.cst,
lbState: rt.vm.lbStateGet,
2020-07-18 13:46:47 +00:00
verifier: verifier,
}
}
}
type syscallShim struct {
2020-04-10 15:14:43 +00:00
ctx context.Context
2020-11-17 05:53:26 +00:00
epoch abi.ChainEpoch
networkVersion network.Version
lbState LookbackStateGetter
actor address.Address
cstate *state.StateTree
cst cbor.IpldStore
verifier ffiwrapper.Verifier
}
2020-06-15 16:30:49 +00:00
func (ss *syscallShim) ComputeUnsealedSectorCID(st abi.RegisteredSealProof, pieces []abi.PieceInfo) (cid.Cid, error) {
2020-02-23 00:47:47 +00:00
var sum abi.PaddedPieceSize
for _, p := range pieces {
2020-02-23 00:47:47 +00:00
sum += p.Size
}
2020-03-26 02:50:56 +00:00
commd, err := ffiwrapper.GenerateUnsealedCID(st, pieces)
if err != nil {
2020-02-23 00:47:47 +00:00
log.Errorf("generate data commitment failed: %s", err)
return cid.Undef, err
}
2020-02-27 00:42:39 +00:00
return commd, nil
}
func (ss *syscallShim) HashBlake2b(data []byte) [32]byte {
2020-04-16 17:17:56 +00:00
return blake2b.Sum256(data)
}
2020-04-10 15:14:43 +00:00
// Checks validity of the submitted consensus fault with the two block headers needed to prove the fault
// and an optional extra one to check common ancestry (as needed).
// Note that the blocks are ordered: the method requires a.Epoch() <= b.Epoch().
2021-03-10 15:16:44 +00:00
func (ss *syscallShim) VerifyConsensusFault(a, b, extra []byte) (*runtime5.ConsensusFault, error) {
2020-04-10 15:14:43 +00:00
// Note that block syntax is not validated. Any validly signed block will be accepted pursuant to the below conditions.
// Whether or not it could ever have been accepted in a chain is not checked/does not matter here.
// for that reason when checking block parent relationships, rather than instantiating a Tipset to do so
// (which runs a syntactic check), we do it directly on the CIDs.
// (0) cheap preliminary checks
// can blocks be decoded properly?
var blockA, blockB types.BlockHeader
2020-04-10 15:14:43 +00:00
if decodeErr := blockA.UnmarshalCBOR(bytes.NewReader(a)); decodeErr != nil {
return nil, xerrors.Errorf("cannot decode first block header: %w", decodeErr)
2020-04-10 15:14:43 +00:00
}
if decodeErr := blockB.UnmarshalCBOR(bytes.NewReader(b)); decodeErr != nil {
return nil, xerrors.Errorf("cannot decode second block header: %f", decodeErr)
2020-04-10 15:14:43 +00:00
}
// workaround chain halt
if build.IsNearUpgrade(blockA.Height, build.UpgradeOrangeHeight) {
return nil, xerrors.Errorf("consensus reporting disabled around Upgrade Orange")
}
if build.IsNearUpgrade(blockB.Height, build.UpgradeOrangeHeight) {
return nil, xerrors.Errorf("consensus reporting disabled around Upgrade Orange")
}
// are blocks the same?
if blockA.Cid().Equals(blockB.Cid()) {
return nil, fmt.Errorf("no consensus fault: submitted blocks are the same")
}
2020-04-10 15:14:43 +00:00
// (1) check conditions necessary to any consensus fault
// were blocks mined by same miner?
if blockA.Miner != blockB.Miner {
return nil, fmt.Errorf("no consensus fault: blocks not mined by same miner")
}
// block a must be earlier or equal to block b, epoch wise (ie at least as early in the chain).
if blockB.Height < blockA.Height {
return nil, fmt.Errorf("first block must not be of higher height than second")
}
// (2) check for the consensus faults themselves
2021-03-10 15:16:44 +00:00
var consensusFault *runtime5.ConsensusFault
2020-04-10 15:14:43 +00:00
// (a) double-fork mining fault
if blockA.Height == blockB.Height {
2021-03-10 15:16:44 +00:00
consensusFault = &runtime5.ConsensusFault{
2020-04-10 15:14:43 +00:00
Target: blockA.Miner,
Epoch: blockB.Height,
2021-03-10 15:16:44 +00:00
Type: runtime5.ConsensusFaultDoubleForkMining,
2020-04-10 15:14:43 +00:00
}
}
// (b) time-offset mining fault
// strictly speaking no need to compare heights based on double fork mining check above,
// but at same height this would be a different fault.
if types.CidArrsEqual(blockA.Parents, blockB.Parents) && blockA.Height != blockB.Height {
2021-03-10 15:16:44 +00:00
consensusFault = &runtime5.ConsensusFault{
2020-04-10 15:14:43 +00:00
Target: blockA.Miner,
Epoch: blockB.Height,
2021-03-10 15:16:44 +00:00
Type: runtime5.ConsensusFaultTimeOffsetMining,
2020-04-10 15:14:43 +00:00
}
}
// (c) parent-grinding fault
// Here extra is the "witness", a third block that shows the connection between A and B as
// A's sibling and B's parent.
2020-04-10 15:14:43 +00:00
// Specifically, since A is of lower height, it must be that B was mined omitting A from its tipset
2020-08-06 01:14:13 +00:00
//
// B
// |
// [A, C]
var blockC types.BlockHeader
if len(extra) > 0 {
if decodeErr := blockC.UnmarshalCBOR(bytes.NewReader(extra)); decodeErr != nil {
return nil, xerrors.Errorf("cannot decode extra: %w", decodeErr)
}
2020-04-16 19:52:49 +00:00
if types.CidArrsEqual(blockA.Parents, blockC.Parents) && blockA.Height == blockC.Height &&
2020-04-10 20:34:04 +00:00
types.CidArrsContains(blockB.Parents, blockC.Cid()) && !types.CidArrsContains(blockB.Parents, blockA.Cid()) {
2021-03-10 15:16:44 +00:00
consensusFault = &runtime5.ConsensusFault{
Target: blockA.Miner,
Epoch: blockB.Height,
2021-03-10 15:16:44 +00:00
Type: runtime5.ConsensusFaultParentGrinding,
}
2020-04-10 15:14:43 +00:00
}
}
// (3) return if no consensus fault by now
if consensusFault == nil {
return nil, xerrors.Errorf("no consensus fault detected")
}
// else
// (4) expensive final checks
2020-04-10 15:14:43 +00:00
// check blocks are properly signed by their respective miner
// note we do not need to check extra's: it is a parent to block b
// which itself is signed, so it was willingly included by the miner
if sigErr := ss.VerifyBlockSig(&blockA); sigErr != nil {
return nil, xerrors.Errorf("cannot verify first block sig: %w", sigErr)
2020-04-10 15:14:43 +00:00
}
if sigErr := ss.VerifyBlockSig(&blockB); sigErr != nil {
return nil, xerrors.Errorf("cannot verify second block sig: %w", sigErr)
2020-04-10 15:14:43 +00:00
}
return consensusFault, nil
}
func (ss *syscallShim) VerifyBlockSig(blk *types.BlockHeader) error {
waddr, err := ss.workerKeyAtLookback(blk.Height)
if err != nil {
return err
}
2020-04-10 15:14:43 +00:00
if err := sigs.CheckBlockSignature(ss.ctx, blk, waddr); err != nil {
return err
}
return nil
}
func (ss *syscallShim) workerKeyAtLookback(height abi.ChainEpoch) (address.Address, error) {
2020-11-17 05:53:26 +00:00
if ss.networkVersion >= network.Version7 && height < ss.epoch-policy.ChainFinality {
return address.Undef, xerrors.Errorf("cannot get worker key (currEpoch %d, height %d)", ss.epoch, height)
}
lbState, err := ss.lbState(ss.ctx, height)
2020-07-01 11:47:40 +00:00
if err != nil {
return address.Undef, err
}
// get appropriate miner actor
act, err := lbState.GetActor(ss.actor)
if err != nil {
return address.Undef, err
2020-07-01 11:47:40 +00:00
}
// use that to get the miner state
mas, err := miner.Load(adt.WrapStore(ss.ctx, ss.cst), act)
if err != nil {
return address.Undef, err
}
2020-04-10 15:14:43 +00:00
info, err := mas.Info()
if err != nil {
return address.Undef, err
2020-04-10 15:14:43 +00:00
}
return ResolveToKeyAddr(ss.cstate, ss.cst, info.Worker)
}
2021-03-10 15:16:44 +00:00
func (ss *syscallShim) VerifyPoSt(proof proof5.WindowPoStVerifyInfo) error {
2020-04-10 12:19:06 +00:00
ok, err := ss.verifier.VerifyWindowPoSt(context.TODO(), proof)
2020-02-26 22:54:34 +00:00
if err != nil {
return err
}
if !ok {
return fmt.Errorf("proof was invalid")
}
return nil
}
2021-03-10 15:16:44 +00:00
func (ss *syscallShim) VerifySeal(info proof5.SealVerifyInfo) error {
//_, span := trace.StartSpan(ctx, "ValidatePoRep")
//defer span.End()
miner, err := address.NewIDAddress(uint64(info.Miner))
if err != nil {
2020-02-27 00:42:39 +00:00
return xerrors.Errorf("weirdly failed to construct address: %w", err)
}
ticket := []byte(info.Randomness)
proof := info.Proof
seed := []byte(info.InteractiveRandomness)
log.Debugf("Verif r:%s; d:%s; m:%s; t:%x; s:%x; N:%d; p:%x", info.SealedCID, info.UnsealedCID, miner, ticket, seed, info.SectorID.Number, proof)
2020-02-23 20:32:14 +00:00
//func(ctx context.Context, maddr address.Address, ssize abi.SectorSize, commD, commR, ticket, proof, seed []byte, sectorID abi.SectorNumber)
2020-02-27 00:42:39 +00:00
ok, err := ss.verifier.VerifySeal(info)
if err != nil {
2020-02-26 22:54:34 +00:00
return xerrors.Errorf("failed to validate PoRep: %w", err)
}
if !ok {
return fmt.Errorf("invalid proof")
}
2020-02-26 22:54:34 +00:00
return nil
}
2021-03-10 15:16:44 +00:00
func (ss *syscallShim) VerifyAggregateSeals(aggregate proof5.AggregateSealVerifyProofAndInfos) error {
ok, err := ss.verifier.VerifyAggregateSeals(aggregate)
if err != nil {
return xerrors.Errorf("failed to verify aggregated PoRep: %w", err)
}
if !ok {
2021-06-01 17:23:12 +00:00
return fmt.Errorf("invalid aggregate proof")
2021-03-10 15:16:44 +00:00
}
return nil
}
2020-02-26 22:54:34 +00:00
func (ss *syscallShim) VerifySignature(sig crypto.Signature, addr address.Address, input []byte) error {
// TODO: in genesis setup, we are currently faking signatures
kaddr, err := ResolveToKeyAddr(ss.cstate, ss.cst, addr)
if err != nil {
return err
}
return sigs.Verify(&sig, kaddr, input)
}
var BatchSealVerifyParallelism = goruntime.NumCPU()
2021-03-10 15:16:44 +00:00
func (ss *syscallShim) BatchVerifySeals(inp map[address.Address][]proof5.SealVerifyInfo) (map[address.Address][]bool, error) {
out := make(map[address.Address][]bool)
sema := make(chan struct{}, BatchSealVerifyParallelism)
var wg sync.WaitGroup
for addr, seals := range inp {
results := make([]bool, len(seals))
out[addr] = results
for i, s := range seals {
wg.Add(1)
2021-03-10 15:16:44 +00:00
go func(ma address.Address, ix int, svi proof5.SealVerifyInfo, res []bool) {
defer wg.Done()
sema <- struct{}{}
if err := ss.VerifySeal(svi); err != nil {
2020-11-24 12:27:35 +00:00
log.Warnw("seal verify in batch failed", "miner", ma, "sectorNumber", svi.SectorID.Number, "err", err)
res[ix] = false
} else {
res[ix] = true
}
<-sema
}(addr, i, s, results)
}
}
wg.Wait()
return out, nil
}