diff --git a/internal/age/age_test.go b/internal/age/age_test.go
index 7149faf..7775f26 100644
--- a/internal/age/age_test.go
+++ b/internal/age/age_test.go
@@ -8,7 +8,6 @@ package age_test
 
 import (
 	"bytes"
-	"crypto/rand"
 	"encoding/hex"
 	"fmt"
 	"io"
@@ -17,7 +16,6 @@ import (
 	"testing"
 
 	"filippo.io/age/internal/age"
-	"golang.org/x/crypto/curve25519"
 )
 
 func ExampleEncrypt() {
@@ -95,27 +93,16 @@ func ExampleGenerateX25519Identity() {
 const helloWorld = "Hello, Twitch!"
 
 func TestEncryptDecryptX25519(t *testing.T) {
-	secretKeyA := make([]byte, curve25519.ScalarSize)
-	secretKeyB := make([]byte, curve25519.ScalarSize)
-	if _, err := rand.Read(secretKeyA); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := rand.Read(secretKeyB); err != nil {
-		t.Fatal(err)
-	}
-	publicKeyA, _ := curve25519.X25519(secretKeyA, curve25519.Basepoint)
-	publicKeyB, _ := curve25519.X25519(secretKeyB, curve25519.Basepoint)
-
-	rA, err := age.NewX25519Recipient(publicKeyA)
+	a, err := age.GenerateX25519Identity()
 	if err != nil {
 		t.Fatal(err)
 	}
-	rB, err := age.NewX25519Recipient(publicKeyB)
+	b, err := age.GenerateX25519Identity()
 	if err != nil {
 		t.Fatal(err)
 	}
 	buf := &bytes.Buffer{}
-	w, err := age.Encrypt(buf, rA, rB)
+	w, err := age.Encrypt(buf, a.Recipient(), b.Recipient())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -126,11 +113,7 @@ func TestEncryptDecryptX25519(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	i, err := age.NewX25519Identity(secretKeyB)
-	if err != nil {
-		t.Fatal(err)
-	}
-	out, err := age.Decrypt(buf, i)
+	out, err := age.Decrypt(buf, b)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/internal/age/recipients_test.go b/internal/age/recipients_test.go
index f109582..fd80b94 100644
--- a/internal/age/recipients_test.go
+++ b/internal/age/recipients_test.go
@@ -13,24 +13,14 @@ import (
 
 	"filippo.io/age/internal/age"
 	"filippo.io/age/internal/format"
-	"golang.org/x/crypto/curve25519"
 )
 
 func TestX25519RoundTrip(t *testing.T) {
-	secretKey := make([]byte, curve25519.ScalarSize)
-	if _, err := rand.Read(secretKey); err != nil {
-		t.Fatal(err)
-	}
-	publicKey, _ := curve25519.X25519(secretKey, curve25519.Basepoint)
-
-	r, err := age.NewX25519Recipient(publicKey)
-	if err != nil {
-		t.Fatal(err)
-	}
-	i, err := age.NewX25519Identity(secretKey)
+	i, err := age.GenerateX25519Identity()
 	if err != nil {
 		t.Fatal(err)
 	}
+	r := i.Recipient()
 
 	if r.Type() != i.Type() || r.Type() != "X25519" {
 		t.Errorf("invalid Type values: %v, %v", r.Type(), i.Type())
diff --git a/internal/age/x25519.go b/internal/age/x25519.go
index 2907595..705ac6d 100644
--- a/internal/age/x25519.go
+++ b/internal/age/x25519.go
@@ -32,8 +32,8 @@ var _ Recipient = &X25519Recipient{}
 
 func (*X25519Recipient) Type() string { return "X25519" }
 
-// NewX25519Recipient returns a new X25519Recipient from a raw Curve25519 point.
-func NewX25519Recipient(publicKey []byte) (*X25519Recipient, error) {
+// newX25519RecipientFromPoint returns a new X25519Recipient from a raw Curve25519 point.
+func newX25519RecipientFromPoint(publicKey []byte) (*X25519Recipient, error) {
 	if len(publicKey) != curve25519.PointSize {
 		return nil, errors.New("invalid X25519 public key")
 	}
@@ -54,7 +54,7 @@ func ParseX25519Recipient(s string) (*X25519Recipient, error) {
 	if t != "age" {
 		return nil, fmt.Errorf("malformed recipient %q: invalid type %q", s, t)
 	}
-	r, err := NewX25519Recipient(k)
+	r, err := newX25519RecipientFromPoint(k)
 	if err != nil {
 		return nil, fmt.Errorf("malformed recipient %q: %v", s, err)
 	}
@@ -114,8 +114,8 @@ var _ Identity = &X25519Identity{}
 
 func (*X25519Identity) Type() string { return "X25519" }
 
-// NewX25519Identity returns a new X25519Identity from a raw Curve25519 scalar.
-func NewX25519Identity(secretKey []byte) (*X25519Identity, error) {
+// newX25519IdentityFromScalar returns a new X25519Identity from a raw Curve25519 scalar.
+func newX25519IdentityFromScalar(secretKey []byte) (*X25519Identity, error) {
 	if len(secretKey) != curve25519.ScalarSize {
 		return nil, errors.New("invalid X25519 secret key")
 	}
@@ -127,13 +127,13 @@ func NewX25519Identity(secretKey []byte) (*X25519Identity, error) {
 	return i, nil
 }
 
-// GenerateX25519Identity generates a fresh X25519Identity.
+// GenerateX25519Identity randomly generates a new X25519Identity.
 func GenerateX25519Identity() (*X25519Identity, error) {
 	secretKey := make([]byte, curve25519.ScalarSize)
 	if _, err := rand.Read(secretKey); err != nil {
 		return nil, fmt.Errorf("internal error: %v", err)
 	}
-	return NewX25519Identity(secretKey)
+	return newX25519IdentityFromScalar(secretKey)
 }
 
 // ParseX25519Identity returns a new X25519Recipient from a Bech32 private key
@@ -146,7 +146,7 @@ func ParseX25519Identity(s string) (*X25519Identity, error) {
 	if t != "AGE-SECRET-KEY-" {
 		return nil, fmt.Errorf("malformed secret key %q: invalid type %q", s, t)
 	}
-	r, err := NewX25519Identity(k)
+	r, err := newX25519IdentityFromScalar(k)
 	if err != nil {
 		return nil, fmt.Errorf("malformed secret key %q: %v", s, err)
 	}