• android平台上AES,DES加解密及问题


    在使用java进行AES加密的时候,会用到如下方法: SecureRandom sr = SecureRandom.getInstance("SHA1PRNG"); 
    但是在android4.2以上进行加密、解密时,会报类似badPadding的异常,但是把该代码替换成一下方法则一切都OK。 SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "Crypto"); 
    AES加密算法:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    import java.security.SecureRandom;
     
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
     
    public class AESUtil {
     
        public static String encrypt(String seed, String cleartext)
                throws Exception {
            byte[] rawKey = getRawKey(seed.getBytes());
            byte[] result = encrypt(rawKey, cleartext.getBytes());
            return toHex(result);
        }
     
        public static String decrypt(String seed, String encrypted)
                throws Exception {
            byte[] rawKey = getRawKey(seed.getBytes());
            byte[] enc = toByte(encrypted);
            byte[] result = decrypt(rawKey, enc);
            return new String(result);
        }
     
        private static byte[] getRawKey(byte[] seed) throws Exception {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
    //      SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
            SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
            sr.setSeed(seed);
            kgen.init(128, sr); // 192 and 256 bits may not be available
            SecretKey skey = kgen.generateKey();
            byte[] raw = skey.getEncoded();
            return raw;
        }
     
        private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception {
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
            byte[] encrypted = cipher.doFinal(clear);
            return encrypted;
        }
     
        private static byte[] decrypt(byte[] raw, byte[] encrypted)
                throws Exception {
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            byte[] decrypted = cipher.doFinal(encrypted);
            return decrypted;
        }
     
        public static String toHex(String txt) {
            return toHex(txt.getBytes());
        }
     
        public static String fromHex(String hex) {
            return new String(toByte(hex));
        }
     
        public static byte[] toByte(String hexString) {
            int len = hexString.length()/2;
            byte[] result = new byte[len];
            for (int i = 0; i < len; i++)
                result[i] = Integer.valueOf(hexString.substring(2*i, 2*i+2), 16).byteValue();
            return result;
        }
     
        public static String toHex(byte[] buf) {
            if (buf == null)
                return "";
            StringBuffer result = new StringBuffer(2*buf.length);
            for (int i = 0; i < buf.length; i++) {
                appendHex(result, buf[i]);
            }
            return result.toString();
        }
     
        private final static String HEX = "0123456789ABCDEF";
     
        private static void appendHex(StringBuffer sb, byte b) {
             sb.append(HEX.charAt((b>>4)&0x0f)).append(HEX.charAt(b&0x0f));
        }
    }


    DES加密算法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    import java.io.UnsupportedEncodingException;
    import java.security.Key;
    import java.util.Locale;
     
    import javax.crypto.Cipher;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESedeKeySpec;
    import javax.crypto.spec.IvParameterSpec;
     
    /**
     * DES加密
     *
     * @author houjinyun
     *
     */
    public class DesUtils {
     
        private static final String KEY = "********************";
         
        /**
         * 对字符串进行DES3加密
         *
         * @param str
         * @return 加密后的字符串,若失败则返回null
         */
        public static String encode(String str) {
            try {
                byte[] key = KEY.getBytes("UTF-8");
                byte[] data = str.getBytes("UTF-8");
                byte[] encodedData = des3EncodeECB(key, data);
                return byte2HexString(encodedData);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }      
            return null;
        }
     
        public static String decode(String str) {
            try {
                byte[] key = KEY.getBytes("UTF-8");
                byte[] data = hexString2Byte(str);
                byte[] decodedData = des3DecodeECB(key, data);
                return new String(decodedData, "UTF-8");
            } catch(Exception e) {
                e.printStackTrace();
            }
            return null;
        }
         
        /**
         * ECB加密,不要IV
         *
         * @param key
         *            密钥
         * @param data
         *            明文
         * @return Base64编码的密文
         * @throws Exception
         */
        public static byte[] des3EncodeECB(byte[] key, byte[] data)
                throws Exception {
            Key deskey = null;
            DESedeKeySpec spec = new DESedeKeySpec(key);
            SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
            deskey = keyfactory.generateSecret(spec);
            Cipher cipher = Cipher.getInstance("desede" + "/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, deskey);
            byte[] bOut = cipher.doFinal(data);
            return bOut;
        }
     
        /**
         * ECB解密,不要IV
         *
         * @param key
         *            密钥
         * @param data
         *            Base64编码的密文
         * @return 明文
         * @throws Exception
         */
        public static byte[] ees3DecodeECB(byte[] key, byte[] data)
                throws Exception {
            Key deskey = null;
            DESedeKeySpec spec = new DESedeKeySpec(key);
            SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
            deskey = keyfactory.generateSecret(spec);
            Cipher cipher = Cipher.getInstance("desede" + "/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, deskey);
            byte[] bOut = cipher.doFinal(data);
            return bOut;
        }
     
        /**
         * CBC加密
         *
         * @param key
         *            密钥
         * @param keyiv
         *            IV
         * @param data
         *            明文
         * @return Base64编码的密文
         * @throws Exception
         */
        public static byte[] des3EncodeCBC(byte[] key, byte[] keyiv, byte[] data)
                throws Exception {
            Key deskey = null;
            DESedeKeySpec spec = new DESedeKeySpec(key);
            SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
            deskey = keyfactory.generateSecret(spec);
            Cipher cipher = Cipher.getInstance("desede" + "/CBC/PKCS5Padding");
            IvParameterSpec ips = new IvParameterSpec(keyiv);
            cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);
            byte[] bOut = cipher.doFinal(data);
            return bOut;
        }
     
        /**
         * CBC解密
         *
         * @param key
         *            密钥
         * @param keyiv
         *            IV
         * @param data
         *            Base64编码的密文
         * @return 明文
         * @throws Exception
         */
        public static byte[] des3DecodeCBC(byte[] key, byte[] keyiv, byte[] data)
                throws Exception {
            Key deskey = null;
            DESedeKeySpec spec = new DESedeKeySpec(key);
            SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
            deskey = keyfactory.generateSecret(spec);
     
            Cipher cipher = Cipher.getInstance("desede" + "/CBC/PKCS5Padding");
            IvParameterSpec ips = new IvParameterSpec(keyiv);
            cipher.init(Cipher.DECRYPT_MODE, deskey, ips);
            byte[] bOut = cipher.doFinal(data);
            return bOut;
        }
     
        public static byte[] des3DecodeECB(byte[] key, byte[] data)
                throws Exception {
            Key deskey = null;
            DESedeKeySpec spec = new DESedeKeySpec(key);
            SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
            deskey = keyfactory.generateSecret(spec);
            Cipher cipher = Cipher.getInstance("desede" + "/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, deskey);
            byte[] bOut = cipher.doFinal(data);
            return bOut;
        }
         
        private static String byte2HexString(byte[] b) {
            String a = "";
            for (int i = 0; i < b.length; i++) {
                String hex = Integer.toHexString(b[i] & 0xFF)
                        .toUpperCase(Locale.US);
                if (hex.length() == 1) {
                    hex = '0' + hex;
                }
                a = a + hex;
            }
            return a;
        }
     
        private static byte[] hexString2Byte(String str) {
            if (str == null)
                return null;
            str = str.trim();
            int len = str.length();
            if (len == 0 || len % 2 == 1)
                return null;
            byte[] b = new byte[len / 2];
            try {
                for (int i = 0; i < str.length(); i += 2) {
                    b[i / 2] = (byte) Integer.decode("0x" + str.substring(i, i + 2)).intValue();
                }
                return b;
            } catch (Exception e) {
                return null;
            }
        }
         
    }
     

    结伴旅游,一个免费的交友网站:www.jieberu.com

    推推族,免费得门票,游景区:www.tuituizu.com

  • 相关阅读:
    Ajax调用WCF报405错误
    字符串转json方法
    正则取括号里面的内容
    string[] 转int[] 的方法
    C# 中结构与类的区别
    通用的权限模块是如何设计的?
    .net打包自动安装数据库!
    VS.net 2005快捷键一览表
    Windows Forms DataGridView 中合并单元格
    VS2005 制作安装程序
  • 原文地址:https://www.cnblogs.com/rabbit-bunny/p/4184987.html
Copyright © 2020-2023  润新知