完善不同加密方法的使用

2026-09-30 15:49:12 +08:00
parent 034315ddbd
commit 7db722f8b9
69 changed files with 21362 additions and 2563 deletions
@@ -0,0 +1,380 @@
+// Package ecdsax 基于标准库 crypto/ecdsa 提供 ECDSA 数字签名的密钥生成、
+// PEM 编解码、签名与验签能力，支持 NIST P-256 / P-384 / P-521 三条曲线。
+//
+// 摘要算法按曲线自动选择，调用方无需（也不允许）自行指定：
+//
+//	P-256 -> SHA-256
+//	P-384 -> SHA-384
+//	P-521 -> SHA-512
+//
+// 安全说明：
+//   - 仅接受标准库的三条 NIST 曲线单例（elliptic.P256/P384/P521），
+//     P-224 已不再安全、自定义曲线可能实现错误或被替换，一律拒绝。
+//   - Sign 内部使用 crypto/ecdsa 的加固实现：每个签名都消耗系统安全随机源
+//     生成 nonce，调用方不提供也不能复用 nonce，从而避免 nonce 重复导致
+//     私钥泄露（这是 ECDSA 最经典的事故来源）。
+//   - Verify 使用标准库实现，签名校验过程为常量时间语义，不会因签名的部分
+//     字节正确而提前返回。
+//   - 私钥（*ecdsa.PrivateKey）泄露等同于身份被完全冒充；本包不会把私钥、
+//     明文或随机数写入错误信息或标准输出，也不提供自动清零，调用方用完应
+//     自行零覆盖 priv.D 等敏感值。
+//   - 本包只做签名/验签，不提供加密与密钥协商；如需加密请使用 AES-GCM 或
+//     RSA-OAEP 等方案。
+//   - ECDSA 的兼容性好，但签名非确定且有参数（曲线、哈希）；新系统若没有
+//     互操作要求，签名场景优先考虑 Ed25519（见包 ed25519x）。
+package ecdsax
+
+import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/sha256"
+	"crypto/sha512"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"hash"
+	"os"
+)
+
+// PEM 块类型标签：PKCS#8 私钥、SEC1 私钥（兼容 OpenSSL ecparam 产物）、PKIX 公钥。
+const (
+	pemTypePrivateKeyPKCS8 = "PRIVATE KEY"
+	pemTypePrivateKeySEC1  = "EC PRIVATE KEY"
+	pemTypePublicKey       = "PUBLIC KEY"
+	pemTypePublicKeySEC1   = "EC PUBLIC KEY"
+)
+
+// 文件权限：私钥仅所有者可读写，公钥可被其他用户读取。
+const (
+	privateFileMode os.FileMode = 0o600
+	publicFileMode  os.FileMode = 0o644
+)
+
+// hashForCurve 返回曲线对应的摘要构造函数，同时完成曲线白名单校验。
+//
+// 用接口值相等（而非曲线名字符串）判断，只接受标准库的曲线单例：名字相同
+// 的自定义曲线可能伪装成 P-256 却使用可预测的运算，必须拒绝。
+func hashForCurve(curve elliptic.Curve) (func() hash.Hash, error) {
+	switch curve {
+	case elliptic.P256():
+		return sha256.New, nil
+	case elliptic.P384():
+		return sha512.New384, nil
+	case elliptic.P521():
+		return sha512.New, nil
+	default:
+		return nil, fmt.Errorf("不支持的椭圆曲线 %s: 仅支持 P-256、P-384、P-521", curveName(curve))
+	}
+}
+
+// curveName 安全地取出曲线名，用于错误信息；任何情况下都不会因 nil 而 panic。
+func curveName(curve elliptic.Curve) string {
+	if curve == nil {
+		return "<nil>"
+	}
+	if params := curve.Params(); params != nil {
+		return params.Name
+	}
+	return fmt.Sprintf("%T", curve)
+}
+
+// validatePrivateKey 校验私钥并返回其摘要构造函数。
+//
+// nil、曲线不受支持、坐标或私钥标量缺失、点不在曲线上等情形都返回错误；
+// 校验放在签名之前，可避免底层实现遇到畸形密钥时 panic 或产生有泄漏风险的运算。
+func validatePrivateKey(priv *ecdsa.PrivateKey) (func() hash.Hash, error) {
+	if priv == nil {
+		return nil, errors.New("ECDSA 私钥为 nil")
+	}
+	newHash, err := hashForCurve(priv.Curve)
+	if err != nil {
+		return nil, err
+	}
+	if priv.D == nil {
+		return nil, errors.New("非法的 ECDSA 私钥: 缺少私钥标量 D")
+	}
+	if priv.X == nil || priv.Y == nil {
+		return nil, errors.New("非法的 ECDSA 私钥: 缺少公钥坐标 X/Y")
+	}
+	if _, err := priv.ECDH(); err != nil {
+		return nil, fmt.Errorf("非法的 ECDSA 私钥: %w", err)
+	}
+	return newHash, nil
+}
+
+// validatePublicKey 校验公钥并返回其摘要构造函数。
+//
+// nil、曲线不受支持、坐标缺失、点不在曲线上或为无穷远点等情形都返回错误；
+// 校验放在验签之前，可避免底层实现对畸形公钥 panic。
+func validatePublicKey(pub *ecdsa.PublicKey) (func() hash.Hash, error) {
+	if pub == nil {
+		return nil, errors.New("ECDSA 公钥为 nil")
+	}
+	newHash, err := hashForCurve(pub.Curve)
+	if err != nil {
+		return nil, err
+	}
+	if pub.X == nil || pub.Y == nil {
+		return nil, errors.New("非法的 ECDSA 公钥: 缺少坐标 X/Y")
+	}
+	if _, err := pub.ECDH(); err != nil {
+		return nil, fmt.Errorf("非法的 ECDSA 公钥: %w", err)
+	}
+	return newHash, nil
+}
+
+// GenerateKey 生成一条指定曲线的 ECDSA 私钥。
+//
+// curve 只能是 elliptic.P256()、elliptic.P384() 或 elliptic.P521()；传入 nil、
+// P-224 或自定义曲线返回错误（P-224 的安全强度已不足，且标准库在部分模式下
+// 已不再支持）。私钥包含公钥，请按私钥级别保护返回值。
+func GenerateKey(curve elliptic.Curve) (*ecdsa.PrivateKey, error) {
+	if _, err := hashForCurve(curve); err != nil {
+		return nil, err
+	}
+	priv, err := ecdsa.GenerateKey(curve, rand.Reader)
+	if err != nil {
+		return nil, fmt.Errorf("生成 ECDSA 私钥失败: %w", err)
+	}
+	return priv, nil
+}
+
+// GenerateKeyPEM 生成一条指定曲线的 ECDSA 密钥对并以 PEM 文本返回。
+//
+// privatePEM 为 PKCS#8 编码（"PRIVATE KEY"），publicPEM 为 PKIX 编码
+// （"PUBLIC KEY"）。privatePEM 是明文私钥，落盘时务必使用严格权限。
+func GenerateKeyPEM(curve elliptic.Curve) (privatePEM, publicPEM []byte, err error) {
+	priv, err := GenerateKey(curve)
+	if err != nil {
+		return nil, nil, err
+	}
+	privatePEM, err = MarshalPrivateKeyPEM(priv)
+	if err != nil {
+		return nil, nil, err
+	}
+	publicPEM, err = MarshalPublicKeyPEM(&priv.PublicKey)
+	if err != nil {
+		return nil, nil, err
+	}
+	return privatePEM, publicPEM, nil
+}
+
+// MarshalPrivateKeyPEM 把 ECDSA 私钥编码为 PKCS#8 的 PEM 文本。
+//
+// priv 为 nil、曲线不受支持或密钥字段不完整时返回错误，不会 panic。
+// 返回值是未加密的明文私钥，请按私钥要求保护。
+func MarshalPrivateKeyPEM(priv *ecdsa.PrivateKey) ([]byte, error) {
+	if _, err := validatePrivateKey(priv); err != nil {
+		return nil, err
+	}
+	der, err := x509.MarshalPKCS8PrivateKey(priv)
+	if err != nil {
+		return nil, fmt.Errorf("PKCS#8 编码 ECDSA 私钥失败: %w", err)
+	}
+	return pem.EncodeToMemory(&pem.Block{Type: pemTypePrivateKeyPKCS8, Bytes: der}), nil
+}
+
+// MarshalPublicKeyPEM 把 ECDSA 公钥编码为 PKIX 的 PEM 文本。
+//
+// pub 为 nil、曲线不受支持或坐标非法时返回错误，不会 panic。
+func MarshalPublicKeyPEM(pub *ecdsa.PublicKey) ([]byte, error) {
+	if _, err := validatePublicKey(pub); err != nil {
+		return nil, err
+	}
+	der, err := x509.MarshalPKIXPublicKey(pub)
+	if err != nil {
+		return nil, fmt.Errorf("PKIX 编码 ECDSA 公钥失败: %w", err)
+	}
+	return pem.EncodeToMemory(&pem.Block{Type: pemTypePublicKey, Bytes: der}), nil
+}
+
+// ParsePrivateKeyPEM 解析 ECDSA 私钥 PEM。
+//
+// 接受 PKCS#8（"PRIVATE KEY"）与 SEC1（"EC PRIVATE KEY"，OpenSSL 传统格式）
+// 两种块类型；块缺失、DER 非法、内容是别的算法，或曲线为 P-224/自定义曲线时
+// 均返回错误。错误文本只包含类型、块类型与曲线名，不含任何私钥材料。
+func ParsePrivateKeyPEM(data []byte) (*ecdsa.PrivateKey, error) {
+	block, _ := pem.Decode(data)
+	if block == nil {
+		return nil, errors.New("解析 ECDSA 私钥 PEM 失败: 数据不是合法的 PEM")
+	}
+
+	var (
+		priv *ecdsa.PrivateKey
+		err  error
+	)
+	switch block.Type {
+	case pemTypePrivateKeyPKCS8:
+		var key any
+		key, err = x509.ParsePKCS8PrivateKey(block.Bytes)
+		if err != nil {
+			return nil, fmt.Errorf("解析 PKCS#8 私钥失败: %w", err)
+		}
+		parsed, ok := key.(*ecdsa.PrivateKey)
+		if !ok {
+			return nil, fmt.Errorf("PEM 中的私钥类型为 %T, 不是 ECDSA 私钥", key)
+		}
+		priv = parsed
+	case pemTypePrivateKeySEC1:
+		priv, err = x509.ParseECPrivateKey(block.Bytes)
+		if err != nil {
+			return nil, fmt.Errorf("解析 SEC1 EC 私钥失败: %w", err)
+		}
+	default:
+		return nil, fmt.Errorf("不支持解析 ECDSA 私钥的 PEM 块类型 %q: 期望 %q 或 %q", block.Type, pemTypePrivateKeyPKCS8, pemTypePrivateKeySEC1)
+	}
+
+	if _, err := validatePrivateKey(priv); err != nil {
+		return nil, err
+	}
+	return priv, nil
+}
+
+// ParsePublicKeyPEM 解析 PKIX 的 ECDSA 公钥 PEM。
+//
+// 只接受块类型 "PUBLIC KEY"（以及 OpenSSL 早期输出的 "EC PUBLIC KEY"，其
+// DER 仍是 PKIX），并强制校验解析结果的具体类型与曲线：传入 RSA/Ed25519 公钥、
+// 证书或截断数据都会返回错误，绝不会因非受检类型断言而 panic。
+func ParsePublicKeyPEM(data []byte) (*ecdsa.PublicKey, error) {
+	block, _ := pem.Decode(data)
+	if block == nil {
+		return nil, errors.New("解析 ECDSA 公钥 PEM 失败: 数据不是合法的 PEM")
+	}
+	if block.Type != pemTypePublicKey && block.Type != pemTypePublicKeySEC1 {
+		return nil, fmt.Errorf("不支持解析 ECDSA 公钥的 PEM 块类型 %q: 期望 %q", block.Type, pemTypePublicKey)
+	}
+
+	key, err := x509.ParsePKIXPublicKey(block.Bytes)
+	if err != nil {
+		return nil, fmt.Errorf("解析 PKIX 公钥失败: %w", err)
+	}
+	pub, ok := key.(*ecdsa.PublicKey)
+	if !ok {
+		return nil, fmt.Errorf("PEM 中的公钥类型为 %T, 不是 ECDSA 公钥", key)
+	}
+	if _, err := validatePublicKey(pub); err != nil {
+		return nil, err
+	}
+	return pub, nil
+}
+
+// LoadPrivateKey 从文件读取并解析 ECDSA 私钥。
+//
+// 文件不存在、不可读或内容非法都返回错误。请确保该路径的访问权限受控，
+// 私钥内容不会出现在任何返回值或日志里。
+func LoadPrivateKey(path string) (*ecdsa.PrivateKey, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("读取 ECDSA 私钥文件 %q 失败: %w", path, err)
+	}
+	return ParsePrivateKeyPEM(data)
+}
+
+// LoadPublicKey 从文件读取并解析 PKIX 的 ECDSA 公钥。
+func LoadPublicKey(path string) (*ecdsa.PublicKey, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("读取 ECDSA 公钥文件 %q 失败: %w", path, err)
+	}
+	return ParsePublicKeyPEM(data)
+}
+
+// SaveKeyPair 生成一条指定曲线的新 ECDSA 密钥并写入两个文件。
+//
+// privatePath 以 0600 权限写入（PKCS#8 PEM），publicPath 以 0644 权限写入
+// （PKIX PEM）；已存在的同名文件会被覆盖。若公钥写入失败，会尽力删除刚写入的
+// 私钥文件以免留下不一致的残片。注意：在 Windows 上 os.WriteFile 的权限位只
+// 影响只读属性，私钥文件的访问控制需依赖目录权限另行加固。
+func SaveKeyPair(privatePath, publicPath string, curve elliptic.Curve) error {
+	privatePEM, publicPEM, err := GenerateKeyPEM(curve)
+	if err != nil {
+		return err
+	}
+
+	if err := os.WriteFile(privatePath, privatePEM, privateFileMode); err != nil {
+		return fmt.Errorf("写入 ECDSA 私钥文件 %q 失败: %w", privatePath, err)
+	}
+	if err := os.WriteFile(publicPath, publicPEM, publicFileMode); err != nil {
+		if removeErr := os.Remove(privatePath); removeErr != nil {
+			return fmt.Errorf("写入 ECDSA 公钥文件 %q 失败: %w（回滚私钥文件 %q 也失败: %v）", publicPath, err, privatePath, removeErr)
+		}
+		return fmt.Errorf("写入 ECDSA 公钥文件 %q 失败: %w（已回滚私钥文件）", publicPath, err)
+	}
+	return nil
+}
+
+// Sign 使用 ECDSA 私钥对 message 签名，返回 ASN.1 DER 编码的签名。
+//
+// 摘要算法由曲线自动决定（P-256→SHA-256，P-384→SHA-384，P-521→SHA-512），
+// 不需要也不允许调用方预哈希。每次签名都会使用系统安全随机源生成新的 nonce，
+// 因此同一消息的两次签名不同，这是正常现象。
+//
+// priv 为 nil、曲线不受支持或密钥字段非法时返回错误，不会 panic。
+// DER 签名长度随曲线和随机值浮动（P-256 通常约 70~72 字节），
+// 存储时应留足空间，不要按固定长度截断。
+func Sign(priv *ecdsa.PrivateKey, message []byte) ([]byte, error) {
+	newHash, err := validatePrivateKey(priv)
+	if err != nil {
+		return nil, err
+	}
+	h := newHash()
+	if _, err := h.Write(message); err != nil {
+		return nil, fmt.Errorf("计算 ECDSA 摘要失败: %w", err)
+	}
+	signature, err := ecdsa.SignASN1(rand.Reader, priv, h.Sum(nil))
+	if err != nil {
+		return nil, fmt.Errorf("ECDSA 签名失败: %w", err)
+	}
+	return signature, nil
+}
+
+// Verify 校验 signature 是否为 pub 对 message 的有效 ECDSA 签名。
+//
+// signature 必须是 Sign 产生的 ASN.1 DER 编码签名；校验通过返回 nil，否则返回
+// 错误。签名为空、DER 非法或被篡改，以及消息不匹配、公钥不匹配时都返回错误；
+// pub 为 nil 或曲线不受支持时同样返回错误，不会 panic。
+//
+// 标准库的签名校验为常量时间语义，但错误信息不区分失败原因，以免向攻击者
+// 泄露可用于伪造的信息；验签失败只应表现为"拒绝"。
+func Verify(pub *ecdsa.PublicKey, message, signature []byte) error {
+	newHash, err := validatePublicKey(pub)
+	if err != nil {
+		return err
+	}
+	if len(signature) == 0 {
+		return errors.New("ECDSA 签名为空")
+	}
+	h := newHash()
+	if _, err := h.Write(message); err != nil {
+		return fmt.Errorf("计算 ECDSA 摘要失败: %w", err)
+	}
+	if !ecdsa.VerifyASN1(pub, h.Sum(nil), signature) {
+		return errors.New("ECDSA 验签失败: 签名与消息或公钥不匹配")
+	}
+	return nil
+}
+
+// SignToBase64 对 message 签名并返回标准 Base64 编码的 DER 签名文本，
+// 便于放进 JSON、HTTP 头或数据库字段。私钥非法时返回错误。
+func SignToBase64(priv *ecdsa.PrivateKey, message []byte) (string, error) {
+	signature, err := Sign(priv, message)
+	if err != nil {
+		return "", err
+	}
+	return base64.StdEncoding.EncodeToString(signature), nil
+}
+
+// VerifyFromBase64 校验标准 Base64 编码的 DER 签名。
+//
+// signatureB64 非法 Base64，或解码后验签不通过，或公钥非法时均返回错误，
+// 不会 panic。
+func VerifyFromBase64(pub *ecdsa.PublicKey, message []byte, signatureB64 string) error {
+	signature, err := base64.StdEncoding.DecodeString(signatureB64)
+	if err != nil {
+		return fmt.Errorf("Base64 解码 ECDSA 签名失败: %w", err)
+	}
+	return Verify(pub, message, signature)
+}
@@ -0,0 +1,777 @@
+package ecdsax_test
+
+import (
+	"bytes"
+	"crypto/ecdsa"
+	"crypto/ed25519"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/pem"
+	"math/big"
+	mrand "math/rand"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"code.yun.ink/pkg/encryptx/ecdsax"
+)
+
+// curveCase 描述一条受支持的曲线，便于表驱动覆盖 P-256/P-384/P-521。
+type curveCase struct {
+	name  string
+	curve elliptic.Curve
+}
+
+func supportedCurves() []curveCase {
+	return []curveCase{
+		{"P-256", elliptic.P256()},
+		{"P-384", elliptic.P384()},
+		{"P-521", elliptic.P521()},
+	}
+}
+
+// requireError 断言操作失败返回了 error（而非 panic 或静默成功）。
+func requireError(t *testing.T, name string, err error) {
+	t.Helper()
+	if err == nil {
+		t.Errorf("%s: 期望返回错误, 实际返回 nil", name)
+	}
+}
+
+// mustGenerateKey 生成指定曲线的密钥，供其余用例复用。
+func mustGenerateKey(t *testing.T, curve elliptic.Curve) *ecdsa.PrivateKey {
+	t.Helper()
+	priv, err := ecdsax.GenerateKey(curve)
+	if err != nil {
+		t.Fatalf("GenerateKey 返回错误: %v", err)
+	}
+	if priv == nil {
+		t.Fatal("GenerateKey 返回 nil 私钥且无错误")
+	}
+	if priv.Curve != curve {
+		t.Fatalf("生成的私钥曲线 = %v, 期望 %v", priv.Curve, curve)
+	}
+	if priv.D == nil || priv.X == nil || priv.Y == nil {
+		t.Fatal("生成的私钥缺少 D 或 X/Y 字段")
+	}
+	return priv
+}
+
+// TestGenerateKeyRejectsUnsupportedCurves 覆盖：nil 与 P-224 必须被拒绝。
+func TestGenerateKeyRejectsUnsupportedCurves(t *testing.T) {
+	cases := []struct {
+		name  string
+		curve elliptic.Curve
+	}{
+		{"nil 曲线", nil},
+		{"P-224 曲线", elliptic.P224()},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			priv, err := ecdsax.GenerateKey(tc.curve)
+			requireError(t, "GenerateKey("+tc.name+")", err)
+			if priv != nil {
+				t.Error("GenerateKey 失败时应返回 nil 私钥")
+			}
+
+			privatePEM, publicPEM, err := ecdsax.GenerateKeyPEM(tc.curve)
+			requireError(t, "GenerateKeyPEM("+tc.name+")", err)
+			if privatePEM != nil || publicPEM != nil {
+				t.Error("GenerateKeyPEM 失败时应返回 nil PEM")
+			}
+
+			dir := t.TempDir()
+			requireError(t, "SaveKeyPair("+tc.name+")", ecdsax.SaveKeyPair(
+				filepath.Join(dir, "priv.pem"), filepath.Join(dir, "pub.pem"), tc.curve))
+		})
+	}
+}
+
+// TestSignVerifyRoundTrip 覆盖：P-256/P-384/P-521 三条曲线均能完成签名/验签往返。
+func TestSignVerifyRoundTrip(t *testing.T) {
+	for _, tc := range supportedCurves() {
+		t.Run(tc.name, func(t *testing.T) {
+			priv := mustGenerateKey(t, tc.curve)
+			pub := &priv.PublicKey
+			message := []byte("encryptx ecdsax 往返测试消息 / " + tc.name)
+
+			signature, err := ecdsax.Sign(priv, message)
+			if err != nil {
+				t.Fatalf("Sign 返回错误: %v", err)
+			}
+			if len(signature) == 0 {
+				t.Fatal("Sign 返回空签名")
+			}
+			if err := ecdsax.Verify(pub, message, signature); err != nil {
+				t.Fatalf("Verify 应通过, 实际返回错误: %v", err)
+			}
+
+			// ECDSA 每次签名使用新的随机 nonce，两次结果都应能通过校验。
+			second, err := ecdsax.Sign(priv, message)
+			if err != nil {
+				t.Fatalf("第二次 Sign 返回错误: %v", err)
+			}
+			if err := ecdsax.Verify(pub, message, second); err != nil {
+				t.Fatalf("第二次签名的 Verify 应通过, 实际返回错误: %v", err)
+			}
+			if bytes.Equal(signature, second) {
+				t.Log("提示: 两次 ECDSA 签名完全相同, 概率极低, 请确认随机源正常")
+			}
+
+			// 空消息与较长消息同样应能往返。
+			for _, msg := range [][]byte{nil, {}, bytes.Repeat([]byte("B"), 1<<16)} {
+				sig, err := ecdsax.Sign(priv, msg)
+				if err != nil {
+					t.Fatalf("Sign(len=%d) 返回错误: %v", len(msg), err)
+				}
+				if err := ecdsax.Verify(pub, msg, sig); err != nil {
+					t.Fatalf("Verify(len=%d) 应通过, 实际返回错误: %v", len(msg), err)
+				}
+			}
+		})
+	}
+}
+
+// TestPEMRoundTrip 覆盖：GenerateKeyPEM -> 解析 -> 用公钥验签成功，且曲线保持不变。
+func TestPEMRoundTrip(t *testing.T) {
+	for _, tc := range supportedCurves() {
+		t.Run(tc.name, func(t *testing.T) {
+			privatePEM, publicPEM, err := ecdsax.GenerateKeyPEM(tc.curve)
+			if err != nil {
+				t.Fatalf("GenerateKeyPEM 返回错误: %v", err)
+			}
+
+			privateBlock, _ := pem.Decode(privatePEM)
+			if privateBlock == nil {
+				t.Fatal("私钥 PEM 无法解码")
+			}
+			if privateBlock.Type != "PRIVATE KEY" {
+				t.Errorf("私钥 PEM 块类型 = %q, 期望 %q", privateBlock.Type, "PRIVATE KEY")
+			}
+			publicBlock, _ := pem.Decode(publicPEM)
+			if publicBlock == nil {
+				t.Fatal("公钥 PEM 无法解码")
+			}
+			if publicBlock.Type != "PUBLIC KEY" {
+				t.Errorf("公钥 PEM 块类型 = %q, 期望 %q", publicBlock.Type, "PUBLIC KEY")
+			}
+
+			priv, err := ecdsax.ParsePrivateKeyPEM(privatePEM)
+			if err != nil {
+				t.Fatalf("ParsePrivateKeyPEM 返回错误: %v", err)
+			}
+			pub, err := ecdsax.ParsePublicKeyPEM(publicPEM)
+			if err != nil {
+				t.Fatalf("ParsePublicKeyPEM 返回错误: %v", err)
+			}
+			if priv.Curve != tc.curve {
+				t.Errorf("解析出的私钥曲线 = %v, 期望 %v", priv.Curve, tc.curve)
+			}
+			if pub.Curve != tc.curve {
+				t.Errorf("解析出的公钥曲线 = %v, 期望 %v", pub.Curve, tc.curve)
+			}
+			if !priv.PublicKey.Equal(pub) {
+				t.Error("私钥内嵌公钥与解析出的公钥不一致")
+			}
+
+			message := []byte("PEM 往返后验签 / " + tc.name)
+			signature, err := ecdsax.Sign(priv, message)
+			if err != nil {
+				t.Fatalf("Sign 返回错误: %v", err)
+			}
+			if err := ecdsax.Verify(pub, message, signature); err != nil {
+				t.Fatalf("Verify 应通过, 实际返回错误: %v", err)
+			}
+		})
+	}
+}
+
+// TestMarshalParsePEMRoundTrip 覆盖：Marshal -> Parse 后私钥标量与公钥坐标完全一致。
+func TestMarshalParsePEMRoundTrip(t *testing.T) {
+	for _, tc := range supportedCurves() {
+		t.Run(tc.name, func(t *testing.T) {
+			priv := mustGenerateKey(t, tc.curve)
+
+			privatePEM, err := ecdsax.MarshalPrivateKeyPEM(priv)
+			if err != nil {
+				t.Fatalf("MarshalPrivateKeyPEM 返回错误: %v", err)
+			}
+			parsedPriv, err := ecdsax.ParsePrivateKeyPEM(privatePEM)
+			if err != nil {
+				t.Fatalf("ParsePrivateKeyPEM 返回错误: %v", err)
+			}
+			if parsedPriv.D.Cmp(priv.D) != 0 {
+				t.Error("私钥 PEM 往返后 D 不一致")
+			}
+			if !parsedPriv.PublicKey.Equal(&priv.PublicKey) {
+				t.Error("私钥 PEM 往返后公钥不一致")
+			}
+
+			publicPEM, err := ecdsax.MarshalPublicKeyPEM(&priv.PublicKey)
+			if err != nil {
+				t.Fatalf("MarshalPublicKeyPEM 返回错误: %v", err)
+			}
+			parsedPub, err := ecdsax.ParsePublicKeyPEM(publicPEM)
+			if err != nil {
+				t.Fatalf("ParsePublicKeyPEM 返回错误: %v", err)
+			}
+			if !parsedPub.Equal(&priv.PublicKey) {
+				t.Error("公钥 PEM 往返后不一致")
+			}
+		})
+	}
+}
+
+// TestBase64RoundTrip 覆盖：Base64 便利函数的正常往返。
+func TestBase64RoundTrip(t *testing.T) {
+	for _, tc := range supportedCurves() {
+		t.Run(tc.name, func(t *testing.T) {
+			priv := mustGenerateKey(t, tc.curve)
+			message := []byte("Base64 签名 / " + tc.name)
+
+			encoded, err := ecdsax.SignToBase64(priv, message)
+			if err != nil {
+				t.Fatalf("SignToBase64 返回错误: %v", err)
+			}
+			if err := ecdsax.VerifyFromBase64(&priv.PublicKey, message, encoded); err != nil {
+				t.Fatalf("VerifyFromBase64 应通过, 实际返回错误: %v", err)
+			}
+			raw, err := base64.StdEncoding.DecodeString(encoded)
+			if err != nil {
+				t.Fatalf("Base64 解码失败: %v", err)
+			}
+			if len(raw) == 0 {
+				t.Fatal("Base64 解码后签名为空")
+			}
+		})
+	}
+}
+
+// TestTamperedMessageFails 覆盖：篡改消息后验签必须失败。
+func TestTamperedMessageFails(t *testing.T) {
+	for _, tc := range supportedCurves() {
+		t.Run(tc.name, func(t *testing.T) {
+			priv := mustGenerateKey(t, tc.curve)
+			pub := &priv.PublicKey
+			message := []byte("原始消息 payload")
+			signature, err := ecdsax.Sign(priv, message)
+			if err != nil {
+				t.Fatalf("Sign 返回错误: %v", err)
+			}
+
+			tampered := [][]byte{
+				[]byte("原始消息 payloa"),   // 少一个字节
+				[]byte("原始消息 payload "), // 多一个空格
+				[]byte("篡改消息 payload"),  // 同长度改写
+				bytes.Repeat([]byte{0x00}, len(message)),
+			}
+			for _, msg := range tampered {
+				if bytes.Equal(msg, message) {
+					t.Fatal("用例构造错误: 篡改消息与原始消息相同")
+				}
+				requireError(t, "篡改消息后 Verify", ecdsax.Verify(pub, msg, signature))
+				requireError(t, "篡改消息后 VerifyFromBase64",
+					ecdsax.VerifyFromBase64(pub, msg, base64.StdEncoding.EncodeToString(signature)))
+			}
+
+			// 空消息的签名不能通过非空消息的校验。
+			emptySignature, err := ecdsax.Sign(priv, nil)
+			if err != nil {
+				t.Fatalf("Sign 返回错误: %v", err)
+			}
+			requireError(t, "空消息签名用于非空消息", ecdsax.Verify(pub, message, emptySignature))
+		})
+	}
+}
+
+// TestTamperedSignatureFails 覆盖：翻转签名字节、截断、全零签名后验签必须失败。
+func TestTamperedSignatureFails(t *testing.T) {
+	for _, tc := range supportedCurves() {
+		t.Run(tc.name, func(t *testing.T) {
+			priv := mustGenerateKey(t, tc.curve)
+			pub := &priv.PublicKey
+			message := []byte("签名篡改测试")
+			signature, err := ecdsax.Sign(priv, message)
+			if err != nil {
+				t.Fatalf("Sign 返回错误: %v", err)
+			}
+
+			for _, pos := range []int{0, 1, len(signature) / 2, len(signature) - 1} {
+				flipped := append([]byte{}, signature...)
+				flipped[pos] ^= 0x01
+				if bytes.Equal(flipped, signature) {
+					t.Fatalf("位置 %d 翻转后签名未变化", pos)
+				}
+				requireError(t, "翻转签名字节后 Verify", ecdsax.Verify(pub, message, flipped))
+			}
+
+			requireError(t, "截断签名", ecdsax.Verify(pub, message, signature[:len(signature)-1]))
+			requireError(t, "全零签名", ecdsax.Verify(pub, message, make([]byte, len(signature))))
+			requireError(t, "全 0xFF 签名", ecdsax.Verify(pub, message, bytes.Repeat([]byte{0xFF}, len(signature))))
+
+			// 合法签名的 Base64 文本被破坏后必须失败。
+			encoded := []byte(base64.StdEncoding.EncodeToString(signature))
+			if encoded[0] == 'A' {
+				encoded[0] = 'B'
+			} else {
+				encoded[0] = 'A'
+			}
+			requireError(t, "Base64 破坏后 VerifyFromBase64",
+				ecdsax.VerifyFromBase64(pub, message, string(encoded)))
+		})
+	}
+}
+
+// TestWrongPublicKeyFails 覆盖：用另一对密钥的公钥验签必须失败。
+func TestWrongPublicKeyFails(t *testing.T) {
+	for _, tc := range supportedCurves() {
+		t.Run(tc.name, func(t *testing.T) {
+			privA := mustGenerateKey(t, tc.curve)
+			privB := mustGenerateKey(t, tc.curve)
+			if privA.PublicKey.Equal(&privB.PublicKey) {
+				t.Fatal("两次生成的密钥不应相同")
+			}
+
+			message := []byte("错误公钥测试 / " + tc.name)
+			signature, err := ecdsax.Sign(privA, message)
+			if err != nil {
+				t.Fatalf("Sign 返回错误: %v", err)
+			}
+			if err := ecdsax.Verify(&privA.PublicKey, message, signature); err != nil {
+				t.Fatalf("使用正确公钥应当通过, 实际返回错误: %v", err)
+			}
+			requireError(t, "使用错误公钥 Verify", ecdsax.Verify(&privB.PublicKey, message, signature))
+			requireError(t, "使用错误公钥 VerifyFromBase64",
+				ecdsax.VerifyFromBase64(&privB.PublicKey, message, base64.StdEncoding.EncodeToString(signature)))
+		})
+	}
+}
+
+// TestCrossCurveVerifyFails 覆盖：跨曲线的公钥不能验证另一条曲线产生的签名。
+func TestCrossCurveVerifyFails(t *testing.T) {
+	signer := mustGenerateKey(t, elliptic.P256())
+	message := []byte("跨曲线验签测试")
+	signature, err := ecdsax.Sign(signer, message)
+	if err != nil {
+		t.Fatalf("Sign 返回错误: %v", err)
+	}
+
+	for _, tc := range supportedCurves() {
+		if tc.curve == elliptic.P256() {
+			continue
+		}
+		t.Run(tc.name, func(t *testing.T) {
+			other := mustGenerateKey(t, tc.curve)
+			requireError(t, "跨曲线 Verify", ecdsax.Verify(&other.PublicKey, message, signature))
+		})
+	}
+}
+
+// TestSEC1PrivateKeyPEM 覆盖：兼容 OpenSSL 的 SEC1（"EC PRIVATE KEY"）私钥解析。
+func TestSEC1PrivateKeyPEM(t *testing.T) {
+	priv := mustGenerateKey(t, elliptic.P256())
+
+	der, err := x509.MarshalECPrivateKey(priv)
+	if err != nil {
+		t.Fatalf("MarshalECPrivateKey 返回错误: %v", err)
+	}
+	sec1PEM := pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: der})
+
+	parsed, err := ecdsax.ParsePrivateKeyPEM(sec1PEM)
+	if err != nil {
+		t.Fatalf("ParsePrivateKeyPEM(SEC1) 返回错误: %v", err)
+	}
+	if parsed.D.Cmp(priv.D) != 0 {
+		t.Error("SEC1 私钥往返后 D 不一致")
+	}
+
+	message := []byte("SEC1 私钥签名")
+	signature, err := ecdsax.Sign(parsed, message)
+	if err != nil {
+		t.Fatalf("Sign 返回错误: %v", err)
+	}
+	if err := ecdsax.Verify(&priv.PublicKey, message, signature); err != nil {
+		t.Fatalf("Verify 应通过, 实际返回错误: %v", err)
+	}
+}
+
+// TestInvalidPEMInputs 覆盖：空 PEM、垃圾字节、其他算法、P-224 与错误块类型都必须返回 error。
+func TestInvalidPEMInputs(t *testing.T) {
+	priv := mustGenerateKey(t, elliptic.P256())
+	validPrivatePEM, err := ecdsax.MarshalPrivateKeyPEM(priv)
+	if err != nil {
+		t.Fatalf("MarshalPrivateKeyPEM 返回错误: %v", err)
+	}
+	validPublicPEM, err := ecdsax.MarshalPublicKeyPEM(&priv.PublicKey)
+	if err != nil {
+		t.Fatalf("MarshalPublicKeyPEM 返回错误: %v", err)
+	}
+	privateBlock, _ := pem.Decode(validPrivatePEM)
+	publicBlock, _ := pem.Decode(validPublicPEM)
+	if privateBlock == nil || publicBlock == nil {
+		t.Fatal("自产 PEM 无法解码, 测试前提不成立")
+	}
+
+	// 其他算法：Ed25519 与 RSA 的 PKCS#8 私钥、PKIX 公钥。
+	edPub, edPriv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		t.Fatalf("生成 Ed25519 测试密钥失败: %v", err)
+	}
+	edPrivateDER, err := x509.MarshalPKCS8PrivateKey(edPriv)
+	if err != nil {
+		t.Fatalf("编码 Ed25519 私钥失败: %v", err)
+	}
+	edPublicDER, err := x509.MarshalPKIXPublicKey(edPub)
+	if err != nil {
+		t.Fatalf("编码 Ed25519 公钥失败: %v", err)
+	}
+	rsaKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		t.Fatalf("生成 RSA 测试密钥失败: %v", err)
+	}
+	rsaPrivateDER, err := x509.MarshalPKCS8PrivateKey(rsaKey)
+	if err != nil {
+		t.Fatalf("编码 RSA 私钥失败: %v", err)
+	}
+	rsaPublicDER, err := x509.MarshalPKIXPublicKey(&rsaKey.PublicKey)
+	if err != nil {
+		t.Fatalf("编码 RSA 公钥失败: %v", err)
+	}
+
+	// P-224 密钥：标准库仍能解析，但本包必须因曲线不受支持而拒绝。
+	p224Priv, err := ecdsa.GenerateKey(elliptic.P224(), rand.Reader)
+	if err != nil {
+		t.Fatalf("生成 P-224 测试密钥失败: %v", err)
+	}
+	p224PrivateDER, err := x509.MarshalPKCS8PrivateKey(p224Priv)
+	if err != nil {
+		t.Fatalf("编码 P-224 私钥失败: %v", err)
+	}
+	p224PublicDER, err := x509.MarshalPKIXPublicKey(&p224Priv.PublicKey)
+	if err != nil {
+		t.Fatalf("编码 P-224 公钥失败: %v", err)
+	}
+
+	cases := []struct {
+		name string
+		fn   func() error
+	}{
+		{"空 PEM 私钥(nil)", func() error { _, err := ecdsax.ParsePrivateKeyPEM(nil); return err }},
+		{"空 PEM 私钥(空切片)", func() error { _, err := ecdsax.ParsePrivateKeyPEM([]byte{}); return err }},
+		{"空 PEM 私钥(仅空白)", func() error { _, err := ecdsax.ParsePrivateKeyPEM([]byte("  \n\t")); return err }},
+		{"垃圾字节私钥", func() error { _, err := ecdsax.ParsePrivateKeyPEM([]byte("这不是 PEM 数据")); return err }},
+		{"随机字节私钥", func() error {
+			_, err := ecdsax.ParsePrivateKeyPEM(bytes.Repeat([]byte{0xCD}, 256))
+			return err
+		}},
+		{"无 PEM 头尾的裸 DER 私钥", func() error { _, err := ecdsax.ParsePrivateKeyPEM(privateBlock.Bytes); return err }},
+		{"块类型为 CERTIFICATE 的私钥", func() error {
+			_, err := ecdsax.ParsePrivateKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: privateBlock.Bytes}))
+			return err
+		}},
+		{"块内容为垃圾的 PKCS#8 私钥", func() error {
+			_, err := ecdsax.ParsePrivateKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: []byte("garbage")}))
+			return err
+		}},
+		{"块内容为垃圾的 SEC1 私钥", func() error {
+			_, err := ecdsax.ParsePrivateKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: []byte("garbage")}))
+			return err
+		}},
+		{"Ed25519 私钥 PEM", func() error {
+			_, err := ecdsax.ParsePrivateKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: edPrivateDER}))
+			return err
+		}},
+		{"RSA 私钥 PEM", func() error {
+			_, err := ecdsax.ParsePrivateKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: rsaPrivateDER}))
+			return err
+		}},
+		{"P-224 私钥 PEM", func() error {
+			_, err := ecdsax.ParsePrivateKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: p224PrivateDER}))
+			return err
+		}},
+		{"公钥 PEM 传给 ParsePrivateKeyPEM", func() error { _, err := ecdsax.ParsePrivateKeyPEM(validPublicPEM); return err }},
+		{"空 PEM 公钥(nil)", func() error { _, err := ecdsax.ParsePublicKeyPEM(nil); return err }},
+		{"垃圾字节公钥", func() error {
+			_, err := ecdsax.ParsePublicKeyPEM([]byte("-----BEGIN PUBLIC KEY-----\n不是Base64\n-----END PUBLIC KEY-----"))
+			return err
+		}},
+		{"块类型为 PRIVATE KEY 的公钥", func() error {
+			_, err := ecdsax.ParsePublicKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: publicBlock.Bytes}))
+			return err
+		}},
+		{"块内容为垃圾的 PKIX 公钥", func() error {
+			_, err := ecdsax.ParsePublicKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: []byte("garbage")}))
+			return err
+		}},
+		{"Ed25519 公钥 PEM", func() error {
+			_, err := ecdsax.ParsePublicKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: edPublicDER}))
+			return err
+		}},
+		{"RSA 公钥 PEM", func() error {
+			_, err := ecdsax.ParsePublicKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: rsaPublicDER}))
+			return err
+		}},
+		{"P-224 公钥 PEM", func() error {
+			_, err := ecdsax.ParsePublicKeyPEM(pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: p224PublicDER}))
+			return err
+		}},
+		{"私钥 PEM 传给 ParsePublicKeyPEM", func() error { _, err := ecdsax.ParsePublicKeyPEM(validPrivatePEM); return err }},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			requireError(t, tc.name, tc.fn())
+		})
+	}
+}
+
+// TestInvalidKeyAndSignatureInputs 覆盖：nil/残缺密钥、空或畸形签名、非法 Base64 都必须返回 error 且不 panic。
+func TestInvalidKeyAndSignatureInputs(t *testing.T) {
+	priv := mustGenerateKey(t, elliptic.P256())
+	message := []byte("非法输入测试")
+	validSignature, err := ecdsax.Sign(priv, message)
+	if err != nil {
+		t.Fatalf("Sign 返回错误: %v", err)
+	}
+
+	// 手工构造的残缺密钥：用于证明入口处的校验能挡住会让标准库 panic 的输入。
+	nilCurveKey := &ecdsa.PrivateKey{}
+	nilScalarKey := &ecdsa.PrivateKey{PublicKey: ecdsa.PublicKey{Curve: elliptic.P256()}}
+	missingPointKey := &ecdsa.PrivateKey{
+		PublicKey: ecdsa.PublicKey{Curve: elliptic.P256()},
+		D:         big.NewInt(1),
+	}
+	offCurveKey := &ecdsa.PrivateKey{
+		PublicKey: ecdsa.PublicKey{Curve: elliptic.P256(), X: big.NewInt(1), Y: big.NewInt(1)},
+		D:         big.NewInt(1),
+	}
+
+	nilCurvePub := &ecdsa.PublicKey{}
+	missingPointPub := &ecdsa.PublicKey{Curve: elliptic.P256()}
+	offCurvePub := &ecdsa.PublicKey{Curve: elliptic.P256(), X: big.NewInt(1), Y: big.NewInt(1)}
+	infinityPub := &ecdsa.PublicKey{Curve: elliptic.P256(), X: big.NewInt(0), Y: big.NewInt(0)}
+
+	cases := []struct {
+		name string
+		fn   func() error
+	}{
+		{"Sign 私钥为 nil", func() error { _, err := ecdsax.Sign(nil, message); return err }},
+		{"Sign 私钥曲线为 nil", func() error { _, err := ecdsax.Sign(nilCurveKey, message); return err }},
+		{"Sign 私钥缺少标量 D", func() error { _, err := ecdsax.Sign(nilScalarKey, message); return err }},
+		{"Sign 私钥缺少坐标", func() error { _, err := ecdsax.Sign(missingPointKey, message); return err }},
+		{"Sign 私钥公钥点不在曲线上", func() error { _, err := ecdsax.Sign(offCurveKey, message); return err }},
+		{"SignToBase64 私钥为 nil", func() error { _, err := ecdsax.SignToBase64(nil, message); return err }},
+		{"MarshalPrivateKeyPEM 私钥为 nil", func() error { _, err := ecdsax.MarshalPrivateKeyPEM(nil); return err }},
+		{"MarshalPrivateKeyPEM 私钥缺少标量 D", func() error { _, err := ecdsax.MarshalPrivateKeyPEM(nilScalarKey); return err }},
+		{"Verify 公钥为 nil", func() error { return ecdsax.Verify(nil, message, validSignature) }},
+		{"Verify 公钥曲线为 nil", func() error { return ecdsax.Verify(nilCurvePub, message, validSignature) }},
+		{"Verify 公钥缺少坐标", func() error { return ecdsax.Verify(missingPointPub, message, validSignature) }},
+		{"Verify 公钥点不在曲线上", func() error { return ecdsax.Verify(offCurvePub, message, validSignature) }},
+		{"Verify 公钥为无穷远点", func() error { return ecdsax.Verify(infinityPub, message, validSignature) }},
+		{"MarshalPublicKeyPEM 公钥为 nil", func() error { _, err := ecdsax.MarshalPublicKeyPEM(nil); return err }},
+		{"MarshalPublicKeyPEM 公钥缺少坐标", func() error { _, err := ecdsax.MarshalPublicKeyPEM(missingPointPub); return err }},
+		{"Verify 签名为 nil", func() error { return ecdsax.Verify(&priv.PublicKey, message, nil) }},
+		{"Verify 签名为空切片", func() error { return ecdsax.Verify(&priv.PublicKey, message, []byte{}) }},
+		{"Verify 签名被截断", func() error {
+			return ecdsax.Verify(&priv.PublicKey, message, validSignature[:len(validSignature)-1])
+		}},
+		{"Verify 签名非 DER", func() error { return ecdsax.Verify(&priv.PublicKey, message, []byte("not-a-der-signature")) }},
+		{"VerifyFromBase64 非法 Base64", func() error {
+			return ecdsax.VerifyFromBase64(&priv.PublicKey, message, "!!!not-base64!!!")
+		}},
+		{"VerifyFromBase64 空字符串", func() error { return ecdsax.VerifyFromBase64(&priv.PublicKey, message, "") }},
+		{"VerifyFromBase64 公钥为 nil", func() error {
+			return ecdsax.VerifyFromBase64(nil, message, base64.StdEncoding.EncodeToString(validSignature))
+		}},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			requireError(t, tc.name, tc.fn())
+		})
+	}
+}
+
+// TestSaveLoadKeyPair 覆盖：三条曲线的 SaveKeyPair -> LoadPrivateKey/LoadPublicKey 往返。
+func TestSaveLoadKeyPair(t *testing.T) {
+	for _, tc := range supportedCurves() {
+		t.Run(tc.name, func(t *testing.T) {
+			dir := t.TempDir()
+			privatePath := filepath.Join(dir, "ec_private.pem")
+			publicPath := filepath.Join(dir, "ec_public.pem")
+
+			if err := ecdsax.SaveKeyPair(privatePath, publicPath, tc.curve); err != nil {
+				t.Fatalf("SaveKeyPair 返回错误: %v", err)
+			}
+
+			priv, err := ecdsax.LoadPrivateKey(privatePath)
+			if err != nil {
+				t.Fatalf("LoadPrivateKey 返回错误: %v", err)
+			}
+			pub, err := ecdsax.LoadPublicKey(publicPath)
+			if err != nil {
+				t.Fatalf("LoadPublicKey 返回错误: %v", err)
+			}
+			if priv.Curve != tc.curve {
+				t.Errorf("加载的私钥曲线 = %v, 期望 %v", priv.Curve, tc.curve)
+			}
+			if !priv.PublicKey.Equal(pub) {
+				t.Error("加载的私钥与公钥不匹配")
+			}
+
+			message := []byte("落盘往返测试 / " + tc.name)
+			signature, err := ecdsax.Sign(priv, message)
+			if err != nil {
+				t.Fatalf("Sign 返回错误: %v", err)
+			}
+			if err := ecdsax.Verify(pub, message, signature); err != nil {
+				t.Fatalf("Verify 应通过, 实际返回错误: %v", err)
+			}
+
+			// 权限位只在类 Unix 系统上有意义，Windows 只用 mode 表示只读属性。
+			if runtime.GOOS != "windows" {
+				privateInfo, err := os.Stat(privatePath)
+				if err != nil {
+					t.Fatalf("Stat 私钥文件失败: %v", err)
+				}
+				if perm := privateInfo.Mode().Perm(); perm != 0o600 {
+					t.Errorf("私钥文件权限 = %o, 期望 600", perm)
+				}
+				publicInfo, err := os.Stat(publicPath)
+				if err != nil {
+					t.Fatalf("Stat 公钥文件失败: %v", err)
+				}
+				if perm := publicInfo.Mode().Perm(); perm != 0o644 {
+					t.Errorf("公钥文件权限 = %o, 期望 644", perm)
+				}
+			}
+		})
+	}
+}
+
+// TestLoadKeyErrors 覆盖：路径不存在、路径是目录、文件内容非法时都必须返回 error。
+func TestLoadKeyErrors(t *testing.T) {
+	dir := t.TempDir()
+
+	requireError(t, "LoadPrivateKey 路径不存在", func() error {
+		_, err := ecdsax.LoadPrivateKey(filepath.Join(dir, "missing.pem"))
+		return err
+	}())
+	requireError(t, "LoadPublicKey 路径不存在", func() error {
+		_, err := ecdsax.LoadPublicKey(filepath.Join(dir, "missing.pem"))
+		return err
+	}())
+	requireError(t, "LoadPrivateKey 路径为目录", func() error {
+		_, err := ecdsax.LoadPrivateKey(dir)
+		return err
+	}())
+
+	junkPath := filepath.Join(dir, "junk.pem")
+	if err := os.WriteFile(junkPath, []byte("这不是 PEM"), 0o600); err != nil {
+		t.Fatalf("写入测试文件失败: %v", err)
+	}
+	requireError(t, "LoadPrivateKey 内容非法", func() error {
+		_, err := ecdsax.LoadPrivateKey(junkPath)
+		return err
+	}())
+	requireError(t, "LoadPublicKey 内容非法", func() error {
+		_, err := ecdsax.LoadPublicKey(junkPath)
+		return err
+	}())
+}
+
+// flipRandomBits 复制一份数据并随机翻转若干位，用于构造逼近真实攻击面的畸形输入。
+func flipRandomBits(rng *mrand.Rand, data []byte) []byte {
+	out := append([]byte{}, data...)
+	for i := 0; i < 1+rng.Intn(4); i++ {
+		out[rng.Intn(len(out))] ^= byte(1 << rng.Intn(8))
+	}
+	return out
+}
+
+// randomBytes 生成指定长度的随机字节串。
+func randomBytes(rng *mrand.Rand, size int) []byte {
+	out := make([]byte, size)
+	for i := range out {
+		out[i] = byte(rng.Intn(256))
+	}
+	return out
+}
+
+// TestMalformedInputsDoNotPanic 覆盖：随机字节、随机位翻转的 PEM/签名，以及坐标随机的公钥，
+// 都不会触发 panic。这是对"任何情况下不得 panic"这一硬性要求的直接验证，
+// 因此只要求不 panic，不约束具体错误内容。
+func TestMalformedInputsDoNotPanic(t *testing.T) {
+	privatePEM, publicPEM, err := ecdsax.GenerateKeyPEM(elliptic.P256())
+	if err != nil {
+		t.Fatalf("GenerateKeyPEM 返回错误: %v", err)
+	}
+	priv, err := ecdsax.ParsePrivateKeyPEM(privatePEM)
+	if err != nil {
+		t.Fatalf("ParsePrivateKeyPEM 返回错误: %v", err)
+	}
+	pub, err := ecdsax.ParsePublicKeyPEM(publicPEM)
+	if err != nil {
+		t.Fatalf("ParsePublicKeyPEM 返回错误: %v", err)
+	}
+	message := []byte("畸形输入测试")
+	signature, err := ecdsax.Sign(priv, message)
+	if err != nil {
+		t.Fatalf("Sign 返回错误: %v", err)
+	}
+
+	rng := mrand.New(mrand.NewSource(20240517))
+	for i := 0; i < 200; i++ {
+		// 完全随机的字节串。
+		raw := make([]byte, rng.Intn(256))
+		for j := range raw {
+			raw[j] = byte(rng.Intn(256))
+		}
+		_, _ = ecdsax.ParsePrivateKeyPEM(raw)
+		_, _ = ecdsax.ParsePublicKeyPEM(raw)
+		_ = ecdsax.Verify(pub, message, raw)
+		_ = ecdsax.VerifyFromBase64(pub, message, string(raw))
+
+		// 在合法 PEM 上随机翻转比特位，更容易命中解析器的深层分支。
+		_, _ = ecdsax.ParsePrivateKeyPEM(flipRandomBits(rng, privatePEM))
+		_, _ = ecdsax.ParsePublicKeyPEM(flipRandomBits(rng, publicPEM))
+
+		// 在合法签名上随机翻转比特位。
+		_ = ecdsax.Verify(pub, message, flipRandomBits(rng, signature))
+		_ = ecdsax.VerifyFromBase64(pub, message, base64.StdEncoding.EncodeToString(flipRandomBits(rng, signature)))
+
+		// 坐标与标量完全是随机数的密钥：标准库对畸形点会报错，
+		// 本包必须在进入标准库之前就拦住，不能 panic。
+		randomPub := &ecdsa.PublicKey{
+			Curve: elliptic.P256(),
+			X:     new(big.Int).SetBytes(randomBytes(rng, 32)),
+			Y:     new(big.Int).SetBytes(randomBytes(rng, 32)),
+		}
+		randomPriv := &ecdsa.PrivateKey{
+			PublicKey: *randomPub,
+			D:         new(big.Int).SetBytes(randomBytes(rng, 32)),
+		}
+		_ = ecdsax.Verify(randomPub, message, signature)
+		_, _ = ecdsax.Sign(randomPriv, message)
+		_, _ = ecdsax.MarshalPublicKeyPEM(randomPub)
+		_, _ = ecdsax.MarshalPrivateKeyPEM(randomPriv)
+	}
+}
+
+// TestSaveKeyPairErrors 覆盖：写入路径非法时返回 error 而不是 panic。
+func TestSaveKeyPairErrors(t *testing.T) {
+	dir := t.TempDir()
+	requireError(t, "SaveKeyPair 私钥路径为目录",
+		ecdsax.SaveKeyPair(dir, filepath.Join(dir, "pub.pem"), elliptic.P256()))
+
+	privatePath := filepath.Join(dir, "priv.pem")
+	requireError(t, "SaveKeyPair 公钥路径目录不存在",
+		ecdsax.SaveKeyPair(privatePath, filepath.Join(dir, "no-such-dir", "pub.pem"), elliptic.P256()))
+	if _, err := os.Stat(privatePath); err == nil {
+		t.Error("公钥写入失败后应删除已写入的私钥文件")
+	}
+}
@@ -0,0 +1,14 @@
+# 本包有意读取 crypto/ecdsa 的已废弃字段：PrivateKey.D 与 PublicKey.X / PublicKey.Y。
+#
+# 原因是标准库自身在这些字段缺失时会崩溃，而不是返回错误：
+#
+#	(&ecdsa.PublicKey{}).ECDH()   -> panic: invalid memory address or nil pointer dereference
+#	(&ecdsa.PrivateKey{}).ECDH()  -> panic: invalid memory address or nil pointer dereference
+#	ecdsa.VerifyASN1 / SignASN1   -> 同样会解引用 X / Y / D
+#
+# 本包对外承诺「任何畸形密钥都返回 error，绝不 panic」，因此必须在调用标准库
+# 之前先判空。我们只**读取**这些字段，从不修改，不构成 Go 1.26 弃用说明所警告的
+# 风险（该说明针对的是修改原始值，以及用 big.Int 做大数运算）。
+#
+# 测试文件同样需要这些字段来构造畸形密钥，故整包排除 SA1019。其余检查保持开启。
+checks = ["all", "-SA1019"]