Java cipher

欧易okx交易所下载

欧易交易所又称欧易OKX，是世界领先的数字资产交易所，主要面向全球用户提供比特币、莱特币、以太币等数字资产的现货和衍生品交易服务，通过使用区块链技术为全球交易者提供高级金融服务。

APP下载   官网注册

今天和大家分享一下javacrypto的知识，其中也会讲解javacryptodemo。如果你碰巧解决了你现在面临的问题，不要'；别忘了关注这个网站。如果你有不同的看法和意见，请在评论区留言。现在让'；咱们言归正传吧！

DES密钥生成，加密和解密方法，可以看一下

//DES密钥生成工具

importJava.io.file；

导入Java。io。找不到文件异常；

导入Java。io。文件输出流；

导入Java。io。io异常；

导入Java。io。对象输出流；

导入Java。安全。invalidkeyexception

导入Java。安全。nosuchalgorithm异常；

导入Java。安全。securerandom

导入Java。安全。规格。invalidkeyspecexception

导入javax。密码。密钥生成器；

导入javax。密码。密钥；

导入javax。密码。密钥工厂；

导入javax。密码。规格。deskey规范；

publicclassGenKey{

privatestaticfinalstringDES="DES

公共静态最终字符串SKEY_NAME="钥匙。des"；

公共静态voidgenKey1(字符串路径){

//密钥

密钥skey=null

//密钥随机数生成

SecureRandomSr=newSecureRandom()；

//生成密钥文件

Filefile=genFile(path);

Try{

//Getanexampleofkeygeneration

keygeneratorgen=keygenerator.getinstance(DES)；

Initialisierungschlsselgenerator

gen.init(Sr)；

//生成密钥

skey=gen.generatekey()；

//系统。出去。println(斯基)；

objectoutputstreamOOS=newobjectoutputstream(

newfile输出流(file))；

OOS.writeobject(skey)；

OOS.close()；

}catch(nosuchalgorithmexceptione){

e.printstacktrace()；

}catch(找不到文件异常e){

e.printstacktrace()；

}catch(io异常e){

e.printstacktrace()；

}

}

/*

*@paramfile:thepathtogeneratethekey

*secretkeyfactorymethodtogeneratethedataencryptionstandardkey

**/

publicstaticvoidgenkey2(stringpath){

//keyrandomnumbergeneration

SecureRandomSr=newSecureRandom()；

//byte[]bytes={11，12，44，99，76，45，1，8}；

byte[]bytes=Sr.generateseed(20)；

//密钥

密钥skey=null

//Generatekeyfilepath

Filefile=genFile(path);

Try{

//Createadesktopspecificationobject

deskeyspecdeskeyspec=newdeskeyspec(bytes，9)；

//实例化数据加密标准密钥工厂

secretkey工厂key工厂=secretkey工厂。getinstance(DES)；

//生成密钥对象

skey=钥匙厂。生成秘密(deskey规范)；

//写出密钥对象

objectoutputstreamOOS=newobjectoutputstream(

newfile输出流(file))；

OOS.writeobject(skey)；

OOS.close()；

}catch(nosuchalgorithmexceptione){

e.printstacktrace()；

}catch(InvalidKeyExceptione){

e.printstacktrace()；

}catch(InvalidKeySpecExceptione){

e.printstacktrace()；

}catch(找不到文件异常e){

e.打印堆栈跟踪()；

}catch(io异常e){

e.printstacktrace()；

}

}

privatestaticfilegenFile(stringpath){

stringtemp=null;

FilenewFile=null；

如果(路径。endswith("；/)||路径。endswith("；\"){

temp=path；

}else{

temp=path"；/"；

}

文件路径File=newFile(temp)；

if(！路径文件。exists())

路径文件。mkdirs()；

新文件=新文件(临时SKEY_NAME)；

返回新文件；

}

/**

*@paramargs

*/

publicstaticvoidmain(String[]args){

//TODO自动生成的方法存根

genkey2("；e:/a/aa/"；);

}

}

//DES加解密方法

导入Java。io。bufferedinputstream

导入Java。io。bufferedoutputstream

导入Java。io。文件；

导入Java。io。文件输入流；

导入Java。io。找不到文件异常；

导入Java。io。文件输出流；

导入Java。io。objectinputstream

导入javax。密码。密码；

导入javax。密码。密码输入流；

导入javax。密码。密钥；

导入org。阿帕奇。公地。伐木。日志；

导入org。阿帕奇。公地。伐木。原木工厂；

/**

*Encryptionmethodofbusinesscardprintingfileencryption/decryptionDES

*/

publicclassSecUtil{

公共静态最终日志Log=日志工厂。获取日志(secutil。类)；

/**

*解密

*

*@param键路径

*密钥路径

*@paramsource

*解密前的文件

*@paramdest

*解密后的文件

*/

publicstaticvoiddecrypt(Stringkeypath，Stringsource，Stringdest){

秘钥key=null

try{

ObjectInputStreamkeyFile=newObjectInputStream(

//Readtheencryptionkey

newfileinputstream(keypath))；);

key=(秘密密钥)keyfile。readobject()；

密钥文件。close()；

}catch(找不到文件异常ey1){

日志。信息("读取密钥文件时出错");

抛出新的运行时异常(ey1)；

}捕捉(异常ey2){

log.info("；读取密钥文件时出错");

抛出新的运行时异常(ey2)；

}

//生成密钥为

cipher的密码=null

try{

//设置算法，应该和加密的时候一样。

密码=密码。getinstance("；DES");

//设置解密模式

cipher.init(密码.DECRYPT_MODE，key)；

}捕捉(例外ey3){

log.info("；创建密码时出错");

抛出新的运行时异常(ey3)；

}

//获取要解密的文件并解密

filefile=newfile(source)；

Stringfilename=file.getname()；

Try{

/outputstream,pleasepayattentiontotheacquisitionoffilename

BufferedOutputStreamout=newBufferedOutputStream(

newfileoutputstream(dest))；

//输入流

密码输入流in=新密码输入流(

newBufferedInputStream(新文件inputstream(file))、cipher)；

int字节=0；

while((thebyte=in.read())！=-1){

out。写(字节)；

}

英寸。close()；

完毕。close()；

}捕捉(例外ey5){

log.info("；加密文件时出错");

抛出新的运行时异常(ey5)；

}

}

/**

*加密

*@paramkeyPath密钥路径

*@paramsource加密前文件

*@paramdest加密后文件

*/

publicstaticvoidencrypt(Stringkeypath，Stringsource，Stringdest){

秘钥key=null

try{

ObjectInputStreamkeyFile=newObjectInputStream(

//Readtheencryptionkey

newfileinputstream(keypath))；);

key=(秘密密钥)keyfile。readobject()；

密钥文件。close()；

}catch(找不到文件异常ey1){

日志。信息("读取密钥文件时出错");

抛出新的运行时异常(ey1)；

}捕捉(异常ey2){

log.info("；读取密钥文件时出错");

抛出新的运行时异常(ey2)；

}

//生成密钥为

cipher的密码=null

try{

//设置算法，应该和加密的时候一样。

密码=密码。getinstance("；DES");

//设置解密模式

cipher.init(密码.ENCRYPT_MODE，key)；

}捕捉(例外ey3){

log.info("；创建密码时出错");

抛出新的运行时异常(ey3)；

}

//获取要解密的文件并解密

filefile=newfile(source)；

Stringfilename=file.getname()；

Try{

/outputstream,pleasepayattentiontotheacquisitionoffilename

BufferedOutputStreamout=newBufferedOutputStream(

newfileoutputstream(dest))；

//输入流

密码输入流in=新密码输入流(

newBufferedInputStream(新文件inputstream(file))、cipher)；

int字节=0；

while((thebyte=in.read())！=-1){

out。写(字节)；

}

英寸。close()；

完毕。close()；

}捕捉(例外ey5){

log.info("；加密文件时出错");

抛出新的运行时异常(ey5)；

}

}

}

这里有个例子，直接用就好。

包com.nnff.des；

导入Java。安全。安全性；

导入javax。密码。密码；

导入javax。密码。密钥；

导入javax。密码。规格。secretkeyspec

/*stringDESede(3DES)加密

*3DES(TripleDES)是一种用于从DES过渡到AES的加密算法(1999年，NIST指定3-DES作为过渡

*加密标准)，它是DES的一种更安全的变体。。它以DES为基本模块，结合分组方法设计了一种分组加

*加密算法。其具体实现如下：设Ek()和Dk()代表DES算法的加解密过程，K代表DES算法使用的

*key，其中p代表明文，c代表密表，所以

*3DES的加密过程是：c=ek3(dk2(ek1(p))]

*3DES解密过程为：P=Dk1((EK2(Dk3(C)))

**/

公共类ThreeDes{

/**

*@paramargs用java调用sun公司提供的3DES加解密算法时，需要使

*Thefollowingfourconflictpackagesareusedinthe$JAVA_HOME/jre/lib/directory:

*jce.jar

*security/US_export_policy。jar

*安全/本地策略。罐子

*分机/孙JCE_提供者。jar

*/

privatestaticfinalstringalgorithm="DESede//definestheencryptionalgorithm,whichcanbeDES,DESedeandPuffer

//keybyte是长度为24字节的加密密钥

//src是加密数据缓冲区(源)

公共静态字节[]加密模式(字节[]密钥字节，字节[]src){

尝试{

//生成密钥

SecretKeydeskey=newSecretKeySpec(密钥字节，算法)；

//加密密码C1=密码。getinstance(算法);

c1.init(密码.ENCRYPT_MODE，deskey)；

返回C1.dofinal(src)；//单方面加密或解密

}catch(Java。安全。nosuch算法异常E1){

//TODO:处理异常E1。printstacktrace()；

}catch(javax。密码。nosuchpaddingexceptionE2){

E2。printstacktrace()；

}catch(Java。郎。例外E3){

}

返回null

}

//keybyte是长度为24字节的加密密钥

//src是加密缓冲区

公共静态字节[]解密模式(字节[]密钥字节，字节[]src){

尝试{

//生成密钥

SecretKeydeskey=newSecretKeySpec(密钥字节，算法)；

//解密密码C1=密码。getinstance(算法);

c1.init(密码.DECRYPT_MODE，deskey)；

返回C1。做final(src)；

}catch(Java。安全。nosuch算法异常E1){

//TODO:处理异常E1。printstacktrace()；

}catch(javax。密码。nosuchpaddingexceptionE2){

E2。printstacktrace()；

}catch(Java。郎。例外E3){

}

返回空

}

//Converttohexadecimalstring

publicstaticstringbyte2Hex(byte[]b){

Stringhs="；"

Stringstmp="；"

for(intn=0；注意：长度；n){

stmp=(Java。郎。整数。tohexstring(b[n]0xff))；

if(stmp。length()==1){

hs=hs"；0>；stmp

}else{

hs=hsstmp；

}

if(nb。长度-1)hs=hs"；"；

}

返回hs。touppercase()；

}

publicstaticvoidmain(string[]args){

//Todoautomaticallygeneratedmethodstub.

//添加新的安全算法。如果使用JCE，将添加

安全。添加提供程序(新的com。星期日密码。提供商。孙JCE())；

Lastbyte[]Keybyte={0x11,0x22,0x4F,0x58,

(字节)0x88，0x10，0x40，0x38，0x28，0x25，0x79，0x51，

(字节)0xCB，

(字节)0xDD，0x55，0x66，0x77，0x29，0x74，

(字节)0x98，0x30，0x40，0x36，

(字节)0xE2

}；//24字节的密钥

StringSZsrc="；这是一个3DES测试。测试"

system.out.println("；加密前的字符串：“SZsrc)；

byte[]加密模式(密钥字节，SZsrc。getbytes())；

System.out.println("Encryptedstring:"Newstring(encoding)"

byte[]srcbytes=解密模式(密钥字节，已编码)；

system.out.println("；解密后的字符串："（新字符串(src字节)))；

}

}

包com。电话。停下来。c；

导入Java。安全。关键；

导入javax。密码。密码；

导入javax。密码。规格。secretkeyspec

公共b类

{

//属性

privatestaticstringa="123456

//PasswordThisclassprovidescryptographicfunctionsforencryptionanddecryption

Privatepasswordb=null.

privatepasswordc=null

/*

*constructorcallsstaticmethoda()

/

publicb()[

{

This(1);

}

/*

*Constructionmethodstringparameters

/

publicb(StringparamString)

{

//调用私钥b(byte[]paraarrayofbyte)方法

KeylocalKey=b(paramstring。getbytes())；

//返回实现指定转换的

密码对象

这个。b=密码。getinstance("；DES");

//用密钥初始化此零对象

this.b.init(1，localKey)；

这个。c=密码。getinstance("；DES");

this.c.init(2，localKey)；[XY002][XY001]}[XY002][XY001]/*[XY002]*Calculationparametersconvertsubmarinethermalneutronreactor(abbreviationofsubmarinethermalreactor)intohexadecimalvalue

*/

publicstaticbyte[]a(stringparamstring)

{

byte[]arrayofbyte1=paramstring。getbytes()；

intI=arrayofbyte1。长度；

byte[]arrayOfByte2=新字节[I/2]；

for(intj=0；j=2)

{

if(j=i){

返回arrayofbyte2

}

Stringstr=newString(arrayofbyte1，j，2)；

arrayofbyte2[(j/2)]=((字节)整数。parseint(str，16))；

}

}

/*

*根据给定的字节数组构造一个键，使用键中第一个lenbytes

*/

私钥b(byte[]paraarrayofbyte)

{

byte[]arrayOfByte=newbyte[8]；

for(intI=0；i)

{

if((I=paramarrayofbyte。length)||(I=arrayofbyte。长度)){

返回新的SecretKeySpec(arrayOfByte，"DES");

}

arrayOfByte[I]=paraarrayofbyte[I]；

}

}

公共字节[]a(字节[]paramArrayOfByte)

{

还这个。c.dofinal(paramArrayOfByte)；

}

公共字符串b(StringparamString)

{

返回新字符串(a(a(paramString)))；

}

}

第一步：

导入Java。安全。消息摘要；

第二步：

私有最终静态字符串[]位数={"0>；"1"，"2"，"3"，"4"，"5"，"6"，"7"，

"；8"，"9"，"a"，"b"，"c"，"d"，"e"，"f"};

第三步：

公共静态字符串byteArrayToHexString(byte[]b){

Stringbuffersb=newStringbuffer()；

for(字节aB:b){

sb。append(byteToHexString(aB))；

}

返回sb。tostring()；

}

第四步：

私有静态字符串byteToHexString(byteb){

intn=b；

if(n0){

n=256n；

}

intD1=n/16；

intD2=n；

Returnsthenumberofdigits[d1]andthenumberofdigits[d2];

}

Step5:

公共静态字符串MD5编码(字符串原点){

字符串结果=""尝试{

结果=原点；

消息摘要MD=消息摘要。getinstance("；MD5");

MD.更新(结果。getbytes("；UTF-8"；));

result=byteArrayToHexString(MD.digest())；

}catch(异常e){

e.printstacktrace()；

}

返回结果；

}

应用实例：

包zy.until

导入Java。安全。消息摘要；

/**

*User:lxy

*Date:June23,2015

*/

私有最终静态字符串[]位数={"0>；"1"，"2"，"3"，"4"，"5"，"6"，"7"，

"；8"，"9"，"a"，"b"，"c"，"d"，"e"，"f"};

公共静态字符串byteArrayToHexString(byte[]b){

Stringbuffersb=newStringbuffer()；

for(字节aB:b){

sb。append(byteToHexString(aB))；

}

返回sb。tostring()；

}

私有静态字符串byteToHexString(byteb){

intn=b；

if(n0){

n=256n；

}

intD1=n/16；

intD2=n；

Returnsthenumberofdigits[d1]andthenumberofdigits[d2];

}

CommonstaticstringMD5Encode(stringsource){

Stringresult=""

try{

result=origin;

消息摘要MD=消息摘要。getinstance("；MD5");

MD.更新(结果。getbytes("；UTF-8"；));

result=byteArrayToHexString(MD.digest())；

}捕捉（异常e){

e.printstacktrace()；

}

returnstheresult;[XY002][XY001]}[XY002]}[XY002][XY001]TheJavaencryptionstringcanusethedataencryptionstandardencryptionalgorithm.,实例如下：

包测试；

导入Java。io。文件输入流；

导入Java。io。文件输出流；

导入Java。io。io异常；

导入Java。io。objectinputstream

导入Java。io。对象输出流；

导入Java。安全。*;

导入javax。密码。密码；

导入javax。密码。密钥生成器；

导入javax。密码。密钥；

/**

*加密解密

*

*@作者shy.qiu

*@Encryptmessagedigest5from

*/

publicclasscrypttest{

/*

*

*@paraminfo

*要加密的信息

*@returnString加密字符串

*/

公共字符串encryptomD5(字符串信息){

byte[]digesta=null；尝试{

//得到一个讯息摘要5的消息摘要

消息摘要alga=消息摘要。getinstance("；MD5");

//添加要汇总的信息

alga.update(info.getbytes())；

//获取摘要

digesta=alga。digest()；

}catch(nosuch算法异常e){

e.printstacktrace()；

}

//将摘要转为字符串

StringRS=byte2hex(digesta)；

返回RS；

}

/**

*进行恒星时角加密

*

*@paraminfo

*要加密的信息

*@returnString加密字符串

*/

公共字符串encryptToSHA(Stringinfo){

byte[]digesta=null；尝试{

//得到一个SHA-1的消息摘要

消息摘要alga=消息摘要。getinstance("；SHA-1"；);

//添加要汇总的信息

alga.update(info.getbytes())；

//获取摘要

digesta=alga。digest()；

}catch(nosuch算法异常e){

e.printstacktrace()；

}

//将摘要转为字符串

StringRS=byte2hex(digesta)；

返回RS；

}

/////////////////////////

/**

*Createthekey

*

*Encryptionalgorithm,whichcanbeDES,DESedeandPuffer

*@returnSecretKey秘密（对称)密钥

*/

publicsecretkeycreatesecretkey{

//Declarethekeygeneratorobject

密钥生成器密钥gen

//声明密钥对象

密钥deskey=null尝试{

//Returnsthekeygeneratorobject

keygen=keygenerator.getinstance(algorithm)thatgeneratesthesecretkeyofthespecifiedalgorithm;

//生成一个密钥

deskey=keygen。生成密钥()；

}catch(nosuchalgorithmexceptione){

e.printstacktrace()；

}

//返回密匙

Returnsdeskey[XY002][XY001]}[XY002][XY001]/*[XY002][XY001]*Dataencryptionaccordingtothekey[XY002][XY001][XY002]]

*key

*@paraminfo

*要加密的信息

*@返回字符串加密的信息。

*/

公共字符串encryptodes(密钥key，字符串信息){

//定义加密算法，可用DES，DESede，Blowfish

字符串算法="DES"；

//加密随机数生成器(RNG)，(你不'；t不需要写)

SecureRandomSr=NewSecureRandom()；

//定义要生成的密文

byte[]密码字节=null

试试{

//得到加密/解密器

cipherC1=cipher.getinstance(algorithm);

//Initializesthezeroobjectwiththespecifiedkeyandpattern

//参数：(ENCRYPT_MODE，DECRYPT_MODE，WRAP_MODE，UNWRAP_MODE)

c1.init(密码。ENCRYPT_MODE，key，Sr)；

//对要加密的内容进行编码，

密码字节=C1。做最后的(信息。getbytes())；

}捕捉（异常e){

e.printstacktrace()；

}

//返回密文的十六进制形式

返回字节2十六进制(密码字节)；

}

/**

*Decryptionofdataencryptionstandardaccordingtokey

*

*@paramkey

.

*@paramsinfo

*要解密的密文

*@returnString返回解密后的信息

*/

公共字符串decryptByDES(SecretKeykey，StringsInfo){

//定义加密算法，

字符串算法="DES"；

//加密随机数生成器(RNG)

SecureRandomSr=newSecureRandom()；

字节[]密码字节=空；尝试{

//得到加密/解密器密码C1=密码。getinstance(算法);

//用指定的密钥和模式初始化密码对象

C1.init(Cipher.decrypt_mode，key，Sr)；

//对要解密的内容进行编码

密码字节=C1.dofinal(hex2byte(sinfo))；

}catch(exceptione){

e.printstacktrace()；

//返回字节2十六进制(密码字节)；

返回新字符串(密码字节)；

}

////////////

/**

*创建一个密钥组，将公钥和私钥放入指定的文件

*

*/

publicvoidcreatepairkey(){

try{

//根据特定算法生成的密钥对生成器

keypairgeneratorkeygen=keypairgenerator.getinstance("；DSA");RNG发电公司

SecureRandomrandom=newSecureRandom()；

//重新设置此随机对象的种子

random.setseed(1000)；

//初始化密钥对生成器，以便使用给定的随机源(和默认参数集

keygen.initialize(512，随机);//keygen。初始化(512)；

//生成密钥组

keypairkeys=keygen.generatekeypair()；

获取公钥(XY002)

公钥pubkey=keys。getpublic()；

//得到私匙

私钥prikey=keys。getprivate()；

//将公匙私匙写入到文件当中

doObjToFile("；mykeys.bat"，新对象[]{prikey，pubkey})；

}catch(nosuchalgorithmexceptione){

e.printstacktrace()；

}

}

/**

*用私钥对信息进行签名，并将签名后的信息放入指定的文件

*

*待签名信息

*@param签名文件

*已保存文件

*/

publicvoidsigntoinfo(字符串信息，字符串签名文件){

//从文件当中读取私匙

私钥myprikey=(私钥)getObjFromFile("；我的钥匙。bat",1);

//从文件中读取公匙

publickeymypubkey=(publickey)getObjFromFile("；mykeys.bat",2);尝试{

//Signatureobjectcanbeusedtogenerateandverifydigitalsignature

Signature=signature.getinstance("DSA")；

//初始化签名

图章的私钥。初始化标志(myprikey)；

//按字节更新待签名或验证的数据

signet.update(info.getbytes())；

//签署或验证所有更新字节的签名，并返回签名

byte[]signed=signet.sign()；

//将数字签名、公钥和信息放入文件

doObjToFile(signfile，newObject[]{signed，mypubkey，info})；

}catch(异常e){

e.printstacktrace()；

}

}

/**

*读取数字签名文件，根据公钥、签名和信息验证信息的合法性

*

*@返回真验证成功，假验证失败

*/

公共布尔验证签名(字符串签名文件){

//读取公匙

publickeymypubkey=(publickey)getObjFromFile(signfile，2)；请签名(xy002)

byte[]signed=(byte[])getObjFromFile(signfile，1)；

//读取信息

Stringinfo=(String)getObjFromFile(signfile，3)；尝试{

//Initializeasignatureobjectandverifyitwiththepublickeyandsignature

Signaturesignetcheck=signature.getinstance("DSA")；

//初始化验证签名的公钥

签名检查。初始化验证(我的公钥)；

//用指定的字节数组

signetcheck.Update(info.getbytes())更新待签名或验证的数据；

系统。出去。println(info)；

//验证传入的签名

返回signetcheck.verify(已签名);

}catch(异常e){

e.printstacktrace()；

返回false

}

}

/**

*将二进制转换为十六进制字符串

*

*@returnString

*/

公共字符串byte2hex(byte[]b){

Stringhs="；"

Stringstmp="；"

for(intn=0；注意长度；n){

stmp=(Java。郎。整数。tohexstring(b[n]0xff))；

if(stmp。length()==1){

hs=hs"；0>；stmp

}else{

hs=hsstmp；

}

}

返回hs。touppercase()；

}

/**

*十六进制字符串转化为2进制

*

*@paramhex

*@return

*/

publicbyte[]hex2byte(Stringhex){

byte[]ret=新字节[8];

byte[]tmp=hex。getbytes()；

for(intI=0；I8；I){

ret[I]=unitebytes(tmp[I*2]，tmp[I*21])；

}

retreturns;

}

/*

*SynthesizetwoAmericanstandardcodecharactersintoonebyte;Suchas:"EF"-0xEF

*

*@paramsrc0

*byte

*@paramsrc1

*byte

*@returnbyte

*/

公共静态字节单位字节(字节src0，字节src1){

byte_B0=字节。解码("0x"新字符串(新字节[]{src0})

.字节值()；

_b0=(字节)(_B04)；

byte_B1=byte。解码("0x"新字符串（新字节[]{src1}))

.字节值()；

byteret=(byte)(_B0^_B1)；

retret；

}

/**

*将指定对象写入指定文件

*

*@paramfile

*指定写入的文件

*@paramobjs

*要写入的对象

*/

publicvoiddoObjToFile(Stringfile，Object[]objs){

对象输出流OOS=null；

try{

文件输出流fos=新文件输出流(file)；

oos=新对象输出流(fos)；

for(intI=0；我反对。长度；i){

}

}捕捉（例外e){

e.printstacktrace()；

}最后试试{

OOS。close()；

}catch(io异常e){

e.printstacktrace()；

}

}

}

/**

*返回对象

*

*@paramfile

*指定的文件

*@parami

*从一开始

*@return

*/

公共对象getObjFromFile(Stringfile，intI){

ObjectInputStreamois=null；

对象obj=null

try{

fileinputstreamfis=newfileinputstream(file)；

ois=newObjectInputStream(fis)；

for(intj=0；jI；j){

obj=ois。readobject()；

}

}捕捉（例外e){

e.printstacktrace()；

}最后{

试试{

ois。close()；

}catch(io异常e){

e.printstacktrace()；

}

}

返回obj

}

/**

*测试

*

*@paramargs

*/

publicstaticvoidmain(String[]args){

CryptTestjiami=newCryptTest()；

//Executemessagedigest5toencrypt"Helloworld!"

system.out.println("；你好经过MD5:"；嘉米。加密tomd5喂"));

//生成一个数据加密标准算法的密匙

秘钥key=佳米。创建密钥("DES");

//用密匙加密信息"你好世界!"

Stringstr1=jiami。encryptodes(键，“Hello”)；

system.out.println("；用des加密信息你好是："str1)；

//使用此密钥解密

Stringstr2=jiami。decryptbydes(key，str1)；

系统。出去。println("；解密后为："str2)；

//创建公钥和私钥

jiami.createpairkey()；

//是的，你好世界！用私钥签名

jiami.signtoinfo("；喂"，"我的标志。bat");

//利用公匙对签名进行验证

if(佳米。验证签名("我的标志。bat"){

系统。出去。println("；成功！");

}else{

系统。出去。println("；失败！");

}

}

}

相信通过边肖对javacrypto和javacryptodemo的介绍，您对javacrypto有了更深入的了解。感谢大家的支持和关注！

相关内容