BouncyCastle 实现 Ed25519 算法示例（ aardio 版 ）:

```aardio 
import console;
import BouncyCastle;
import crypt;

//----------- 生成 Ed25519 密钥对 ------------------

// 初始化 Ed25519 密钥对生成器
var keyPairGen = BouncyCastle.Crypto.Generators.Ed25519KeyPairGenerator();
keyPairGen.Init( BouncyCastle.Crypto.KeyGenerationParameters(BouncyCastle.Security.SecureRandom(), 256) );

// 生成密钥对
var keyPair = keyPairGen.GenerateKeyPair();
var privateKey = keyPair.Private;
var publicKey = keyPair.Public;

//----------- 导入导出 PEM 格式 Key ------------------

// 从 PEM 格式导入公钥或私钥
var importPemKey = function(pem){
	var h = string.match(pem,"!\N<@-----BEGIN@>\s+(.+?)<@-----@>");		
	var bytes = raw.buffer( crypt.decodeBin(pem) );
	
	if(h=="PUBLIC KEY"){
		return BouncyCastle.Security.PublicKeyFactory.CreateKey(bytes);
	}
	elseif(h=="PRIVATE KEY"){
		return BouncyCastle.Security.PrivateKeyFactory.CreateKey(bytes);
	} 
};

// 导出的公钥 PEM
var exportPublicKeyX509 = function(publicKey){
	var publicKeyInfo = BouncyCastle.X509.SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey);
	return crypt.pem(publicKeyInfo.GetEncoded(), "PUBLIC KEY");
}

// 导出的私钥 PEM
var exportPrivateKeyPkcs8ToPem = function(privateKey){
	var privateKeyInfo = BouncyCastle.Pkcs.PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
	return crypt.pem(privateKeyInfo.GetEncoded(), "PRIVATE KEY");	
};

// 导出的私钥 PEM 
var privateKeyPem = exportPrivateKeyPkcs8ToPem(privateKey);
console.log(privateKeyPem);

//导出的公钥 PEM
var publicKeyPem = exportPublicKeyX509(publicKey);
console.log(publicKeyPem);

// 从 PEM 导入私钥
var newPrivKey = importPemKey(privateKeyPem);
// 从 PEM 导入公钥
var newPubKey = importPemKey(publicKeyPem);

//----------- 导入导出不带 ASN.1 结构的原始 32 字节 Key (Raw 数据) ------------------

// 公钥 Raw 导出（返回 buffer 类型字节串）
var rawPubKeyBytes = publicKey.GetEncoded(); // Ed25519 原始公钥就是 32 字节
// 私钥 Raw 导出（返回 buffer 类型字节串）
var rawPrivKeyBytes = privateKey.GetEncoded(); // Ed25519 原始私钥也是 32 字节
 
// 公钥 Raw 导入
var newPubKeyFromRaw = BouncyCastle.Crypto.Parameters.Ed25519PublicKeyParameters(rawPubKeyBytes, 0);
// 私钥 Raw 导入
var newPrivKeyFromRaw = BouncyCastle.Crypto.Parameters.Ed25519PrivateKeyParameters(rawPrivKeyBytes, 0);

console.log("原始公钥长度:", #rawPubKeyBytes);
console.log("原始私钥长度:", #rawPrivKeyBytes);
//----------- 签名验证演示 ------------------

var msg = "测试数据";
var msgBytes = raw.buffer(msg);

// 签名
var signer = BouncyCastle.Crypto.Signers.Ed25519Signer();
signer.Init(true, newPrivKey); 
signer.BlockUpdate(msgBytes, 0, #msgBytes);

var signature = signer.GenerateSignature();

// 验证
var verifier = BouncyCastle.Crypto.Signers.Ed25519Signer();
verifier.Init(false, newPubKey); 
verifier.BlockUpdate(msgBytes, 0, #msgBytes);

var isMatched = verifier.VerifySignature(signature);
console.status(isMatched,"签名验证结果 (使用导入的密钥)"); 

console.pause();

```

JWT 使用 EdDSA（Ed25519） 算法示例：

```aardio 
import console;
import BouncyCastle;
import crypt.jwt.algorithm.EdDSA;

//----------- 生成 Ed25519 密钥对 ------------------
var keyPairGen = BouncyCastle.Crypto.Generators.Ed25519KeyPairGenerator();
keyPairGen.Init(BouncyCastle.Crypto.KeyGenerationParameters(
    BouncyCastle.Security.SecureRandom(), 256));

var keyPair = keyPairGen.GenerateKeyPair();
var privateKey = keyPair.Private;
var publicKey = keyPair.Public;
 
//----------- JWT 编码/解码测试 ------------------

// 要存储的数据
var data = {
    sub = "user123";
    name = "张三";
    role = "admin";
    exp = tonumber(time().addSeconds(3600)); // 1小时后过期
};

// 使用私钥 + Ed25519 签名生成 JWT
var token = crypt.jwt.encode(data, privateKey, "EdDSA");
console.log("=== 生成的 JWT Token ===");
console.log(token);
console.log();

// 使用公钥 + Ed25519 验证并解码 JWT
var decoded = crypt.jwt.decode(token, publicKey, "EdDSA");

if(decoded) {
    console.success("=== 验证成功，解码结果 ===");
    console.log("Header:");
    console.dump(decoded.header);
    console.log("Payload:");
    console.dump(decoded.payload);
} else {
    console.fail("JWT 验证失败！");
}

console.log();

//----------- 测试篡改后的 Token ------------------
console.log("=== 测试篡改 Token ===");
var tamperedToken = string.replace(token, "张三", "李四");
var tamperedResult = crypt.jwt.decode(tamperedToken, publicKey, ed25519Verify);
console.status(tamperedResult,"篡改后验证签名（应当显示失败)")

console.pause();
```

crypt.jwt.algorithm.EdDSA 库的源代码如下;

```aardio 
//wt.algorithm.ed25519 算法
import crypt.jwt;
import BouncyCastle;

namespace crypt.jwt.algorithm.EdDSA{
	sign = function(key, payload) {
		
		var signer = ..BouncyCastle.Crypto.Signers.Ed25519Signer();
		signer.Init(true, key);
		
		var msgBytes = ..raw.buffer(payload);
		signer.BlockUpdate(msgBytes, 0, #msgBytes);
		
		return signer.GenerateSignature();
	};
	verify = function(key, signature, payload) {
		
		var verifier = ..BouncyCastle.Crypto.Signers.Ed25519Signer();
		verifier.Init(false, key);
		
		var msgBytes = ..raw.buffer(payload);
		verifier.BlockUpdate(msgBytes, 0, #msgBytes);
		
		return verifier.VerifySignature(..raw.buffer(signature));
	};	
} 

/*****intellisense()
crypt.jwt.algorithm.EdDSA = 导入此库为 crypt.jwt 添加 ed25519 算法。
end intellisense*****/

```