forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-20 10:52:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

swarm, p2p/simulations, cmd/swarm: Use nodekey in binary record sign

Browse source
This commit is contained in:
lash 2019-03-21 09:17:26 +01:00
parent dfce98d01b
commit 70061520cb
10 changed files with 108 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
cmd/swarm/config.go
View file

@ -130,7 +130,7 @@ func initSwarmNode(config *bzzapi.Config, stack *node.Node, ctx *cli.Context) er
//set the resolved config path (geth --datadir)
config.Path = expandPath(stack.InstanceDir())
//finally, initialize the configuration
err := config.Init(prvkey)
err := config.Init(prvkey, stack.Server().PrivateKey)
if err != nil {
return err
}

6
p2p/simulations/adapters/exec.go
View file

@ -92,7 +92,7 @@ func (e *ExecAdapter) NewNode(config *NodeConfig) (Node, error) {
return nil, fmt.Errorf("error creating node directory: %s", err)
}
err := config.initDefaultEnode()
err := config.initDummyEnode()
if err != nil {
return nil, err
}
@ -411,11 +411,11 @@ func startExecNodeStack() (*node.Node, error) {
if err := json.Unmarshal([]byte(confEnv), &conf); err != nil {
return nil, fmt.Errorf("error decoding %s: %v", envNodeConfig, err)
}
// TODO verify that ListenAddr will contain the corrent tcp addr
// TODO verify that ListenAddr will contain the correct tcp addr
// if we should start using exec adapters with other host than local
nodeTcpConn, err := net.ResolveTCPAddr("tcp", conf.Stack.P2P.ListenAddr)
if err != nil {
conf.Node.initDefaultEnode()
conf.Node.initDummyEnode()
} else {
conf.Node.initEnode(nodeTcpConn.IP, nodeTcpConn.Port, nodeTcpConn.Port)
}

2
p2p/simulations/adapters/inproc.go
View file

@ -92,7 +92,7 @@ func (s *SimAdapter) NewNode(config *NodeConfig) (Node, error) {
}
}
err := config.initDefaultEnode()
err := config.initDummyEnode()
if err != nil {
return nil, err
}

2
p2p/simulations/adapters/types.go
View file

@ -290,6 +290,6 @@ func (n *NodeConfig) initEnode(ip net.IP, tcpport int, udpport int) error {
return nil
}
func (n *NodeConfig) initDefaultEnode() error {
func (n *NodeConfig) initDummyEnode() error {
return n.initEnode(net.IPv4(127, 0, 0, 1), 0, 0)
}

61
swarm/api/config.go
View file

@ -29,7 +29,6 @@ import (
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/enr"
"github.com/ethereum/go-ethereum/swarm/network"
"github.com/ethereum/go-ethereum/swarm/pss"
"github.com/ethereum/go-ethereum/swarm/services/swap"
@ -104,43 +103,35 @@ func NewConfig() (c *Config) {
//some config params need to be initialized after the complete
//config building phase is completed (e.g. due to overriding flags)
func (c *Config) Init(prvKey *ecdsa.PrivateKey) error {
func (c *Config) Init(prvKey *ecdsa.PrivateKey, nodeKey *ecdsa.PrivateKey) error {
address := crypto.PubkeyToAddress(prvKey.PublicKey)
c.Path = filepath.Join(c.Path, "bzz-"+common.Bytes2Hex(address.Bytes()))
err := os.MkdirAll(c.Path, os.ModePerm)
// create swarm dir and record key
err := c.createAndSetPath(c.Path, prvKey)
if err != nil {
return fmt.Errorf("Error creating root swarm data directory: %v", err)
}
c.setKey(prvKey)
pubkey := crypto.FromECDSAPub(&prvKey.PublicKey)
pubkeyhex := common.ToHex(pubkey)
bzzkeybytes := network.PrivateKeyToBzzKey(prvKey)
keyhex := hexutil.Encode(bzzkeybytes)
c.PublicKey = pubkeyhex
c.BzzKey = keyhex
var record enr.Record
record.Set(network.NewENRAddrEntry(bzzkeybytes))
record.Set(network.ENRLightNodeEntry(c.LightNodeEnabled))
record.Set(network.ENRBootNodeEntry(c.BootnodeMode))
err = enode.SignV4(&record, prvKey)
if err != nil {
return fmt.Errorf("ENR create fail: %v", err)
// create the new enode record
// signed with the ephemeral node key
enodeParams := &network.EnodeParams{
PrivateKey: prvKey,
EnodeKey: nodeKey,
Lightnode: c.LightNodeEnabled,
Bootnode: c.BootnodeMode,
}
c.Enode, err = enode.New(enode.V4ID{}, &record)
c.Enode, err = network.NewEnode(enodeParams)
if err != nil {
return fmt.Errorf("Enode create fail: %v", err)
return fmt.Errorf("Error creating enode: %v", err)
}
// initialize components that depend on the swarm instance's private key
if c.SwapEnabled {
c.Swap.Init(c.Contract, prvKey)
}
c.privateKey = prvKey
c.LocalStoreParams.Init(c.Path)
c.LocalStoreParams.BaseKey = common.FromHex(keyhex)
c.LocalStoreParams.BaseKey = common.FromHex(c.BzzKey)
c.Pss = c.Pss.WithPrivateKey(c.privateKey)
return nil
@ -153,3 +144,25 @@ func (c *Config) ShiftPrivateKey() (privKey *ecdsa.PrivateKey) {
}
return privKey
}
func (c *Config) setKey(prvKey *ecdsa.PrivateKey) {
bzzkeybytes := network.PrivateKeyToBzzKey(prvKey)
pubkey := crypto.FromECDSAPub(&prvKey.PublicKey)
pubkeyhex := hexutil.Encode(pubkey)
keyhex := hexutil.Encode(bzzkeybytes)
c.privateKey = prvKey
c.PublicKey = pubkeyhex
c.BzzKey = keyhex
}
func (c *Config) createAndSetPath(datadirPath string, prvKey *ecdsa.PrivateKey) error {
address := crypto.PubkeyToAddress(prvKey.PublicKey)
bzzdirPath := filepath.Join(datadirPath, "bzz-"+common.Bytes2Hex(address.Bytes()))
err := os.MkdirAll(bzzdirPath, os.ModePerm)
if err != nil {
return err
}
c.Path = bzzdirPath
return nil
}

7
swarm/api/config_test.go
View file

@ -27,11 +27,16 @@ import (
func TestConfig(t *testing.T) {
var hexprvkey = "65138b2aa745041b372153550584587da326ab440576b2a1191dd95cee30039c"
var hexnodekey = "75138b2aa745041b372153550584587da326ab440576b2a1191dd95cee30039c"
prvkey, err := crypto.HexToECDSA(hexprvkey)
if err != nil {
t.Fatalf("failed to load private key: %v", err)
}
nodekey, err := crypto.HexToECDSA(hexnodekey)
if err != nil {
t.Fatalf("failed to load private key: %v", err)
}
one := NewConfig()
two := NewConfig()
@ -41,7 +46,7 @@ func TestConfig(t *testing.T) {
t.Fatal("Two default configs are not equal")
}
err := one.Init(prvkey)
err = one.Init(prvkey, nodekey)
if err != nil {
t.Fatal(err)
}

35
swarm/network/network.go
View file

@ -7,6 +7,7 @@ import (
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/enr"
)
// BzzAddr implements the PeerAddr interface
@ -68,3 +69,37 @@ func PrivateKeyToBzzKey(prvKey *ecdsa.PrivateKey) []byte {
pubkeyBytes := crypto.FromECDSAPub(&prvKey.PublicKey)
return crypto.Keccak256Hash(pubkeyBytes).Bytes()
}
type EnodeParams struct {
PrivateKey *ecdsa.PrivateKey
EnodeKey *ecdsa.PrivateKey
Lightnode bool
Bootnode bool
}
func NewEnodeRecord(params *EnodeParams) (*enr.Record, error) {
if params.PrivateKey == nil {
return nil, fmt.Errorf("all param private keys must be defined")
}
bzzkeybytes := PrivateKeyToBzzKey(params.PrivateKey)
var record enr.Record
record.Set(NewENRAddrEntry(bzzkeybytes))
record.Set(ENRLightNodeEntry(params.Lightnode))
record.Set(ENRBootNodeEntry(params.Bootnode))
return &record, nil
}
func NewEnode(params *EnodeParams) (*enode.Node, error) {
record, err := NewEnodeRecord(params)
if err != nil {
return nil, err
}
err = enode.SignV4(record, params.EnodeKey)
if err != nil {
return nil, fmt.Errorf("ENR create fail: %v", err)
}
return enode.New(enode.V4ID{}, record)
}

18
swarm/network/simulation/node.go
View file

@ -102,16 +102,16 @@ func (s *Simulation) AddNode(opts ...AddNodeOption) (id enode.ID, err error) {
// most importantly the bzz overlay address
//
// for now we have no way of setting bootnodes or lightnodes in sims
// so we just set them as false
// so we just let them be set to false
// they should perhaps be possible to override them with AddNodeOption
bzzKey := network.PrivateKeyToBzzKey(conf.PrivateKey)
bzzAddr := network.NewENRAddrEntry(bzzKey)
var lightnode network.ENRLightNodeEntry
var bootnode network.ENRBootNodeEntry
conf.Record.Set(bzzAddr)
conf.Record.Set(&lightnode)
conf.Record.Set(&bootnode)
enodeParams := &network.EnodeParams{
PrivateKey: conf.PrivateKey,
}
record, err := network.NewEnodeRecord(enodeParams)
if err != nil {
return enode.ID{}, err
}
conf.Record = *record
// Add the bzz address to the node config
node, err := s.Net.NewNodeWithConfig(conf)

6
swarm/network_test.go
View file

@ -311,8 +311,12 @@ func testSwarmNetwork(t *testing.T, o *testSwarmNetworkOptions, steps ...testSwa
if err != nil {
return nil, cleanup, err
}
nodekey, err := crypto.GenerateKey()
if err != nil {
return nil, cleanup, err
}
config.Init(privkey)
config.Init(privkey, nodekey)
config.DeliverySkipCheck = o.SkipCheck
config.Port = ""

12
swarm/swarm_test.go
View file

@ -170,8 +170,12 @@ func TestNewSwarm(t *testing.T) {
if err != nil {
t.Fatal(err)
}
nodekey, err := crypto.GenerateKey()
if err != nil {
t.Fatal(err)
}
config.Init(privkey)
config.Init(privkey, nodekey)
if tc.configure != nil {
tc.configure(config)
@ -307,8 +311,12 @@ func TestLocalStoreAndRetrieve(t *testing.T) {
if err != nil {
t.Fatal(err)
}
nodekey, err := crypto.GenerateKey()
if err != nil {
t.Fatal(err)
}
config.Init(privkey)
config.Init(privkey, nodekey)
swarm, err := NewSwarm(config, nil)
if err != nil {