public static final void main(String[] args) throws Exception { // Generate a PBE key SecretKeyFactory skFac = SecretKeyFactory.getInstance("PBE"); SecretKey skey = skFac.generateSecret(new PBEKeySpec("test123".toCharArray())); // Initialize the PBE cipher Cipher cipher = Cipher.getInstance(ALGO); cipher.init(Cipher.ENCRYPT_MODE, skey); // Permit access to the Cipher.spi field (a CipherSpi object) Field spi = Cipher.class.getDeclaredField("spi"); spi.setAccessible(true); Object value = spi.get(cipher); // Permit access to the CipherSpi.engineGetKeySize method Method engineGetKeySize = PKCS12PBECipherCore$PBEWithSHA1AndDESede.class.getDeclaredMethod( "engineGetKeySize", Key.class); engineGetKeySize.setAccessible(true); // Check the key size int keySize = (int) engineGetKeySize.invoke(value, skey); if (keySize == KEYSIZE) { System.out.println(ALGO + ".engineGetKeySize returns " + keySize + " bits, as expected"); System.out.println("OK"); } else { throw new Exception("ERROR: " + ALGO + " key size is incorrect"); } }
/** * @param s * @return * @throws GeneralSecurityException * @throws UnsupportedEncodingException */ public static String decrypt(final String s) throws GeneralSecurityException, UnsupportedEncodingException { String decrypted = null; try { if (s != null) { final SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES"); final SecretKey secretKey = secretKeyFactory.generateSecret(new PBEKeySpec(secret.toCharArray())); final Cipher cipher = Cipher.getInstance("PBEWithMD5AndDES"); cipher.init(Cipher.DECRYPT_MODE, secretKey, new PBEParameterSpec(SALT, 20)); final byte[] stringBytes = s.getBytes("UTF-8"); final byte[] decodedBytes = Base64.decode(stringBytes, Base64.DEFAULT); final byte[] decryptedBytes = cipher.doFinal(decodedBytes); decrypted = new String(decryptedBytes, "UTF-8"); } } catch (GeneralSecurityException x) { throw x; } catch (UnsupportedEncodingException x) { throw x; } catch (Exception x) { DBG.m(x); } return decrypted; }
private static void runTest(boolean isUnlimited) throws Exception { System.out.println("Testing " + (isUnlimited ? "un" : "") + "limited policy..."); String algo = "Blowfish"; int keyLength = Cipher.getMaxAllowedKeyLength(algo); AlgorithmParameterSpec spec = Cipher.getMaxAllowedParameterSpec(algo); if (isUnlimited) { if ((keyLength != Integer.MAX_VALUE) || (spec != null)) { throw new Exception("Check for " + algo + " failed under unlimited policy"); } } else { if ((keyLength != 128) || (spec != null)) { throw new Exception("Check for " + algo + " failed under default policy"); } } algo = "RC5"; keyLength = Cipher.getMaxAllowedKeyLength(algo); RC5ParameterSpec rc5param = (RC5ParameterSpec) Cipher.getMaxAllowedParameterSpec(algo); if (isUnlimited) { if ((keyLength != Integer.MAX_VALUE) || (rc5param != null)) { throw new Exception("Check for " + algo + " failed under unlimited policy"); } } else { if ((keyLength != 128) || (rc5param.getRounds() != 12) || (rc5param.getVersion() != Integer.MAX_VALUE) || (rc5param.getWordSize() != Integer.MAX_VALUE)) { throw new Exception("Check for " + algo + " failed under default policy"); } } System.out.println("All tests passed"); }
/* * Encrypt private key using Password-based encryption (PBE) * as defined in PKCS#5. * * NOTE: Currently pbeWithSHAAnd3-KeyTripleDES-CBC algorithmID is * used to derive the key and IV. * * @return encrypted private key encoded as EncryptedPrivateKeyInfo */ private byte[] encryptPrivateKey(byte[] data, char[] password) throws IOException, NoSuchAlgorithmException, UnrecoverableKeyException { byte[] key = null; try { // create AlgorithmParameters AlgorithmParameters algParams = getAlgorithmParameters("PBEWithSHA1AndDESede"); // Use JCE SecretKey skey = getPBEKey(password); Cipher cipher = Cipher.getInstance("PBEWithSHA1AndDESede"); cipher.init(Cipher.ENCRYPT_MODE, skey, algParams); byte[] encryptedKey = cipher.doFinal(data); // wrap encrypted private key in EncryptedPrivateKeyInfo // as defined in PKCS#8 AlgorithmId algid = new AlgorithmId(pbeWithSHAAnd3KeyTripleDESCBC_OID, algParams); EncryptedPrivateKeyInfo encrInfo = new EncryptedPrivateKeyInfo(algid, encryptedKey); key = encrInfo.getEncoded(); } catch (Exception e) { UnrecoverableKeyException uke = new UnrecoverableKeyException("Encrypt Private Key failed: " + e.getMessage()); uke.initCause(e); throw uke; } return key; }
public void run() { try { ObjectInputStream ois = new ObjectInputStream(s.getInputStream()); ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream()); BigInteger bg = dhSpec.getG(); BigInteger bp = dhSpec.getP(); oos.writeObject(bg); oos.writeObject(bp); KeyPairGenerator kpg = KeyPairGenerator.getInstance("DH"); kpg.initialize(1024); KeyPair kpa = (KeyPair) ois.readObject(); KeyAgreement dh = KeyAgreement.getInstance("DH"); KeyPair kp = kpg.generateKeyPair(); oos.writeObject(kp); dh.init(kp.getPrivate()); Key pk = dh.doPhase(kpa.getPublic(), true); MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] rawbits = sha256.digest(dh.generateSecret()); Cipher c = Cipher.getInstance(CIPHER_MODE); SecretKey key = new SecretKeySpec(rawbits, 0, 16, "AES"); byte ivbits[] = (byte[]) ois.readObject(); IvParameterSpec iv = new IvParameterSpec(ivbits); c.init(Cipher.DECRYPT_MODE, key, iv); Mac m = Mac.getInstance("HmacSHA1"); SecretKey mackey = new SecretKeySpec(rawbits, 16, 16, "HmacSHA1"); m.init(mackey); byte ciphertext[], cleartext[], mac[]; try { while (true) { ciphertext = (byte[]) ois.readObject(); mac = (byte[]) ois.readObject(); if (Arrays.equals(mac, m.doFinal(ciphertext))) { cleartext = c.update(ciphertext); System.out.println(ct + " : " + new String(cleartext, "UTF-8")); } else { // System.exit(1); System.out.println(ct + "error"); } } } catch (EOFException e) { cleartext = c.doFinal(); System.out.println(ct + " : " + new String(cleartext, "UTF-8")); System.out.println("[" + ct + "]"); } finally { if (ois != null) ois.close(); if (oos != null) oos.close(); } } catch (Exception e) { e.printStackTrace(); } }
/** * 指定密钥构造方法 * * @param strKey 指定的密钥 * @throws Exception */ public DESPlus(String strKey) throws Exception { Security.addProvider(new com.sun.crypto.provider.SunJCE()); Key key = getKey(strKey.getBytes()); encryptCipher = Cipher.getInstance("DES"); encryptCipher.init(Cipher.ENCRYPT_MODE, key); decryptCipher = Cipher.getInstance("DES"); decryptCipher.init(Cipher.DECRYPT_MODE, key); }
public byte[] decrypt(final byte[] toDecrypt) { try { final Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding"); cipher.init(Cipher.DECRYPT_MODE, skey, sRand); return cipher.doFinal(toDecrypt); } catch (final Exception e) { throw new RuntimeException(e); } }
public static byte[] encode(String paramString, byte[] paramArrayOfByte) { SecretKeySpec localSecretKeySpec = new SecretKeySpec(paramArrayOfByte, "AES"); try { byte[] arrayOfByte1 = paramString.getBytes(); Cipher localCipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); localCipher.init(Cipher.ENCRYPT_MODE, localSecretKeySpec); byte[] arrayOfByte2 = localCipher.doFinal(arrayOfByte1); return arrayOfByte2; } catch (Exception localException) { } return null; }
public static void main(String[] args) throws Exception { // decide if the installed jurisdiction policy file is the // unlimited version boolean isUnlimited = true; Cipher c = Cipher.getInstance("AES", "SunJCE"); try { c.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(new byte[24], "AES")); } catch (InvalidKeyException ike) { isUnlimited = false; } runTest(isUnlimited); }
public static byte[] decode(byte[] paramArrayOfByte1, byte[] paramArrayOfByte2) { SecretKeySpec localSecretKeySpec = new SecretKeySpec(paramArrayOfByte2, "AES"); try { Cipher localCipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); localCipher.init(Cipher.DECRYPT_MODE, localSecretKeySpec); byte[] arrayOfByte = localCipher.doFinal(paramArrayOfByte1); return arrayOfByte; } catch (Exception localException) { localException.printStackTrace(); } return null; }
/** * Reads the raw data from the input File, encrypts and saves its contents to the output File, and * then save the raw data of the SecretKey used to the SecretKey File. * * @param input the File to be read and encrypted * @param output the File the encrypted data will be saved to * @param keyFile the File the SecretKey data will be saved to * @throws InvalidKeyException if the given key is inappropriate for initializing this cipher, or * if this cipher is being initialized for decryption and requires algorithm parameters that * cannot be determined from the given key, or if the given key has a keysize that exceeds the * maximum allowable keysize (as determined from the configured jurisdiction policy files). * @throws IOException if any of the files do not exist, are a directory rather than a regular * file, or for some other reason cannot be opened for reading or if an I/O error occurs. * @throws IllegalBlockSizeException if the cipher is a block cipher, no padding has been * requested (only in encryption mode), and the total input length of the data processed by * this cipher is not a multiple of block size; or if this encryption algorithm is unable to * process the input data provided. * @throws BadPaddingException if the cipher is in decryption mode, and (un)padding has been * requested, but the decrypted data is not bounded by the appropriate padding bytes */ public void encrypt(File input, File output, File keyFile) throws InvalidKeyException, IOException, IllegalBlockSizeException, BadPaddingException { if (debug) { System.out.println("Initializing encryption..."); } cipher.init(Cipher.ENCRYPT_MODE, key); FileInputStream fis = null; try { fis = new FileInputStream(input); data = new byte[(int) input.length()]; if (debug) { System.out.println("Reading data..."); } fis.read(data); } finally { if (fis != null) { fis.close(); } } if (debug) { System.out.println("Encrypting data..."); } data = cipher.doFinal(data); FileOutputStream fos = null; try { fos = new FileOutputStream(output); if (debug) { System.out.println("Saving data..."); } fos.write(data); } finally { if (fos != null) { fos.close(); } } if (debug) { System.out.println("Saving key..."); } data = key.getEncoded(); fos = null; try { fos = new FileOutputStream(keyFile); fos.write(data); } finally { if (fos != null) { fos.close(); } } if (debug) { System.out.println("Encryption complete!"); } data = null; }
// <editor-fold desc="Class Constructor" defaultstate="collapsed"> public AES256Encrypt(char[] plaintext, char[] key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException { // We have to convert the real key into a hash that can fit into the AES algorithm. hash = new SHA256Hash(key); secretKey = new SecretKeySpec(hash.getHash().getEncoded(), encryptionAlgorithm); // Creating the actual cipher cipher = Cipher.getInstance(encryptionAlgorithm); cipher.init(Cipher.ENCRYPT_MODE, secretKey); encryptedCipher = cipher.doFinal(new String(plaintext).getBytes()); }
public Encrypter() { try { SecretKey key = KeyGenerator.getInstance("DES").generateKey(); ecipher = Cipher.getInstance("DES"); dcipher = Cipher.getInstance("DES"); ecipher.init(Cipher.ENCRYPT_MODE, key); dcipher.init(Cipher.DECRYPT_MODE, key); } catch (javax.crypto.NoSuchPaddingException e) { } catch (java.security.NoSuchAlgorithmException e) { } catch (java.security.InvalidKeyException e) { } }
public static String encodeWithBase64(String paramString) { SecretKeySpec localSecretKeySpec = new SecretKeySpec(BaseSecretKey, "AES"); try { byte[] arrayOfByte = paramString.getBytes(); Cipher localCipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); localCipher.init(Cipher.ENCRYPT_MODE, localSecretKeySpec); // String str = Base64.encodeBase64String(localCipher.doFinal(arrayOfByte)); String str = new String(Base64.encode(localCipher.doFinal(arrayOfByte), Base64.DEFAULT)); return str; } catch (Exception localException) { } return null; }
/** * Decrypts the given input data. * * @param in data to decrypt * @param k secret key * @param a encryption algorithm * @param ivl initialization vector length * @return decrypted data * @throws NoSuchAlgorithmException ex * @throws NoSuchPaddingException ex * @throws InvalidKeyException ex * @throws InvalidAlgorithmParameterException ex * @throws IllegalBlockSizeException ex * @throws BadPaddingException ex */ private static byte[] decrypt(final byte[] in, final byte[] k, final byte[] a, final int ivl) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException { final SecretKeySpec keySpec = new SecretKeySpec(k, string(a)); final Cipher cipher = Cipher.getInstance(string(ALGN.get(lc(a)))); // extract iv from message beginning final byte[] iv = substring(in, 0, ivl); final IvParameterSpec ivspec = new IvParameterSpec(iv); cipher.init(Cipher.DECRYPT_MODE, keySpec, ivspec); return cipher.doFinal(substring(in, ivl, in.length)); }
private static Cipher func_75886_a(int p_75886_0_, String p_75886_1_, Key p_75886_2_) { try { Cipher cipher = Cipher.getInstance(p_75886_1_); cipher.init(p_75886_0_, p_75886_2_); return cipher; } catch (InvalidKeyException invalidkeyexception) { invalidkeyexception.printStackTrace(); } catch (NoSuchAlgorithmException nosuchalgorithmexception) { nosuchalgorithmexception.printStackTrace(); } catch (NoSuchPaddingException nosuchpaddingexception) { nosuchpaddingexception.printStackTrace(); } System.err.println("Cipher creation failed!"); return null; }
public static byte[] decode64(byte[] paramArrayOfByte) { SecretKeySpec localSecretKeySpec = new SecretKeySpec(BaseSecretKey, "AES"); try { // byte[] arrayOfByte1 = Base64.decodeBase64(paramArrayOfByte); byte[] arrayOfByte1 = Base64.decode(paramArrayOfByte, Base64.DEFAULT); Cipher localCipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); localCipher.init(Cipher.DECRYPT_MODE, localSecretKeySpec); byte[] arrayOfByte2 = localCipher.doFinal(arrayOfByte1); return arrayOfByte2; } catch (Exception localException) { localException.printStackTrace(); } return null; }
void initCipher() { try { b64Decoder = new BASE64Decoder(); b64Encoder = new BASE64Encoder(); Provider sunJce = new com.sun.crypto.provider.SunJCE(); Security.addProvider(sunJce); byte[] raw = b64Decoder.decodeBuffer(key); SecretKeySpec skeySpec = new SecretKeySpec(raw, "Blowfish"); deCipher = Cipher.getInstance("Blowfish"); deCipher.init(Cipher.DECRYPT_MODE, skeySpec); enCipher = Cipher.getInstance("Blowfish"); enCipher.init(Cipher.ENCRYPT_MODE, skeySpec); } catch (Exception ex) { textPane.setText("Unable to create the cipher"); } }
/** * Extract the enclosed PKCS8EncodedKeySpec object from the encrypted data and return it. * * @return the PKCS8EncodedKeySpec object. * @exception InvalidKeySpecException if the given cipher is inappropriate for the encrypted data * or the encrypted data is corrupted and cannot be decrypted. */ public PKCS8EncodedKeySpec getKeySpec(Cipher c) throws InvalidKeySpecException { try { return new PKCS8EncodedKeySpec(c.doFinal(this.getEncryptedData())); } catch (Exception e) { throw new InvalidKeySpecException("can't get keySpec: " + e.toString()); } }
public static byte[] encryptData(Key key, byte[] toEncrypt) { try { Cipher cipher = Cipher.getInstance(key.getAlgorithm()); cipher.init(Cipher.ENCRYPT_MODE, key); return cipher.doFinal(toEncrypt); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (NoSuchPaddingException e) { e.printStackTrace(); } catch (InvalidKeyException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } return new byte[0]; }
private String decrypt(String s) { try { byte[] encrypted = b64Decoder.decodeBuffer(s); byte[] decrypted = deCipher.doFinal(encrypted); return new String(decrypted); } catch (Exception ex) { return "error"; } }
public String decrypt(String str) { try { return new String(cipherDecrypt.doFinal(StringUtils.hex2byte(str)), "UTF8"); } catch (UnsupportedEncodingException e) { } catch (BadPaddingException e) { } catch (IllegalBlockSizeException e) { } return null; }
public String encrypt(String str) { try { return StringUtils.byte2hex(cipherEncrypt.doFinal(str.getBytes("UTF8"))); } catch (UnsupportedEncodingException e) { } catch (BadPaddingException e) { } catch (IllegalBlockSizeException e) { } return null; }
/** * 加密字节数组 * * @param arrB 需加密的字节数组 * @return 加密后的字节数组 * @throws Exception */ public byte[] encrypt(byte[] arrB) { try { return encryptCipher.doFinal(arrB); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } return arrB; }
@SuppressWarnings("restriction") public String getencrypt(String p) throws Exception { String encrypted = ""; try { KeyGenerator kgen = KeyGenerator.getInstance("AES"); kgen.init(128, new SecureRandom(KEY.getBytes())); SecretKey skey = kgen.generateKey(); byte[] raw = skey.getEncoded(); SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES"); Cipher cipher = Cipher.getInstance("AES"); cipher.init(Cipher.ENCRYPT_MODE, skeySpec); byte[] encrypt = cipher.doFinal(p.getBytes()); encrypted = new BASE64Encoder().encodeBuffer(encrypt).trim(); // System.out.println("encrypted="+encrypted); } // try catch (Exception e) { System.out.println(e); } return encrypted; // return 密文 }
/** * Encrypts the given input data. * * @param in input data to encrypt * @param k key * @param a encryption algorithm * @param ivl initialization vector length * @return encrypted input data * @throws InvalidKeyException ex * @throws InvalidAlgorithmParameterException ex * @throws NoSuchAlgorithmException ex * @throws NoSuchPaddingException ex * @throws IllegalBlockSizeException ex * @throws BadPaddingException ex */ private static byte[] encrypt(final byte[] in, final byte[] k, final byte[] a, final int ivl) throws InvalidKeyException, InvalidAlgorithmParameterException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException { final Cipher cipher = Cipher.getInstance(string(ALGN.get(lc(a)))); final SecretKeySpec kspec = new SecretKeySpec(k, string(a)); // generate random iv. random iv is necessary to make the encryption of a // string look different every time it is encrypted. final byte[] iv = new byte[ivl]; // create new random iv if encrypting final SecureRandom rand = SecureRandom.getInstance("SHA1PRNG"); rand.nextBytes(iv); final IvParameterSpec ivspec = new IvParameterSpec(iv); // encrypt/decrypt cipher.init(Cipher.ENCRYPT_MODE, kspec, ivspec); final byte[] t = cipher.doFinal(in); // initialization vector is appended to the message for later decryption return concat(iv, t); }
/** Creates a new instance of Encrypter */ public AltEncrypter(String passPhrase) { try { SecureRandom sr = SecureRandom.getInstance("SHA1PRNG"); sr.setSeed(passPhrase.getBytes("UTF8")); KeyGenerator kGen = KeyGenerator.getInstance("DESEDE"); kGen.init(168, sr); Key key = kGen.generateKey(); cipherEncrypt = Cipher.getInstance("DESEDE/ECB/PKCS5Padding"); cipherEncrypt.init(Cipher.ENCRYPT_MODE, key); cipherDecrypt = Cipher.getInstance("DESEDE/ECB/PKCS5Padding"); cipherDecrypt.init(Cipher.DECRYPT_MODE, key); } catch (UnsupportedEncodingException e) { } catch (NoSuchPaddingException e) { } catch (NoSuchAlgorithmException e) { } catch (InvalidKeyException e) { } }
public String get_K() { if (rsa_key.length() < 2) return null; Cipher localCipher; byte[] arrayOfByte = null; PublicKey localPublicKey; try { // byte[] b = Base64.decode(rsa_key); byte[] b = Base64.decode(rsa_key, Base64.DEFAULT); X509EncodedKeySpec sp = new X509EncodedKeySpec(b); localPublicKey = KeyFactory.getInstance("RSA").generatePublic(sp); localCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); localCipher.init(Cipher.ENCRYPT_MODE, localPublicKey); arrayOfByte = localCipher.doFinal(aes_key.getBytes("utf-8")); } catch (Exception e) { // e.printStackTrace(); return null; } // return new String(Base64.encode(arrayOfByte)); return new String(Base64.encode(arrayOfByte, Base64.DEFAULT)); }
public String getdecrypt(String base64) throws Exception { String decrypted = ""; try { @SuppressWarnings("restriction") byte[] b = new BASE64Decoder().decodeBuffer(base64); KeyGenerator kgen2 = KeyGenerator.getInstance("AES"); kgen2.init(128, new SecureRandom(KEY.getBytes())); SecretKey skey2 = kgen2.generateKey(); byte[] raw2 = skey2.getEncoded(); SecretKeySpec skeySpec2 = new SecretKeySpec(raw2, "AES"); Cipher cipher2 = Cipher.getInstance("AES"); cipher2.init(Cipher.DECRYPT_MODE, skeySpec2); byte[] decrypt = cipher2.doFinal(b); decrypted = new String(decrypt); // System.out.println("decrypted="+decrypted); } catch (Exception e) { System.out.println(e); } return decrypted; }
/** * Uses a cipher to transform the bytes in an input stream and sends the transformed bytes to an * output stream. * * @param in the input stream * @param out the output stream * @param cipher the cipher that transforms the bytes */ public static void crypt(InputStream in, OutputStream out, Cipher cipher) throws IOException, GeneralSecurityException { int blockSize = cipher.getBlockSize(); int outputSize = cipher.getOutputSize(blockSize); byte[] inBytes = new byte[blockSize]; byte[] outBytes = new byte[outputSize]; int inLength = 0; ; boolean more = true; while (more) { inLength = in.read(inBytes); if (inLength == blockSize) { int outLength = cipher.update(inBytes, 0, blockSize, outBytes); out.write(outBytes, 0, outLength); } else more = false; } if (inLength > 0) outBytes = cipher.doFinal(inBytes, 0, inLength); else outBytes = cipher.doFinal(); out.write(outBytes); }