一个php加密方法，怎么用java实现，高分！

Posted 2023-03-22

最近做一个php项目的改写，里面有个调第三方webservices用到的加密方法，怎么样用java来实现它。
php代码：

function getSecureString($s)
$key = pack("H*" , '145b206c283b3c534a3822454c313a4f');
$iv = pack("H*" , '343c232c2a1b123d');
$encrypted = openssl_encrypt($s, 'bf-cbc', $key, OPENSSL_RAW_DATA, $iv);
$encryptedString = base64_encode($encrypted);
return $encryptedString;

好像里面的openssl_encrypt方法，我在网上找都找不到，不知道内部是怎么实现的。
第三方又是老外，交流不来，给了我文档，里面也没有提到这个加密原理。
50分求解答！答案解决了加50分
bf-cbc的加密方式，求java实现代码，跪求啊，快被逼疯

Java OpenSSLPBEInputStream  

   
import java.io.IOException;    
import java.io.InputStream;    
import java.security.InvalidAlgorithmParameterException;    
import java.security.InvalidKeyException;    
import java.security.NoSuchAlgorithmException;    
import java.security.spec.InvalidKeySpecException;    
   
import javax.crypto.BadPaddingException;    
import javax.crypto.Cipher;    
import javax.crypto.IllegalBlockSizeException;    
import javax.crypto.NoSuchPaddingException;    
   
public class OpenSSLPBEInputStream extends InputStream     
   
   private final static int READ_BLOCK_SIZE = 64 * 1024;    
   
   private final Cipher cipher;    
   private final InputStream inStream;    
   private final byte[] bufferCipher = new byte[READ_BLOCK_SIZE];    
   
   private byte[] bufferClear = null;    
   
   private int index = Integer.MAX_VALUE;    
   private int maxIndex = 0;    
   
   public OpenSSLPBEInputStream(final InputStream streamIn, String algIn, int iterationCount, char[] password)    
           throws IOException     
       this.inStream = streamIn;    
       try     
           byte[] salt = readSalt();    
           cipher = OpenSSLPBECommon.initializeCipher(password, salt, Cipher.DECRYPT_MODE, algIn, iterationCount);    
        catch (Exception e)     
           throw new IOException(e);    
           
       
   
   @Override    
   public int available() throws IOException     
       return inStream.available();    
       
   
   @Override    
   public int read() throws IOException     
   
       if (index > maxIndex)     
           index = 0;    
           int read = inStream.read(bufferCipher);    
           if (read != -1)     
               bufferClear = cipher.update(bufferCipher, 0, read);    
               
           if (read == -1 || bufferClear == null || bufferClear.length == 0)     
               try     
                   bufferClear = cipher.doFinal();    
                catch (Exception e)     
                   bufferClear = null;    
                   
               
           if (bufferClear == null || bufferClear.length == 0)     
               return -1;    
               
           maxIndex = bufferClear.length - 1;    
           
   
       if (bufferClear == null || bufferClear.length == 0)     
           return -1;    
           
   
       return bufferClear[index++] & 0xff;    
   
       
   
   private byte[] readSalt() throws IOException     
   
       byte[] headerBytes = new byte[OpenSSLPBECommon.OPENSSL_HEADER_STRING.length()];    
       inStream.read(headerBytes);    
       String headerString = new String(headerBytes, OpenSSLPBECommon.OPENSSL_HEADER_ENCODE);    
   
       if (!OpenSSLPBECommon.OPENSSL_HEADER_STRING.equals(headerString))     
           throw new IOException("unexpected file header " + headerString);    
           
   
       byte[] salt = new byte[OpenSSLPBECommon.SALT_SIZE_BYTES];    
       inStream.read(salt);    
   
       return salt;    
       
   

Java OpenSSLPBEOutputStream

import java.io.IOException;    
import java.io.OutputStream;    
import java.security.SecureRandom;    
   
import javax.crypto.Cipher;    
   
public class OpenSSLPBEOutputStream extends OutputStream     
   
private static final int BUFFER_SIZE = 5 * 1024 * 1024;    
   
private final Cipher cipher;    
private final OutputStream outStream;    
private final byte[] buffer = new byte[BUFFER_SIZE];    
private int bufferIndex = 0;    
   
public OpenSSLPBEOutputStream(final OutputStream outputStream, String algIn, int iterationCount,    
                             char[] password) throws IOException     
   outStream = outputStream;    
   try     
       /* Create and use a random SALT for each instance of this output stream. */    
       byte[] salt = new byte[OpenSSLPBECommon.SALT_SIZE_BYTES];    
       new SecureRandom().nextBytes(salt);    
       cipher = OpenSSLPBECommon.initializeCipher(password, salt, Cipher.ENCRYPT_MODE, algIn, iterationCount);    
       /* Write header */    
       writeHeader(salt);    
    catch (Exception e)     
       throw new IOException(e);    
       
    
   
@Override    
public void write(int b) throws IOException     
   buffer[bufferIndex] = (byte) b;    
   bufferIndex++;    
   if (bufferIndex == BUFFER_SIZE)     
       byte[] result = cipher.update(buffer, 0, bufferIndex);    
       outStream.write(result);    
       bufferIndex = 0;    
       
    
   
@Override    
public void flush() throws IOException     
   if (bufferIndex > 0)     
       byte[] result;    
       try     
           result = cipher.doFinal(buffer, 0, bufferIndex);    
           outStream.write(result);    
        catch (Exception e)     
           throw new IOException(e);    
           
       bufferIndex = 0;    
       
    
   
@Override    
public void close() throws IOException     
   flush();    
   outStream.close();    
    
   
private void writeHeader(byte[] salt) throws IOException     
   outStream.write(OpenSSLPBECommon.OPENSSL_HEADER_STRING.getBytes(OpenSSLPBECommon.OPENSSL_HEADER_ENCODE));    
   outStream.write(salt);    
    
   

Main Class 测试以上两个class

import javax.crypto.Cipher;    
import javax.crypto.NoSuchPaddingException;    
import javax.crypto.SecretKey;    
import javax.crypto.SecretKeyFactory;    
import javax.crypto.spec.PBEKeySpec;    
import javax.crypto.spec.PBEParameterSpec;    
import java.security.InvalidAlgorithmParameterException;    
import java.security.InvalidKeyException;    
import java.security.NoSuchAlgorithmException;    
import java.security.spec.InvalidKeySpecException;    
   
class OpenSSLPBECommon     
   
protected static final int SALT_SIZE_BYTES = 8;    
protected static final String OPENSSL_HEADER_STRING = "Salted__";    
protected static final String OPENSSL_HEADER_ENCODE = "ASCII";    
   
protected static Cipher initializeCipher(char[] password, byte[] salt, int cipherMode,    
                                        final String algorithm, int iterationCount) throws NoSuchAlgorithmException, InvalidKeySpecException,    
       InvalidKeyException, NoSuchPaddingException, InvalidAlgorithmParameterException     
   
   PBEKeySpec keySpec = new PBEKeySpec(password);    
   SecretKeyFactory factory = SecretKeyFactory.getInstance(algorithm);    
   SecretKey key = factory.generateSecret(keySpec);    
   
   Cipher cipher = Cipher.getInstance(algorithm);    
   cipher.init(cipherMode, key, new PBEParameterSpec(salt, iterationCount));    
   
   return cipher;    

   

来源引用

   https://github.com/guardianproject/ChatSecureandroid/tree/master/src/info/guardianproject/otr

参考技术A 先找出来是什么算法，JAVA 里面的现成的算法还是较多的。

看加密的方法，应该是 blowfish 请百度 还是较容易找到的 blowfish JAVA 实现

接口测试时遇到Java代码加密请求数据，用Python的我该怎么办？

前言

自动化测试应用越来越多了，尤其是接口自动化测试。

在接口测试数据传递方面，很多公司都会选择对请求数据进行加密处理。

而目前为主，大部分公司的产品都是java语言实现的。所以加密处理也是java实现的。

作为用python做测试的我，要做接口自动化时，如何去对请求数据进行加密呢？ 

解决方法

基于此，首先去找开发了解一下具体的加密过程，甚至可以画一个加密流程图出来。

一种方法是：用python代码去实现加密流程。

对测试人员技术能力有所要求，对加密的实现也需要与开发人员密切进行交流。

另外一种便捷的方法就是：直接用python语言调java的加密方式，得到加密后的数据。

这种方式的好处：不用管加密的过程。只要知道如何调用、怎么传加密数据，怎么得到加密后的数据就可以。

调用Java加密代码-方式一

使用python语言调用java加密代码—方式一

此处感谢歪歪大佬提供了java版加密代码。

本篇文章中，歪歪大佬角色：开发GG

1、了解需要用到的加密信息

而我作为测试MM((有一点java基础的)做的第一件事情就是：

愉快的和开发GG聊起了天，咨询了在Java的加密方式中，调用哪个函数可以实现数据加密

第二件事情，就是让开发GG给我打了一个jar包。

这样我用python代码直接调用jar包里的函数就可以了。

2、开始编写python代码，调用java包里的加密函数

python是胶水语言，可以与很多语言一起使用。

python3有个第三方库Jpype1

将开发提供的jar包放在py工程的目录下面。

python代码如下(看每一行代码的注释哦)：

运行此段代码之后，对数据1234的加密结果为：

  

调用Java加密代码-方式二

使用python语言调用java加密代码—方式二

在完成以上操作之后，我又开始和开发GG聊了起来。

问了一句，我可以直接给jar包传参吗？不用去调用java的函数，在调用jar包的同时 给它传参，直接得到加密后的数据？

开发GG说，可以！

等我改一下，我重新发一个jar给你。

于是，5分钟后，开发GG甩了我一个新的jar包，告诉我使用方式。

我又愉快的开启了第二种使用模式。

使用方式是这样的：

在命令行当中使用java命令行：java -jar jar包 -d 要加密的数据。

命令行输出的就是加密后的数据了。

我在命令行试了一下，果真如此：

于是，我转换成了python代码

(需要获取命令行执行的结果，所以要用到subprocess模块)：

执行结果如下：

综上，当我们在用python遇到java加密的时候。

可以使用以上2种方式来利用java加密得到加密后的数据。

当然，在这个过程中，我也会遇到问题。

当有问题时，我会向开发GG咨询，因为从启动JVM之后，都是java了，运行出错了或者整不明白的，我都会向开发GG请教。

所以，在工作当中有什么问题，自己查资料的基础上，多与相关人员进行沟通，带着具体的问题去沟通和请教。

希望大家也可以多多有自己解决问题的能力。

本文由柠檬班小简老师原创，转载需注明出处！

让软件测试学习变得更简单！

今日问题

Java如何面向对象编程？

想知道答案吗？

扫描即可解锁解题视频

来都来了，点个在看再走吧~~~