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.

473 lines
13 KiB

  1. package conn
  2. import (
  3. "bufio"
  4. "encoding/hex"
  5. "flag"
  6. "fmt"
  7. "io"
  8. "log"
  9. "os"
  10. "path/filepath"
  11. "strconv"
  12. "strings"
  13. "sync"
  14. "testing"
  15. "github.com/stretchr/testify/assert"
  16. "github.com/stretchr/testify/require"
  17. "github.com/tendermint/tendermint/crypto"
  18. "github.com/tendermint/tendermint/crypto/ed25519"
  19. "github.com/tendermint/tendermint/crypto/secp256k1"
  20. "github.com/tendermint/tendermint/libs/async"
  21. tmos "github.com/tendermint/tendermint/libs/os"
  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. tmos.WriteFile(goldenFilepath, []byte(data), 0644)
  206. }
  207. f, err := os.Open(goldenFilepath)
  208. if err != nil {
  209. log.Fatal(err)
  210. }
  211. defer f.Close()
  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. defer fooConn.Close()
  234. defer barConn.Close()
  235. var fooPrvKey = ed25519.GenPrivKey()
  236. var barPrvKey = privKeyWithNilPubKey{ed25519.GenPrivKey()}
  237. go MakeSecretConnection(fooConn, fooPrvKey)
  238. _, err := MakeSecretConnection(barConn, barPrvKey)
  239. require.Error(t, err)
  240. assert.Equal(t, "toproto: key type <nil> is not supported", err.Error())
  241. }
  242. func TestNonEd25519Pubkey(t *testing.T) {
  243. var fooConn, barConn = makeKVStoreConnPair()
  244. defer fooConn.Close()
  245. defer barConn.Close()
  246. var fooPrvKey = ed25519.GenPrivKey()
  247. var barPrvKey = secp256k1.GenPrivKey()
  248. go MakeSecretConnection(fooConn, fooPrvKey)
  249. _, err := MakeSecretConnection(barConn, barPrvKey)
  250. require.Error(t, err)
  251. assert.Contains(t, err.Error(), "is not supported")
  252. }
  253. func writeLots(t *testing.T, wg *sync.WaitGroup, conn io.Writer, txt string, n int) {
  254. defer wg.Done()
  255. for i := 0; i < n; i++ {
  256. _, err := conn.Write([]byte(txt))
  257. if err != nil {
  258. t.Errorf("failed to write to fooSecConn: %v", err)
  259. return
  260. }
  261. }
  262. }
  263. func readLots(t *testing.T, wg *sync.WaitGroup, conn io.Reader, n int) {
  264. readBuffer := make([]byte, dataMaxSize)
  265. for i := 0; i < n; i++ {
  266. _, err := conn.Read(readBuffer)
  267. assert.NoError(t, err)
  268. }
  269. wg.Done()
  270. }
  271. // Creates the data for a test vector file.
  272. // The file format is:
  273. // Hex(diffie_hellman_secret), loc_is_least, Hex(recvSecret), Hex(sendSecret), Hex(challenge)
  274. func createGoldenTestVectors(t *testing.T) string {
  275. data := ""
  276. for i := 0; i < 32; i++ {
  277. randSecretVector := tmrand.Bytes(32)
  278. randSecret := new([32]byte)
  279. copy((*randSecret)[:], randSecretVector)
  280. data += hex.EncodeToString((*randSecret)[:]) + ","
  281. locIsLeast := tmrand.Bool()
  282. data += strconv.FormatBool(locIsLeast) + ","
  283. recvSecret, sendSecret := deriveSecrets(randSecret, locIsLeast)
  284. data += hex.EncodeToString((*recvSecret)[:]) + ","
  285. data += hex.EncodeToString((*sendSecret)[:]) + ","
  286. }
  287. return data
  288. }
  289. // Each returned ReadWriteCloser is akin to a net.Connection
  290. func makeKVStoreConnPair() (fooConn, barConn kvstoreConn) {
  291. barReader, fooWriter := io.Pipe()
  292. fooReader, barWriter := io.Pipe()
  293. return kvstoreConn{fooReader, fooWriter}, kvstoreConn{barReader, barWriter}
  294. }
  295. func makeSecretConnPair(tb testing.TB) (fooSecConn, barSecConn *SecretConnection) {
  296. var (
  297. fooConn, barConn = makeKVStoreConnPair()
  298. fooPrvKey = ed25519.GenPrivKey()
  299. fooPubKey = fooPrvKey.PubKey()
  300. barPrvKey = ed25519.GenPrivKey()
  301. barPubKey = barPrvKey.PubKey()
  302. )
  303. // Make connections from both sides in parallel.
  304. var trs, ok = async.Parallel(
  305. func(_ int) (val interface{}, abort bool, err error) {
  306. fooSecConn, err = MakeSecretConnection(fooConn, fooPrvKey)
  307. if err != nil {
  308. tb.Errorf("failed to establish SecretConnection for foo: %v", err)
  309. return nil, true, err
  310. }
  311. remotePubBytes := fooSecConn.RemotePubKey()
  312. if !remotePubBytes.Equals(barPubKey) {
  313. err = fmt.Errorf("unexpected fooSecConn.RemotePubKey. Expected %v, got %v",
  314. barPubKey, fooSecConn.RemotePubKey())
  315. tb.Error(err)
  316. return nil, true, err
  317. }
  318. return nil, false, nil
  319. },
  320. func(_ int) (val interface{}, abort bool, err error) {
  321. barSecConn, err = MakeSecretConnection(barConn, barPrvKey)
  322. if barSecConn == nil {
  323. tb.Errorf("failed to establish SecretConnection for bar: %v", err)
  324. return nil, true, err
  325. }
  326. remotePubBytes := barSecConn.RemotePubKey()
  327. if !remotePubBytes.Equals(fooPubKey) {
  328. err = fmt.Errorf("unexpected barSecConn.RemotePubKey. Expected %v, got %v",
  329. fooPubKey, barSecConn.RemotePubKey())
  330. tb.Error(err)
  331. return nil, true, err
  332. }
  333. return nil, false, nil
  334. },
  335. )
  336. require.Nil(tb, trs.FirstError())
  337. require.True(tb, ok, "Unexpected task abortion")
  338. return fooSecConn, barSecConn
  339. }
  340. ///////////////////////////////////////////////////////////////////////////////
  341. // Benchmarks
  342. func BenchmarkWriteSecretConnection(b *testing.B) {
  343. b.StopTimer()
  344. b.ReportAllocs()
  345. fooSecConn, barSecConn := makeSecretConnPair(b)
  346. randomMsgSizes := []int{
  347. dataMaxSize / 10,
  348. dataMaxSize / 3,
  349. dataMaxSize / 2,
  350. dataMaxSize,
  351. dataMaxSize * 3 / 2,
  352. dataMaxSize * 2,
  353. dataMaxSize * 7 / 2,
  354. }
  355. fooWriteBytes := make([][]byte, 0, len(randomMsgSizes))
  356. for _, size := range randomMsgSizes {
  357. fooWriteBytes = append(fooWriteBytes, tmrand.Bytes(size))
  358. }
  359. // Consume reads from bar's reader
  360. go func() {
  361. readBuffer := make([]byte, dataMaxSize)
  362. for {
  363. _, err := barSecConn.Read(readBuffer)
  364. if err == io.EOF {
  365. return
  366. } else if err != nil {
  367. b.Errorf("failed to read from barSecConn: %v", err)
  368. return
  369. }
  370. }
  371. }()
  372. b.StartTimer()
  373. for i := 0; i < b.N; i++ {
  374. idx := tmrand.Intn(len(fooWriteBytes))
  375. _, err := fooSecConn.Write(fooWriteBytes[idx])
  376. if err != nil {
  377. b.Errorf("failed to write to fooSecConn: %v", err)
  378. return
  379. }
  380. }
  381. b.StopTimer()
  382. if err := fooSecConn.Close(); err != nil {
  383. b.Error(err)
  384. }
  385. //barSecConn.Close() race condition
  386. }
  387. func BenchmarkReadSecretConnection(b *testing.B) {
  388. b.StopTimer()
  389. b.ReportAllocs()
  390. fooSecConn, barSecConn := makeSecretConnPair(b)
  391. randomMsgSizes := []int{
  392. dataMaxSize / 10,
  393. dataMaxSize / 3,
  394. dataMaxSize / 2,
  395. dataMaxSize,
  396. dataMaxSize * 3 / 2,
  397. dataMaxSize * 2,
  398. dataMaxSize * 7 / 2,
  399. }
  400. fooWriteBytes := make([][]byte, 0, len(randomMsgSizes))
  401. for _, size := range randomMsgSizes {
  402. fooWriteBytes = append(fooWriteBytes, tmrand.Bytes(size))
  403. }
  404. go func() {
  405. for i := 0; i < b.N; i++ {
  406. idx := tmrand.Intn(len(fooWriteBytes))
  407. _, err := fooSecConn.Write(fooWriteBytes[idx])
  408. if err != nil {
  409. b.Errorf("failed to write to fooSecConn: %v, %v,%v", err, i, b.N)
  410. return
  411. }
  412. }
  413. }()
  414. b.StartTimer()
  415. for i := 0; i < b.N; i++ {
  416. readBuffer := make([]byte, dataMaxSize)
  417. _, err := barSecConn.Read(readBuffer)
  418. if err == io.EOF {
  419. return
  420. } else if err != nil {
  421. b.Fatalf("Failed to read from barSecConn: %v", err)
  422. }
  423. }
  424. b.StopTimer()
  425. }