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

最近做一个php项目的改写，里面有个调第三方webservices用到的加密方法，怎么样用java来实现它。php代码：functiongetSecureString($... 最近做一个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实现代码，跪求啊，快被逼疯展开

 我来答

2个回答

#热议# 应届生在签三方时要注意什么？

chenhao_89
2015-08-21 · TA获得超过1352个赞

知道小有建树答主

回答量：764

采纳率：83%

帮助的人：423万

我也去答题访问个人页

关注

展开全部

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

已赞过 已踩过<

评论收起

匿名用户
2015-08-21

展开全部

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

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

本回答被网友采纳

已赞过已踩过<

你对这个回答的评价是？
评论收起

推荐律师服务：若未解决您的问题，请您详细描述您的问题，通过百度律临进行免费专业咨询

您可能关注的内容

代码加密软件—领先的安卓Apk修改工具

轻松修改安卓应用名称和图标、定制软件的功能和界面、并将apk转成AS源代码项目。通过加固和混淆的方式让应用过白不报毒，还能将网页打包成各种手机平台的应用。

2025版Java面试题-Java面试题&笔试超5000道~超级码客

涵盖java面试高级海量Java面试题#Java语言，多线程，JVM，SpringBoot，SpringCloud，Dubbo，Java微服务，Java数据结构算法，MyBatis，Hibernate等Java面试题超5000题java面试高级

www.chaojimake.cn广告

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

您可能关注的内容

其他类似问题

为你推荐：