github.com/sberex/go-sberex@v1.8.2-0.20181113200658-ed96ac38f7d7/whisper/whisperv5/benchmarks_test.go (about) 1 // This file is part of the go-sberex library. The go-sberex library is 2 // free software: you can redistribute it and/or modify it under the terms 3 // of the GNU Lesser General Public License as published by the Free 4 // Software Foundation, either version 3 of the License, or (at your option) 5 // any later version. 6 // 7 // The go-sberex library is distributed in the hope that it will be useful, 8 // but WITHOUT ANY WARRANTY; without even the implied warranty of 9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser 10 // General Public License <http://www.gnu.org/licenses/> for more details. 11 12 package whisperv5 13 14 import ( 15 "testing" 16 17 "github.com/Sberex/go-sberex/crypto" 18 ) 19 20 func BenchmarkDeriveKeyMaterial(b *testing.B) { 21 for i := 0; i < b.N; i++ { 22 deriveKeyMaterial([]byte("test"), 0) 23 } 24 } 25 26 func BenchmarkEncryptionSym(b *testing.B) { 27 InitSingleTest() 28 29 params, err := generateMessageParams() 30 if err != nil { 31 b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 32 } 33 34 for i := 0; i < b.N; i++ { 35 msg, _ := NewSentMessage(params) 36 _, err := msg.Wrap(params) 37 if err != nil { 38 b.Errorf("failed Wrap with seed %d: %s.", seed, err) 39 b.Errorf("i = %d, len(msg.Raw) = %d, params.Payload = %d.", i, len(msg.Raw), len(params.Payload)) 40 return 41 } 42 } 43 } 44 45 func BenchmarkEncryptionAsym(b *testing.B) { 46 InitSingleTest() 47 48 params, err := generateMessageParams() 49 if err != nil { 50 b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 51 } 52 key, err := crypto.GenerateKey() 53 if err != nil { 54 b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) 55 } 56 params.KeySym = nil 57 params.Dst = &key.PublicKey 58 59 for i := 0; i < b.N; i++ { 60 msg, _ := NewSentMessage(params) 61 _, err := msg.Wrap(params) 62 if err != nil { 63 b.Fatalf("failed Wrap with seed %d: %s.", seed, err) 64 } 65 } 66 } 67 68 func BenchmarkDecryptionSymValid(b *testing.B) { 69 InitSingleTest() 70 71 params, err := generateMessageParams() 72 if err != nil { 73 b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 74 } 75 msg, _ := NewSentMessage(params) 76 env, err := msg.Wrap(params) 77 if err != nil { 78 b.Fatalf("failed Wrap with seed %d: %s.", seed, err) 79 } 80 f := Filter{KeySym: params.KeySym} 81 82 for i := 0; i < b.N; i++ { 83 msg := env.Open(&f) 84 if msg == nil { 85 b.Fatalf("failed to open with seed %d.", seed) 86 } 87 } 88 } 89 90 func BenchmarkDecryptionSymInvalid(b *testing.B) { 91 InitSingleTest() 92 93 params, err := generateMessageParams() 94 if err != nil { 95 b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 96 } 97 msg, _ := NewSentMessage(params) 98 env, err := msg.Wrap(params) 99 if err != nil { 100 b.Fatalf("failed Wrap with seed %d: %s.", seed, err) 101 } 102 f := Filter{KeySym: []byte("arbitrary stuff here")} 103 104 for i := 0; i < b.N; i++ { 105 msg := env.Open(&f) 106 if msg != nil { 107 b.Fatalf("opened envelope with invalid key, seed: %d.", seed) 108 } 109 } 110 } 111 112 func BenchmarkDecryptionAsymValid(b *testing.B) { 113 InitSingleTest() 114 115 params, err := generateMessageParams() 116 if err != nil { 117 b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 118 } 119 key, err := crypto.GenerateKey() 120 if err != nil { 121 b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) 122 } 123 f := Filter{KeyAsym: key} 124 params.KeySym = nil 125 params.Dst = &key.PublicKey 126 msg, _ := NewSentMessage(params) 127 env, err := msg.Wrap(params) 128 if err != nil { 129 b.Fatalf("failed Wrap with seed %d: %s.", seed, err) 130 } 131 132 for i := 0; i < b.N; i++ { 133 msg := env.Open(&f) 134 if msg == nil { 135 b.Fatalf("fail to open, seed: %d.", seed) 136 } 137 } 138 } 139 140 func BenchmarkDecryptionAsymInvalid(b *testing.B) { 141 InitSingleTest() 142 143 params, err := generateMessageParams() 144 if err != nil { 145 b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 146 } 147 key, err := crypto.GenerateKey() 148 if err != nil { 149 b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) 150 } 151 params.KeySym = nil 152 params.Dst = &key.PublicKey 153 msg, _ := NewSentMessage(params) 154 env, err := msg.Wrap(params) 155 if err != nil { 156 b.Fatalf("failed Wrap with seed %d: %s.", seed, err) 157 } 158 159 key, err = crypto.GenerateKey() 160 if err != nil { 161 b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) 162 } 163 f := Filter{KeyAsym: key} 164 165 for i := 0; i < b.N; i++ { 166 msg := env.Open(&f) 167 if msg != nil { 168 b.Fatalf("opened envelope with invalid key, seed: %d.", seed) 169 } 170 } 171 } 172 173 func increment(x []byte) { 174 for i := 0; i < len(x); i++ { 175 x[i]++ 176 if x[i] != 0 { 177 break 178 } 179 } 180 } 181 182 func BenchmarkPoW(b *testing.B) { 183 InitSingleTest() 184 185 params, err := generateMessageParams() 186 if err != nil { 187 b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 188 } 189 params.Payload = make([]byte, 32) 190 params.PoW = 10.0 191 params.TTL = 1 192 193 for i := 0; i < b.N; i++ { 194 increment(params.Payload) 195 msg, _ := NewSentMessage(params) 196 _, err := msg.Wrap(params) 197 if err != nil { 198 b.Fatalf("failed Wrap with seed %d: %s.", seed, err) 199 } 200 } 201 }