aboutsummaryrefslogtreecommitdiffstats
path: root/les/protocol.go
blob: 6a7354d1c2ba56623907af79b94a056702d39cd5 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
// Copyright 2016 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

// Package les implements the Light Ethereum Subprotocol.
package les

import (
    "bytes"
    "crypto/ecdsa"
    "crypto/elliptic"
    "errors"
    "fmt"
    "io"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/crypto/secp256k1"
    "github.com/ethereum/go-ethereum/rlp"
)

// Constants to match up protocol versions and messages
const (
    lpv1 = 1
    lpv2 = 2
)

// Supported versions of the les protocol (first is primary)
var (
    ClientProtocolVersions    = []uint{lpv2, lpv1}
    ServerProtocolVersions    = []uint{lpv2, lpv1}
    AdvertiseProtocolVersions = []uint{lpv2} // clients are searching for the first advertised protocol in the list
)

// Number of implemented message corresponding to different protocol versions.
var ProtocolLengths = map[uint]uint64{lpv1: 15, lpv2: 22}

const (
    NetworkId          = 1
    ProtocolMaxMsgSize = 10 * 1024 * 1024 // Maximum cap on the size of a protocol message
)

// les protocol message codes
const (
    // Protocol messages belonging to LPV1
    StatusMsg          = 0x00
    AnnounceMsg        = 0x01
    GetBlockHeadersMsg = 0x02
    BlockHeadersMsg    = 0x03
    GetBlockBodiesMsg  = 0x04
    BlockBodiesMsg     = 0x05
    GetReceiptsMsg     = 0x06
    ReceiptsMsg        = 0x07
    GetProofsV1Msg     = 0x08
    ProofsV1Msg        = 0x09
    GetCodeMsg         = 0x0a
    CodeMsg            = 0x0b
    SendTxMsg          = 0x0c
    GetHeaderProofsMsg = 0x0d
    HeaderProofsMsg    = 0x0e
    // Protocol messages belonging to LPV2
    GetProofsV2Msg         = 0x0f
    ProofsV2Msg            = 0x10
    GetHelperTrieProofsMsg = 0x11
    HelperTrieProofsMsg    = 0x12
    SendTxV2Msg            = 0x13
    GetTxStatusMsg         = 0x14
    TxStatusMsg            = 0x15
)

type errCode int

const (
    ErrMsgTooLarge = iota
    ErrDecode
    ErrInvalidMsgCode
    ErrProtocolVersionMismatch
    ErrNetworkIdMismatch
    ErrGenesisBlockMismatch
    ErrNoStatusMsg
    ErrExtraStatusMsg
    ErrSuspendedPeer
    ErrUselessPeer
    ErrRequestRejected
    ErrUnexpectedResponse
    ErrInvalidResponse
    ErrTooManyTimeouts
    ErrMissingKey
)

func (e errCode) String() string {
    return errorToString[int(e)]
}

// XXX change once legacy code is out
var errorToString = map[int]string{
    ErrMsgTooLarge:             "Message too long",
    ErrDecode:                  "Invalid message",
    ErrInvalidMsgCode:          "Invalid message code",
    ErrProtocolVersionMismatch: "Protocol version mismatch",
    ErrNetworkIdMismatch:       "NetworkId mismatch",
    ErrGenesisBlockMismatch:    "Genesis block mismatch",
    ErrNoStatusMsg:             "No status message",
    ErrExtraStatusMsg:          "Extra status message",
    ErrSuspendedPeer:           "Suspended peer",
    ErrRequestRejected:         "Request rejected",
    ErrUnexpectedResponse:      "Unexpected response",
    ErrInvalidResponse:         "Invalid response",
    ErrTooManyTimeouts:         "Too many request timeouts",
    ErrMissingKey:              "Key missing from list",
}

type announceBlock struct {
    Hash   common.Hash // Hash of one particular block being announced
    Number uint64      // Number of one particular block being announced
    Td     *big.Int    // Total difficulty of one particular block being announced
}

// announceData is the network packet for the block announcements.
type announceData struct {
    Hash       common.Hash // Hash of one particular block being announced
    Number     uint64      // Number of one particular block being announced
    Td         *big.Int    // Total difficulty of one particular block being announced
    ReorgDepth uint64
    Update     keyValueList
}

// sign adds a signature to the block announcement by the given privKey
func (a *announceData) sign(privKey *ecdsa.PrivateKey) {
    rlp, _ := rlp.EncodeToBytes(announceBlock{a.Hash, a.Number, a.Td})
    sig, _ := crypto.Sign(crypto.Keccak256(rlp), privKey)
    a.Update = a.Update.add("sign", sig)
}

// checkSignature verifies if the block announcement has a valid signature by the given pubKey
func (a *announceData) checkSignature(pubKey *ecdsa.PublicKey) error {
    var sig []byte
    if err := a.Update.decode().get("sign", &sig); err != nil {
        return err
    }
    rlp, _ := rlp.EncodeToBytes(announceBlock{a.Hash, a.Number, a.Td})
    recPubkey, err := secp256k1.RecoverPubkey(crypto.Keccak256(rlp), sig)
    if err != nil {
        return err
    }
    pbytes := elliptic.Marshal(pubKey.Curve, pubKey.X, pubKey.Y)
    if bytes.Equal(pbytes, recPubkey) {
        return nil
    } else {
        return errors.New("Wrong signature")
    }
}

type blockInfo struct {
    Hash   common.Hash // Hash of one particular block being announced
    Number uint64      // Number of one particular block being announced
    Td     *big.Int    // Total difficulty of one particular block being announced
}

// getBlockHeadersData represents a block header query.
type getBlockHeadersData struct {
    Origin  hashOrNumber // Block from which to retrieve headers
    Amount  uint64       // Maximum number of headers to retrieve
    Skip    uint64       // Blocks to skip between consecutive headers
    Reverse bool         // Query direction (false = rising towards latest, true = falling towards genesis)
}

// hashOrNumber is a combined field for specifying an origin block.
type hashOrNumber struct {
    Hash   common.Hash // Block hash from which to retrieve headers (excludes Number)
    Number uint64      // Block hash from which to retrieve headers (excludes Hash)
}

// EncodeRLP is a specialized encoder for hashOrNumber to encode only one of the
// two contained union fields.
func (hn *hashOrNumber) EncodeRLP(w io.Writer) error {
    if hn.Hash == (common.Hash{}) {
        return rlp.Encode(w, hn.Number)
    }
    if hn.Number != 0 {
        return fmt.Errorf("both origin hash (%x) and number (%d) provided", hn.Hash, hn.Number)
    }
    return rlp.Encode(w, hn.Hash)
}

// DecodeRLP is a specialized decoder for hashOrNumber to decode the contents
// into either a block hash or a block number.
func (hn *hashOrNumber) DecodeRLP(s *rlp.Stream) error {
    _, size, _ := s.Kind()
    origin, err := s.Raw()
    if err == nil {
        switch {
        case size == 32:
            err = rlp.DecodeBytes(origin, &hn.Hash)
        case size <= 8:
            err = rlp.DecodeBytes(origin, &hn.Number)
        default:
            err = fmt.Errorf("invalid input size %d for origin", size)
        }
    }
    return err
}

// CodeData is the network response packet for a node data retrieval.
type CodeData []struct {
    Value []byte
}

type proofsData [][]rlp.RawValue

type txStatus struct {
    Status core.TxStatus
    Lookup *core.TxLookupEntry
    Error  error
}