forked from mirror/go-ethereum
Merge branch 'p2p-handshake-2' of https://github.com/fjl/go-ethereum into fjl-p2p-handshake-2
obscuren
10 years ago
commit
ba0c41436c
@ -0,0 +1,174 @@ |
||||
package p2p |
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto/aes" |
||||
"crypto/cipher" |
||||
"crypto/hmac" |
||||
"errors" |
||||
"hash" |
||||
"io" |
||||
|
||||
"github.com/ethereum/go-ethereum/rlp" |
||||
) |
||||
|
||||
var ( |
||||
// this is used in place of actual frame header data.
|
||||
// TODO: replace this when Msg contains the protocol type code.
|
||||
zeroHeader = []byte{0xC2, 0x80, 0x80} |
||||
|
||||
// sixteen zero bytes
|
||||
zero16 = make([]byte, 16) |
||||
|
||||
maxUint24 = ^uint32(0) >> 8 |
||||
) |
||||
|
||||
// rlpxFrameRW implements a simplified version of RLPx framing.
|
||||
// chunked messages are not supported and all headers are equal to
|
||||
// zeroHeader.
|
||||
//
|
||||
// rlpxFrameRW is not safe for concurrent use from multiple goroutines.
|
||||
type rlpxFrameRW struct { |
||||
conn io.ReadWriter |
||||
enc cipher.Stream |
||||
dec cipher.Stream |
||||
|
||||
macCipher cipher.Block |
||||
egressMAC hash.Hash |
||||
ingressMAC hash.Hash |
||||
} |
||||
|
||||
func newRlpxFrameRW(conn io.ReadWriter, s secrets) *rlpxFrameRW { |
||||
macc, err := aes.NewCipher(s.MAC) |
||||
if err != nil { |
||||
panic("invalid MAC secret: " + err.Error()) |
||||
} |
||||
encc, err := aes.NewCipher(s.AES) |
||||
if err != nil { |
||||
panic("invalid AES secret: " + err.Error()) |
||||
} |
||||
// we use an all-zeroes IV for AES because the key used
|
||||
// for encryption is ephemeral.
|
||||
iv := make([]byte, encc.BlockSize()) |
||||
return &rlpxFrameRW{ |
||||
conn: conn, |
||||
enc: cipher.NewCTR(encc, iv), |
||||
dec: cipher.NewCTR(encc, iv), |
||||
macCipher: macc, |
||||
egressMAC: s.EgressMAC, |
||||
ingressMAC: s.IngressMAC, |
||||
} |
||||
} |
||||
|
||||
func (rw *rlpxFrameRW) WriteMsg(msg Msg) error { |
||||
ptype, _ := rlp.EncodeToBytes(msg.Code) |
||||
|
||||
// write header
|
||||
headbuf := make([]byte, 32) |
||||
fsize := uint32(len(ptype)) + msg.Size |
||||
if fsize > maxUint24 { |
||||
return errors.New("message size overflows uint24") |
||||
} |
||||
putInt24(fsize, headbuf) // TODO: check overflow
|
||||
copy(headbuf[3:], zeroHeader) |
||||
rw.enc.XORKeyStream(headbuf[:16], headbuf[:16]) // first half is now encrypted
|
||||
|
||||
// write header MAC
|
||||
copy(headbuf[16:], updateMAC(rw.egressMAC, rw.macCipher, headbuf[:16])) |
||||
if _, err := rw.conn.Write(headbuf); err != nil { |
||||
return err |
||||
} |
||||
|
||||
// write encrypted frame, updating the egress MAC hash with
|
||||
// the data written to conn.
|
||||
tee := cipher.StreamWriter{S: rw.enc, W: io.MultiWriter(rw.conn, rw.egressMAC)} |
||||
if _, err := tee.Write(ptype); err != nil { |
||||
return err |
||||
} |
||||
if _, err := io.Copy(tee, msg.Payload); err != nil { |
||||
return err |
||||
} |
||||
if padding := fsize % 16; padding > 0 { |
||||
if _, err := tee.Write(zero16[:16-padding]); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
// write frame MAC. egress MAC hash is up to date because
|
||||
// frame content was written to it as well.
|
||||
fmacseed := rw.egressMAC.Sum(nil) |
||||
mac := updateMAC(rw.egressMAC, rw.macCipher, fmacseed) |
||||
_, err := rw.conn.Write(mac) |
||||
return err |
||||
} |
||||
|
||||
func (rw *rlpxFrameRW) ReadMsg() (msg Msg, err error) { |
||||
// read the header
|
||||
headbuf := make([]byte, 32) |
||||
if _, err := io.ReadFull(rw.conn, headbuf); err != nil { |
||||
return msg, err |
||||
} |
||||
// verify header mac
|
||||
shouldMAC := updateMAC(rw.ingressMAC, rw.macCipher, headbuf[:16]) |
||||
if !hmac.Equal(shouldMAC, headbuf[16:]) { |
||||
return msg, errors.New("bad header MAC") |
||||
} |
||||
rw.dec.XORKeyStream(headbuf[:16], headbuf[:16]) // first half is now decrypted
|
||||
fsize := readInt24(headbuf) |
||||
// ignore protocol type for now
|
||||
|
||||
// read the frame content
|
||||
var rsize = fsize // frame size rounded up to 16 byte boundary
|
||||
if padding := fsize % 16; padding > 0 { |
||||
rsize += 16 - padding |
||||
} |
||||
framebuf := make([]byte, rsize) |
||||
if _, err := io.ReadFull(rw.conn, framebuf); err != nil { |
||||
return msg, err |
||||
} |
||||
|
||||
// read and validate frame MAC. we can re-use headbuf for that.
|
||||
rw.ingressMAC.Write(framebuf) |
||||
fmacseed := rw.ingressMAC.Sum(nil) |
||||
if _, err := io.ReadFull(rw.conn, headbuf[:16]); err != nil { |
||||
return msg, err |
||||
} |
||||
shouldMAC = updateMAC(rw.ingressMAC, rw.macCipher, fmacseed) |
||||
if !hmac.Equal(shouldMAC, headbuf[:16]) { |
||||
return msg, errors.New("bad frame MAC") |
||||
} |
||||
|
||||
// decrypt frame content
|
||||
rw.dec.XORKeyStream(framebuf, framebuf) |
||||
|
||||
// decode message code
|
||||
content := bytes.NewReader(framebuf[:fsize]) |
||||
if err := rlp.Decode(content, &msg.Code); err != nil { |
||||
return msg, err |
||||
} |
||||
msg.Size = uint32(content.Len()) |
||||
msg.Payload = content |
||||
return msg, nil |
||||
} |
||||
|
||||
// updateMAC reseeds the given hash with encrypted seed.
|
||||
// it returns the first 16 bytes of the hash sum after seeding.
|
||||
func updateMAC(mac hash.Hash, block cipher.Block, seed []byte) []byte { |
||||
aesbuf := make([]byte, aes.BlockSize) |
||||
block.Encrypt(aesbuf, mac.Sum(nil)) |
||||
for i := range aesbuf { |
||||
aesbuf[i] ^= seed[i] |
||||
} |
||||
mac.Write(aesbuf) |
||||
return mac.Sum(nil)[:16] |
||||
} |
||||
|
||||
func readInt24(b []byte) uint32 { |
||||
return uint32(b[2]) | uint32(b[1])<<8 | uint32(b[0])<<16 |
||||
} |
||||
|
||||
func putInt24(v uint32, b []byte) { |
||||
b[0] = byte(v >> 16) |
||||
b[1] = byte(v >> 8) |
||||
b[2] = byte(v) |
||||
} |
||||
@ -0,0 +1,124 @@ |
||||
package p2p |
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto/rand" |
||||
"io/ioutil" |
||||
"strings" |
||||
"testing" |
||||
|
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
"github.com/ethereum/go-ethereum/crypto/sha3" |
||||
"github.com/ethereum/go-ethereum/rlp" |
||||
) |
||||
|
||||
func TestRlpxFrameFake(t *testing.T) { |
||||
buf := new(bytes.Buffer) |
||||
hash := fakeHash([]byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}) |
||||
rw := newRlpxFrameRW(buf, secrets{ |
||||
AES: crypto.Sha3(), |
||||
MAC: crypto.Sha3(), |
||||
IngressMAC: hash, |
||||
EgressMAC: hash, |
||||
}) |
||||
|
||||
golden := unhex(` |
||||
00828ddae471818bb0bfa6b551d1cb42 |
||||
01010101010101010101010101010101 |
||||
ba628a4ba590cb43f7848f41c4382885 |
||||
01010101010101010101010101010101 |
||||
`) |
||||
|
||||
// Check WriteMsg. This puts a message into the buffer.
|
||||
if err := EncodeMsg(rw, 8, 1, 2, 3, 4); err != nil { |
||||
t.Fatalf("WriteMsg error: %v", err) |
||||
} |
||||
written := buf.Bytes() |
||||
if !bytes.Equal(written, golden) { |
||||
t.Fatalf("output mismatch:\n got: %x\n want: %x", written, golden) |
||||
} |
||||
|
||||
// Check ReadMsg. It reads the message encoded by WriteMsg, which
|
||||
// is equivalent to the golden message above.
|
||||
msg, err := rw.ReadMsg() |
||||
if err != nil { |
||||
t.Fatalf("ReadMsg error: %v", err) |
||||
} |
||||
if msg.Size != 5 { |
||||
t.Errorf("msg size mismatch: got %d, want %d", msg.Size, 5) |
||||
} |
||||
if msg.Code != 8 { |
||||
t.Errorf("msg code mismatch: got %d, want %d", msg.Code, 8) |
||||
} |
||||
payload, _ := ioutil.ReadAll(msg.Payload) |
||||
wantPayload := unhex("C401020304") |
||||
if !bytes.Equal(payload, wantPayload) { |
||||
t.Errorf("msg payload mismatch:\ngot %x\nwant %x", payload, wantPayload) |
||||
} |
||||
} |
||||
|
||||
type fakeHash []byte |
||||
|
||||
func (fakeHash) Write(p []byte) (int, error) { return len(p), nil } |
||||
func (fakeHash) Reset() {} |
||||
func (fakeHash) BlockSize() int { return 0 } |
||||
|
||||
func (h fakeHash) Size() int { return len(h) } |
||||
func (h fakeHash) Sum(b []byte) []byte { return append(b, h...) } |
||||
|
||||
func TestRlpxFrameRW(t *testing.T) { |
||||
var ( |
||||
aesSecret = make([]byte, 16) |
||||
macSecret = make([]byte, 16) |
||||
egressMACinit = make([]byte, 32) |
||||
ingressMACinit = make([]byte, 32) |
||||
) |
||||
for _, s := range [][]byte{aesSecret, macSecret, egressMACinit, ingressMACinit} { |
||||
rand.Read(s) |
||||
} |
||||
conn := new(bytes.Buffer) |
||||
|
||||
s1 := secrets{ |
||||
AES: aesSecret, |
||||
MAC: macSecret, |
||||
EgressMAC: sha3.NewKeccak256(), |
||||
IngressMAC: sha3.NewKeccak256(), |
||||
} |
||||
s1.EgressMAC.Write(egressMACinit) |
||||
s1.IngressMAC.Write(ingressMACinit) |
||||
rw1 := newRlpxFrameRW(conn, s1) |
||||
|
||||
s2 := secrets{ |
||||
AES: aesSecret, |
||||
MAC: macSecret, |
||||
EgressMAC: sha3.NewKeccak256(), |
||||
IngressMAC: sha3.NewKeccak256(), |
||||
} |
||||
s2.EgressMAC.Write(ingressMACinit) |
||||
s2.IngressMAC.Write(egressMACinit) |
||||
rw2 := newRlpxFrameRW(conn, s2) |
||||
|
||||
// send some messages
|
||||
for i := 0; i < 10; i++ { |
||||
// write message into conn buffer
|
||||
wmsg := []interface{}{"foo", "bar", strings.Repeat("test", i)} |
||||
err := EncodeMsg(rw1, uint64(i), wmsg...) |
||||
if err != nil { |
||||
t.Fatalf("WriteMsg error (i=%d): %v", i, err) |
||||
} |
||||
|
||||
// read message that rw1 just wrote
|
||||
msg, err := rw2.ReadMsg() |
||||
if err != nil { |
||||
t.Fatalf("ReadMsg error (i=%d): %v", i, err) |
||||
} |
||||
if msg.Code != uint64(i) { |
||||
t.Fatalf("msg code mismatch: got %d, want %d", msg.Code, i) |
||||
} |
||||
payload, _ := ioutil.ReadAll(msg.Payload) |
||||
wantPayload, _ := rlp.EncodeToBytes(wmsg) |
||||
if !bytes.Equal(payload, wantPayload) { |
||||
t.Fatalf("msg payload mismatch:\ngot %x\nwant %x", payload, wantPayload) |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue