You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

471 lines
13 KiB

  1. package conn
  2. import (
  3. "bufio"
  4. "encoding/hex"
  5. "flag"
  6. "fmt"
  7. "io"
  8. "io/ioutil"
  9. "log"
  10. "os"
  11. "path/filepath"
  12. "strconv"
  13. "strings"
  14. "sync"
  15. "testing"
  16. "github.com/stretchr/testify/assert"
  17. "github.com/stretchr/testify/require"
  18. "github.com/tendermint/tendermint/crypto"
  19. "github.com/tendermint/tendermint/crypto/ed25519"
  20. "github.com/tendermint/tendermint/crypto/sr25519"
  21. "github.com/tendermint/tendermint/libs/async"
  22. tmrand "github.com/tendermint/tendermint/libs/rand"
  23. )
  24. // Run go test -update from within this module
  25. // to update the golden test vector file
  26. var update = flag.Bool("update", false, "update .golden files")
  27. type kvstoreConn struct {
  28. *io.PipeReader
  29. *io.PipeWriter
  30. }
  31. func (drw kvstoreConn) Close() (err error) {
  32. err2 := drw.PipeWriter.CloseWithError(io.EOF)
  33. err1 := drw.PipeReader.Close()
  34. if err2 != nil {
  35. return err
  36. }
  37. return err1
  38. }
  39. type privKeyWithNilPubKey struct {
  40. orig crypto.PrivKey
  41. }
  42. func (pk privKeyWithNilPubKey) Bytes() []byte { return pk.orig.Bytes() }
  43. func (pk privKeyWithNilPubKey) Sign(msg []byte) ([]byte, error) { return pk.orig.Sign(msg) }
  44. func (pk privKeyWithNilPubKey) PubKey() crypto.PubKey { return nil }
  45. func (pk privKeyWithNilPubKey) Equals(pk2 crypto.PrivKey) bool { return pk.orig.Equals(pk2) }
  46. func (pk privKeyWithNilPubKey) Type() string { return "privKeyWithNilPubKey" }
  47. func TestSecretConnectionHandshake(t *testing.T) {
  48. fooSecConn, barSecConn := makeSecretConnPair(t)
  49. if err := fooSecConn.Close(); err != nil {
  50. t.Error(err)
  51. }
  52. if err := barSecConn.Close(); err != nil {
  53. t.Error(err)
  54. }
  55. }
  56. func TestConcurrentWrite(t *testing.T) {
  57. fooSecConn, barSecConn := makeSecretConnPair(t)
  58. fooWriteText := tmrand.Str(dataMaxSize)
  59. // write from two routines.
  60. // should be safe from race according to net.Conn:
  61. // https://golang.org/pkg/net/#Conn
  62. n := 100
  63. wg := new(sync.WaitGroup)
  64. wg.Add(3)
  65. go writeLots(t, wg, fooSecConn, fooWriteText, n)
  66. go writeLots(t, wg, fooSecConn, fooWriteText, n)
  67. // Consume reads from bar's reader
  68. readLots(t, wg, barSecConn, n*2)
  69. wg.Wait()
  70. if err := fooSecConn.Close(); err != nil {
  71. t.Error(err)
  72. }
  73. }
  74. func TestConcurrentRead(t *testing.T) {
  75. fooSecConn, barSecConn := makeSecretConnPair(t)
  76. fooWriteText := tmrand.Str(dataMaxSize)
  77. n := 100
  78. // read from two routines.
  79. // should be safe from race according to net.Conn:
  80. // https://golang.org/pkg/net/#Conn
  81. wg := new(sync.WaitGroup)
  82. wg.Add(3)
  83. go readLots(t, wg, fooSecConn, n/2)
  84. go readLots(t, wg, fooSecConn, n/2)
  85. // write to bar
  86. writeLots(t, wg, barSecConn, fooWriteText, n)
  87. wg.Wait()
  88. if err := fooSecConn.Close(); err != nil {
  89. t.Error(err)
  90. }
  91. }
  92. func TestSecretConnectionReadWrite(t *testing.T) {
  93. fooConn, barConn := makeKVStoreConnPair()
  94. fooWrites, barWrites := []string{}, []string{}
  95. fooReads, barReads := []string{}, []string{}
  96. // Pre-generate the things to write (for foo & bar)
  97. for i := 0; i < 100; i++ {
  98. fooWrites = append(fooWrites, tmrand.Str((tmrand.Int()%(dataMaxSize*5))+1))
  99. barWrites = append(barWrites, tmrand.Str((tmrand.Int()%(dataMaxSize*5))+1))
  100. }
  101. // A helper that will run with (fooConn, fooWrites, fooReads) and vice versa
  102. genNodeRunner := func(id string, nodeConn kvstoreConn, nodeWrites []string, nodeReads *[]string) async.Task {
  103. return func(_ int) (interface{}, bool, error) {
  104. // Initiate cryptographic private key and secret connection trhough nodeConn.
  105. nodePrvKey := ed25519.GenPrivKey()
  106. nodeSecretConn, err := MakeSecretConnection(nodeConn, nodePrvKey)
  107. if err != nil {
  108. t.Errorf("failed to establish SecretConnection for node: %v", err)
  109. return nil, true, err
  110. }
  111. // In parallel, handle some reads and writes.
  112. var trs, ok = async.Parallel(
  113. func(_ int) (interface{}, bool, error) {
  114. // Node writes:
  115. for _, nodeWrite := range nodeWrites {
  116. n, err := nodeSecretConn.Write([]byte(nodeWrite))
  117. if err != nil {
  118. t.Errorf("failed to write to nodeSecretConn: %v", err)
  119. return nil, true, err
  120. }
  121. if n != len(nodeWrite) {
  122. err = fmt.Errorf("failed to write all bytes. Expected %v, wrote %v", len(nodeWrite), n)
  123. t.Error(err)
  124. return nil, true, err
  125. }
  126. }
  127. if err := nodeConn.PipeWriter.Close(); err != nil {
  128. t.Error(err)
  129. return nil, true, err
  130. }
  131. return nil, false, nil
  132. },
  133. func(_ int) (interface{}, bool, error) {
  134. // Node reads:
  135. readBuffer := make([]byte, dataMaxSize)
  136. for {
  137. n, err := nodeSecretConn.Read(readBuffer)
  138. if err == io.EOF {
  139. if err := nodeConn.PipeReader.Close(); err != nil {
  140. t.Error(err)
  141. return nil, true, err
  142. }
  143. return nil, false, nil
  144. } else if err != nil {
  145. t.Errorf("failed to read from nodeSecretConn: %v", err)
  146. return nil, true, err
  147. }
  148. *nodeReads = append(*nodeReads, string(readBuffer[:n]))
  149. }
  150. },
  151. )
  152. assert.True(t, ok, "Unexpected task abortion")
  153. // If error:
  154. if trs.FirstError() != nil {
  155. return nil, true, trs.FirstError()
  156. }
  157. // Otherwise:
  158. return nil, false, nil
  159. }
  160. }
  161. // Run foo & bar in parallel
  162. var trs, ok = async.Parallel(
  163. genNodeRunner("foo", fooConn, fooWrites, &fooReads),
  164. genNodeRunner("bar", barConn, barWrites, &barReads),
  165. )
  166. require.Nil(t, trs.FirstError())
  167. require.True(t, ok, "unexpected task abortion")
  168. // A helper to ensure that the writes and reads match.
  169. // Additionally, small writes (<= dataMaxSize) must be atomically read.
  170. compareWritesReads := func(writes []string, reads []string) {
  171. for {
  172. // Pop next write & corresponding reads
  173. var read, write string = "", writes[0]
  174. var readCount = 0
  175. for _, readChunk := range reads {
  176. read += readChunk
  177. readCount++
  178. if len(write) <= len(read) {
  179. break
  180. }
  181. if len(write) <= dataMaxSize {
  182. break // atomicity of small writes
  183. }
  184. }
  185. // Compare
  186. if write != read {
  187. t.Errorf("expected to read %X, got %X", write, read)
  188. }
  189. // Iterate
  190. writes = writes[1:]
  191. reads = reads[readCount:]
  192. if len(writes) == 0 {
  193. break
  194. }
  195. }
  196. }
  197. compareWritesReads(fooWrites, barReads)
  198. compareWritesReads(barWrites, fooReads)
  199. }
  200. func TestDeriveSecretsAndChallengeGolden(t *testing.T) {
  201. goldenFilepath := filepath.Join("testdata", t.Name()+".golden")
  202. if *update {
  203. t.Logf("Updating golden test vector file %s", goldenFilepath)
  204. data := createGoldenTestVectors(t)
  205. require.NoError(t, ioutil.WriteFile(goldenFilepath, []byte(data), 0644))
  206. }
  207. f, err := os.Open(goldenFilepath)
  208. if err != nil {
  209. log.Fatal(err)
  210. }
  211. t.Cleanup(closeAll(t, f))
  212. scanner := bufio.NewScanner(f)
  213. for scanner.Scan() {
  214. line := scanner.Text()
  215. params := strings.Split(line, ",")
  216. randSecretVector, err := hex.DecodeString(params[0])
  217. require.Nil(t, err)
  218. randSecret := new([32]byte)
  219. copy((*randSecret)[:], randSecretVector)
  220. locIsLeast, err := strconv.ParseBool(params[1])
  221. require.Nil(t, err)
  222. expectedRecvSecret, err := hex.DecodeString(params[2])
  223. require.Nil(t, err)
  224. expectedSendSecret, err := hex.DecodeString(params[3])
  225. require.Nil(t, err)
  226. recvSecret, sendSecret := deriveSecrets(randSecret, locIsLeast)
  227. require.Equal(t, expectedRecvSecret, (*recvSecret)[:], "Recv Secrets aren't equal")
  228. require.Equal(t, expectedSendSecret, (*sendSecret)[:], "Send Secrets aren't equal")
  229. }
  230. }
  231. func TestNilPubkey(t *testing.T) {
  232. var fooConn, barConn = makeKVStoreConnPair()
  233. t.Cleanup(closeAll(t, fooConn, barConn))
  234. var fooPrvKey = ed25519.GenPrivKey()
  235. var barPrvKey = privKeyWithNilPubKey{ed25519.GenPrivKey()}
  236. go MakeSecretConnection(fooConn, fooPrvKey) //nolint:errcheck // ignore for tests
  237. _, err := MakeSecretConnection(barConn, barPrvKey)
  238. require.Error(t, err)
  239. assert.Equal(t, "toproto: key type <nil> is not supported", err.Error())
  240. }
  241. func TestNonEd25519Pubkey(t *testing.T) {
  242. var fooConn, barConn = makeKVStoreConnPair()
  243. t.Cleanup(closeAll(t, fooConn, barConn))
  244. var fooPrvKey = ed25519.GenPrivKey()
  245. var barPrvKey = sr25519.GenPrivKey()
  246. go MakeSecretConnection(fooConn, fooPrvKey) //nolint:errcheck // ignore for tests
  247. _, err := MakeSecretConnection(barConn, barPrvKey)
  248. require.Error(t, err)
  249. assert.Contains(t, err.Error(), "is not supported")
  250. }
  251. func writeLots(t *testing.T, wg *sync.WaitGroup, conn io.Writer, txt string, n int) {
  252. defer wg.Done()
  253. for i := 0; i < n; i++ {
  254. _, err := conn.Write([]byte(txt))
  255. if err != nil {
  256. t.Errorf("failed to write to fooSecConn: %v", err)
  257. return
  258. }
  259. }
  260. }
  261. func readLots(t *testing.T, wg *sync.WaitGroup, conn io.Reader, n int) {
  262. readBuffer := make([]byte, dataMaxSize)
  263. for i := 0; i < n; i++ {
  264. _, err := conn.Read(readBuffer)
  265. assert.NoError(t, err)
  266. }
  267. wg.Done()
  268. }
  269. // Creates the data for a test vector file.
  270. // The file format is:
  271. // Hex(diffie_hellman_secret), loc_is_least, Hex(recvSecret), Hex(sendSecret), Hex(challenge)
  272. func createGoldenTestVectors(t *testing.T) string {
  273. data := ""
  274. for i := 0; i < 32; i++ {
  275. randSecretVector := tmrand.Bytes(32)
  276. randSecret := new([32]byte)
  277. copy((*randSecret)[:], randSecretVector)
  278. data += hex.EncodeToString((*randSecret)[:]) + ","
  279. locIsLeast := tmrand.Bool()
  280. data += strconv.FormatBool(locIsLeast) + ","
  281. recvSecret, sendSecret := deriveSecrets(randSecret, locIsLeast)
  282. data += hex.EncodeToString((*recvSecret)[:]) + ","
  283. data += hex.EncodeToString((*sendSecret)[:]) + ","
  284. }
  285. return data
  286. }
  287. // Each returned ReadWriteCloser is akin to a net.Connection
  288. func makeKVStoreConnPair() (fooConn, barConn kvstoreConn) {
  289. barReader, fooWriter := io.Pipe()
  290. fooReader, barWriter := io.Pipe()
  291. return kvstoreConn{fooReader, fooWriter}, kvstoreConn{barReader, barWriter}
  292. }
  293. func makeSecretConnPair(tb testing.TB) (fooSecConn, barSecConn *SecretConnection) {
  294. var (
  295. fooConn, barConn = makeKVStoreConnPair()
  296. fooPrvKey = ed25519.GenPrivKey()
  297. fooPubKey = fooPrvKey.PubKey()
  298. barPrvKey = ed25519.GenPrivKey()
  299. barPubKey = barPrvKey.PubKey()
  300. )
  301. // Make connections from both sides in parallel.
  302. var trs, ok = async.Parallel(
  303. func(_ int) (val interface{}, abort bool, err error) {
  304. fooSecConn, err = MakeSecretConnection(fooConn, fooPrvKey)
  305. if err != nil {
  306. tb.Errorf("failed to establish SecretConnection for foo: %v", err)
  307. return nil, true, err
  308. }
  309. remotePubBytes := fooSecConn.RemotePubKey()
  310. if !remotePubBytes.Equals(barPubKey) {
  311. err = fmt.Errorf("unexpected fooSecConn.RemotePubKey. Expected %v, got %v",
  312. barPubKey, fooSecConn.RemotePubKey())
  313. tb.Error(err)
  314. return nil, true, err
  315. }
  316. return nil, false, nil
  317. },
  318. func(_ int) (val interface{}, abort bool, err error) {
  319. barSecConn, err = MakeSecretConnection(barConn, barPrvKey)
  320. if barSecConn == nil {
  321. tb.Errorf("failed to establish SecretConnection for bar: %v", err)
  322. return nil, true, err
  323. }
  324. remotePubBytes := barSecConn.RemotePubKey()
  325. if !remotePubBytes.Equals(fooPubKey) {
  326. err = fmt.Errorf("unexpected barSecConn.RemotePubKey. Expected %v, got %v",
  327. fooPubKey, barSecConn.RemotePubKey())
  328. tb.Error(err)
  329. return nil, true, err
  330. }
  331. return nil, false, nil
  332. },
  333. )
  334. require.Nil(tb, trs.FirstError())
  335. require.True(tb, ok, "Unexpected task abortion")
  336. return fooSecConn, barSecConn
  337. }
  338. // Benchmarks
  339. func BenchmarkWriteSecretConnection(b *testing.B) {
  340. b.StopTimer()
  341. b.ReportAllocs()
  342. fooSecConn, barSecConn := makeSecretConnPair(b)
  343. randomMsgSizes := []int{
  344. dataMaxSize / 10,
  345. dataMaxSize / 3,
  346. dataMaxSize / 2,
  347. dataMaxSize,
  348. dataMaxSize * 3 / 2,
  349. dataMaxSize * 2,
  350. dataMaxSize * 7 / 2,
  351. }
  352. fooWriteBytes := make([][]byte, 0, len(randomMsgSizes))
  353. for _, size := range randomMsgSizes {
  354. fooWriteBytes = append(fooWriteBytes, tmrand.Bytes(size))
  355. }
  356. // Consume reads from bar's reader
  357. go func() {
  358. readBuffer := make([]byte, dataMaxSize)
  359. for {
  360. _, err := barSecConn.Read(readBuffer)
  361. if err == io.EOF {
  362. return
  363. } else if err != nil {
  364. b.Errorf("failed to read from barSecConn: %v", err)
  365. return
  366. }
  367. }
  368. }()
  369. b.StartTimer()
  370. for i := 0; i < b.N; i++ {
  371. idx := tmrand.Intn(len(fooWriteBytes))
  372. _, err := fooSecConn.Write(fooWriteBytes[idx])
  373. if err != nil {
  374. b.Errorf("failed to write to fooSecConn: %v", err)
  375. return
  376. }
  377. }
  378. b.StopTimer()
  379. if err := fooSecConn.Close(); err != nil {
  380. b.Error(err)
  381. }
  382. // barSecConn.Close() race condition
  383. }
  384. func BenchmarkReadSecretConnection(b *testing.B) {
  385. b.StopTimer()
  386. b.ReportAllocs()
  387. fooSecConn, barSecConn := makeSecretConnPair(b)
  388. randomMsgSizes := []int{
  389. dataMaxSize / 10,
  390. dataMaxSize / 3,
  391. dataMaxSize / 2,
  392. dataMaxSize,
  393. dataMaxSize * 3 / 2,
  394. dataMaxSize * 2,
  395. dataMaxSize * 7 / 2,
  396. }
  397. fooWriteBytes := make([][]byte, 0, len(randomMsgSizes))
  398. for _, size := range randomMsgSizes {
  399. fooWriteBytes = append(fooWriteBytes, tmrand.Bytes(size))
  400. }
  401. go func() {
  402. for i := 0; i < b.N; i++ {
  403. idx := tmrand.Intn(len(fooWriteBytes))
  404. _, err := fooSecConn.Write(fooWriteBytes[idx])
  405. if err != nil {
  406. b.Errorf("failed to write to fooSecConn: %v, %v,%v", err, i, b.N)
  407. return
  408. }
  409. }
  410. }()
  411. b.StartTimer()
  412. for i := 0; i < b.N; i++ {
  413. readBuffer := make([]byte, dataMaxSize)
  414. _, err := barSecConn.Read(readBuffer)
  415. if err == io.EOF {
  416. return
  417. } else if err != nil {
  418. b.Fatalf("Failed to read from barSecConn: %v", err)
  419. }
  420. }
  421. b.StopTimer()
  422. }