flip/dcrd
1
0
Fork 0
mirror of https://github.com/FlipsideCrypto/dcrd.git synced 2026-02-06 10:56:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

dcrec: remove testify dependency.

Browse Source
This commit is contained in:
Donald Adu-Poku 2017-08-23 00:26:12 +00:00
parent c7f65938f8
commit 3b65c66d21
8 changed files with 299 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
dcrec/edwards/curve_test.go
View File

@ -5,11 +5,10 @@
package edwards
import (
"bytes"
"encoding/hex"
"math/rand"
"testing"
"github.com/stretchr/testify/assert"
)
type XRecoveryVector struct {
@ -58,22 +57,37 @@ func TestXRecovery(t *testing.T) {
x2 := curve.RecoverXBigInt(isNegative, y)
if !curve.IsOnCurve(x2, y) {
assert.Equal(t, notOnCurve, true)
if !notOnCurve {
t.Fatalf("expected %v, got %v", true, notOnCurve)
}
} else {
assert.Equal(t, notOnCurve, false)
if notOnCurve {
t.Fatalf("expected %v, got %v", false, notOnCurve)
}
b2 := BigIntPointToEncodedBytes(x2, y)
assert.Equal(t, vector.bIn, b2)
cmp := bytes.Compare(vector.bIn[:], b2[:]) == 0
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
}
yFE := EncodedBytesToFieldElement(vector.bIn)
x3 := curve.RecoverXFieldElement(isNegative, yFE)
x3BI := FieldElementToBigInt(x3)
if !curve.IsOnCurve(x3BI, y) {
assert.Equal(t, notOnCurve, true)
if !notOnCurve {
t.Fatalf("expected %v, got %v", true, notOnCurve)
}
} else {
assert.Equal(t, notOnCurve, false)
if notOnCurve {
t.Fatalf("expected %v, got %v", false, notOnCurve)
}
b3 := BigIntPointToEncodedBytes(x3BI, y)
assert.Equal(t, vector.bIn, b3)
cmp := bytes.Compare(vector.bIn[:], b3[:]) == 0
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
}
}
}
@ -125,7 +139,10 @@ func TestAdd(t *testing.T) {
pointEncAsStr := hex.EncodeToString(pointEnc[:])
// Assert our results.
pointHexStr := pointHexStrSet[pointHexStrIdx]
assert.Equal(t, pointEncAsStr, pointHexStr)
cmp := pointEncAsStr == pointHexStr
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
pointHexStrIdx++
}
}
@ -205,6 +222,9 @@ func TestScalarMult(t *testing.T) {
sBig := EncodedBytesToBigInt(vector.s) // We need big endian
xMul, yMul := curve.ScalarMult(x, y, sBig.Bytes())
finalPoint := BigIntPointToEncodedBytes(xMul, yMul)
assert.Equal(t, vector.bRes, finalPoint)
cmp := bytes.Equal(vector.bRes[:], finalPoint[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
}
}

97
dcrec/edwards/ecdsa_test.go
View File

@ -15,8 +15,6 @@ import (
"os"
"strings"
"testing"
"github.com/stretchr/testify/assert"
)
func TestGolden(t *testing.T) {
@ -82,24 +80,61 @@ func TestGolden(t *testing.T) {
pkS2 := privkeyS2.SerializeSecret()
pubkS1 := pubkeyS1.Serialize()
pubkS2 := pubkeyS2.Serialize()
assert.Equal(t, pkS1, pkS2)
assert.Equal(t, privArray, copyBytes64(pkS1))
assert.Equal(t, privArray, copyBytes64(pkS2))
assert.Equal(t, pubkS1, pubkS2)
assert.Equal(t, pubArray, copyBytes(pubkS1))
assert.Equal(t, pubArray, copyBytes(pubkS2))
cmp := bytes.Equal(pkS1[:], pkS2[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
cmp = bytes.Equal(privArray[:], copyBytes64(pkS1)[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
cmp = bytes.Equal(privArray[:], copyBytes64(pkS2)[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
cmp = bytes.Equal(pubkS1[:], pubkS2[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
cmp = bytes.Equal(pubArray[:], copyBytes(pubkS1)[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
cmp = bytes.Equal(pubArray[:], copyBytes(pubkS2)[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Deserialize pubkey and test functions.
pubkeyP, err := ParsePubKey(curve, pubKeyBytes)
pubkP := pubkeyP.Serialize()
assert.Equal(t, pubkS1, pubkP)
assert.Equal(t, pubkS2, pubkP)
assert.Equal(t, pubArray, copyBytes(pubkP))
cmp = bytes.Equal(pubkS1[:], pubkP[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
cmp = bytes.Equal(pubkS2[:], pubkP[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
cmp = bytes.Equal(pubArray[:], copyBytes(pubkP)[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Deserialize signature and test functions.
internalSig, err := ParseSignature(curve, sig)
iSigSerialized := internalSig.Serialize()
assert.Equal(t, sigArray, copyBytes64(iSigSerialized))
cmp = bytes.Equal(sigArray[:], copyBytes64(iSigSerialized)[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
sig2r, sig2s, err := Sign(curve, privkeyS2, msg)
sig2 := &Signature{sig2r, sig2s}
@ -174,21 +209,39 @@ func TestNonStandardSignatures(t *testing.T) {
pks := randPrivScalarKeyList(curve, 50)
for _, pk := range pks {
r, s, err := Sign(curve, pk, msg)
assert.NoError(t, err)
if err != nil {
t.Fatalf("unexpected error %s", err)
}
pubX, pubY := pk.Public()
pub := NewPublicKey(curve, pubX, pubY)
ok := Verify(pub, msg, r, s)
assert.True(t, ok)
if !ok {
t.Fatalf("expected %v, got %v", true, ok)
}
// Test serializing/deserializing.
privKeyDupTest, _, err := PrivKeyFromScalar(curve,
copyBytes(pk.ecPk.D.Bytes())[:])
assert.NoError(t, err)
assert.Equal(t, privKeyDupTest.GetD(), pk.GetD())
if err != nil {
t.Fatalf("unexpected error %s", err)
}
cmp := privKeyDupTest.GetD().Cmp(pk.GetD()) == 0
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
privKeyDupTest2, _, err := PrivKeyFromScalar(curve, pk.Serialize())
assert.NoError(t, err)
assert.Equal(t, privKeyDupTest2.GetD(), pk.GetD())
if err != nil {
t.Fatalf("unexpected error %s", err)
}
cmp = privKeyDupTest2.GetD().Cmp(pk.GetD()) == 0
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Screw up a random bit in the signature and
// make sure it still fails.
@ -204,7 +257,9 @@ func TestNonStandardSignatures(t *testing.T) {
continue
}
ok = Verify(pub, msg, bSig.GetR(), bSig.GetS())
assert.False(t, ok)
if ok {
t.Fatalf("expected %v, got %v", false, ok)
}
// Screw up a random bit in the pubkey and
// make sure it still fails.
@ -220,7 +275,9 @@ func TestNonStandardSignatures(t *testing.T) {
bPub, err := ParsePubKey(curve, pkBad)
if err == nil && bPub != nil {
ok = Verify(bPub, msg, r, s)
assert.False(t, ok)
if ok {
t.Fatalf("expected %v, got %v", false, ok)
}
}
}
}

47
dcrec/edwards/primitives_test.go
View File

@ -9,8 +9,6 @@ import (
"encoding/hex"
"math/rand"
"testing"
"github.com/stretchr/testify/assert"
)
type ConversionVector struct {
@ -158,31 +156,49 @@ func TestConversion(t *testing.T) {
// Test encoding to FE --> bytes.
feFB := EncodedBytesToFieldElement(vector.bIn)
feTB := FieldElementToEncodedBytes(feFB)
assert.Equal(t, vector.bIn, feTB)
cmp := bytes.Equal(vector.bIn[:], feTB[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Test encoding to big int --> FE --> bytes.
big := EncodedBytesToBigInt(vector.bIn)
fe := BigIntToFieldElement(big)
b := FieldElementToEncodedBytes(fe)
assert.Equal(t, vector.bIn, b)
cmp = bytes.Equal(vector.bIn[:], b[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Test encoding to big int --> bytes.
b = BigIntToEncodedBytes(big)
assert.Equal(t, vector.bIn, b)
cmp = bytes.Equal(vector.bIn[:], b[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Test encoding FE --> big int --> bytes.
feBig := FieldElementToBigInt(fe)
b = BigIntToEncodedBytes(feBig)
assert.Equal(t, vector.bIn, b)
cmp = bytes.Equal(vector.bIn[:], b[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Asert our results.
encodedNumStr := encodedNumToStrSet[encodedNumToStrIdx]
assert.Equal(t, encodedNumStr, big.String())
cmp = encodedNumStr == big.String()
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
encodedNumToStrIdx++
// Assert our results.
encodedBytesToStr := encodedBytesToStrSet[encodedBytesToStrIdx]
assert.Equal(t, hex.EncodeToString(vector.bIn[:]), encodedBytesToStr)
cmp = hex.EncodeToString(vector.bIn[:]) == encodedBytesToStr
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
encodedBytesToStrIdx++
}
}
@ -280,7 +296,10 @@ func TestPointConversion(t *testing.T) {
}
yB := BigIntPointToEncodedBytes(x, y)
assert.Equal(t, vector.bIn, yB)
cmp := bytes.Equal(vector.bIn[:], yB[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Assert our results.
var buffer bytes.Buffer
@ -289,12 +308,18 @@ func TestPointConversion(t *testing.T) {
buffer.WriteString(y.String())
localStr := buffer.String()
decodedPoint := decodedPointsSet[decodedPointsIdx]
assert.Equal(t, localStr, decodedPoint)
cmp = localStr == decodedPoint
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
decodedPointsIdx++
// Assert our results.
encodedPoint := encodedPointsSet[encodedPointsIdx]
assert.Equal(t, hex.EncodeToString(vector.bIn[:]), encodedPoint)
cmp = hex.EncodeToString(vector.bIn[:]) == encodedPoint
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
encodedPointsIdx++
}
}

59
dcrec/edwards/threshold_test.go
View File

@ -10,8 +10,6 @@ import (
"math/big"
"math/rand"
"testing"
"github.com/stretchr/testify/assert"
)
type signerHex struct {
@ -91,9 +89,19 @@ func TestSchnorrThreshold(t *testing.T) {
privNonce, pubNonce, err := PrivKeyFromScalar(curve,
nonce[:])
assert.NotNil(t, privNonce)
assert.NotNil(t, pubNonce)
assert.NoError(t, err)
cmp := privNonce != nil
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
cmp = pubNonce != nil
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
privNoncesToUse[j] = privNonce
pubNoncesToUse[j] = pubNonce
@ -103,20 +111,27 @@ func TestSchnorrThreshold(t *testing.T) {
// Partial signature generation.
publicNonceSum := CombinePubkeys(curve, pubNoncesToUse)
assert.NotNil(t, publicNonceSum)
cmp := publicNonceSum != nil
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
for j := range keysToUse {
r, s, err := schnorrPartialSign(curve, msg, keysToUse[j].Serialize(),
allPksSum.Serialize(), privNoncesToUse[j].Serialize(),
publicNonceSum.Serialize())
assert.NoError(t, err)
localSig := NewSignature(r, s)
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
localSig := NewSignature(r, s)
partialSignatures[j] = localSig
}
// Combine signatures.
combinedSignature, err := SchnorrCombineSigs(curve, partialSignatures)
assert.NoError(t, err)
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
// Make sure the combined signatures are the same as the
// signatures that would be generated by simply adding
@ -135,20 +150,32 @@ func TestSchnorrThreshold(t *testing.T) {
combinedPrivkey, _, err := PrivKeyFromScalar(curve,
copyBytes(combinedPrivkeysD.Bytes())[:])
assert.NoError(t, err)
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
combinedNonce, _, err := PrivKeyFromScalar(curve,
copyBytes(combinedNonceD.Bytes())[:])
assert.NoError(t, err)
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
cSigR, cSigS, err := SignFromScalar(curve, combinedPrivkey,
combinedNonce.Serialize(), msg)
sumSig := NewSignature(cSigR, cSigS)
assert.Equal(t, sumSig.Serialize(), combinedSignature.Serialize())
cmp = bytes.Equal(sumSig.Serialize(), combinedSignature.Serialize())
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
// Verify the combined signature and public keys.
ok := Verify(allPksSum, msg, combinedSignature.GetR(),
combinedSignature.GetS())
assert.NoError(t, err)
assert.Equal(t, true, ok)
if !ok {
t.Fatalf("expected %v, got %v", true, ok)
}
// Corrupt some memory and make sure it breaks something.
corruptWhat := tRand.Intn(3)
@ -217,7 +244,9 @@ func TestSchnorrThreshold(t *testing.T) {
if allPksSum != nil && combinedSignature != nil {
ok = Verify(allPksSum, msg, combinedSignature.GetR(),
combinedSignature.GetS())
assert.Equal(t, false, ok)
if ok {
t.Fatalf("expected %v, got %v", false, ok)
}
}
}
}

68
dcrec/secp256k1/schnorr/ecdsa_test.go
View File

@ -12,7 +12,6 @@ import (
"github.com/decred/dcrd/chaincfg/chainhash"
"github.com/decred/dcrd/dcrec/secp256k1"
"github.com/stretchr/testify/assert"
)
type SchorrSigningTestVectorHex struct {
@ -130,22 +129,33 @@ func TestSchnorrSigning(t *testing.T) {
sig, err :=
schnorrSign(curve, tv.msg, tv.priv, tv.nonce, nil, nil,
testSchnorrHash)
if err != nil {
t.Fatalf("unexpected error %v", err)
}
assert.NoError(t, err)
assert.Equal(t, sig.Serialize(), tv.sig)
cmp := bytes.Equal(sig.Serialize()[:], tv.sig[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Make sure they verify too while we're at it.
_, err = schnorrVerify(curve, sig.Serialize(), pubkey, tv.msg,
testSchnorrHash)
assert.NoError(t, err)
if err != nil {
t.Fatalf("unexpected error %v", err)
}
// See if we can recover the public keys OK.
var pkRecover *secp256k1.PublicKey
pkRecover, _, err = schnorrRecover(curve, sig.Serialize(), tv.msg,
testSchnorrHash)
assert.NoError(t, err)
if err == nil {
assert.Equal(t, pubkey.Serialize(), pkRecover.Serialize())
if err != nil {
t.Fatalf("unexpected error %v", err)
}
cmp = bytes.Equal(pubkey.Serialize()[:], pkRecover.Serialize()[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Screw up the signature at a random bit and make sure that breaks it.
@ -155,16 +165,23 @@ func TestSchnorrSigning(t *testing.T) {
sigBad[pos] ^= 1 << uint8(bitPos)
_, err = schnorrVerify(curve, sigBad, pubkey, tv.msg,
testSchnorrHash)
assert.Error(t, err)
if err == nil {
t.Fatalf("expected an error, got %v", err)
}
// Make sure it breaks pubkey recovery too.
valid := false
pkRecover, valid, err = schnorrRecover(curve, sigBad, tv.msg,
testSchnorrHash)
if valid {
assert.NotEqual(t, pubkey.Serialize(), pkRecover.Serialize())
cmp = bytes.Equal(pubkey.Serialize()[:], pkRecover.Serialize()[:])
if cmp {
t.Fatalf("expected %v, got %v", false, cmp)
}
} else {
assert.Error(t, err)
if err == nil {
t.Fatalf("expected an error, got %v", err)
}
}
}
}
@ -279,18 +296,26 @@ func TestSignaturesAndRecovery(t *testing.T) {
// Make sure we can verify the original signature.
_, err := schnorrVerify(curve, sig.Serialize(), pubkey, tv.msg,
chainhash.HashB)
assert.NoError(t, err)
if err != nil {
t.Fatalf("expected an error, got %v", err)
}
ok := Verify(curve, pubkey, tv.msg, sig.R, sig.S)
assert.Equal(t, true, ok)
if !ok {
t.Fatalf("expected %v, got %v", true, ok)
}
// See if we can recover the public keys OK.
var pkRecover *secp256k1.PublicKey
pkRecover, _, err = schnorrRecover(curve, sig.Serialize(), tv.msg,
chainhash.HashB)
assert.NoError(t, err)
if err == nil {
assert.Equal(t, pubkey.Serialize(), pkRecover.Serialize())
if err != nil {
t.Fatalf("unexpected error %s", err)
}
cmp := bytes.Equal(pubkey.Serialize()[:], pkRecover.Serialize()[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Screw up the signature at some random bits and make sure
@ -305,16 +330,23 @@ func TestSignaturesAndRecovery(t *testing.T) {
}
_, err = schnorrVerify(curve, sigBad, pubkey, tv.msg,
chainhash.HashB)
assert.Error(t, err)
if err == nil {
t.Fatalf("expected an error, got %v", err)
}
// Make sure it breaks pubkey recovery too.
valid := false
pkRecover, valid, err = schnorrRecover(curve, sigBad, tv.msg,
testSchnorrHash)
if valid {
assert.NotEqual(t, pubkey.Serialize(), pkRecover.Serialize())
cmp := bytes.Equal(pubkey.Serialize()[:], pkRecover.Serialize()[:])
if cmp {
t.Fatalf("expected %v, got %v", false, cmp)
}
} else {
assert.Error(t, err)
if err == nil {
t.Fatalf("expected an error, got %v", err)
}
}
}
}

71
dcrec/secp256k1/schnorr/threshold_test.go
View File

@ -13,7 +13,6 @@ import (
"github.com/decred/dcrd/chaincfg/chainhash"
"github.com/decred/dcrd/dcrec/secp256k1"
"github.com/stretchr/testify/assert"
)
type signerHex struct {
@ -224,13 +223,22 @@ func TestSchnorrThresholdRef(t *testing.T) {
for i, signer := range tv.signers {
nonce := nonceRFC6979(signer.privkey, tv.msg, nil,
Sha256VersionStringRFC6979)
assert.Equal(t, nonce, signer.privateNonce)
cmp := bytes.Equal(nonce[:], signer.privateNonce[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
_, pubkey := secp256k1.PrivKeyFromBytes(curve, signer.privkey)
assert.Equal(t, pubkey.Serialize(), signer.pubkey.Serialize())
cmp = bytes.Equal(pubkey.Serialize()[:], signer.pubkey.Serialize()[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
_, pubNonce := secp256k1.PrivKeyFromBytes(curve, nonce)
assert.Equal(t, pubNonce.Serialize(), signer.publicNonce.Serialize())
cmp = bytes.Equal(pubNonce.Serialize()[:], signer.publicNonce.Serialize()[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Calculate the public nonce sum.
pubKeys := make([]*secp256k1.PublicKey, len(tv.signers)-1,
@ -246,20 +254,35 @@ func TestSchnorrThresholdRef(t *testing.T) {
itr++
}
publicNonceSum := CombinePubkeys(curve, pubKeys)
assert.Equal(t, publicNonceSum, signer.pubKeySumLocal)
cmp = bytes.Equal(publicNonceSum.Serialize()[:], signer.pubKeySumLocal.Serialize()[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
sig, err := schnorrPartialSign(curve, tv.msg, signer.privkey, nonce,
publicNonceSum, testSchnorrSha256Hash)
assert.NoError(t, err)
assert.Equal(t, sig.Serialize(), signer.partialSignature)
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
cmp = bytes.Equal(sig.Serialize()[:], signer.partialSignature[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
partialSignatures[i] = sig
}
// Combine signatures.
combinedSignature, err := CombineSigs(curve, partialSignatures)
assert.NoError(t, err)
assert.Equal(t, combinedSignature.Serialize(), tv.combinedSignature)
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
cmp := bytes.Equal(combinedSignature.Serialize()[:], tv.combinedSignature[:])
if !cmp {
t.Fatalf("expected %v, got %v", true, cmp)
}
// Combine pubkeys.
allPubkeys := make([]*secp256k1.PublicKey, len(tv.signers),
@ -272,8 +295,13 @@ func TestSchnorrThresholdRef(t *testing.T) {
// Verify the combined signature and public keys.
ok, err := schnorrVerify(curve, combinedSignature.Serialize(),
allPksSum, tv.msg, testSchnorrSha256Hash)
assert.NoError(t, err)
assert.Equal(t, true, ok)
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
if !ok {
t.Fatalf("expected %v, got %v", true, ok)
}
}
}
@ -335,14 +363,18 @@ func TestSchnorrThreshold(t *testing.T) {
sig, err := schnorrPartialSign(curve, msg, keysToUse[j].Serialize(),
privNoncesToUse[j].Serialize(), publicNonceSum,
chainhash.HashB)
assert.NoError(t, err)
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
partialSignatures[j] = sig
}
// Combine signatures.
combinedSignature, err := CombineSigs(curve, partialSignatures)
assert.NoError(t, err)
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
// Combine pubkeys.
allPubkeys := make([]*secp256k1.PublicKey, numKeysForTest)
@ -353,8 +385,13 @@ func TestSchnorrThreshold(t *testing.T) {
// Verify the combined signature and public keys.
ok, err := schnorrVerify(curve, combinedSignature.Serialize(),
allPksSum, msg, chainhash.HashB)
assert.NoError(t, err)
assert.Equal(t, true, ok)
if err != nil {
t.Fatalf("unexpected error %s, ", err)
}
if !ok {
t.Fatalf("expected %v, got %v", true, ok)
}
// Corrupt some memory and make sure it breaks something.
corruptWhat := tRand.Intn(3)
@ -427,7 +464,9 @@ func TestSchnorrThreshold(t *testing.T) {
if allPksSum != nil && combinedSignature != nil {
ok, _ = schnorrVerify(curve, combinedSignature.Serialize(),
allPksSum, msg, chainhash.HashB)
assert.Equal(t, false, ok)
if ok {
t.Fatalf("expected %v, got %v", false, ok)
}
}
}
}

19
glide.lock generated
View File

@ -1,5 +1,5 @@
hash: 08687d42743fa8e53a336734ae67bd4801a606ced8c7c2dd774404f32391eca6
updated: 2017-08-29T16:54:41.153871329-04:00
updated: 2017-08-30T22:08:08.795369694Z
imports:
- name: github.com/agl/ed25519
version: 278e1ec8e8a6e017cd07577924d6766039146ced
@ -51,7 +51,7 @@ imports:
- name: github.com/decred/dcrrpcclient
version: abc326aeb97b299c7eb6b13b81353fc375e9b95d
- name: github.com/decred/dcrutil
version: 166211f0196be1d3be344ae64149e7c4f5ca36b0
version: 4ce0f41cf3f957fcdf3f0de049602ac834449b9c
subpackages:
- base58
- bloom
@ -61,21 +61,12 @@ imports:
subpackages:
- rotator
- name: golang.org/x/crypto
version: 81e90905daefcd6fd217b62423c0908922eadb30
version: 6914964337150723782436d56b3f21610a74ce7b
subpackages:
- ripemd160
- ssh/terminal
- name: golang.org/x/sys
version: ab9e364efd8b52800ff7ee48a9ffba4e0ed78dfb
version: 90796e5a05ce440b41c768bd9af257005e470461
subpackages:
- unix
- windows
testImports:
- name: github.com/pmezard/go-difflib
version: d8ed2627bdf02c080bf22230dbb337003b7aba2d
subpackages:
- difflib
- name: github.com/stretchr/testify
version: 69483b4bd14f5845b5a1e55bca19e954e827f1d0
subpackages:
- assert
testImports: []

6
glide.yaml
View File

@ -41,8 +41,6 @@ import:
subpackages:
- ripemd160
- ssh/terminal
testImport:
- package: github.com/stretchr/testify
version: ^1.1.0
- package: github.com/jrick/logrotate
subpackages:
- assert
- rotator