1、SHA-256加密算法：
package com.arithmetic.encryption;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
//使用java.security.MessageDigest类来进行SHA-256摘要的计算。
//通过getInstance("SHA-256")方法获取SHA-256摘要的实例。
//将要进行摘要计算的密码作为字节数组传递给digest()方法来计算消息摘要。
//将摘要转换为十六进制字符串输出。
//实际应用中，还需要考虑密码的安全存储、密码强度要求等。
public class SHA256ExampleDemo {
public static void main(String[] args) {
String password = "mypassword";
try {
// 创建SHA-256摘要
MessageDigest md = MessageDigest.getInstance("SHA-256");
// 计算消息摘要
byte[] hash = md.digest(password.getBytes());
// 将摘要转换为十六进制字符串
StringBuilder sb = new StringBuilder();
for (byte b : hash) {
sb.append(String.format("%02x", b));
}
String hashHex = sb.toString();
System.out.println("SHA-256摘要值：" + hashHex);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
}2、加强型SHA-256加密算法：
package com.arithmetic.encryption;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
//使用SHA-256算法对密码进行加密，并添加了随机盐值和迭代计算的步骤。
//运行代码，将在控制台打印出经过加密处理的密码。
//实际使用中需要根据具体需求进行适当的修改和补充。
public class SHA256PasswordHashingExampleAdd {
public static void main(String[] args) {
String password = "1297+mypasswo!rdvdhajifr";
byte[] salt = generateSalt();
byte[] hashedPassword = hashPassword(password, salt);
System.out.println("Hashed Password: " + bytesToHex(hashedPassword));
}
//迭代计算摘要：将密码进行多次迭代计算摘要，这样可以增加密码破解的时间和计算成本。
private static byte[] generateSalt() {
SecureRandom random = new SecureRandom();
byte[] salt = new byte[16];
random.nextBytes(salt);
return salt;
}
private static byte[] hashPassword(String password, byte[] salt) {
try {
MessageDigest md = MessageDigest.getInstance("SHA-256");
byte[] saltedPassword = new byte[password.getBytes().length + salt.length];
System.arraycopy(password.getBytes(), 0, saltedPassword, 0, password.getBytes().length);
System.arraycopy(salt, 0, saltedPassword, password.getBytes().length, salt.length);
md.update(saltedPassword);
byte[] hash = md.digest();
for (int i = 0; i < 10000; i++) {
md.reset();
hash = md.digest(hash);
}
return hash;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}
private static String bytesToHex(byte[] bytes) {
StringBuilder hexString = new StringBuilder();
for (byte b : bytes) {
String hex = Integer.toHexString(0xFF & b);
if (hex.length() == 1) {
hexString.append('0');
}
hexString.append(hex);
}
return hexString.toString();
}
}3、SHA-512加密算法：
package com.arithmetic.encryption;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
//定义一个input变量来保存要进行SHA-512哈希的输入，然后调用getSHA512方法来获取SHA-512哈希结果，并打印输出。
//在getSHA512方法中，使用MessageDigest类来获取SHA-512算法的实例，然后调用digest方法计算输入的哈希值。
//最后，将哈希值转换为16进制字符串并返回。如果算法不支持或者发生异常，将返回null。
public class SHA512ExampleDemo {
public static void main(String[] args) {
String input = "Hello World";
String sha512 = getSHA512(input);
System.out.println("SHA-512 hash: " + sha512);
}
private static String getSHA512(String input) {
try {
MessageDigest md = MessageDigest.getInstance("SHA-512");
byte[] messageDigest = md.digest(input.getBytes());
StringBuilder sb = new StringBuilder();
for (byte b : messageDigest) {
sb.append(Integer.toString((b & 0xff) + 0x100, 16).substring(1));
}
return sb.toString();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}
}4、加强型SHA-512加密算法：
package com.arithmetic.encryption;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
//在实际应用中，存储密码或敏感数据时应该使用更安全的方法，例如使用安全的哈希函数库或加密算法库，且需要注意密码的传输和存储的安全性。
//请根据实际需求进行适当的修改和改进。
//要加强SHA-512算法的安全性，可以采取以下措施：
//使用随机盐值：在计算SHA-512哈希值之前，先生成一个随机的盐值。
//将盐值与输入字符串进行组合，然后再计算哈希值。这样做可以增加哈希的强度和安全性，防止彩虹表等攻击。
//迭代计算：多次迭代计算哈希值，每次将前一次的哈希值与输入字符串进行组合。
//这样做可以增加计算哈希值的时间和资源成本，防止暴力破解攻击。
//使用加密密钥：使用一个加密密钥对输入字符串进行加密，然后再计算哈希值。
//只有在使用正确的密钥解密后，才能得到正确的输入字符串。这样可以防止对哈希值进行重放攻击。
//使用更长的输出长度：SHA-512算法默认的输出长度是512位，可以使用更长的输出长度来增加哈希值的长度，提高安全性。
//定期更新哈希算法：定期更新SHA-512算法，使用更新版本的算法库或升级到更安全的哈希算法。
//这可以确保使用的哈希算法是最新、最安全的。
//这些措施并不能完全保证SHA-512算法的安全性，它们只能增加攻击者破解哈希值的难度。
//实际应用中，根据具体的安全需求和架构选择合适的加固措施，并且持续关注最新的密码学发展和安全威胁。
public class SHA512EnhancedAddDemo {
public static void main(String[] args) throws NoSuchAlgorithmException {
// 生成随机的盐值
SecureRandom random = new SecureRandom();
byte[] salt = new byte[16]; // 根据需要设置盐值的长度
random.nextBytes(salt);
// 将盐值与输入字符串进行组合
String input = "yourInputString";
byte[] inputBytes = input.getBytes(StandardCharsets.UTF_8);
byte[] saltedInputBytes = new byte[salt.length + inputBytes.length];
System.arraycopy(salt, 0, saltedInputBytes, 0, salt.length);
System.arraycopy(inputBytes, 0, saltedInputBytes, salt.length, inputBytes.length);
// 计算SHA-512哈希值
MessageDigest digest = MessageDigest.getInstance("SHA-512");
byte[] hash = digest.digest(saltedInputBytes);
// 打印盐值和哈希值
System.out.println("Salt: " + bytesToHex(salt));
System.out.println("Hash: " + bytesToHex(hash));
// 使用迭代计算
int iterations = 10000; // 设置迭代次数
byte[] hashedBytes = saltedInputBytes;
for (int i = 0; i < iterations; i++) {
hashedBytes = digest.digest(hashedBytes);
}
// 打印迭代计算后的哈希值
System.out.println("Iterated Hash: " + bytesToHex(hashedBytes));
// 使用加密密钥
String keyString = "yourEncryptionKey";
byte[] keyBytes = keyString.getBytes(StandardCharsets.UTF_8);
byte[] validKeyBytes = Arrays.copyOf(keyBytes, 16); // 将密钥长度调整为16字节
SecretKeySpec keySpec = new SecretKeySpec(validKeyBytes, "AES");
Cipher cipher;
try {
cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, keySpec);
byte[] encryptedBytes = cipher.doFinal(inputBytes);
// 计算哈希值
hash = digest.digest(encryptedBytes);
// 打印加密后的哈希值
System.out.println("Encrypted Hash: " + bytesToHex(hash));
} catch (Exception e) {
e.printStackTrace();
}
}
// 将字节数组转换为十六进制表示的字符串
private static String bytesToHex(byte[] bytes) {
StringBuilder result = new StringBuilder();
for (byte b : bytes) {
result.append(String.format("%02x", b));
}
return result.toString();
}
}
