src/jp/gr/java_conf/ofnhwx/olib/utils/OCrypt.java

   1 package jp.gr.java_conf.ofnhwx.olib.utils;
   2
   3 import java.security.MessageDigest;
   4 import java.security.NoSuchAlgorithmException;
   5 import java.security.SecureRandom;
   6
   7 import javax.crypto.Cipher;
   8 import javax.crypto.spec.IvParameterSpec;
   9 import javax.crypto.spec.SecretKeySpec;
  10
  11 /**
  12  * 暗号用ライブラリ.
  13  * @author yuta
  14  */
  15 public final class OCrypt {
  16
  17     private static final String ALGORITHM_AES = "AES";
  18     private static final String ALGORITHM_MD5 = "MD5";
  19     private static final String ALGORITHM_SHA = "SHA1PRNG";
  20
  21     private static final String AES_ECB_PKCS5 = "AES/ECB/PKCS5Padding";
  22     private static final String AES_CBC_PKCS5 = "AES/CBC/PKCS5Padding";
  23
  24     private OCrypt() {}
  25
  26     /**
  27      * CBC形式で使用するデータ.
  28      */
  29     public static class EncryptedData {
  30         public byte[] iv;
  31         public byte[] data;
  32         public EncryptedData(byte[] iv, byte[] data) {
  33             this.iv   = iv;
  34             this.data = data;
  35         }
  36     }
  37
  38     /**
  39      * 暗号化失敗.
  40      */
  41     @SuppressWarnings("serial")
  42     public static class BadEncryptException extends Exception {
  43         public BadEncryptException(Throwable e) {
  44             super(e);
  45         }
  46     }
  47
  48     /**
  49      * 復号失敗.
  50      */
  51     @SuppressWarnings("serial")
  52     public static class BadDecryptException extends Exception {
  53         public BadDecryptException(Throwable e) {
  54             super(e);
  55         }
  56     }
  57
  58     /**
  59      * ダイジェスト生成失敗.
  60      */
  61     @SuppressWarnings("serial")
  62     public static class BadDigestException extends Exception {
  63         public BadDigestException(Throwable e) {
  64             super(e);
  65         }
  66     }
  67
  68     /**
  69      * データの暗号化(ECB).
  70      * @param key  暗号化に使用するキー
  71      * @param data 暗号化するデータ
  72      * @return 暗号化されたデータ
  73      */
  74     public static final byte[] encryptECB(byte[] key, byte[] data) {
  75         try {
  76             return encryptECBwithThrow(key, data);
  77         } catch (BadEncryptException e) {
  78             return null;
  79         }
  80     }
  81
  82     /**
  83      * データの暗号化(ECB).
  84      * @param key  暗号化に使用するキー
  85      * @param data 暗号化するデータ
  86      * @return 暗号化されたデータ
  87      * @throws BadEncryptException 暗号化に失敗.
  88      */
  89     public static final byte[] encryptECBwithThrow(byte[] key, byte[] data) throws BadEncryptException {
  90         try {
  91             SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM_AES);
  92             Cipher cipher = Cipher.getInstance(AES_ECB_PKCS5);
  93             cipher.init(Cipher.ENCRYPT_MODE, keySpec);
  94             return cipher.doFinal(data);
  95         } catch (RuntimeException e) {
  96             throw e;
  97         } catch (Exception e) {
  98             throw new BadEncryptException(e);
  99         }
 100     }
 101
 102     /**
 103      * データの復号(ECB).
 104      * @param key  復号に使用するキー
 105      * @param data 復号するデータ
 106      * @return 復号されたデータ
 107      */
 108     public static final byte[] decryptECB(byte[] key, byte[] data) {
 109         try {
 110             return decryptECBwithThrow(key, data);
 111         } catch (BadDecryptException e) {
 112             return null;
 113         }
 114     }
 115
 116     /**
 117      * データの復号(ECB).
 118      * @param key  復号に使用するキー
 119      * @param data 復号するデータ
 120      * @return 復号されたデータ
 121      * @throws BadDecryptException 復号に失敗
 122      */
 123     public static final byte[] decryptECBwithThrow(byte[] key, byte[] data) throws BadDecryptException {
 124         try {
 125             SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM_AES);
 126             Cipher cipher = Cipher.getInstance(AES_ECB_PKCS5);
 127             cipher.init(Cipher.DECRYPT_MODE, keySpec);
 128             return cipher.doFinal(data);
 129         } catch (RuntimeException e) {
 130             throw e;
 131         } catch (Exception e) {
 132             throw new BadDecryptException(e);
 133         }
 134     }
 135
 136     /**
 137      * データの暗号化(CBC).
 138      * @param key  暗号化に使用するキー
 139      * @param data 暗号化するデータ
 140      * @return 暗号化されたデータ
 141      */
 142     public static final EncryptedData encryptCBC(byte[] key, byte[] data) {
 143         try {
 144             return encryptCBCwithThrow(key, data);
 145         } catch (BadEncryptException e) {
 146             return null;
 147         }
 148     }
 149
 150     /**
 151      * データの暗号化(CBC).
 152      * @param key  暗号化に使用するキー
 153      * @param data 暗号化するデータ
 154      * @return 暗号化されたデータ
 155      * @throws BadEncryptException 暗号化に失敗
 156      */
 157     public static final EncryptedData encryptCBCwithThrow(byte[] key, byte[] data) throws BadEncryptException {
 158         try {
 159             SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM_AES);
 160             Cipher cipher = Cipher.getInstance(AES_CBC_PKCS5);
 161             SecureRandom random = SecureRandom.getInstance(ALGORITHM_SHA);
 162             cipher.init(Cipher.ENCRYPT_MODE, keySpec, random);
 163             return new EncryptedData(cipher.getIV(), cipher.doFinal(data));
 164         } catch (RuntimeException e) {
 165             throw e;
 166         } catch (Exception e) {
 167             throw new BadEncryptException(e);
 168         }
 169     }
 170
 171     /**
 172      * データの復号(CBC).
 173      * @param key  復号に使用するキー
 174      * @param data 復号するデータ
 175      * @return 復号されたデータ
 176      */
 177     public static final byte[] decryptCBC(byte[] key, EncryptedData data) {
 178         try {
 179             return decryptCBCwithThrow(key, data);
 180         } catch (BadDecryptException e) {
 181             return null;
 182         }
 183     }
 184
 185     /**
 186      * データの復号(CBC).
 187      * @param key  復号に使用するキー
 188      * @param data 復号するデータ
 189      * @return 復号されたデータ
 190      * @throws BadDecryptException 復号に失敗
 191      */
 192     public static final byte[] decryptCBCwithThrow(byte[] key, EncryptedData data) throws BadDecryptException {
 193         try {
 194             SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM_AES);
 195             Cipher cipher = Cipher.getInstance(AES_CBC_PKCS5);
 196             cipher.init(Cipher.DECRYPT_MODE, keySpec, new IvParameterSpec(data.iv));
 197             return cipher.doFinal(data.data);
 198         } catch (RuntimeException e) {
 199             throw e;
 200         } catch (Exception e) {
 201             throw new BadDecryptException(e);
 202         }
 203     }
 204
 205     /**
 206      * MD5ダイジェストの取得.
 207      * @param data MD5ダイジェストを取得するデータ
 208      * @return MD5ダイジェスト
 209      */
 210     public static final byte[] digestMD5(byte[] data) {
 211         try {
 212             return digestMD5withThrow(data);
 213         } catch (BadDigestException e) {
 214             return null;
 215         }
 216     }
 217
 218     /**
 219      * MD5ダイジェストの取得.
 220      * @param data MD5ダイジェストを取得するデータ
 221      * @return MD5ダイジェスト
 222      * @throws BadDigestException
 223      */
 224     public static final byte[] digestMD5withThrow(byte[] data) throws BadDigestException {
 225         try {
 226             MessageDigest digest = MessageDigest.getInstance(ALGORITHM_MD5);
 227             return digest.digest(data);
 228         } catch (RuntimeException e) {
 229             throw e;
 230         } catch (NoSuchAlgorithmException e) {
 231             throw new BadDigestException(e);
 232         }
 233     }
 234
 235 }