前后端调用接口，防止他人窃取，用什么方式

85 0 0

在Java中，如果你希望保护接口调用时的参数不被轻易获取，你可以通过加密参数的方式来增加安全性。以下是几种常见的做法：

对称加密:
使用像AES（Advanced Encryption Standard）这样的对称加密算法，可以对参数进行加密。客户端和服务器共享同一个密钥，发送时加密，接收时解密。
示例代码片段：

     import javax.crypto.Cipher;
     import javax.crypto.spec.SecretKeySpec;
     import java.util.Base64;

     // 加密
     byte[] encrypt(String key, String plainText) {
         SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), "AES");
         Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
         cipher.init(Cipher.ENCRYPT_MODE, secretKey);
         return Base64.getEncoder().encode(cipher.doFinal(plainText.getBytes()));
     }

     // 解密
     String decrypt(String key, byte[] encryptedBytes) {
         SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), "AES");
         Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
         cipher.init(Cipher.DECRYPT_MODE, secretKey);
         return new String(cipher.doFinal(Base64.getDecoder().decode(encryptedBytes)));
     }

非对称加密:
RSA或DSA等非对称加密算法，使用一对公钥和私钥。客户端使用服务器的公钥加密参数，服务器使用私钥解密。
这种方法更适合在不安全的网络环境中，因为即使公钥被截获，也无法解密数据，因为只有私钥才能解密。
在Java中，常用的非对称加密算法主要是RSA和ECC。以下是使用这两种算法的基本步骤：
RSA（Rivest-Shamir-Adleman）
导入必要的库：

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import javax.crypto.Cipher;
import java.io.*;

生成公钥和私钥：

KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(2048); // 指定密钥长度，例如2048位
KeyPair keyPair = keyGen.generateKeyPair();
PublicKey publicKey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();

加密数据：

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); // 选择填充模式
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encryptedData = cipher.doFinal(data.getBytes()); // data是待加密的字符串

解密数据：

cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] decryptedData = cipher.doFinal(encryptedData);
String originalData = new String(decryptedData);

ECC（Elliptic Curve Cryptography）
导入必要的库（可能需要Bouncy Castle库，因为它在Java标准库中不是默认支持的）：

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import java.security.Security;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.ECGenParameterSpec;
import javax.crypto.Cipher;
import java.io.*;

添加Bouncy Castle Provider：

if (Security.getProvider("BC") == null) {
    Security.addProvider(new BouncyCastleProvider());
}

生成公钥和私钥：

KeyPairGenerator keyGen = KeyPairGenerator.getInstance("EC", "BC");
keyGen.initialize(new ECGenParameterSpec("secp256r1")); // 选择椭圆曲线
KeyPair keyPair = keyGen.generateKeyPair();
PublicKey publicKey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();

加密数据：

Cipher cipher = Cipher.getInstance("ECIES", "BC"); // 选择合适的椭圆曲线加密算法
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encryptedData = cipher.doFinal(data.getBytes());

解密数据：

cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] decryptedData = cipher.doFinal(encryptedData);
String originalData = new String(decryptedData);

请注意，实际应用中还需要考虑密钥的存储、传输和生命周期管理等问题，以及可能需要处理的异常。同时，非对称加密通常用于建立对称加密的密钥，因为非对称加密速度较慢，不适合大量数据的加密

数字签名:
使用哈希函数（如SHA-1或SHA-256）和私钥创建签名，然后将签名与原始参数一起发送。服务器使用公钥验证签名的有效性，确保数据未被篡改。
在Java中，使用盐（Salt）加密密码的常见步骤如下，这里以BCrypt强散列函数为例，因为它是专门为密码存储设计的，提供了自动盐值生成和较强的加密强度。BCrypt是由OpenBSD团队开发的一种加密算法，现在广泛应用于Web应用程序中。
使用BCrypt进行加盐加密
首先，你需要添加BCrypt库到你的项目中。如果你使用Maven，可以在pom.xml文件中添加依赖：

<dependency>
    <groupId>org.mindrot</groupId>
    <artifactId>jbcrypt</artifactId>
    <version>0.4</version>
</dependency>

接下来，使用BCrypt进行加盐加密的示例代码：

import org.mindrot.jbcrypt.BCrypt;

public class PasswordEncryptionExample {

    // 生成一个加密后的密码（自动包含盐值）
    public static String encryptPassword(String plainTextPassword) {
        return BCrypt.hashpw(plainTextPassword, BCrypt.gensalt());
    }

    // 验证密码
    public static boolean verifyPassword(String plainTextPassword, String storedHash) {
        return BCrypt.checkpw(plainTextPassword, storedHash);
    }

    public static void main(String[] args) {
        String passwordToEncrypt = "mySecurePassword";
        
        // 加密密码
        String hashedPassword = encryptPassword(passwordToEncrypt);
        System.out.println("Encrypted Password: " + hashedPassword);
        
        // 模拟验证密码
        boolean isMatch = verifyPassword(passwordToEncrypt, hashedPassword);
        System.out.println("Does the password match? " + isMatch);
    }
}

使用其他哈希函数手动加盐
如果不使用BCrypt，而是使用如SHA-256等哈希函数手动加盐，步骤如下：
生成盐值：通常使用一个安全的随机数生成器（如SecureRandom）来生成一个随机的盐值。
拼接密码和盐值：将原始密码字符串与盐值拼接。
哈希拼接后的字符串：使用哈希函数（如SHA-256）对拼接后的字符串进行哈希。
存储盐值和哈希值：将盐值和哈希后的值一并存储在数据库中。
示例代码（使用SHA-256和手动盐值）：使用其他哈希函数手动加盐
如果不使用BCrypt，而是使用如SHA-256等哈希函数手动加盐，步骤如下：
生成盐值：通常使用一个安全的随机数生成器（如SecureRandom）来生成一个随机的盐值。
拼接密码和盐值：将原始密码字符串与盐值拼接。
哈希拼接后的字符串：使用哈希函数（如SHA-256）对拼接后的字符串进行哈希。
存储盐值和哈希值：将盐值和哈希后的值一并存储在数据库中。
示例代码（使用SHA-256和手动盐值）：

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

public class SHA256WithSaltExample {

    public static void main(String[] args) throws NoSuchAlgorithmException {
        String password = "mySecurePassword";
        SecureRandom random = new SecureRandom();
        byte[] salt = new byte[16]; // 16 bytes salt
        random.nextBytes(salt); // Generate a random salt
        
        String hashed = hashWithSalt(password, salt);
        System.out.println("Hashed Password: " + hashed);
        // 实际应用中，应将salt和hashedPassword一起存储
    }
    
    public static String hashWithSalt(String password, byte[] salt) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        md.update(salt);
        byte[] hashedPassword = md.digest(password.getBytes());
        // 可选：进一步处理hash，如Base64编码，使其可打印和存储
        return bytesToHex(hashedPassword);
    }
    
    private static String bytesToHex(byte[] bytes) {
        StringBuilder result = new StringBuilder();
        for (byte b : bytes) {
            result.append(String.format("%02x", b));
        }
        return result.toString();
    }
}

请注意，手动管理盐和哈希过程虽然提供了灵活性，但也增加了实现错误的风险。因此，推荐使用成熟的库和算法，如BCrypt，它们已经考虑到了安全性最佳实践。

HTTPS/TLS:
在网络层使用HTTPS（HTTP over TLS/SSL）协议，可以对整个HTTP请求进行加密，包括URL、头信息和正文，防止中间人攻击。

使用框架集成:
如果你在Spring框架中工作，可以利用Spring Security来实现加密和解密，包括自定义拦截器来处理加密逻辑。
Spring Security 提供了内置的密码编码器来处理密码的加密和验证，其中最常用的是 BCryptPasswordEncoder。下面是如何使用 Spring Security 的 BCryptPasswordEncoder 来处理密码的加密和解密（实际上在密码验证场景中，我们并不需要解密，而是对比加密后的密码）：
1.密码加密：添加 BCryptPasswordEncoder 到你的 Spring Boot 应用中，并使用它来加密密码。以下是一个简单的例子：

   import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

   @Configuration
   public class SecurityConfig {

       @Bean
       public BCryptPasswordEncoder passwordEncoder() {
           return new BCryptPasswordEncoder();
       }
   }

在用户注册或密码修改时，你可以使用这个密码编码器来加密密码：

   @Autowired
   private BCryptPasswordEncoder bCryptPasswordEncoder;

   public String encodePassword(String plainPassword) {
       return bCryptPasswordEncoder.encode(plainPassword);
   }

2.密码验证：当用户尝试登录时，Spring Security 会自动处理密码的验证。你需要确保在 UserDetailsService 实现中使用了正确的加密密码：

   @Service
   public class CustomUserDetailsService implements UserDetailsService {

       @Autowired
       private UserRepository userRepository;

       @Override
       public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
           User user = userRepository.findByUsername(username)
                   .orElseThrow(() -> new UsernameNotFoundException("User not found"));

           return new User(user.getUsername(), user.getPassword(), user.getAuthorities());
       }
   }

在上述代码中，user.getPassword() 应该返回的是数据库中存储的 BCrypt 加密后的密码。Spring Security 的 AuthenticationManager 将使用 BCryptPasswordEncoder 自动验证用户输入的密码与数据库中存储的密码是否匹配。
3.配置 Spring Security：在你的安全配置类中，设置 BCryptPasswordEncoder 作为默认的密码编码器：

   @Override
   protected void configure(AuthenticationManagerBuilder auth) throws Exception {
       auth.userDetailsService(customUserDetailsService())
               .passwordEncoder(passwordEncoder());
   }

其中，passwordEncoder() 是从 SecurityConfig 类中注入的 BCryptPasswordEncoder 实例。
请注意，密码编码器并不负责解密密码，因为密码是单向哈希，不可逆。在处理密码时，我们通常只关心密码的验证，即检查用户输入的密码与存储的哈希值是否匹配。

Token-based认证:
使用JWT（JSON Web Tokens）或OAuth2等机制，生成加密的令牌，令牌中包含用户信息和权限，而不是直接传递敏感参数。
参数混淆:
除了加密，还可以通过参数混淆或者编码转换来增加破解的难度，但这种方式不如加密安全。
请根据你的具体需求和安全级别选择合适的方法。通常，结合多种策略（比如HTTPS + 加密参数）可以提供更好的安全性。

# 随笔