Back to project page interdroid-vdb.
The source code is released under:
Copyright (c) 2008-2012 Vrije Universiteit, The Netherlands All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the follo...
If you think the Android project interdroid-vdb listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
/* * Copyright (c) 2008-2012 Vrije Universiteit, The Netherlands All rights * reserved.// w ww . j ava 2 s. co m * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * Neither the name of the Vrije Universiteit nor the names of its contributors * may be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ package interdroid.util; import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.security.PrivateKey; import java.security.PublicKey; import java.security.Signature; import java.security.SignatureException; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.KeyGenerator; import javax.crypto.Mac; import javax.crypto.NoSuchPaddingException; import javax.crypto.SecretKey; /** * A utility library for doing various cryptography related things with sensible defaults. * Uses java.security and javax.crypto packages and deals only in Strings. * * @author nick palmer@cs.vu.nl * */ public class CryptoUtil { /** * The default encoding for String->byte[] and byte[]->String to use. */ public static final String DEFAULT_ENCODING = "UTF8"; /** * The default MAC generation scheme */ public static final String DEFAULT_MAC = "HmacMD5"; /** * The default Digest generation scheme */ public static final String DEFAULT_DIGEST = "MD5"; /** * The default cypher to use for secret key encryption/decryption */ public static final String DEFAULT_CYPHER = "Blowfish"; /** * The default mode to use for secret key encryption/decryption */ public static final String DEFAULT_MODE = "ECB"; /** * The default padding scheme to use for secret key encryption/decryption */ public static final String DEFAULT_PADDING = "PKCS5Padding"; /** * The default public key encryption scheme */ public static final String DEFAULT_KEY_PAIR_TYPE = "RSA"; /** * The default signature scheme */ public static final String DEFAULT_SIGNATURE_SPEC = "MD5WithRSA"; /** * The default cypher specification which is the combination of the DEFAULT_CYPHER, DEFAULT_MODE and DEFAULT_PADDING */ public static final String DEFAULT_CYPHER_SPEC = DEFAULT_CYPHER + "/" + DEFAULT_MODE + "/" + DEFAULT_PADDING; /** * The default key size for public key encryption */ public static final int DEFAULT_KEY_PAIR_SIZE = 2048; // Signature stuff /** * Generates a signature for the given plainTextString using the PrivateKey key and the signature type and * string encoding scheme specified. * * @param plainTextString The text to be signed * @param key The private key to use to sign * @param type The signature specification * @param encoding The string encoding method * @return The generated signature * @throws UnsupportedEncodingException if the encoding is not supported * @throws NoSuchAlgorithmException if the type is not supported * @throws InvalidKeyException if the private key is invalid * @throws SignatureException if there is a problem generating the signature */ public String generateSignatureTypeEncoded(String plainTextString, PrivateKey key, String type, String encoding) throws UnsupportedEncodingException, NoSuchAlgorithmException, InvalidKeyException, SignatureException { byte[] plainText = plainTextString.getBytes(encoding); Signature sig = Signature.getInstance(type); sig.initSign(key); sig.update(plainText); byte[] signature = sig.sign(); return new String(signature, encoding); } /** * Generates a signature for the given plain text using the private key and the DEFAULT_SIGNATURE_SPEC and DEFAULT_ENCODING * * @param plainTextString The text to sign * @param key The key to use to generate the signature * @return The signature * @throws InvalidKeyException If the key is invalid * @throws UnsupportedEncodingException If the DEFAULT_ENCODING is not supported * @throws NoSuchAlgorithmException If the DEFAULT_SIGNATURE_SPEC is not supported * @throws SignatureException If there is a problem generating the signature */ public String generateSignature(String plainTextString, PrivateKey key) throws InvalidKeyException, UnsupportedEncodingException, NoSuchAlgorithmException, SignatureException { return generateSignatureTypeEncoded(plainTextString, key, DEFAULT_SIGNATURE_SPEC, DEFAULT_ENCODING); } /** * Verifies the signature for the given plain text using the specified key, signature scheme and string encoding * * @param plainTextString The plain text to be verified * @param signatureString The signature to be checked * @param key The public key to verify with * @param type The signature scheme being used * @param encoding The string encoding scheme to use * @throws NoSuchAlgorithmException If the signature type is not supported * @throws UnsupportedEncodingException If the encoding type is not supported * @throws InvalidKeyException If the key is invalid * @throws SignatureException If there is a problem verifying the signature */ public void verifySignatureTypeEncoded(String plainTextString, String signatureString, PublicKey key, String type, String encoding) throws NoSuchAlgorithmException, UnsupportedEncodingException, InvalidKeyException, SignatureException { byte[] plainText = plainTextString.getBytes(encoding); byte[] signature = signatureString.getBytes(encoding); Signature sig = Signature.getInstance(type); sig.initVerify(key); sig.update(plainText); sig.verify( signature ); } /** * Verifies the signature on the given plain text using the specified key using the DEFAULT_SIGNATURE_SPEC and the DEFAULT_ENCODING * * @param plainTextString The plain text to be verified * @param signature The signature to be checked * @param key The public key to verify with * @throws NoSuchAlgorithmException If the DEFAULT_SIGNATURE_SPEC is not supported * @throws UnsupportedEncodingException If the DEFAULT_ENCODING is not supported * @throws InvalidKeyException If the key is invalid * @throws SignatureException If there is a problem verifying the signature */ public void verifySignature(String plainTextString, String signature, PublicKey key) throws InvalidKeyException, NoSuchAlgorithmException, UnsupportedEncodingException, SignatureException { verifySignatureTypeEncoded(plainTextString, signature, key, DEFAULT_SIGNATURE_SPEC, DEFAULT_ENCODING); } // Secret Key Encryption and Decryption /** * Decrypt using the DEFAULT_CYPHER_SPEC and the DEFAULT_ENCODING * * @param plainTextString the plain text to encrypt * @param key The secret key to do the encoding with * @throws NoSuchPaddingException If the DEFAULT_PADDING is not supported * @throws NoSuchAlgorithmException If the DEFAULT_CYPHER not supported * @throws UnsupportedEncodingException If the DEFAULT_ENCODING is not supported * @throws InvalidKeyException If the key is invalid * @throws BadPaddingException If the padding is incorrect for the DEFAULT_PADING * @throws IllegalBlockSizeException If the block size is incorrect while decrypting * @return the decrypted text */ public static String decrypt(String plainTextString, SecretKey key) throws NoSuchAlgorithmException, NoSuchPaddingException, UnsupportedEncodingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException { Cipher cipher = Cipher.getInstance(DEFAULT_CYPHER_SPEC); byte[] plainText = plainTextString.getBytes(DEFAULT_ENCODING); cipher.init(Cipher.DECRYPT_MODE, key); return new String(cipher.doFinal(plainText), DEFAULT_ENCODING); } /** * Encrypt using the DEFAULT_CYPHER_SPEC and the DEFAULT_ENCODING * * @param plainTextString the plain text to encrypt * @param key The secret key to do the encoding with * @throws NoSuchPaddingException If the DEFAULT_PADDING is not supported * @throws NoSuchAlgorithmException If the DEFAULT_CYPHER is not supported * @throws UnsupportedEncodingException If the DEFAULT_ENCODING is not supported * @throws InvalidKeyException If the key is invalid * @throws BadPaddingException If the padding is incorrect * @throws IllegalBlockSizeException If there is a block size problem * @return the encrypted text */ public static String encrypt(String plainTextString, SecretKey key) throws NoSuchAlgorithmException, NoSuchPaddingException, UnsupportedEncodingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException { Cipher cipher = Cipher.getInstance(DEFAULT_CYPHER); byte[] plainText = plainTextString.getBytes(DEFAULT_ENCODING); cipher.init(Cipher.ENCRYPT_MODE, key); return new String(cipher.doFinal(plainText), DEFAULT_ENCODING); } // Key Methods /** * Generates a KeyPair with the given type and given size * * @param type The type of key pair to generate * @param size The size of the key pair to generate * @return The generated key pair * @throws NoSuchAlgorithmException if the type is not supported */ public static KeyPair generateKeyPairTypeSize(String type, int size) throws NoSuchAlgorithmException { KeyPairGenerator keyGen = KeyPairGenerator.getInstance(type); keyGen.initialize(size); return keyGen.generateKeyPair(); } /** * Generates a KeyPair with the DEFAULT_KEY_PAIR_TYPE and the DEFAULT_KEY_PAIR_SIZE * * @return The generated key pair * @throws NoSuchAlgorithmException If the DEFAULT_KEY_PAIR_TYPE is not supported */ public static KeyPair generateKeyPair() throws NoSuchAlgorithmException { return generateKeyPairTypeSize(DEFAULT_KEY_PAIR_TYPE, DEFAULT_KEY_PAIR_SIZE); } /** * Generates a new secret key of the requested type * * @param type A key type like "HmacMD5" or "DES" * @param keysize The size of the key to generate * @return a new SecretKey of the given type and size * @throws NoSuchAlgorithmException If teh type is not supported */ public static SecretKey generateSecretKeySized(String type, int keysize) throws NoSuchAlgorithmException { KeyGenerator keyGen = KeyGenerator.getInstance(type); keyGen.init( keysize ); SecretKey key = keyGen.generateKey(); return key; } /** * Generates a new secret key of the requested type * * @param type A key type like "HmacMD5" * @return a new SecretKey of the given type * @throws NoSuchAlgorithmException If the type is not supported */ public static SecretKey generateSecretKey(String type) throws NoSuchAlgorithmException { KeyGenerator keyGen = KeyGenerator.getInstance(type); SecretKey key = keyGen.generateKey(); return key; } // MAC methods /** * Generates a MAC using the specified type and encoding * * @param plainTextString The plain text to generate a MAC for * @param key The key to use to generate the MAC * @param type The type of algorithm to use * @param encoding The encoding scheme to use * @return The MAC for the plain text * @throws NoSuchAlgorithmException If the type is not supported * @throws InvalidKeyException If the key is invalid * @throws UnsupportedEncodingException If the encoding is not supported */ public static String getMacTypeEncoded(String plainTextString, SecretKey key, String type, String encoding) throws NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException { Mac mac = Mac.getInstance(type); mac.init(key); byte[] plainText = plainTextString.getBytes(encoding); mac.update(plainText); return new String(mac.doFinal(), encoding); } /** * Generates a MAC using the DEFAULT_MAC and the DEFAULT_ENCODING * * @param plainTextString The plain text to generate a MAC for * @param key The key to use to generate the MAC * @return The MAC for the given plain text * @throws NoSuchAlgorithmException If the DEFAULT_MAC is not supported * @throws InvalidKeyException If the key is invalid * @throws UnsupportedEncodingException If the DEFAULT_ENCODING is not supported */ public static String getMac(String plainTextString, SecretKey key) throws NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException { return getMacTypeEncoded(plainTextString, key, DEFAULT_MAC, DEFAULT_ENCODING); } // Digest Methods /** * Generates a digest using the specified digest and encoding * * @param plainTextString * @param type * @param encoding * @return the digest as a string * @throws UnsupportedEncodingException * @throws NoSuchAlgorithmException */ public static String getDigestTypeEncoded(String plainTextString, String type, String encoding) throws UnsupportedEncodingException, NoSuchAlgorithmException { byte[] plainText = plainTextString.getBytes(encoding); MessageDigest messageDigest = MessageDigest.getInstance(type); messageDigest.update( plainText); return new String( messageDigest.digest(), encoding); } /** * Generates a digest using the DEFAULT_DIGEST and the DEFAULT_ENCODING * * @param plainTextString * @return the digest as a string * @throws UnsupportedEncodingException * @throws NoSuchAlgorithmException */ public static String getDigest(String plainTextString) throws UnsupportedEncodingException, NoSuchAlgorithmException { return getDigestTypeEncoded(plainTextString, DEFAULT_DIGEST, DEFAULT_ENCODING); } }