2. 程式人生 > >Java實現加密演算法

Java實現加密演算法

阿新 • • 發佈：2019-02-20

目錄:

Base64
訊息摘要演算法
MD
SHA
MAC
對稱加密演算法
DES
3DES
AES
PBE
非對稱加密演算法
DH
RSA
ElGamal
數字簽名演算法
RSA
DSA
ECDSA
其它演算法
IDEA
CRC

Base64

public static void jdkBase64(String msg) {
try {
BASE64Encoder encoder = new BASE64Encoder();
String encode = encoder.encode(msg.getBytes());
System.out.println("encode:" + encode);

BASE64Decoder decoder = new
 
 BASE64Decoder();
byte[] b = decoder.decodeBuffer(encode);
System.out.println("decoder:" + new String(b));
} catch (Exception e) {
}
}

public static void commonsCodesBase64(String msg) {
byte[] encodeBytes = org.apache.commons.codec.binary.Base64.encodeBase64(msg.getBytes());
System.out.println("encode:"
 
 + new String(encodeBytes));

byte[] decodeBytes = org.apache.commons.codec.binary.Base64.decodeBase64(encodeBytes);
System.out.println("decode:" + new String(decodeBytes));
}

public static void bouncyCastleBase64(String msg) {
byte[] encodeBytes = org.bouncycastle.util.encoders.Base64.encode(msg.getBytes());
System.out
 
.println("encode:" + new String(encodeBytes));

byte[] decodeBytes = org.bouncycastle.util.encoders.Base64.decode(encodeBytes);
System.out.println("decode:" + new String(decodeBytes));
}

訊息摘要演算法 - MD

 演算法:
 MD2  實現方:JDK
 MD4  實現方:BouncyCastle 簡稱BC
 MD5  實現方:JDK

public static void jdkMD2(String msg) {
try {
MessageDigest md = MessageDigest.getInstance("MD2");
byte[] md2Bytes = md.digest(msg.getBytes());
System.out.println("JDK MD2:" + org.apache.commons.codec.binary.Hex.encodeHexString(md2Bytes));
} catch (Exception e) {
e.printStackTrace();
}
}

public static void jdkMD5(String msg) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] md5Bytes = md.digest(msg.getBytes());
System.out.println("JDK MD5:" + org.apache.commons.codec.binary.Hex.encodeHexString(md5Bytes));
} catch (Exception e) {
e.printStackTrace();
}
}

// BouncyCastle
public static void bcMD4(String msg) {
try {
Security.addProvider(new BouncyCastleProvider());// 為JDK設定演算法
MessageDigest md = MessageDigest.getInstance("MD4");
byte[] md4Bytes = md.digest(msg.getBytes());
System.out.println("JDK MD5:" + org.apache.commons.codec.binary.Hex.encodeHexString(md4Bytes));
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}

Digest digest = new MD4Digest();
digest.update(msg.getBytes(), 0, msg.getBytes().length);
byte[] md4Byte = new byte[digest.getDigestSize()];
digest.doFinal(md4Byte, 0);
System.out.println("BC MD4: " + org.bouncycastle.util.encoders.Hex.toHexString(md4Byte));
}

// BouncyCastle
public static void bcMD5(String msg) {
Digest digest = new MD5Digest();
digest.update(msg.getBytes(), 0, msg.getBytes().length);
byte[] md5Byte = new byte[digest.getDigestSize()];
digest.doFinal(md5Byte, 0);
System.out.println("BC MD5: " + org.bouncycastle.util.encoders.Hex.toHexString(md5Byte));
}

//commons codec
public static void ccMD5(String msg){
System.out.println("CC MD5:"+DigestUtils.md5Hex(msg.getBytes()));
}
//commons codec
public static void ccMD2(String msg){
System.out.println("CC MD2:"+DigestUtils.md2Hex(msg.getBytes()));
}

//-----------------
public static final String MD5_TYPE_16 = "t_16";
public static final String MD5_TYPE_32 = "T_32";

public static String md5s(String plainText, String type) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(plainText.getBytes());
byte b[] = md.digest();

int i;

StringBuffer buf = new StringBuffer("");
for (int offset = 0; offset < b.length; offset++) {
i = b[offset];
if (i < 0)
i += 256;
if (i < 16)
buf.append("0");
buf.append(Integer.toHexString(i));
}
String str = buf.toString();

if (type.equals(MD5_TYPE_16)) {
str = str.substring(8, 24);
}

return str;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}

訊息摘要演算法 - SHA

安全雜湊演算法
固定長度摘要資訊
SHA-1  SHA-2(SHA-224,SHA-256,SHA-384,SHA-512)

演算法:
SHA-1    實現方:JDK
SHA-224  實現方:BC
SHA-256  實現方:JDK
SHA-384  實現方:JDK
SHA-512  實現方:JDK

public static void jdkSHA1(String msg) {
try {
MessageDigest md = MessageDigest.getInstance("SHA");// SHA1
md.update(msg.getBytes());
System.out.println("jdk SHA-1:" + Hex.encodeHexString(md.digest()));
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}

public static void bcSHA1(String msg) {
Digest digest = new SHA1Digest();
digest.update(msg.getBytes(), 0, msg.getBytes().length);
byte[] sha1Byte = new byte[digest.getDigestSize()];
digest.doFinal(sha1Byte, 0);
System.out.println("bc SHA-1:" + org.bouncycastle.util.encoders.Hex.toHexString(sha1Byte));
}

public static void bcSHA224(String msg) {
Digest digest = new SHA224Digest();
digest.update(msg.getBytes(), 0, msg.getBytes().length);
byte[] sha224Byte = new byte[digest.getDigestSize()];
digest.doFinal(sha224Byte, 0);
System.out.println("bc SHA-224:" + org.bouncycastle.util.encoders.Hex.toHexString(sha224Byte));
}

public static void jdkSHA224_2(String msg) {
try {
Security.addProvider(new BouncyCastleProvider());// 設定
MessageDigest md = MessageDigest.getInstance("SHA224");// SHA224
md.update(msg.getBytes());
System.out.println("jdk addProvider ->SHA-224:" + Hex.encodeHexString(md.digest()));
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}

public static void ccSHA1(String msg) {
System.out.println("cc sha1:" + DigestUtils.sha1Hex(msg.getBytes()));
System.out.println("cc sha512:" + DigestUtils.sha512Hex((msg.getBytes())));
}

訊息摘要演算法 - MAC

 MAC(Message Authentication Code)
 HMAC(keyed-Hash Message Authentication Code),含有金鑰的雜湊函式演算法
 任何MD,SHA
  -MD系列:HmacMD2 , HmacMD4 , HmacMD5
  -SHA系列: HmacSHA1, HmacSHA224,HmacSHA256,HmacSHA384,HmacSHA512
  
  演算法:
  HmacMD2    實現方:BC
  HmacMD4    實現方:BC
  HmacMD5    實現方:JDK
  HamcSHA1   實現方:JKD
  HmacSHA224 實現方:BC
  HmacSHA256 實現方:JKD
  HmacSHA384 實現方:JKD
  HmacSHA512 實現方:JKD
  
  
  
  其它訊息摘要演算法
  RipeMD
  Tiger
  Whirlpool
  GOST3411
  
  Bouncy Castle實現

public static void jdkHmacMD5(String msg, String keyParameter) {
try {
KeyGenerator keyGenerator = KeyGenerator.getInstance("HmacMD5");
SecretKey secretKey = keyGenerator.generateKey();// 產生金鑰
byte[] key = secretKey.getEncoded();// 獲取金鑰

key = Hex.decodeHex(keyParameter.toCharArray());//

// 還原金鑰
SecretKey restoreSecretKey = new SecretKeySpec(key, "HmacMD5");
Mac mac = Mac.getInstance(restoreSecretKey.getAlgorithm());// 例項化MAC
mac.init(restoreSecretKey);
byte[] hmacMD5Bytes = mac.doFinal(msg.getBytes());// 執行摘要
System.out.println("jdk hmacMD5:" + Hex.encodeHexString(hmacMD5Bytes));
} catch (Exception e) {
e.printStackTrace();
}
}

public static void bcHmacMD5(String msg, String keyParameter) {
HMac hmac = new HMac(new MD5Digest());

byte[] b = org.bouncycastle.util.encoders.Hex.decode(keyParameter.getBytes());
KeyParameter k = new KeyParameter(b);
hmac.init(k);
hmac.update(msg.getBytes(), 0, msg.getBytes().length);

byte[] hmacMD5Bytes = new byte[hmac.getMacSize()];
hmac.doFinal(hmacMD5Bytes, 0);

System.out.println("bc hmacMD5:" + org.bouncycastle.util.encoders.Hex.toHexString(hmacMD5Bytes));
}

對稱加密演算法 - DEC - 3DEC

 初等
 DES
-3DES
 AES
 PBE
 IDEA
 
 DES(Data Encryptiong Standard) 資料加密標準
 對稱加密元老.
 
 金鑰長度56  預設56  工作模式:ECB,CBC,PCBC,CTR,CTS,CFB,CFB8,到128,OFB,OFB8到128 
 實現方:JDK 填充方式:NoPadding,PKCS5Padding,ISO10126Padding, 
 實現方:BC 填充方式:PKCS7Padding,ISO10126d2Padding,X932Padding,ISO7816d4Pading,ZeroBytePading
 
 3DES(Triple DES或者DESede)
 金鑰長度112,168  預設168 
 金鑰長度128,192  預設168

public static void jdkDES(String src) {
try {
// 生成KEY
KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
keyGenerator.init(56);
SecretKey secretKey = keyGenerator.generateKey();
byte[] bytesKey = secretKey.getEncoded();

// KEY轉換
DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
Key convertSecretKey = factory.generateSecret(desKeySpec);

// 加密
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println("jdk des encrypt : " + Hex.encodeHexString(result));

// 解密
cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
result = cipher.doFinal(result);
System.out.println("jdk des decrypt : " + new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}

public static void bcDES(String src) {
try {
Security.addProvider(new BouncyCastleProvider());

// 生成KEY
KeyGenerator keyGenerator = KeyGenerator.getInstance("DES", "BC");
keyGenerator.getProvider();
keyGenerator.init(56);
SecretKey secretKey = keyGenerator.generateKey();
byte[] bytesKey = secretKey.getEncoded();

// KEY轉換
DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
Key convertSecretKey = factory.generateSecret(desKeySpec);

// 加密
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println("bc des encrypt : " + Hex.encodeHexString(result));

// 解密
cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
result = cipher.doFinal(result);
System.out.println("bc des decrypt : " + new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}

public static void jdk3DES(String src) {
try {
// 生成KEY
KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
// keyGenerator.init(168);
keyGenerator.init(new SecureRandom());// 預設長度
SecretKey secretKey = keyGenerator.generateKey();
byte[] bytesKey = secretKey.getEncoded();

// KEY轉換
DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
Key convertSecretKey = factory.generateSecret(desKeySpec);

// 加密
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println("jdk 3des encrypt : " + Base64.encodeBase64String(result));

// 解密
cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
result = cipher.doFinal(result);
System.out.println("jdk 3des decrypt : " + new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}

對稱加密演算法 - AES

 DES替代者
 
 金鑰長度:128,192,256 預設128 工作模式:ECB,CBC,PCBC,CTR,CTS,CFB,CFB8到128,OFB,OFB8到128 
 填充方式:NoPadding,PKCS5Padding,ISO10126Padding 實現方:JDK(256位金鑰需要獲得無政策限制許可權檔案)
 填充方式:PKCS7Padding,ZeroBytePadding 實現方:BC
 
 無政策限制許可權檔案是指,因為某些國家的進口管制限制,Java釋出的遠行環境包中的加解密有一定的限制

public static void jdkAES(String src) {
try {
// 生成KEY
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(128);
SecretKey secretKey = keyGenerator.generateKey();
byte[] keyBytes = secretKey.getEncoded();

// key轉換
Key key = new SecretKeySpec(keyBytes, "AES");

// 加密
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println("jdk aes encrypt : " + Base64.encodeBase64String(result));

// 解密
cipher.init(Cipher.DECRYPT_MODE, key);
result = cipher.doFinal(result);
System.out.println("jdk aes desrypt : " + new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}

對稱加密演算法 - PBE

PBE(Password Based Encryption)基於口令加密

演算法                         金鑰長度    預設  工作模式       填充方式      實現
PBEWithMD5AndDES                64       64      CBC       PKCS5Padding       BC
PBEWithMd5AndRC2                112      128               PKCS7Padding
PBEWithSHA1AndDES               6        64                ISO10126Padding
PBEWithSHAAndIDEA-CBC           128      128
PBEWithSHAAnd2-KeyTripleDES-CBC 128      128
PBEWithSHAAnd3-KeyTripleDES-CBC 192      192

public static void jdkPBE(String src) {
try {
// 初始化鹽
SecureRandom random = new SecureRandom();
byte[] salt = random.generateSeed(8);

// 口令與金鑰
String password = "password_comtu";
PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray());
SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
Key key = factory.generateSecret(pbeKeySpec);

// 加密
PBEParameterSpec pbeParameterSpec = new PBEParameterSpec(salt, 100);
Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
cipher.init(Cipher.ENCRYPT_MODE, key, pbeParameterSpec);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println("jdk pbe encrypt : " + Base64.encodeBase64String(result));

// 解密
cipher.init(Cipher.DECRYPT_MODE, key, pbeParameterSpec);
result = cipher.doFinal(result);
System.out.println("jdk pbe decrypt : " + new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}

非對稱加密演算法 - DH

高階 
雙保險 
公鑰,私鑰
 
  DH(Diffie-Hellman)金鑰交換演算法
  RSA-基於因子分解 ElGamal - 基於離散對數 
  ECC(Elliptical Curve Cryptography) - 橢圓曲線加密
 
 
DH 金鑰長度: 512~1024(64倍數) 預設1024 實現方:JDK

public static void jdkDH(String src) {
try {
// 1.初始化傳送方金鑰
KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");
senderKeyPairGenerator.initialize(512);
KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();
byte[] senderPublicKeyEnc = senderKeyPair.getPublic().getEncoded();// 傳送方公鑰，傳送給接收方（網路、檔案。。。）

// 2.初始化接收方金鑰
KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKeyEnc);
PublicKey receiverPublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);
DHParameterSpec dhParameterSpec = ((DHPublicKey) receiverPublicKey).getParams();
KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
receiverKeyPairGenerator.initialize(dhParameterSpec);
KeyPair receiverKeypair = receiverKeyPairGenerator.generateKeyPair();
PrivateKey receiverPrivateKey = receiverKeypair.getPrivate();
byte[] receiverPublicKeyEnc = receiverKeypair.getPublic().getEncoded();

// 3.金鑰構建
KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");
receiverKeyAgreement.init(receiverPrivateKey);
receiverKeyAgreement.doPhase(receiverPublicKey, true);
SecretKey receiverDesKey = receiverKeyAgreement.generateSecret("DES");

KeyFactory senderKeyFactory = KeyFactory.getInstance("DH");
x509EncodedKeySpec = new X509EncodedKeySpec(receiverPublicKeyEnc);
PublicKey senderPublicKey = senderKeyFactory.generatePublic(x509EncodedKeySpec);
KeyAgreement senderKeyAgreement = KeyAgreement.getInstance("DH");
senderKeyAgreement.init(senderKeyPair.getPrivate());
senderKeyAgreement.doPhase(senderPublicKey, true);
SecretKey senderDesKey = senderKeyAgreement.generateSecret("DES");

// if (com.sun.org.apache.xalan.internal.utils.Objects.equals(receiverDesKey, senderDesKey)) {
if (receiverDesKey.equals(senderDesKey)) {
System.out.println("雙方金鑰相同");
} else {
System.out.println("雙方金鑰不同");
}

// 4.加密
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, senderDesKey);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println("jdk dh encrypt : " + Base64.encodeBase64String(result));

// 5.解密
cipher.init(Cipher.DECRYPT_MODE, receiverDesKey);
result = cipher.doFinal(result);
System.out.println("jdk dh decrypt : " + new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}

非對稱加密演算法 - 數字簽名演算法 - RSA

經典演算法 
MD,SHA兩類

演算法:
MD2withRSA       實現方: JDK
MD5withRSA       實現方: JDK
SHA1withRSA      實現方: JDK
SHA224withRSA    實現方: BC
SHA256withRSA    實現方: BC
SHA384withRSA    實現方: BC
SHA512withRSA    實現方: BC
RIPEMD128withRSA 實現方: BC
RIPEMD160withRSA 實現方: BC


非對稱加密演算法-RSA
唯一廣泛接受並實現
資料加密&數字簽名
公鑰加密,私鑰解密
私鑰加密,公鑰解密

JDK 金鑰長度:512~65536(64整數倍) 工作模式:ECB 預設長度:1024 填充方式: 
NoPadding
PKCS1Padding
OAEPWITHMD5AndMGF1Pading
OAEPWITHSHA1AndMGF1Pading
OAEPWITHSHA256AndMGF1Pading
OAEPWITHSHA384AndMGF1Pading
OAEPWITHSHA512AndMGF1Pading

BC 金鑰長度:512~65536(64整數倍) 工作模式:NONE 預設長度:2048 填充方式: 
NoPadding
PKCS1Padding
OAEPWITHMD5AndMGF1Pading
OAEPWITHSHA1AndMGF1Pading
OAEPWITHSHA224AndMGF1Pading
OAEPWITHSHA256AndMGF1Pading
OAEPWITHSHA384AndMGF1Pading
OAEPWITHSHA512AndMGF1Pading
ISO9796-1Padding

public static void jdkRSA(String msg) {
try {
// 1.初始化金鑰
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(512);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

// 2.執行簽名
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initSign(privateKey);
signature.update(msg.getBytes());
byte[] result = signature.sign();
System.out.println("jdk rsa sign: " + Hex.encodeHexString(result));

// 3.驗證簽名
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
signature = Signature.getInstance("MD5withRSA");
signature.initVerify(publicKey);
signature.update(msg.getBytes());
boolean bool = signature.verify(result);
System.out.println("jdk rea verify:" + bool);
} catch (Exception e) {
}
}

public static void jdkRSA2(String src) {
try {
// 1.初始化金鑰
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(512);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
System.out.println("Public Key : " + Base64.encodeBase64String(rsaPublicKey.getEncoded()));
System.out.println("Private Key : " + Base64.encodeBase64String(rsaPrivateKey.getEncoded()));

// 2.私鑰加密、公鑰解密——加密
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println("私鑰加密、公鑰解密——加密 : " + Base64.encodeBase64String(result));

// 3.私鑰加密、公鑰解密——解密
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, publicKey);
result = cipher.doFinal(result);
System.out.println("私鑰加密、公鑰解密——解密：" + new String(result));

// 4.公鑰加密、私鑰解密——加密
x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
result = cipher.doFinal(src.getBytes());
System.out.println("公鑰加密、私鑰解密——加密 : " + Base64.encodeBase64String(result));

// 5.公鑰加密、私鑰解密——解密
pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
result = cipher.doFinal(result);
System.out.println("公鑰加密、私鑰解密——解密：" + new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}

非對稱加密演算法 - ElGamal

  公鑰加密演算法
 實現方:BC 金鑰長度:160~16384(8的整數倍) , 預設:1024 工作模式:ECB,NONE
 填充方式:
 NoPadding , PKCS1Padding
 OAEPWITHMD5AndMGF1Pading
 OAEPWITSHA1AndMGF1Pading
 OAEPWITSHA224AndMGF1Pading
 OAEPWITSHA256AndMGF1Pading
 OAEPWITSHA384AndMGF1Pading
 OAEPWITSHA512AndMGF1Pading
 ISO9796-1Padding

public static void bcElGamal(String src) {
try {
// 公鑰加密,私鑰解密
Security.addProvider(new BouncyCastleProvider());

// 1.初始化金鑰
AlgorithmParameterGenerator algorithmParameterGenerator = AlgorithmParameterGenerator.getInstance("ElGamal");
algorithmParameterGenerator.init(256);
AlgorithmParameters algorithmParameters = algorithmParameterGenerator.generateParameters();

DHParameterSpec dhParameterSpec =  (DHParameterSpec) algorithmParameters.getParameterSpec(DHParameterSpec.class);
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("ElGamal");
keyPairGenerator.initialize(dhParameterSpec, new SecureRandom());
KeyPair keyPair = keyPairGenerator.generateKeyPair();
PublicKey elGamalPublicKey = keyPair.getPublic();
PrivateKey elGamalPrivateKey = keyPair.getPrivate();

System.out.println("Public Key:" + org.apache.commons.codec.binary.Base64.encodeBase64String(elGamalPublicKey.getEncoded()));
System.out.println("Private Key:" + org.apache.commons.codec.binary.Base64.encodeBase64String(elGamalPrivateKey.getEncoded()));

} catch (Exception e) {
e.printStackTrace();
}

}

數字簽名演算法 - DSA

  DSS (Digital Signature Standard)數字簽名標準
  DSA(Digital Signature Algorithm)數字簽名演算法
  DSA僅包含數字簽名
  
  演算法:
  SHA1withDSA    實現方:JDK
  SHA224withDSA  實現方:BC
  SHA256withDSA  實現方:BC
  SHA384withDSA  實現方:BC
  SHA512withDSA  實現方:BC


            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
Java實現加密演算法

     
 
                


目錄:
Base64
訊息摘要演算法
MD
SHA
MAC
對稱加密演算法
DES
3DES
AES
PBE
非對稱加密演算法
DH
RSA
ElGamal
數字簽名演算法
RSA
DSA
ECDSA
其它演算法
IDEA
CRC


Base64
public sta 



  
 

    


    
    
JAVA 可逆加密演算法的簡單實現

     
 
                
很多加密包都提供複雜的加密演算法，比如MD5，這些演算法有的是不可逆的。
有時候我們需要可逆演算法，將敏感資料加密後放在資料庫或配置檔案中，在需要時再再還原。
這裡介紹一種非常簡單的java實現可逆加密演算法。
演算法使用一個預定義的種子(seed)來對加密內容進行異或執行 



  
 

    


    
    
【工具類】Java實現AES演算法 加密和解密

     
 
                
最近在學AES加密，通過網上學習查詢資料，封裝了一個AES加密解密工具類，說幾點：

演算法/模式/填充，這個最好使用"AES/CBC/PKCS5Padding"，"ECB"在IOS中不安全（網上查詢資料得知），不要使用預設填充引數金鑰要使用16位，不使用"AES/CBC/ 



  
 

    


    
    
Java之加密演算法

     
 加密演算法主要分為對稱加密、非對稱加密、Hash加密。 
一、何為對稱加密？ 
　　對稱加密是指對稱密碼編碼技術，它的特點是檔案加密和解密使用相同的金鑰加密。 
對稱機密的金鑰一般小於256bit。因為就金鑰而言，如果加密的金鑰越大，則其計算的複雜度越高，所需要的時間越長，而如果使用的金鑰較小，則很容易破解， 



  
 

    


    
    
Java實現加密|加密模板

     
  
 
  
  
 Java實現加密功能程式碼 
 其實加密就是用函式對應改變相應字元，比如摺疊加密就是 a<->z, b<->y, …,m<->n 所以其實只要知道加密演算法（就是字元對照規則）很好實現加密功能的 
  
 程式碼模板（我省略的部分就是加密演算法） 
  



  
 

    


    
    
java實現權重演算法

     
  
 
  
 一、簡單介紹 
 如有4個元素A、B、C、D，權重分別為1、2、3、4，隨機結果中A:B:C:D的比例要為1:2:3:4。 總體思路：累加每個元素的權重A(1)-B(3)-C(6)-D(10)，則4個元素的的權重管轄區間分別為[0,1)、[1,3)、[3,6)、[6,10)。然後隨機出一個[0 



  
 

    


    
    
java實現加密解密

     
  
  
  
 1.加密 public static String encryt(String str) { // 根據金鑰，對Cipher物件進行初始化，ENCRYPT_MODE表示加密模式 try { Cipher c = Cipher.getInstance(“AES”); c.init(Cipher 



  
 

    


    
    
一個用Java實現密碼演算法，使用socket引發的血案

     
 
                public static void main(String[] args) throws IOException, ParseException {
                ServerSocket serverSocket = new ServerSocket(1 



  
 

    


    
    
Java MD5加密演算法

     
 
								
								            
						
                MD5加密演算法，是一種被廣泛使用的密碼雜湊函式，可以產生出一個128位的雜湊值，用於確保資訊傳輸完全一致，在很多方面都有著廣泛的應用，例如儲存使用者密碼，比較下載檔案的md5值以保證檔案無損毀等等。
 



  
 

    


    
    
java數字加密演算法

     
 數字加密在專案中時常會遇到，如手機號，身份證號資訊等，下面小白將自己手寫的數字加密演算法分享給大家，可在專案中直接運用.加密規則，入參時傳遞一個欄位時間戳 time：*  1.以字母代替數字，0-9分別為["D","e","C","A","#","b","J","I","z","M"]* 2.混淆字母為FxY 



  
 

    


    
    
JAVA密碼加密演算法.RSA演算法(非對稱加密演算法)和密碼加鹽MD5

     
  
 
  
  
 密碼加鹽MD5 
 Message Digest Algorithm MD5（中文名為訊息摘要演算法第五版）為電腦保安領域廣泛使用的一種雜湊函式，用以提供訊息的完整性保護。 是計算機廣泛使用的雜湊演算法之一（又譯摘要演算法、雜湊演算法），主流程式語言普遍已有MD5實現。將資料（如漢字）運 



  
 

    


    
    
Java實現MD5演算法過程，並利用自帶MD5函式進行對比校驗

     
  
  
  
 
 
  文章目錄
  
   
    一、環境說明
    二、演算法原理概述
    三、程式設計
    
     資料結構
     重要模組步驟
    
    四、執行結果
   
  
 
  
 一、環境說明 
 作業系統：window10 
 程式語言：Java （J 



  
 

    


    
    
LeetCode 239. 滑動視窗最大值 java實現 個人演算法之旅筆記

     
 
                239. 滑動視窗最大值

給定一個數組 nums，有一個大小為 k 的滑動視窗從陣列的最左側移動到陣列的最右側。你只可以看到在滑動視窗 k 內的數字。滑動視窗每次只向右移動一位。

返回滑動視窗最大值。

示例:

輸入: nums = [1,3,-1,-3,5,3,6,7 



  
 

    


    
    
希爾排序（java實現）演算法詳解

     
 希爾排序也是一種插入排序演算法，也叫作縮小增量排序，是直接插入排序的一種更高效的改進演算法。

希爾排序因其設計者希爾（Donald Shell）的名字而得名，該演算法在 1959 年被公佈。一些老版本的教科書和參考手冊把該演算法命名為 Shell-Metzner，包含了 Marlene Metzner No 



  
 

    


    
    
java實現排序演算法之歸併排序(2路歸併)

     
 
                
 歸併排序：“歸併”的含義就是將兩個或兩個以上的有序表合併成一個新的有序表，假定待排序表含有n個記錄，則可以看成是n個有序的子表，每個子表的長度為1，然後兩兩歸併，得到n/2個長度為2或1的有序表，然後在兩兩歸併，如此重複，直到合併成一個長度為n的有序表為止，這就是2路歸併 



  
 

    


    
    
JAVA實現遺傳演算法

     
 
                


個人部落格站已經上線了，網址 www.llwjy.com ~歡迎各位吐槽~
------------------------------------------------------------------------------------------------- 



  
 

    


    
    
Java實現DFA演算法對敏感詞、廣告詞過濾功能

     
 
                
一、前言
開發中經常要處理使用者一些文字的提交，所以涉及到了敏感詞過濾的功能，參考資料中DFA有窮狀態機演算法的實現，建立有向圖。完成了對敏感詞、廣告詞的過濾，而且效率較好，所以分享一下。
具體實現：
 1、匹配大小寫過濾
 2、匹配全形半形過濾
 3、匹配過濾停頓詞過濾。 



  
 

    


    
    
修改 OpenVPN 實現加密演算法的自動協商

     
 
由另一篇博中的分析可知，OpenVPN 中有兩個加解密通道。一條是標準的 SSL 協議通道，被 OpenVPN 用於協商自己所用的金鑰。這個通道的加密演算法當然也是通過 SSL 協議來進行協商的，可以通過
--tls-cipher 選項來進行配置。另一條是 OpenVPN 自己的加解密通道，用於交換實際的資 



  
 

    


    
    
營救公主(Java實現A*演算法解決迷宮問題)

     
  
 
 很早就聽說過A*演算法，據說在尋路徑時，是一種比較高效的演算法。但是一直沒有搞清楚原理。 
  
 這段時間剛好有個營救公主的例子： 
 題描述 : 公主被魔王抓走了 ， 王子需要拯救出美麗的公主 。 他進入了魔王的城 堡 ， 魔王的城堡是一座很大的迷宮 。 為了使問題簡單化 ， 我們假設這個迷宮是 



  
 

    


    
    
【安全技術】Java 實現加密資料庫連線

     
 
                一、前言在很多專案中，資料庫相關的配置檔案內容都是以明文的形式展示的，這存在一定的安全隱患。在開發和維護專案時，不僅要關注專案的效能，同時也要注重其安全性。二、實現思路我們都知道專案啟動時，Spring 容器會載入配置檔案並讀取檔案中的內容，那麼我們可以下邊步驟操作：1) 通