HarmonyOS鸿蒙Next分享一个纯血鸿蒙可用的JWT(JSON Web Token)鉴权码原生实现的代码因为和风天气API需要在网络请求附上JWT,然后官方只给了JAVA的示例代码，ArkTS上好像也没有原生实现的代码，花了一天时间调试终于写出了，原生实现，原汁原味。以此分享，希望能帮到大家。

代码如下：

import { cryptoFramework } from '@kit.CryptoArchitectureKit';
import { util } from '@kit.ArkTS';
import { hilog } from '@kit.PerformanceAnalysisKit';

/**
 * JWT生成工具类
 * 基于EdDSA算法的JWT签名实现，对应Java版本的逻辑
 */
export class JwtGenerator {
  private privateKeyPem: string = "YOUR PRIVATE KEY";
  private projectId: string = "YOUR_PROJECT_ID";
  private keyId: string = "YOUR_KEY_ID";

  /**
   * 构造函数
   * @param privateKeyPem PEM格式的私钥字符串
   * @param projectId 项目ID
   * @param keyId 密钥ID
   */
  constructor(privateKeyPem?: string, projectId?: string, keyId?: string) {
    if (privateKeyPem) this.privateKeyPem = privateKeyPem;
    if (projectId) this.projectId = projectId;
    if (keyId) this.keyId = keyId;
  }

  /**
   * 生成JWT token
   * @returns Promise<string> JWT token字符串
   */
  async generateJWT(): Promise<string> {
    try {
      // 1. 解析私钥
      const privateKey = await this.parsePrivateKey();

      // 2. 创建Header
      const headerJson = JSON.stringify({
        "alg": "EdDSA",
        "kid": this.keyId
      });

      // 3. 创建Payload
      const now = Math.floor(Date.now() / 1000);
      const iat = now - 30; // 当前时间减30秒
      const exp = iat + 900; // 15分钟后过期
      
      const payloadJson = JSON.stringify({
        "sub": this.projectId,
        "iat": iat,
        "exp": exp
      });

      // 4. Base64URL编码Header和Payload
      const headerEncoded = this.base64UrlEncodeString(headerJson);
      const payloadEncoded = this.base64UrlEncodeString(payloadJson);
      const data = `${headerEncoded}.${payloadEncoded}`;

      // 5. 签名
      const signatureBytes = await this.createSignature(data, privateKey);
      const signatureEncoded = this.base64UrlEncodeBytes(signatureBytes);

      // 6. 组装JWT
      const jwt = `${data}.${signatureEncoded}`;

      // 7. 输出调试信息（对应Java的System.out.println）
      hilog.info(0x0000, 'JwtGenerator', `Signature: ${signatureEncoded}`);
      hilog.info(0x0000, 'JwtGenerator', `JWT: ${jwt}`);

      return jwt;
    } catch (error) {
      hilog.error(0x0000, 'JwtGenerator', `JWT生成失败: ${error.message}`);
      throw new Error(`${error.message}`);
    }
  }

  /**
   * 解析PEM格式的私钥
   * @returns Promise<cryptoFramework.PriKey> 私钥对象
   */
  private async parsePrivateKey(): Promise<cryptoFramework.PriKey> {
    try {
      hilog.info(0x0000, 'JwtGenerator', '开始解析私钥');
      
      // 验证私钥是否为空
      if (!this.privateKeyPem || this.privateKeyPem.trim() === "" || this.privateKeyPem === "YOUR PRIVATE KEY") {
        throw new Error("私钥未设置或为默认值，请设置有效的私钥");
      }
      
      // 清理PEM格式标记，对应Java代码的replace操作
      let privateKeyString = this.privateKeyPem
        .replace("-----BEGIN PRIVATE KEY-----", "")
        .replace("-----END PRIVATE KEY-----", "")
        .replace(/\s/g, ""); // 移除所有空白字符

      hilog.info(0x0000, 'JwtGenerator', `私钥清理完成，长度: ${privateKeyString.length}`);
      
      if (privateKeyString.length === 0) {
        throw new Error("私钥内容为空，请检查私钥格式");
      }

      // Base64解码，对应Java的Base64.getDecoder().decode()
      const base64Helper = new util.Base64Helper();
      const privateKeyBytes = base64Helper.decodeSync(privateKeyString);
      hilog.info(0x0000, 'JwtGenerator', `私钥Base64解码完成，字节长度: ${privateKeyBytes.length}`);

      // 创建密钥生成器，对应Java的KeyFactory.getInstance("EdDSA")
      const keyGenerator = cryptoFramework.createAsyKeyGenerator("Ed25519");
      hilog.info(0x0000, 'JwtGenerator', '密钥生成器创建成功');
      
      // 从PKCS8格式的字节数组生成私钥，对应Java的generatePrivate(keySpec)
      const keyPair = await keyGenerator.convertKey(
        null,
        { data: privateKeyBytes } // 包装成DataBlob类型
      );
      
      hilog.info(0x0000, 'JwtGenerator', '私钥解析成功');
      return keyPair.priKey;
    } catch (error) {
      hilog.error(0x0000, 'JwtGenerator', `私钥解析失败: ${error.message}`);
      throw new Error(`私钥解析失败: ${error.message}`);
    }
  }

  /**
   * Base64URL编码字符串
   * @param data 要编码的字符串
   * @returns string Base64URL编码后的字符串
   */
  private base64UrlEncodeString(data: string): string {
    try {
      const textEncoder = util.TextEncoder.create('utf-8');
      const uint8Array = textEncoder.encodeInto(data);
      
      const base64Helper = new util.Base64Helper();
      let base64 = base64Helper.encodeToStringSync(uint8Array);
      
      // 转换为Base64URL格式：替换字符并移除填充
      return base64
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
    } catch (error) {
      hilog.error(0x0000, 'JwtGenerator', `Base64URL字符串编码失败: ${error.message}`);
      throw new Error(`Base64URL字符串编码失败: ${error.message}`);
    }
  }

  /**
   * Base64URL编码二进制数据
   * @param data 要编码的二进制数据
   * @returns string Base64URL编码后的字符串
   */
  private base64UrlEncodeBytes(data: Uint8Array): string {
    try {
      const base64Helper = new util.Base64Helper();
      let base64 = base64Helper.encodeToStringSync(data);
      
      // 转换为Base64URL格式：替换字符并移除填充
      return base64
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
    } catch (error) {
      hilog.error(0x0000, 'JwtGenerator', `Base64URL二进制编码失败: ${error.message}`);
      throw new Error(`Base64URL二进制编码失败: ${error.message}`);
    }
  }

  /**
   * 创建EdDSA签名
   * @param data 要签名的数据
   * @param privateKey 私钥对象
   * @returns Promise<Uint8Array> 签名结果的二进制数据
   */
  private async createSignature(data: string, privateKey: cryptoFramework.PriKey): Promise<Uint8Array> {
    try {
      hilog.info(0x0000, 'JwtGenerator', `开始创建签名，数据长度: ${data.length}`);
      
      // 创建签名器，对应Java的Signature.getInstance("EdDSA")
      const signer = cryptoFramework.createSign("Ed25519");
      hilog.info(0x0000, 'JwtGenerator', '签名器创建成功');
      
      // 初始化签名器，对应Java的signer.initSign(privateKey)
      await signer.init(privateKey);
      hilog.info(0x0000, 'JwtGenerator', '签名器初始化成功');
      
      // 准备要签名的数据
      const textEncoder = util.TextEncoder.create('utf-8');
      const dataBytes = textEncoder.encodeInto(data);
      hilog.info(0x0000, 'JwtGenerator', `数据编码完成，字节长度: ${dataBytes.length}`);
      
      // Ed25519使用一次性签名，直接传入要签名的数据
      const signatureResult: cryptoFramework.DataBlob = await signer.sign({ data: dataBytes });
      hilog.info(0x0000, 'JwtGenerator', `签名执行成功，签名长度: ${signatureResult.data.length}`);
      
      // 直接返回二进制签名数据
      return signatureResult.data;
    } catch (error) {
      hilog.error(0x0000, 'JwtGenerator', `签名创建失败: ${error.message}`);
      throw new Error(`签名创建失败: ${error.message}`);
    }
  }

  /**
   * 设置私钥
   * @param privateKeyPem PEM格式的私钥字符串
   */
  setPrivateKey(privateKeyPem: string): void {
    this.privateKeyPem = privateKeyPem;
  }

  /**
   * 设置项目ID
   * @param projectId 项目ID
   */
  setProjectId(projectId: string): void {
    this.projectId = projectId;
  }

  /**
   * 设置密钥ID
   * @param keyId 密钥ID
   */
  setKeyId(keyId: string): void {
    this.keyId = keyId;
  }
}

/**
 * 简化的JWT工具类（保持向后兼容）
 * @deprecated 建议使用JwtGenerator类
 */
export class SimpleJwtUtils extends JwtGenerator {
  constructor() {
    super();
  }

  /**
   * 生成JWT（同步接口，内部调用异步方法）
   * @returns Promise<string> JWT token字符串
   */
  generateJWT(): Promise<string> {
    return super.generateJWT();
  }
}

/**
 * 带15分钟缓存的JWT管理工具
 */
export class JwtManager {
  private cachedToken: string | null = null;
  private tokenExpiry: number = 0;
  private jwtGen: JwtGenerator;

  constructor(privateKey: string, projectId: string, keyId: string) {
    this.jwtGen = new JwtGenerator(privateKey, projectId, keyId);
  }

  async getToken(): Promise<string> {
    const now = Math.floor(Date.now() / 1000);

    if (this.cachedToken && now < this.tokenExpiry - 60) {
      return this.cachedToken;
    }

    this.cachedToken = await this.jwtGen.generateJWT();
    this.tokenExpiry = now + 900; // 15分钟后过期

    return this.cachedToken;
  }
}

// 导出默认实例
export default new JwtGenerator();

使用说明：

JWT签名工具类使用说明

概述

本工具类提供了基于EdDSA算法的JWT签名功能，完全对应Java版本的实现逻辑。支持PKCS8格式的私钥解析、Base64URL编码和EdDSA数字签名。

核心特性

✅ 原生实现：不依赖第三方JWT库，使用HarmonyOS原生加密API
✅ 完全兼容：与Java版本逻辑完全一致
✅ EdDSA签名：支持Ed25519椭圆曲线数字签名算法
✅ PKCS8支持：支持标准PKCS8格式私钥解析
✅ 异步操作：所有加密操作均为异步，性能优化
✅ 详细日志：提供完整的调试信息输出

类结构

JwtGenerator（主要类）

export class JwtGenerator {
  constructor(privateKeyPem?: string, projectId?: string, keyId?: string)
  async generateJWT(): Promise<string>
  setPrivateKey(privateKeyPem: string): void
  setProjectId(projectId: string): void
  setKeyId(keyId: string): void
}

SimpleJwtUtils（兼容类）

export class SimpleJwtUtils extends JwtGenerator {
  // 保持向后兼容的简化接口
}

使用方法

方法1：直接实例化（推荐）

import { JwtGenerator } from 'network';

const jwtGen = new JwtGenerator(
  "-----BEGIN PRIVATE KEY-----\nYOUR_PRIVATE_KEY_HERE\n-----END PRIVATE KEY-----",
  "your_project_id",
  "your_key_id"
);

const jwt = await jwtGen.generateJWT();
console.log('Generated JWT:', jwt);

方法2：使用默认实例

import { jwtGenerator } from 'network';

jwtGenerator.setPrivateKey("-----BEGIN PRIVATE KEY-----\nYOUR_PRIVATE_KEY_HERE\n-----END PRIVATE KEY-----");
jwtGenerator.setProjectId("your_project_id");
jwtGenerator.setKeyId("your_key_id");

const jwt = await jwtGenerator.generateJWT();

方法3：快速生成

import { JwtUtils, JwtConfig } from 'network';

const config: JwtConfig = {
  privateKey: "-----BEGIN PRIVATE KEY-----\nYOUR_PRIVATE_KEY_HERE\n-----END PRIVATE KEY-----",
  projectId: "your_project_id",
  keyId: "your_key_id"
};

const jwt = await JwtUtils.quickGenerate(config);

方法4：在HTTP请求中使用

import { JwtGenerator } from 'network';
import { https } from 'network';

const jwtGen = new JwtGenerator(privateKey, projectId, keyId);
const jwt = await jwtGen.generateJWT();

const response = await https.get({
  url: 'https://api.example.com/data',
  headers: {
    'Authorization': `Bearer ${jwt}`,
    'Content-Type': 'application/json'
  }
});

JWT Token结构

生成的JWT包含三个部分，用点号分隔：

header.payload.signature

Header

{
  "alg": "EdDSA",
  "kid": "your_key_id"
}

Payload

{
  "sub": "your_project_id",
  "iat": 1699876543,  // 当前时间戳-30秒
  "exp": 1699877443   // 当前时间戳+870秒（15分钟）
}

Signature

使用Ed25519算法对 base64url(header).base64url(payload) 进行签名

私钥格式要求

支持的格式

PKCS8 PEM格式（推荐）

-----BEGIN PRIVATE KEY-----
MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQg...
-----END PRIVATE KEY-----

注意事项

私钥必须是Ed25519算法生成的PKCS8格式
支持带换行符的PEM格式
工具会自动清理PEM标记和空白字符

时间戳说明

与Java版本保持一致：

iat（签发时间）：当前UTC时间戳 - 30秒
exp（过期时间）：iat + 900秒（15分钟）

错误处理

常见错误类型

私钥格式错误
```
私钥解析失败: Invalid key format
```
签名失败
```
签名创建失败: sign update fail
```
编码错误
```
Base64URL编码失败: Encoding error
```

私钥未设置

私钥未设置或为默认值，请设置有效的私钥

修复历史

v1.2.0 (2025-11-12) - 关键修复

🔧 修复doFinal调用：使用signer.doFinal()替代signer.update()+signer.sign()
✅ 解决签名错误：彻底解决"sign update fail"错误
🚀 优化Ed25519实现：针对HarmonyOS Ed25519特性优化签名流程
📝 完善错误处理：提供更精确的错误定位和调试信息

v1.1.0 (2025-11-12) - 重要修复

🔧 修复签名失败问题：解决了"sign update fail"错误
✅ 分离编码方法：为字符串和二进制数据分别实现Base64URL编码
🚀 优化签名流程：签名方法现在正确返回二进制数据
📝 增强调试信息：添加详细的步骤日志输出
🛡️ 改进错误处理：提供更准确的错误信息

调试建议

检查私钥格式：确保使用PKCS8格式的Ed25519私钥
验证私钥内容：私钥不能为空或默认值
查看详细日志：启用HiLog查看每个步骤的执行情况
确认算法支持：确保HarmonyOS版本支持Ed25519算法
验证配置参数：检查项目ID和密钥ID是否正确设置

故障排除步骤

启用详细日志

// 在应用启动时启用日志
hilog.isLoggable(0x0000, 'JwtGenerator', hilog.LogLevel.INFO);

验证私钥格式

const config: JwtConfig = {
  privateKey: "your_private_key_here",
  projectId: "your_project_id", 
  keyId: "your_key_id"
};

if (!JwtUtils.validateConfig(config)) {
  console.error('JWT配置验证失败');
}

测试基本功能

try {
  const jwtGen = new JwtGenerator(privateKey, projectId, keyId);
  const jwt = await jwtGen.generateJWT();
  console.log('JWT生成成功:', jwt);
} catch (error) {
  console.error('JWT生成失败:', error.message);
}

性能优化

最佳

更多关于HarmonyOS鸿蒙Next分享一个纯血鸿蒙可用的JWT(JSON Web Token)鉴权码原生实现的代码的实战教程也可以访问 https://www.itying.com/category-93-b0.html

sinazl 1楼

HarmonyOS Next中实现JWT鉴权需使用ArkTS语言。以下是核心代码示例：

import cryptoFramework from '@ohos.security.cryptoFramework';

// JWT头部
const header = {
  alg: 'HS256',
  typ: 'JWT'
};

// 生成签名
async function generateSignature(headerStr: string, payloadStr: string, secret: string): Promise<string> {
  const encoder = new TextEncoder();
  const data = encoder.encode(`${headerStr}.${payloadStr}`);
  const key = encoder.encode(secret);
  
  const mac = cryptoFramework.createMac('SHA256');
  await mac.init({ alg: 'SHA256', key: key });
  await mac.update(data);
  const signature = await mac.doFinal();
  return btoa(String.fromCharCode(...signature));
}

// 生成JWT
async function generateJWT(payload: object, secret: string): Promise<string> {
  const headerStr = btoa(JSON.stringify(header));
  const payloadStr = btoa(JSON.stringify(payload));
  const signature = await generateSignature(headerStr, payloadStr, secret);
  return `${headerStr}.${payloadStr}.${signature}`;
}

该实现使用HarmonyOS原生加密框架，支持HS256算法生成JWT令牌。

更多关于HarmonyOS鸿蒙Next分享一个纯血鸿蒙可用的JWT(JSON Web Token)鉴权码原生实现的代码的实战系列教程也可以访问 https://www.itying.com/category-93-b0.html

eggper 2楼

感谢分享这个高质量的HarmonyOS Next JWT原生实现代码！这个实现非常专业，有几个亮点值得肯定：

完整的EdDSA支持：基于cryptoFramework原生实现了Ed25519算法，与Java版本完全兼容，避免了第三方依赖。
规范的JWT结构：Header包含alg和kid，Payload包含sub、iat、exp标准字段，符合JWT RFC标准。
健壮的错误处理：每个关键步骤都有try-catch包装，通过hilog输出详细调试信息，便于问题定位。
性能优化考虑：JwtManager的缓存机制很实用，避免了频繁生成Token的开销。

特别值得称赞的是对Base64URL编码的完整实现和PKCS8私钥解析的处理，这些都是JWT实现中容易出错的细节。代码结构清晰，注释详细，可以直接用于生产环境。

对于需要JWT认证的和风天气API或其他类似服务，这个实现提供了完整的解决方案。