PFX文件解析及读取、写入、删除相关操作

已于 2022-08-12 11:59:35 修改
阅读量2.6k 收藏 1
点赞数
分类专栏： java PFX 文章标签： java jvm 开发语言
于 2022-08-11 17:31:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37298500/article/details/126289677
版权

针对pfx文件的解析及操作，java 标准库提供了很好的支持，需要做一定得封装，才能比较友好的使用，如下是我做的一些封装及核心代码，话不多说，直接上代码

本次JDK版本 zulu-11

pfx自定义封装类：方便使用公私钥信息

import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.security.PrivateKey;
import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import java.util.Date;

@Data
@NoArgsConstructor
public class PfxObj implements Serializable {
    // 私钥
    private PrivateKey privateKey;
    // 公钥数组 
    private Certificate[] certificateChain;
    // 核心公钥信息，包含公钥、过期日期等等
    private X509Certificate x509Certificate;
    // 证书公钥过期时间
    private Date expiredAt;
    
    private String commonName;
    //alias
    private String aliasName;
}

pfx解析及读写操作核心工具类


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.bindo.module.PfxObj;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;

import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.security.Key;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

@Slf4j
public class PfxTools {
    public final static String UPDATE_PFX_KEY="manual_update_pfx";
    public final static String JUST_ONE_TASK="JUST_ONE_TASK";
    public final static Map<String,Date> MANUAL_UPDATE_PFX = new ConcurrentHashMap<>();

    /**
     * 读取pfx文件,获取KeyStore对象
     * @param keyStorePath pfx文件
     * @param password pfx访问密码
     * @return
     */
    public static KeyStore loadKeyStore(String keyStorePath, String password) {
        KeyStore keyStore = null;
        FileInputStream fisFrom = null;
        try {
            keyStore = KeyStore.getInstance("PKCS12");
            fisFrom = new FileInputStream(keyStorePath);
            keyStore.load(fisFrom, password.toCharArray());
        } catch (Exception e) {
            log.error("加载pfx时异常，file" + keyStorePath, e);
        } finally {
            if (fisFrom != null) {
                try {
                    fisFrom.close();
                } catch (IOException e) {
                    log.error("关闭文件流异常.", e);
                }
            }
        }
        return keyStore;
    }

    /**
     * 保存KeyStore对象至pfx文件
     * @param ksFrom KeyStore对象
     * @param fromPw pfx访问密码
     * @param storePath pfx保存路径及文件
     * @return
     */
    public static boolean storeKeyStore(KeyStore ksFrom, String fromPw, String storePath) {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(storePath);
            ksFrom.store(fileOutputStream, fromPw.toCharArray());
        } catch (Exception e) {
            log.error("保存pfx到文件异常.storePath=" + storePath, e);
            return false;
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    log.error("关闭文件流异常.", e);
                }
            }
        }
        return true;
    }

    /**
     * 读取pfx文件,生成pfx自定义对象（PfxObj）集合
     * @param pfxFileStr pfx文件
     * @param pfxPassword pfx访问密码
     * @return
     * @throws Exception
     */
    public static Map<String, PfxObj> readPfxFile(String pfxFileStr, String pfxPassword) throws Exception {
        Map<String, PfxObj> pfxObjMap = new HashMap<>();
        KeyStore ks = KeyStore.getInstance("PKCS12");
        FileInputStream fis = new FileInputStream(pfxFileStr);
        // If the keystore password is empty(""), then we have to set
        // to null, otherwise it won't work!!!
        char[] nPassword = null;
        if ((pfxPassword == null) || pfxPassword.trim().equals("")) {
            nPassword = null;
        } else {
            nPassword = pfxPassword.toCharArray();
        }
        ks.load(fis, nPassword);
        fis.close();
        // System.out.println("keystore type=" + ks.getType());
        // Now we loop all the aliases, we need the alias to get keys.
        // It seems that this value is the "Friendly name" field in the
        // detals tab <-- Certificate window <-- view <-- Certificate
        // Button <-- Content tab <-- Internet Options <-- Tools menu
        // In MS IE 6.
        Enumeration enumas = ks.aliases();
        String keyAlias = null;
        PrivateKey prikey = null;
        int times = 0;
        while (enumas.hasMoreElements())// we are readin just one certificate.
        {
            keyAlias = (String) enumas.nextElement();
            prikey = (PrivateKey) ks.getKey(keyAlias, nPassword);
            Certificate cert = ks.getCertificate(keyAlias);
            X509Certificate x509Certificate = (X509Certificate) ks.getCertificate(keyAlias);
            Certificate[] certificateChain = ks.getCertificateChain(keyAlias);
            PublicKey pubkey = cert.getPublicKey();
            times++;
            PfxObj pfxObj = new PfxObj();
            pfxObj.setCertificateChain(certificateChain);
            pfxObj.setPrivateKey(prikey);
            pfxObj.setX509Certificate(x509Certificate);
            pfxObj.setAliasName(keyAlias);
            pfxObj.setCommonName(((JSONObject) JSON.toJSON(x509Certificate)).getJSONObject("subjectDN").getString("commonName"));
            pfxObj.setExpiredAt(x509Certificate.getNotAfter());
            pfxObjMap.put(keyAlias, pfxObj);
        }
        // System.out.println("=============== 证书数量=" + times + " =============");
        return pfxObjMap;
    }

    /**
     * 以account为维度，获取pfx证书，多个证书时，取最新的过期时间
     *
     * @param pfxFileStr
     * @param pfxPassword
     * @return
     * @throws Exception
     */
    public static Map<String, PfxObj> getPfxToSpAccountMap(String pfxFileStr, String pfxPassword) throws Exception {
        Map<String, PfxObj> pfxObjMap = readPfxFile(pfxFileStr, pfxPassword);
        Map<String, PfxObj> spAccountPfxMap = new HashMap<>();
        if (CollectionUtils.isEmpty(pfxObjMap)) {
            return spAccountPfxMap;
        }
        Iterator<Map.Entry<String, PfxObj>> iterator = pfxObjMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, PfxObj> pfxCer = iterator.next();
            if (spAccountPfxMap.containsKey(pfxCer.getValue().getCommonName())) {
                if (spAccountPfxMap.get(pfxCer.getValue().getCommonName()).getExpiredAt().before(pfxCer.getValue().getExpiredAt())) {
                    spAccountPfxMap.replace(pfxCer.getValue().getCommonName(), pfxCer.getValue());
                }

            } else {
                spAccountPfxMap.put(pfxCer.getValue().getCommonName(), pfxCer.getValue());
            }
        }
        return spAccountPfxMap;
    }

    /**
     * pfx的A文件写入至B文件
     * 此处未保存到文件，只是存入B的KeyStore对象
     * @param toFile 接收pfx的文件
     * @param toPw 接收文件的访问密码
     * @param fromFile 被复制的
     * @param fromPw
     * @return
     * @throws Exception
     */
    public static KeyStore writePFX(String toFile, String toPw, String fromFile, String fromPw) throws Exception {
        KeyStore ksTo = KeyStore.getInstance("PKCS12");
        FileInputStream fisTo = new FileInputStream(toFile);
        ksTo.load(fisTo, toPw.toCharArray());

        KeyStore ksFrom = KeyStore.getInstance("PKCS12");
        FileInputStream fisFrom = new FileInputStream(fromFile);
        ksFrom.load(fisFrom, fromPw.toCharArray());
        Enumeration<String> aliases = ksFrom.aliases();
        while (aliases.hasMoreElements()) {
            String aliase = aliases.nextElement();
            if (!ksFrom.isKeyEntry(aliase)) {
                continue;
            }
            Key keyFrom = ksFrom.getKey(aliase, fromPw.toCharArray());
            Certificate[] certificateChainFrom = ksFrom.getCertificateChain(aliase);
            ksTo.setKeyEntry(aliase, keyFrom, toPw.toCharArray(), certificateChainFrom);
        }
        return ksTo;
    }

    /**
     * pfx的A文件写入至B文件
     * 只是写入到某个已存在的KeyStore对象，还未保存至文件
     * @param ksTo KeyStore接收公私钥
     * @param toPw 接收者的访问密码
     * @param fromFile 待读取的pfx文件
     * @param fromPw 访问密码
     * @return
     * @throws Exception
     */
    public static KeyStore writePFX(KeyStore ksTo, String toPw, String fromFile, String fromPw) throws Exception {
        KeyStore ksFrom = KeyStore.getInstance("PKCS12");
        FileInputStream fisFrom = new FileInputStream(fromFile);
        ksFrom.load(fisFrom, fromPw.toCharArray());
        Enumeration<String> aliases = ksFrom.aliases();
        while (aliases.hasMoreElements()) {
            String aliase = aliases.nextElement();
            if (!ksFrom.isKeyEntry(aliase)) {
                continue;
            }
            Key keyFrom = ksFrom.getKey(aliase, fromPw.toCharArray());
            Certificate[] certificateChainFrom = ksFrom.getCertificateChain(aliase);
            ksTo.setKeyEntry(aliase, keyFrom, toPw.toCharArray(), certificateChainFrom);
        }
        return ksTo;
    }

    /**
     * pfx的A文件写入至B文件
     * 将pfx自定义对象写入到KeyStore，未保存至文件
     * @param ksTo KeyStore接收公私钥
     * @param toPw 接收者的访问密码
     * @param pfxObj pfx自定义对象
     * @return
     * @throws Exception
     */
    public static KeyStore writePFX(KeyStore ksTo, String toPw, PfxObj pfxObj) throws Exception {
        ksTo.setKeyEntry(pfxObj.getCommonName(), pfxObj.getPrivateKey(), toPw.toCharArray(), pfxObj.getCertificateChain());
        return ksTo;
    }

    /**
     * 从pfx文件中删除某个alias的公私钥信息
     * 未保存至文件
     * @param fromFile
     * @param fromPw
     * @param aliaseRemove
     * @return
     * @throws Exception
     */
    public static KeyStore removePFX(String fromFile, String fromPw, String aliaseRemove) throws Exception {

        KeyStore ksFrom = KeyStore.getInstance("PKCS12");
        FileInputStream fisFrom = new FileInputStream(fromFile);
        ksFrom.load(fisFrom, fromPw.toCharArray());
        Enumeration<String> aliases = ksFrom.aliases();
        boolean removeFlag = false;
        while (aliases.hasMoreElements()) {
            String aliase = aliases.nextElement();
            if (aliase.equalsIgnoreCase(aliaseRemove)) {
                removeFlag = true;
            }
        }
        if (removeFlag) {
            ksFrom.deleteEntry(aliaseRemove);
        }
        return ksFrom;
    }

    /**
     * 从KeyStore删除某个公私钥对
     * @param ksFrom
     * @param fromPw
     * @param aliaseRemove
     * @return
     * @throws Exception
     */
    public static KeyStore removePFX(KeyStore ksFrom, String fromPw, String aliaseRemove) throws Exception {
        Enumeration<String> aliases = ksFrom.aliases();
        boolean removeFlag = false;
        while (aliases.hasMoreElements()) {
            String aliase = aliases.nextElement();
            if (aliase.equalsIgnoreCase(aliaseRemove)) {
                removeFlag = true;
            }
        }
        if (removeFlag) {
            ksFrom.deleteEntry(aliaseRemove);
        }
        return ksFrom;
    }

    /**
     * 下载pfx文件
     * @param fileUri
     * @param downloadedFile
     * @throws Exception
     */
    public static void downloadNetFile(String fileUri, String downloadedFile) throws Exception {
        // 下载网络文件
        int bytesum = 0;
        int byteread = 0;

        URL url = new URL(fileUri);
        InputStream inStream = null;
        FileOutputStream fs = null;
        try {
            URLConnection conn = url.openConnection();
            inStream = conn.getInputStream();
            fs = new FileOutputStream(downloadedFile);

            byte[] buffer = new byte[1204];
            int length;
            while ((byteread = inStream.read(buffer)) != -1) {
                bytesum += byteread;
                fs.write(buffer, 0, byteread);
            }
            fs.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            inStream.close();
            fs.close();
        }
    }

    /**
     * 执行shell命令
     * @param commands
     * @return
     */
    public static List<String> executeNewFlow(List<String> commands) {
        List<String> rspList = new ArrayList<String>();
        Runtime run = Runtime.getRuntime();
        try {
            Process proc = run.exec("/bin/bash", null, null);
            BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
            PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(proc.getOutputStream())), true);
            for (String line : commands) {
                out.println(line);
            }
            out.println("exit");// 这个命令必须执行，否则in流不结束。
            String rspLine = "";
            while ((rspLine = in.readLine()) != null) {
                System.out.println(rspLine);
                rspList.add(rspLine);
            }
            proc.waitFor();
            in.close();
            out.close();
            proc.destroy();
        } catch (IOException e1) {
            e1.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return rspList;
    }

    /**
     * 是否在有效期内
     *
     * @param expriedDate 过期时间
     * @param days        即将过期预警天数
     * @return
     */
    public static boolean isValidIn(Date expriedDate, int days) {
        int expiredInTimes = days * 24 * 60 * 60 * 1000;
        long gapTime = expriedDate.getTime() - new Date().getTime();
        return gapTime - expiredInTimes > 0 ? true : false;
    }

    public static Integer extractSpId(String str) {
        if (StringUtils.isBlank(str) || !str.startsWith("SP") || !str.contains("-")) {
            log.error("无效的sp身份ID=" + str);
            return null;
        }
        int index = str.indexOf("-");
        Integer spId = null;
        try {
            spId = Integer.valueOf(str.substring(2, index));
        } catch (NumberFormatException e) {
            log.error("无效的sp身份ID=" + str, e);
        }
        return spId;
    }

    public static void main(String[] args) throws Exception {
//        Map<String, PfxObj> pfxObjMap = readPfxFile("/Users/bindo/Downloads/ecert.pfx", "123456");
//        Iterator<String> iterator = pfxObjMap.keySet().iterator();
//        Map<String,Integer> commonNameMap = new HashMap<>();
//        while (iterator.hasNext()){
//            String key = iterator.next();
//            String commonName = pfxObjMap.get(key).getCommonName();
//            if (commonNameMap.containsKey(commonName)){
//                commonNameMap.put(commonName,commonNameMap.get(commonName)+1);
//            }else {
//                commonNameMap.put(commonName,1);
//            }
//            // System.out.println("证书的alias="+key+", commonName="+commonName+", 有效期="+pfxObjMap.get(key).getX509Certificate().getNotAfter()+", 是否失效="+pfxObjMap.get(key).getX509Certificate().getNotAfter().before(new Date()));
//
//        }
//        Iterator<String> iterator1 = commonNameMap.keySet().iterator();
//        // System.out.println("sip是否有同名:");
//        while (iterator1.hasNext()){
//            String next = iterator1.next();
//            // System.out.println(next+"="+commonNameMap.get(next));
//        }


//        downloadNetFile("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fpic1.win4000.com%2Fwallpaper%2F2020-07-23%2F5f195601471b5.jpg&refer=http%3A%2F%2Fpic1.win4000.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1659774124&t=330917ba468613cc969d159e4a7d1a28","/Users/bindo/Downloads/OSDX-3/abc.gif");
        // System.out.println(extractSpId("SP59938s5t-_mop"));
    }
}

证书体系： PFX 文件格式解析
Useless Programmer 的专栏
11-24 7565
章节目录 PFX 简介 PFX 格式解析 2.1 最外层结构 2.2 AuthenticatedSafe 结构 参考 https://tools.ietf.org/html/rfc7292. PFX 简介## 以下引用自维基百科 在密码学中，PKCS #12 定义了一种存档文件格式，用于实现存储许多加密对象在一个单独的文件中。通常用它来打包一个私钥及有关的 X.509 证书，或者打包信任...
Windows环境下使用OpenSSL查看pfx证书的有效期
最新发布
weixin_44326073的博客
03-25 850
Windows环境下使用OpenSSL查看pfx证书的有效期
pfx证书解析
u010980938的专栏
10-20 1602
从pfx中获取CA证书 openssl pkcs12 -in test.pfx -nodes -out server.pem 输入证书密码， 提取公钥 openssl x509 -in server.pem -out public.cer 提取私钥 openssl rsa -in server.pem -out private.key
pfx文件是什么
linux_tcpdump的博客
12-24 9982
pfx两个要点： 1、pfx 文件中包含私钥与公钥和证书 别人要是问.pfx文件里放的是啥，你可以直白的说告诉他里面放的就是公钥和私钥和证书。 2、pfx 有访问密码保护 私钥不能随便让人查看，访问密码是为了进行安全控制。 即使pfx文件被别人得到，没有访问密码也较难获取私钥。 数字证书文件格式（cer和pfx）的区别 1.带有私钥的证书 由Public Key Cryptography Standards #12，PKCS#12标准定义，包含了公钥和私钥的二进制格式的证书形式，以pfx作为证书文件后缀
Java 解析PFX证书获取私钥 附加Byte以及字符类型转换
优道子的博客
12-08 1067
PFX证书，同时包含了公钥信息和私钥信息。 这里编写解析处理PFX的工具类，用来获取私钥。 引用相关： import java.io.*; import java.util.*; import java.security.*; import java.security.cert.Certificate; import java.security.spec.InvalidKeySpecException; import java.security.spec.PKCS8EncodedKeySpe
pfx文件-解析时使用
07-12
pfx文件，用于解析时，使用
pfx证书管理辅助工具
08-11
本篇文章将详细探讨与"Pfx证书管理辅助工具"相关的知识，包括PFX证书的读取、写入、删除，以及如何进行定时自动维护。 首先，我们需要理解PFX证书的基本概念。PFX文件是由Microsoft开发的一种标准，用于安全地导出...
Openssl解析私pfx/p12证书(1)
游走的山鸡的博客
05-14 1916
   PKCS#12标准描述了个人标识信息的语法，一种交换数字证书的加密标准，包括用户公钥、私钥、证书等。Openssl提供了API供我们解析pfx/p12文件，提取我们需要的信息。    首先我们需要了解几个数据结构，由于Openssl文档里面有些介绍的不是很详细，在这里列举一下：    1、X509 structtypedef struct x509_st X509; struct x509...
【文件服务与存储管理高级特性】：Windows Server 2012深度解析
[【文件服务与存储管理高级特性】：Windows Server 2012深度解析](https://mshub.co.uk/wp-content/uploads/install-configure-dfs-replication.webp) # 摘要 本文深入探讨了Windows Server 2012中文件服务的多个...
Docx4J核心概念全解析：打造高效文档操作代码的5个基础
[Docx4J核心概念全解析：打造高效文档操作代码的5个基础](https://img-blog.csdnimg.cn/img_convert/04e35662abbfabcc3f2560ca57cf3862.png) # 摘要 Docx4J 是一个强大的 Java 库，用于处理 Microsoft Word 文档（....
电子数据取证技术，第四章，Windows操作系统取证技术
qq_34871944的博客
01-08 744
预定义项，是代表注册表中的主要部分的项，指在注册表中以HKEY作为前缀的文件夹，位于注册表树状结构的最顶层。预定义项类似于硬盘上的根目录，Windows 2000/XP注册表编辑器中有五大预定义项，分别为 ：HKEY_USERS在Windows 9x操作系统的注册表中，另外还有一个预定义项。
pfx file generate and import
xylz_yang的专栏
10-23 272
tools: makecert.exe  cert2spc.exe pvk2pfx.exe steps: 1. create cer and pvk file makecert -r -n "CN=&lt;PublisherName&gt;" -b 01/01/2008 -e 01/01/2010 -sv &lt;MyCertName&gt;.pvk &lt;MyCertName&gt;....
Java实现读取PFX文件
老张的便利贴
12-23 1895
实现代码 /** * getPvkformPfx: 从PFX文件中获取私钥 * @param strPfx 文件存储目录 * @param strPassword PFX密码 */ private static PrivateKey getPvkformPfx(String strPfx, String strPassword){ ...
java读取.pfx证书内容demo(公私钥)
lxhlxh1256lxh的博客
05-14 373
java读取.pfx证书内容demo(公私钥)
pfx文件解析私钥和公钥
liwenpeng123400的专栏
10-14 9714
最近和某行对接，发现私钥和公钥以pfx文件形式传给我们，需要我们自己进行读取，当时头就有点儿大（菜鸟，第一次接触，哎~~~） 先说一下pfx证书与cer证书的区别 PFX证书：由Public Key Cryptography Standards #12，PKCS#12标准定义，包含了公钥和私钥的二进制格式的证书形式，以pfx作为证书文件后缀名。 CER证书：证书中没有私钥，DER 编码二进制
java获取pfx证书私钥_从PFX文件中读取私钥
weixin_42508241的博客
02-25 1024
我知道，有很多关于此的帖子，但我仍然无法找到解决方案来实现这一点 . 我在我的机器上生成了一个带有 openssl 的PFX文件，如下所示：openssl x509 -req -days 365 -in "myReqest.csr" -signkey "myPrivateKey.pem" -out "myCertificate.crt"openssl pkcs12 -export -out "my...
pfx读私钥 & cer文件pfx文件
weixin_40800533的博客
05-09 951
从证书私钥pfx文件拿到key字符串内容的方法 第一：从私钥文件中读出里面的key内容； openssl pkcs12 -in C:/Users/heli38/Desktop/002/A.pfx-nocerts-nodes -out C:/Users/heli38/Desktop/002/B.key 第二：再从上一步中得到的B.key文件中读出里面的私钥串 openss...
操作pfx文件工具-openSSL
xiaopang2020的博客
11-04 552
提取秘钥对 openssl pkcs12 -in 1.pfx -nocerts -nodes -out 1.key 从秘钥对提取私钥 openssl rsa -in 1.key -out 1_pri.key 从密钥对提取公钥 openssl rsa -in 1.key -pubout -out 1_pub.key 因为RSA算法使用的是pkcs8模式补足，需要对提取的私钥进一步处理（可选） openssl pkcs8 -in 1_pri.key -out 1_pri.p8 -outform der -noc
java pfx_java读取pfx或P12格式的个人交换库公私钥
weixin_31861055的博客
02-12 288
使用的是CFCA签发的用于银行间交换数据的证书，下载后直接添加到浏览器中1、导出从浏览器导出p12文件(包含私钥)2、验证两种方式：openssl代码(请注意alias别名是如何获取的)：package com.shengpay.mas.demo.cert;import org.apache.commons.codec.binary.Base64;import java.io.FileInputS...
VC++数据库编程：ODBC与ADO技术解析
在教学过程中，通过一个简单的学生信息管理系统（ODBC）和教职工信息管理系统（ADO）的项目，学生可以实践如何连接数据库、执行SQL语句、读取和写入数据，以及掌握使用ODBC和ADO开发数据库应用程序的方法和技巧。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值