Exemple #1
0
// GenerateKey generates a key using a random number generator, returning
// the private scalar and the corresponding public key points from a
// random secret.
func GenerateKey(curve *TwistedEdwardsCurve, rand io.Reader) (priv []byte, x,
	y *big.Int, err error) {
	var pub *[PubKeyBytesLen]byte
	var privArray *[PrivKeyBytesLen]byte
	pub, privArray, err = ed25519.GenerateKey(rand)
	priv = privArray[:]

	x, y, err = curve.EncodedBytesToBigIntPoint(pub)
	if err != nil {
		return nil, nil, nil, err
	}

	return
}
Exemple #2
0
func TestCurve25519Conversion(t *testing.T) {
	public, private, _ := ed25519.GenerateKey(rand.Reader)

	var curve25519Public, curve25519Public2, curve25519Private [32]byte
	PrivateKeyToCurve25519(&curve25519Private, private)
	curve25519.ScalarBaseMult(&curve25519Public, &curve25519Private)

	if !PublicKeyToCurve25519(&curve25519Public2, public) {
		t.Fatalf("PublicKeyToCurve25519 failed")
	}

	if !bytes.Equal(curve25519Public[:], curve25519Public2[:]) {
		t.Errorf("Values didn't match: curve25519 produced %x, conversion produced %x", curve25519Public[:], curve25519Public2[:])
	}
}
Exemple #3
0
// PrivKeyFromSecret returns a private and public key for `curve' based on the
// 32-byte private key secret passed as an argument as a byte slice.
func PrivKeyFromSecret(curve *TwistedEdwardsCurve, s []byte) (*PrivateKey,
	*PublicKey) {
	if len(s) != PrivKeyBytesLen/2 {
		return nil, nil
	}

	// Instead of using rand to generate our scalar, use the scalar
	// itself as a reader.
	sReader := bytes.NewReader(s)
	_, pk, err := ed25519.GenerateKey(sReader)
	if err != nil {
		return nil, nil
	}

	return PrivKeyFromBytes(curve, pk[:])
}