func TestHashChunk(t *testing.T) {
tmpfileIO, err := ioutil.TempFile("", "hash_test.bin")
if err != nil {
t.Fatal(err)
}
tmpfileIO.Close()
tmpfile := tmpfileIO.Name()
defer os.Remove(tmpfile)
str := make([]byte, 1234)
err = ioutil.WriteFile(tmpfile, str, 0777)
if err != nil {
t.Fatal("Couldn't write file")
}
for _, i := range []int{16, 128, 1024} {
log.Lvl3("Reading", i, "bytes")
hash, err := crypto.HashFileChunk(ed25519.NewAES128SHA256Ed25519(false).Hash(),
tmpfile, i)
if err != nil {
t.Fatal("Couldn't hash", tmpfile, err)
}
if len(hash) != 32 {
t.Fatal("Length of sha256 should be 32")
}
}
}
// All Returns a map of all suites
func All() Suites {
s := make(Suites)
s.add(nist.NewAES128SHA256P256())
s.add(nist.NewAES128SHA256QR512())
s.add(ed25519.NewAES128SHA256Ed25519(false))
s.add(edwards.NewAES128SHA256Ed25519(false))
return s
}
func TestSchnorrSignature(t *testing.T) {
msg := []byte("Hello Schnorr")
suite := ed25519.NewAES128SHA256Ed25519(false)
kp := config.NewKeyPair(suite)
s, err := SignSchnorr(suite, kp.Secret, msg)
if err != nil {
t.Fatalf("Couldn't sign msg: %s: %v", msg, err)
}
err = VerifySchnorr(suite, kp.Public, msg, s)
if err != nil {
t.Fatalf("Couldn't verify signature: \n%+v\nfor msg:'%s'. Error:\n%v", s, msg, err)
}
}
package crypto_test
import (
"bytes"
"crypto/rand"
"io/ioutil"
"testing"
"os"
"github.com/dedis/cothority/crypto"
"github.com/dedis/cothority/log"
"github.com/dedis/crypto/ed25519"
)
var hashSuite = ed25519.NewAES128SHA256Ed25519(false)
func TestHash(t *testing.T) {
buf := make([]byte, 245)
hashed, err := crypto.Hash(hashSuite.Hash(), buf)
if err != nil {
t.Fatal("Error hashing" + err.Error())
}
hasher := hashSuite.Hash()
hasher.Write(buf)
b := hasher.Sum(nil)
if !bytes.Equal(b, hashed) {
t.Fatal("Hashes are not equals")
}
}
package cosi
import (
"fmt"
"testing"
xEd25519 "github.com/bford/golang-x-crypto/ed25519"
"github.com/bford/golang-x-crypto/ed25519/cosi"
"github.com/dedis/crypto/abstract"
"github.com/dedis/crypto/config"
"github.com/dedis/crypto/ed25519"
"github.com/stretchr/testify/assert"
)
var testSuite = ed25519.NewAES128SHA256Ed25519(false)
// TestCosiCommitment test if the commitment generation is correct
func TestCosiCommitment(t *testing.T) {
var length = 5
cosis := genCosis(length)
// gen commitments from children
commitments := genCommitments(cosis[1:])
root := cosis[0]
root.Commit(nil, commitments)
// compute the aggregate commitment ourself...
aggCommit := testSuite.Point().Null()
// add commitment of children
for _, com := range commitments {
aggCommit = aggCommit.Add(aggCommit, com)
}
// add commitment of root
package eddsa
import (
"crypto/cipher"
"crypto/sha512"
"errors"
"fmt"
"github.com/dedis/crypto/abstract"
"github.com/dedis/crypto/ed25519"
"github.com/dedis/crypto/random"
)
var suite = ed25519.NewAES128SHA256Ed25519(false)
// EdDSA implements the EdDSA signature algorithm according to
// the RFC https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-02
type EdDSA struct {
seed []byte
prefix []byte
// Secret being already hashed + bit tweaked
Secret abstract.Scalar
// Public is the corresponding public key
Public abstract.Point
}
// NewEdDSAKey will return a freshly generated key pair to use for generating
// EdDSA signatures.
// If stream == nil, it will take the random.Stream.
func NewEdDSA(stream cipher.Stream) *EdDSA {
if stream == nil {