USBKEY全解析---证书生产(java)

最新推荐文章于 2024-06-25 07:43:41 发布
最新推荐文章于 2024-06-25 07:43:41 发布
阅读量1.8k 收藏 4
点赞数
分类专栏： CA总动员 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liujoi/article/details/106158471
版权 

package org.liuy.bouncycastle;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.security.KeyPair;
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.Date;
import java.util.Vector;

import org.apache.commons.io.FileUtils;
import org.apache.log4j.Logger;
import org.bouncycastle.asn1.DERBMPString;
import org.bouncycastle.asn1.DERIA5String;
import org.bouncycastle.asn1.DERObjectIdentifier;
import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
import org.bouncycastle.asn1.x509.BasicConstraints;
import org.bouncycastle.asn1.x509.DistributionPoint;
import org.bouncycastle.asn1.x509.DistributionPointName;
import org.bouncycastle.asn1.x509.ExtendedKeyUsage;
import org.bouncycastle.asn1.x509.GeneralName;
import org.bouncycastle.asn1.x509.GeneralNames;
import org.bouncycastle.asn1.x509.KeyPurposeId;
import org.bouncycastle.asn1.x509.KeyUsage;
import org.bouncycastle.asn1.x509.X509Extensions;
import org.bouncycastle.jce.PrincipalUtil;
import org.bouncycastle.jce.X509Principal;
import org.bouncycastle.jce.interfaces.PKCS12BagAttributeCarrier;
import org.bouncycastle.x509.X509V3CertificateGenerator;
import org.bouncycastle.x509.extension.AuthorityKeyIdentifierStructure;
import org.bouncycastle.x509.extension.SubjectKeyIdentifierStructure;
import org.liuy.certdn.form.KeyUseForm;
import org.liuy.conf.IConf;
import org.liuy.security.cert.KeyStoreSeal;

/**
 *  
 *  创建p12证书文件。默认密码：123456
 *  @author Liuy
 *  @version 2010-07-19
 *  
 */
public class CretPKCS12 {

	private static char[] passwd = "123456".toCharArray();
	private static X509V3CertificateGenerator v3CertGen = new X509V3CertificateGenerator();
	private final	static Logger logger = Logger.getLogger(CretPKCS12.class.getName ());
    
	
	/**
     * 创建根证书
     */
    private static Certificate createMasterCert(
            PublicKey pubKey,
            PrivateKey privKey)
            throws Exception {

    	  String subjectDN = "CN=FT_ROOT,O=ROOT,C=CN";
    	  v3CertGen.reset();
          v3CertGen.setSerialNumber(BigInteger.valueOf(System.currentTimeMillis()));
          v3CertGen.setIssuerDN(new X509Principal(subjectDN));  
          v3CertGen.setNotBefore(new Date(System.currentTimeMillis()));
          v3CertGen.setNotAfter(new Date(System.currentTimeMillis() + 1000L*60*60*24*30*12*10));
          v3CertGen.setSubjectDN(new X509Principal(subjectDN));
          v3CertGen.setPublicKey(pubKey);
          v3CertGen.setSignatureAlgorithm("SHA256WithRSAEncryption");
          //使用者密钥标示符号
          v3CertGen.addExtension(X509Extensions.SubjectKeyIdentifier,false,
                new SubjectKeyIdentifierStructure(pubKey));
          //颁发机构密钥标示符
          v3CertGen.addExtension(X509Extensions.AuthorityKeyIdentifier,false,
                new AuthorityKeyIdentifierStructure(pubKey));
          //基本路径限制
          v3CertGen.addExtension(X509Extensions.BasicConstraints,true,
                new BasicConstraints(true));
          //密钥用法
          v3CertGen.addExtension(X509Extensions.KeyUsage,true, new KeyUsage(
  				KeyUsage.keyCertSign | KeyUsage.cRLSign));  
          X509Certificate cert = v3CertGen.generate(privKey);
          cert.checkValidity(new Date());
          cert.verify(pubKey);
          PKCS12BagAttributeCarrier bagAttr = (PKCS12BagAttributeCarrier) cert;

          //证书链名称
          bagAttr.setBagAttribute(PKCSObjectIdentifiers.pkcs_9_at_friendlyName,new DERBMPString("FT_ROOT"));
          return cert;
    }
    
    /**
     * 
     * 创建二级证书
     * @param pubKey  二级证书公钥
     * @param caPrivKey  根证书私钥
     * @param caCert 根证书
     */
    private static Certificate createIntermediateCert(
            PublicKey pubKey,
            PrivateKey caPrivKey,
            X509Certificate caCert)
            throws Exception {
    	
    	  String subjectDN = "CN=FT_CA,O=CA,C=CN";
    	  v3CertGen.reset();
          v3CertGen.setSerialNumber(BigInteger.valueOf(System.currentTimeMillis()));
          v3CertGen.setIssuerDN(new X509Principal(PrincipalUtil.getSubjectX509Principal(caCert)));  
          v3CertGen.setNotBefore(new Date(System.currentTimeMillis()));
          v3CertGen.setNotAfter(new Date(System.currentTimeMillis() + 1000L*60*60*24*30*12*5));
          v3CertGen.setSubjectDN(new X509Principal(subjectDN));
          v3CertGen.setPublicKey(pubKey);
          v3CertGen.setSignatureAlgorithm("SHA256WithRSAEncryption");
          //使用者密钥标示符号
          v3CertGen.addExtension(X509Extensions.SubjectKeyIdentifier,false,
                new SubjectKeyIdentifierStructure(pubKey));
          //颁发机构密钥标示符
          v3CertGen.addExtension(X509Extensions.AuthorityKeyIdentifier,false,
                new AuthorityKeyIdentifierStructure(caCert));
          //基本路径限制
          v3CertGen.addExtension(X509Extensions.BasicConstraints,true,
                new BasicConstraints(true));
          //密钥用法
          v3CertGen.addExtension(X509Extensions.KeyUsage,true, new KeyUsage(
  				KeyUsage.keyCertSign | KeyUsage.cRLSign));
          
          X509Certificate cert = v3CertGen.generate(caPrivKey);
          cert.checkValidity(new Date());
          cert.verify(caCert.getPublicKey());
          PKCS12BagAttributeCarrier bagAttr = (PKCS12BagAttributeCarrier) cert;

        //证书链名称
          bagAttr.setBagAttribute(PKCSObjectIdentifiers.pkcs_9_at_friendlyName,new DERBMPString("CFCA FEITIAN TEST"));
          return cert;
    }

    /**
     * 创建证书
     * @param pubKey 证书公钥
     * @param IntermePrivKey 二级证书私钥
     * @param IntermeCert 二级证书对象
     * @param subjectDN  证书DN项
     * @param keyUseForm 证书的附属信息
     */
    public static Certificate createCert(
            PublicKey pubKey,
            PrivateKey IntermePrivKey,
            X509Certificate IntermeCert,
            String subjectDN,KeyUseForm keyUseForm)
            throws Exception {
    	
        //创建V3证书
        v3CertGen.reset();
        v3CertGen.setSerialNumber(BigInteger.valueOf(System.currentTimeMillis()));
        v3CertGen.setIssuerDN(new X509Principal(PrincipalUtil.getSubjectX509Principal(IntermeCert)));  
        v3CertGen.setNotBefore(new Date(System.currentTimeMillis()));
        v3CertGen.setNotAfter(new Date(System.currentTimeMillis()+1000L*60*60*24*30*12));
//      v3CertGen.setNotBefore(ProAssistant.getNormatTiem("2010-08-10 10:00:00"));
//      v3CertGen.setNotAfter(ProAssistant.getNormatTiem("2010-09-10 10:00:00"));
        v3CertGen.setSubjectDN(new X509Principal(subjectDN));
        v3CertGen.setPublicKey(pubKey);
        v3CertGen.setSignatureAlgorithm(keyUseForm.getCertSignAlgo());
        

        //创建扩展项
        /*
         *SubjectKeyIdentifier:主体密钥标识符:
         *   本项提供一种识别包含有一个特定公钥的证书的方法。
         *   此扩展标识了被认证的公开密钥，它能够区分同一主体使用的不同密钥。
         *   对于使用密钥标识符的主体的各个密钥标识符而言，每一个密钥标识符均应是唯一的。
         *   CA签发证书时必须把CA证书中本扩展的值赋给终端实体证书AuthorityKeyIdentifier扩展中的KeyIdentifier项。
         *   CA证书的主体密钥标识符应从公钥中或者生成唯一值的方法中导出。终端实体证书的主体密钥标识符应从公钥中导出。
         *	 所有的CA证书必须包括本扩展，此扩展项为非关键项。
         *
         */
        v3CertGen.addExtension(X509Extensions.SubjectKeyIdentifier,false,
        		new SubjectKeyIdentifierStructure(pubKey));
        /* 
        *AuthorityKeyIdentifier:密钥扩展项
        *	
        *  有多张根证书时区分签发证书
		*
        */
        v3CertGen.addExtension(X509Extensions.AuthorityKeyIdentifier,false,
                new AuthorityKeyIdentifierStructure(IntermeCert));
        
        /* 
         *  证书支持多域名
 		 *
        ASN1EncodableVector sanVector = new ASN1EncodableVector();
        sanVector.add(new GeneralName(GeneralName.dNSName,"localhost"));
        sanVector.add(new GeneralName(GeneralName.dNSName,"192.168.35.13"));
        sanVector.add(new GeneralName(GeneralName.dNSName,"127.0.0.1"));
        sanVector.add(new GeneralName(GeneralName.rfc822Name,"liuy@test.test"));
        DERSequence san = new DERSequence(sanVector);   
        GeneralNames subjectAltName = new GeneralNames(san);  
        v3CertGen.addExtension(X509Extensions.SubjectAlternativeName,false,
        		subjectAltName);
        
        */
         
        int keyUse=0;
        if(keyUseForm.isSignUse())
        {
        	//签名用法
        	keyUse=KeyUsage.digitalSignature | KeyUsage.nonRepudiation;
        }
        if(keyUseForm.isEncUse())
        {
        	//加密用法
        	keyUse+=KeyUsage.keyEncipherment | KeyUsage.keyAgreement;
        }
        if(keyUse!=0)
        {
            v3CertGen.addExtension(X509Extensions.KeyUsage, true, new KeyUsage( keyUse ));
        }
        
        boolean flag=false;
        /* 
         *  扩展密钥标识符
 		 *
         */
        Vector<DERObjectIdentifier> extendedKeyUsageV = new Vector<DERObjectIdentifier>();
//		extendedKeyUsageV.add(KeyPurposeId.id_kp_serverAuth);
//		extendedKeyUsageV.add(KeyPurposeId.id_kp_clientAuth);
		//时间戳增强密钥用法
        if(keyUseForm.isTsaUse())
        {
        	extendedKeyUsageV.add(KeyPurposeId.id_kp_timeStamping);
        	flag=true;
        }
		//邮件证书
        if(keyUseForm.isEMailUse())
        {
        	extendedKeyUsageV.add(KeyPurposeId.id_kp_emailProtection);
        	flag=true;
        }
//		extendedKeyUsageV.add(new KeyPurposeId("1.2.840.113583.1.1.5"));
        
        
       //代码签名证书
        if(keyUseForm.isCodeSign())
        {
            extendedKeyUsageV.add(new KeyPurposeId("1.3.6.1.5.5.7.3.3"));
            flag=true;
        }
        
        //加入扩展秘钥
        if(flag)
        {
    		v3CertGen.addExtension(X509Extensions.ExtendedKeyUsage, true,
			new ExtendedKeyUsage(extendedKeyUsageV));
        }

        
        /* 
         * 证书基本限制
         * 证书路径:
         * new BasicConstraints(true, 0));
         * 1 true代表该证书后 最多的证书链
         * 2 false  公钥不能验证其他证书
         */
        v3CertGen.addExtension(X509Extensions.BasicConstraints,true,
                new BasicConstraints(false));
        
        /*
         * CRL发布点
         *  
         */
        if(keyUseForm.getCrlDL()!=null)
        {
            GeneralName gn = new GeneralName(GeneralName.uniformResourceIdentifier, new DERIA5String(keyUseForm.getCrlDL()));
    		GeneralNames gns = new GeneralNames(new DERSequence(gn));
    		DistributionPointName dpn = new DistributionPointName(0, gns);
    		DistributionPoint distp = new DistributionPoint(dpn, null, null);
    		v3CertGen.addExtension(
    				X509Extensions.CRLDistributionPoints, false,
    				new DERSequence(distp));
        }

//        v3CertGen.addExtension(MiscObjectIdentifiers.netscapeCertType,false,
//                new NetscapeCertType(NetscapeCertType.objectSigning | NetscapeCertType.smime));
        
        //创建并验证信息
        X509Certificate cert = v3CertGen.generate(IntermePrivKey,"BC");
        cert.checkValidity(new Date());
        cert.verify(IntermeCert.getPublicKey());
        PKCS12BagAttributeCarrier bagAttr = (PKCS12BagAttributeCarrier) cert;
        //创建证书链名称
        bagAttr.setBagAttribute(PKCSObjectIdentifiers.pkcs_9_at_friendlyName,
                new DERBMPString("User"));
//        bagAttr.setBagAttribute(PKCSObjectIdentifiers.pkcs_9_at_localKeyId,
//                new SubjectKeyIdentifierStructure(pubKey));
        return cert;
    }
    
    /**
     * 创建root证书KeyStore
     * @param outPath KeyStore输出路径
     * @throws Exception 
     */
    private static void createRootKeyStore(String outPath) throws Exception
    {
    	BC.setBC();
	    //ca  keys
		KeyPair capair = Utils.generateRSAKeyPair(2048);	
	    //intermediate   keys
		KeyPair intermediatepair = Utils.generateRSAKeyPair(2048);
	    //根证书
		PrivateKey caPrivKey = capair.getPrivate();
		PublicKey caPubKey = capair.getPublic();
		//二级证书
		PrivateKey intPrivKey = intermediatepair.getPrivate();
		PublicKey intPubKey = intermediatepair.getPublic();

		//创建证书链
		Certificate[] root = new Certificate[1];
		Certificate[] Inter = new Certificate[1];
		//根证书
		root[0] = createMasterCert(caPubKey, caPrivKey);
		//二级证书
		Inter[0] = createIntermediateCert(intPubKey, caPrivKey, (X509Certificate) root[0]);
		//输出根证书与二级证书
		KeyStore store = KeyStore.getInstance("JKS");
		store.load(null,null);
		store.setKeyEntry("root", caPrivKey, passwd, root);
		store.setKeyEntry("inter", intPrivKey, passwd, Inter);
		FileOutputStream out = new FileOutputStream(outPath);
		store.store(out, passwd);
		out.close();
    }
      
    /**
     * 创建 P12证书
     * @param subjectDN  证书DN项，形式如："C=CN,O=Test,OU=Liuy,oid.2.5.4.1=1234"
     * @throws Exception 
     */
    public static byte[] createP12Cert(String subjectDN,KeyUseForm keyUseForm) 
    {
    	BC.setBC();
    	ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
    	try {
			KeyPair personalpair = Utils.generateRSAKeyPair(keyUseForm.getKeyLen());
			//个人
	        PrivateKey privKey = personalpair.getPrivate();
	        PublicKey pubKey = personalpair.getPublic();
	        //通过配置文件找到root文件路径
			String rootPath= IConf.getValue("rootPath");
			//获取二级证书公钥和私钥
			X509Certificate intCert = KeyStoreSeal.getX500Private(rootPath, "123456", "inter").getCertificate();
			PrivateKey intPrivKey = KeyStoreSeal.getX500Private(rootPath, "123456", "inter").getPrivateKey();
	        //制作证书
	        Certificate user=createCert(pubKey, intPrivKey,intCert, subjectDN,keyUseForm);	        
	        Certificate[] chain = new Certificate[1];
	        chain[0]=user;
	        KeyStore store = KeyStore.getInstance("PKCS12", "BC");
	        store.load(null, null);
//	        String s=StringUtil.getOneKey(subjectDN, "CN");
	        store.setKeyEntry("", privKey, null, chain);
	        store.store(baos, passwd);
	        return baos.toByteArray();
		} catch (Exception e) {
			logger.error("参数证书错误",e);
		}
		 finally
		{
			 try {
				baos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;	
    }
    
    
    public static void main(String[] args) throws Exception 
    {
//     	createRootKeyStore("d:/root");
    	
    	String subjectDN="C=CN";	
		KeyUseForm keyUseForm =new KeyUseForm();
		keyUseForm.setKeyLen(1024);
		keyUseForm.setCrlDL("http://liuy/crl.crl");
		keyUseForm.setSignUse(true);
		keyUseForm.setEncUse(true);
		keyUseForm.setTsaUse(true);
		keyUseForm.setCertSignAlgo("SHA1WithRSAEncryption");
    	byte[] certBy=createP12Cert(subjectDN,keyUseForm);
    	
    	File f=new File("d:/2.pfx");
    	FileUtils.writeByteArrayToFile(f, certBy);
    }
}

 

liujoi
关注
专栏目录
java usbkey ssl_Java读取硬件USBKey(简称UKEY)中的SSL证书信息，创建双向SSL认证上下文环境...
weixin_36483301的博客
02-13 1427
最近项目中遇到了这样的需求，故记录下来，希望可以帮到需要的人O(∩_∩)O~以下以 Linux 环境为基础：读取硬件 UKEY 的SSL证书信息，需要硬件厂商提供：UKEY型号名称、驱动文件(类似pkcs11.so)。直接上代码段示例：//厂商提供的UKEY型号名称staticfinalStringUKEY_PROVIDER="xxx";//UKEY驱动lib库文件staticfi...
【java面试经(架构师&设计师)-第9课】网络编程校验方法和加密算法
金和弦的博客
05-09 479
技术清单 申明：本文属于整理加工原创，部分举证材料来自于网络，仅用于学习参考。 本文主要介绍java网络协议相关知识，通过本文讲解，你可以明白： 1、海明码校验和CRC校验； 2、DES、AES和XXTEA； 3、RSA、TLS和SSL； ...
Java开发 明华usbkey_UsbKey开发文档
weixin_39603908的博客
12-22 368
添加表：epass，执行SQL：CREATETABLEIFNOTEXISTS`epass`(`epass_id`int(11)NOTNULLAUTO_INCREMENT,`epass_sn`varchar(16)CHARACTERSETutf8COLLATEutf8_unicode_ciNOTNULL,`epass_key`varchar(16)CHARACTERSET...
一读通透 | 轻松掌握X.509数字证书全解析，附赠权威详解资料！
最新发布
所有成功的背后，都是痛苦的坚持，所有的痛苦，都是傻瓜般的不放弃!
06-25 2811
我们常见的.pem.pfx后缀的文件就是X.509证书，X.509是最广泛使用的数字证书格式，由X.509标准定义，用于身份验证和加密。在互联网上，如HTTPS、SSL/TLS等安全通信中，服务器通常使用X.509证书来证明其身份。你真得了解X.509证书么？它有哪些字段？分别代表着什么含义？它又有哪些存储格式呢？
USBKEY全解析---证书导入(java)
洋仔专栏
05-13 3964
网上找了一些例子，基本没有找到java向USBKEY（俗称：U盾）导入证书和私钥的例子，方便集成和调用，例子如下： package org.liuy.pkcs11; import java.io.ByteArrayInputStream; import java.io.IOException; import java.math.BigInteger; import java.security.InvalidKeyException; import java.security.KeyPair; impor
Java开发 明华usbkey_明华驱动官方版下载-明华usbkey数字证书驱动下载v3.0.2420.9 最新版-当易网...
weixin_34121505的博客
02-01 794
明华ukey驱动安装后可以让您的登录环境更加的安全，数字证书加密功能，适用于多个领域，证书到期会自动提醒，为您带来的是当前的最新版本驱动程序，可以按照下文中的安装教程来进行操作。明华驱动程序介绍明华ukey驱动是一款非常实用的驱动程序，主要用于保障数字证书的安全性和隐秘性;现在很多用户都在网上进行相关的交易，可以让用户更加安全的进行交易和认证。功能特点1、集智能卡和USB接口技术于一体的安全设备。...
Java读取硬件USBKey(简称UKEY)中的SSL证书信息，创建双向SSL认证上下文环境
weixin_34061482的博客
03-25 4166
为什么80%的码农都做不了架构师？>>> ...
Java从文件中读取数字证书.rar
07-10
Java生成 数字证书源码，从文件中读取数字证书，生成文件输入流,输入文件为c:/mycert.cer，获取一个处理X.509证书的证书工厂，获取证书，请查看以下相关代码： 　//生成文件输入流,输入文件为c:/mycert.cer 　...
数字证书再理解
qq_41644069的博客
11-13 3600
1.基础知识 1.1.公钥密码体制(public-key cryptography) 公钥密码体制分为三个部分，公钥、私钥、加密解密算法，它的加密解密过程如下： 加密：通过加密算法和公钥对内容(或说明文)进行加密，得到密文。加密过程需要用到公钥。 解密：通过解密算法和私钥对密文进行解密，得到明文。解密过程需要用到解密算法和私钥。注意，由公钥加密的内容，只能由私钥进行解密，也就是说，由公钥加密的内容，如果不知道私钥，是无法解密的。 公钥密码体制的公钥和算法都是公开的(...
java 电子签章_PDF开发+电子签章，如何实现真正地脱离硬件的无纸化办公体验（实战篇）？...
weixin_39589557的博客
02-19 766
上一篇中我们主要介绍了PDF的一些基本格式，让大家入门有一个初步的了解，接下来我们进行PDF的开发和电子签章的实战。【PDF文档修改】上篇文章中了解了PDF的基本格式，我们要实现无纸化办公，势必要修改现有的PDF文档，往里面填写具体的数据。那如果我们要对去解析修改PDF的具体内容，那只有上面的基本了解，是远远不够的，就算借助第三方开发包要去解析修改，也是一个庞大复杂的工程。那我们怎么样可以最方便快...
红队专题-Cobalt strike从小白到飞升手册
aming小老弟
10-09 1301
4.0 2019年12月2日 更新 Cobalt Strike 4.0 手册奇安信 A-TEAMCobalt Strike 是一款 美国Red Team开发的 商业GUI框架式 优秀的渗透测试工具 简称CS为对手模拟渗透测试 和红队行动而设计的 协作工具平台，主要用于执行有目标的攻击和模拟高级威胁者的后渗透行动。可以利用网络漏洞获取主机权限后、从一个强大的图形界面控制所有的活动。因可以调用Mimikatz等其他知名工具并且可以作为团队服务使用，因此广受网络安全人员喜爱。
UKey WEBAC基础方案和开发教程
08-11
Ukey WEBAC WebAC Web访问控制 Web Access Control ebAC=Web Access Control 不需要 ActiveX控件 一个UKey 支持多个系统的登录！
java usbkey数字证书_Java创建数字证书
weixin_42452580的博客
02-16 383
BouncyCastle下载：链接：http://pan.baidu.com/s/1vrcL4 密码：6i27package com.what21.security05;import java.io.InputStream;import java.io.OutputStream;import java.math.BigInteger;import java.security.Key;impo...
JAVA：JNA方式调用USBKey SKF接口实现SM2证书的PKCS1格式签名和验证 实验总结_20220111_七侠镇莫尛貝
七侠镇莫小贝的同福客栈
12-03 4372
JAVA：JNA方式调用USBKey SKF接口实现SM2证书的PKCS1格式签名和验证 实验总结
java usbkey数字证书_Java 密钥库和数字证书
weixin_31361715的博客
02-24 476
密钥库中可以存放多个条目(公钥/私钥对和证书)，它们在密钥库中以别名(alias)区分。1.cdC:\Program Files (x86)\Java\jdk1.6.0_10\bin2.生成签名证书：keytool -genkey -v -keystore android.keystore -alias android -keyalg RSA -validity 20000[-genkey：生成...
往USBKey里面导入双证书专题：概念介绍、执行逻辑
CHYabc123456hh的博客
11-24 2473
往USBKey里面导入双证书专题：概念介绍、执行逻辑
java 实现ukey身份认证_一种基于ukey认证的单点登录实现方法与流程
weixin_31998661的博客
02-16 3363
本发明涉及网络技术领域，更具体的说是涉及一种基于ukey认证的单点登录实现方法。背景技术：单点登录sso(singlesignon)简单来说就是在一个多系统共存的环境下，用户在一处登录后，就不用在其他系统中登录，也就是用户的一次登录能得到其他所有系统的信任。无论在大型网站还是企业网站，单点登录是被广泛使用的解决方案。由于网站规模庞大，涉及的子系统成百上千，如果在每个系统都需要重新认证一遍，不仅耗时...
阿翔编程学-Ukey--USB 加密认证设备
曹翔
06-13 4028
Ukey的介绍Ukey--USB 加密认证设备 UKey 特点及安全特性 UKey 是一种通过 USB (通用串行总线接口)直接与计算机相连 具有密码验证功能 可靠高速的小型存 储设备 UKey 的设计小巧精致 携带方便 UKey 自身所具备的存贮器可以用来存储一些个人信息或证书 UKey 的内部密码算法可以为数据传输提供安全的管道 UKey 是适用于单机或网络应用的安全防护产品 优越性 UK
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值