Android Open Source - android-simple-storage Security Util

From Project

Back to project page android-simple-storage.
License

The source code is released under:
Apache License
If you think the Android project android-simple-storage listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
Java Source Code

package com.sromku.simple.storage.security;
/*  w w w.  ja  va 2  s.c o  m*/
import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * Security utils for encryption, xor and more
 * 
 * @author Roman Kushnarenko - sromku (sromku@gmail.com)
 */
public class SecurityUtil {

  /**
   * Encrypt or Descrypt the content. <br>
   * 
   * @param content
   *            The content to encrypt or descrypt.
   * @param encryptionMode
   *            Use: {@link Cipher#ENCRYPT_MODE} or
   *            {@link Cipher#DECRYPT_MODE}
   * @param secretKey
   *            Set the secret key for encryption of file content.
   *            <b>Important: The length must be 16 long</b>. <i>Uses SHA-256
   *            to generate a hash from your key and trim the result to 128
   *            bit (16 bytes)</i>
   * @param ivx
   *            This is not have to be secret. It used just for better
   *            randomizing the cipher. You have to use the same IV parameter
   *            within the same encrypted and written files. Means, if you
   *            want to have the same content after descryption then the same
   *            IV must be used. <i>About this parameter from wiki:
   *            https://en.wikipedia.org/wiki/Block_cipher_modes_of_operation
   *            #Initialization_vector_.28IV.29</i> <b>Important: The length
   *            must be 16 long</b>
   * @return
   */
  public static byte[] encrypt(byte[] content, int encryptionMode, final byte[] secretKey, final byte[] ivx) {
    if (secretKey.length != 16 || ivx.length != 16) {
      throw new RuntimeException("Set the encryption parameters correctly. The must be 16 length long each");
    }

    try {
      final SecretKey secretkey = new SecretKeySpec(secretKey, CipherAlgorithmType.AES.getAlgorithmName());
      final IvParameterSpec IV = new IvParameterSpec(ivx);

      final String transformation = CipherTransformationType.AES_CBC_PKCS5Padding;
      final Cipher decipher = Cipher.getInstance(transformation);

      decipher.init(encryptionMode, secretkey, IV);
      final byte[] plainText = decipher.doFinal(content);
      return plainText;
    }
    catch (NoSuchAlgorithmException e) {
      throw new RuntimeException("Failed to encrypt/descrypt - Unknown Algorithm", e);
    }
    catch (NoSuchPaddingException e) {
      throw new RuntimeException("Failed to encrypt/descrypt- Unknown Padding", e);
    }
    catch (InvalidKeyException e) {
      throw new RuntimeException("Failed to encrypt/descrypt - Invalid Key", e);
    }
    catch (InvalidAlgorithmParameterException e) {
      throw new RuntimeException("Failed to encrypt/descrypt - Invalid Algorithm Parameter", e);
    }
    catch (IllegalBlockSizeException e) {
      throw new RuntimeException("Failed to encrypt/descrypt", e);
    }
    catch (BadPaddingException e) {
      throw new RuntimeException("Failed to encrypt/descrypt", e);
    }
  }

  /**
   * Do xor operation on the string with the key
   * 
   * @param str
   *            The string to xor on
   * @param key
   *            The key by which the xor will work
   * @return The string after xor
   */
  public String xor(String msg, String key) {
    try {
      final String UTF_8 = "UTF-8";
      byte[] msgArray;

      msgArray = msg.getBytes(UTF_8);

      byte[] keyArray = key.getBytes(UTF_8);

      byte[] out = new byte[msgArray.length];
      for (int i = 0; i < msgArray.length; i++) {
        out[i] = (byte) (msgArray[i] ^ keyArray[i % keyArray.length]);
      }
      return new String(out, UTF_8);
    }
    catch (UnsupportedEncodingException e) {
    }
    return null;
  }

}
Java Source Code List
